fix: to_archive and task threads

fixes to_archive work with buffers as well as files.
Settings work on Neon/Node tasks

Author: cdmurph32

js-src/Builder.spec.ts

@@ -29,6 +29,7 @@ import { isActionsAssertion } from "./assertions.js";
 import { CallbackSigner, LocalSigner } from "./Signer.js";
 import { Reader } from "./Reader.js";
 import { Builder } from "./Builder.js";
+import { loadC2paSettings, resetSettings } from "./Settings.js";
 
 const tempDir = path.join(__dirname, "tmp");
 
@@ -277,6 +278,81 @@ describe("Builder", () => {
       expect(activeManifest?.title).toBe("Test_Manifest");
     });
 
+    it("should populate buffer when archiving to buffer", async () => {
+      const archive: DestinationBufferAsset = {
+        buffer: null,
+      };
+      await builder.toArchive(archive);
+      expect(archive.buffer).not.toBeNull();
+      expect(archive.buffer!.length).toBeGreaterThan(0);
+    });
+
+    it("should write archive to file", async () => {
+      const archivePath = path.join(tempDir, "archive_file_test.zip");
+      const archive = { path: archivePath };
+      await builder.toArchive(archive);
+
+      // Verify file was created and has content
+      expect(await fs.pathExists(archivePath)).toBe(true);
+      const stats = await fs.stat(archivePath);
+      expect(stats.size).toBeGreaterThan(0);
+    });
+
+    it("should construct reader directly from builder archive buffer", async () => {
+      // Enable c2pa archive format
+      loadC2paSettings(
+        JSON.stringify({
+          builder: {
+            generate_c2pa_archive: true,
+          },
+          verify: {
+            verify_after_reading: false,
+          },
+        }),
+      );
+
+      try {
+        // Create a builder
+        const simpleManifestDefinition = {
+          claim_generator_info: [
+            {
+              name: "c2pa_test",
+              version: "1.0.0",
+            },
+          ],
+          title: "Test_Manifest",
+          format: "image/jpeg",
+          assertions: [],
+          resources: { resources: {} },
+        };
+
+        const testBuilder = Builder.withJson(simpleManifestDefinition);
+
+        // Add an ingredient
+        await testBuilder.addIngredient(parent_json, source);
+
+        // Create an archive from the builder written to a buffer
+        const archive: DestinationBufferAsset = {
+          buffer: null,
+        };
+        await testBuilder.toArchive(archive);
+
+        // Verify buffer was populated
+        expect(archive.buffer).not.toBeNull();
+        expect(archive.buffer!.length).toBeGreaterThan(0);
+
+        // Construct a reader from the builder archive with mime-type "application/c2pa"
+        const reader = await Reader.fromAsset({
+          buffer: archive.buffer! as Buffer,
+          mimeType: "application/c2pa",
+        });
+        expect(reader).not.toBeNull();
+      } finally {
+        // Reset settings to defaults
+        resetSettings();
+      }
+    });
+
     it("should sign data with callback to file", async () => {
       const dest: FileAsset = {
         path: path.join(tempDir, "callback_signed.jpg"),

js-src/Builder.ts

@@ -235,4 +235,8 @@ export class Builder implements BuilderInterface {
       value,
     );
   }
+
+  getHandle(): NeonBuilderHandle {
+    return this.builder;
+  }
 }

js-src/types.d.ts

@@ -315,6 +315,11 @@ export interface BuilderInterface {
    * @returns The manifest definition
    */
   updateManifestProperty(property: string, value: string | ClaimVersion): void;
+
+  /**
+   * Get the internal handle for use with Neon bindings
+   */
+  getHandle(): NeonBuilderHandle;
 }
 
 export interface ReaderInterface {

src/error.rs

@@ -51,6 +51,9 @@ pub enum Error {
     #[error("Settings handling failed: {0}")]
     Settings(String),
 
+    #[error("Reading failed: {0}")]
+    Reading(String),
+
     #[error("Signing failed: {0}")]
     Signing(String),
 

src/neon_builder.rs

@@ -235,25 +235,47 @@ impl NeonBuilder {
 
     pub fn to_archive(mut cx: FunctionContext) -> JsResult<JsPromise> {
         let this = cx.this::<JsBox<Self>>()?;
-        let dest = cx
-            .argument::<JsObject>(0)
-            .and_then(|obj| parse_asset(&mut cx, obj))?;
+        let dest_obj = cx.argument::<JsObject>(0)?;
+        let dest = parse_asset(&mut cx, dest_obj)?;
+        let is_buffer = dest.name() == "destination_buffer";
         let builder = Arc::clone(&this.builder);
+        let dest_obj_root: Arc<Root<JsObject>> = Arc::new(Root::new(&mut cx, &dest_obj));
 
         let promise = cx
             .task(move || {
                 // Block on acquiring the async mutex lock
+                // Settings are automatically applied when runtime() is called
                 let rt = runtime();
                 let mut builder = rt.block_on(async { builder.lock().await });
 
-                dest.write_stream().and_then(|dest_stream| {
-                    builder.to_archive(dest_stream)?;
-                    Ok(())
+                dest.write_stream().and_then(|mut dest_stream| {
+                    builder.to_archive(&mut dest_stream)?;
+                    if is_buffer {
+                        let mut archive_data = Vec::new();
+                        dest_stream
+                            .rewind()
+                            .map_err(|e| Error::Asset(format!("Failed to rewind stream: {e}")))?;
+                        dest_stream
+                            .read_to_end(&mut archive_data)
+                            .map_err(|e| Error::Asset(format!("Failed to read stream: {e}")))?;
+                        Ok(Some(archive_data))
+                    } else {
+                        Ok(None)
+                    }
                 })
             })
-            .promise(move |mut cx, result: Result<(), Error>| match result {
-                Ok(_) => Ok(cx.undefined()),
-                Err(err) => as_js_error(&mut cx, err).and_then(|err| cx.throw(err)),
+            .promise(move |mut cx, result: Result<Option<Vec<u8>>, Error>| {
+                match result {
+                    Ok(Some(archive_data)) => {
+                        // If the output is a buffer, populate it with the archive data
+                        let buffer = JsBuffer::from_slice(&mut cx, &archive_data)?;
+                        let dest_obj = dest_obj_root.to_inner(&mut cx);
+                        dest_obj.set(&mut cx, "buffer", buffer)?;
+                        Ok(cx.undefined())
+                    }
+                    Ok(None) => Ok(cx.undefined()),
+                    Err(err) => as_js_error(&mut cx, err).and_then(|err| cx.throw(err)),
+                }
             });
         Ok(promise)
     }

src/neon_reader.rs

@@ -52,7 +52,7 @@ impl NeonReader {
                 let format = source
                     .mime_type()
                     .ok_or_else(|| {
-                        Error::Signing("Ingredient asset must have a mime type".to_string())
+                        Error::Reading("Source asset must have a mime type".to_string())
                     })?
                     .to_owned();
 
@@ -100,7 +100,7 @@ impl NeonReader {
                 let format = asset
                     .mime_type()
                     .ok_or_else(|| {
-                        Error::Signing("Ingredient asset must have a mime type".to_string())
+                        Error::Reading("Source asset must have a mime type".to_string())
                     })?
                     .to_owned();
                 let stream = asset.into_read_stream()?;

src/runtime.rs

@@ -28,6 +28,10 @@ fn build_runtime() -> Arc<Runtime> {
 }
 
 pub fn runtime() -> Arc<Runtime> {
+    // Ensure settings are applied to the current thread
+    // This is important for Neon tasks that don't run on Tokio worker threads
+    crate::settings::apply_settings_to_current_thread();
+
     let cell = RUNTIME.get_or_init(|| RwLock::new(build_runtime()));
     cell.read().unwrap().clone()
 }

src/settings.rs

@@ -32,6 +32,14 @@ pub(crate) fn get_global_settings_toml() -> Option<String> {
     global_toml().read().unwrap().clone()
 }
 
+/// Apply settings to the current thread from the global TOML snapshot.
+/// This should be called whenever settings might be needed, as settings may have changed.
+pub(crate) fn apply_settings_to_current_thread() {
+    if let Some(toml) = get_global_settings_toml() {
+        let _ = Settings::from_toml(&toml);
+    }
+}
+
 /// Parse a JSON string (argument 0) into c2pa-rs Settings and apply them globally.
 /// Returns undefined; the JSON snapshot is stored globally for new worker threads.
 pub fn load_settings(mut cx: FunctionContext) -> JsResult<JsUndefined> {
@@ -47,6 +55,8 @@ pub fn load_settings(mut cx: FunctionContext) -> JsResult<JsUndefined> {
                 .or_else(|e| cx.throw_error(format!("Failed to get settings as TOML: {}", e)))?;
             // Save the JSON snapshot for new worker threads
             set_global_settings_toml(Some(toml_string));
+            // Apply settings to current thread
+            apply_settings_to_current_thread();
             reload_runtime();
             Ok(cx.undefined())
         }
@@ -68,6 +78,8 @@ pub fn load_settings_toml(mut cx: FunctionContext) -> JsResult<JsUndefined> {
                 .or_else(|e| cx.throw_error(format!("Failed to get settings as TOML: {}", e)))?;
             // Save the TOML snapshot for new worker threads
             set_global_settings_toml(Some(toml_string));
+            // Apply settings to current thread
+            apply_settings_to_current_thread();
             reload_runtime();
             Ok(cx.undefined())
         }
@@ -152,6 +164,7 @@ pub fn load_trust_config(mut cx: FunctionContext) -> JsResult<JsUndefined> {
             let full_toml = Settings::to_toml()
                 .or_else(|e| cx.throw_error(format!("Failed to get settings as TOML: {}", e)))?;
             set_global_settings_toml(Some(full_toml));
+            apply_settings_to_current_thread();
             reload_runtime();
             Ok(cx.undefined())
         }
@@ -202,6 +215,7 @@ pub fn load_cawg_trust_config(mut cx: FunctionContext) -> JsResult<JsUndefined>
             let full_toml = Settings::to_toml()
                 .or_else(|e| cx.throw_error(format!("Failed to get settings as TOML: {}", e)))?;
             set_global_settings_toml(Some(full_toml));
+            apply_settings_to_current_thread();
             reload_runtime();
             Ok(cx.undefined())
         }
@@ -424,6 +438,7 @@ pub fn load_verify_config(mut cx: FunctionContext) -> JsResult<JsUndefined> {
                 .or_else(|e| cx.throw_error(format!("Failed to get settings as TOML: {}", e)))?;
             // Save the TOML snapshot for new worker threads
             set_global_settings_toml(Some(toml_string));
+            apply_settings_to_current_thread();
             reload_runtime();
             Ok(cx.undefined())
         }
@@ -496,6 +511,7 @@ pub fn reset_settings(mut cx: FunctionContext) -> JsResult<JsUndefined> {
         Ok(_) => {
             // Store the default TOML for worker threads
             set_global_settings_toml(Some(default_toml));
+            apply_settings_to_current_thread();
             reload_runtime();
             Ok(cx.undefined())
         }