capdag 0.177.441 → 0.180.452

package/capdag.js

@@ -1118,7 +1118,7 @@ const MEDIA_COLLECTION_LIST = 'media:collection;list;record';
 // Media URN for adapter selection output - JSON record
 const MEDIA_ADAPTER_SELECTION = 'media:adapter-selection;json;record';
 // Fabric registry lookup wire types (consumed/produced by cap:lookup-cap;fabric
-// and cap:lookup-media-spec;fabric, both implemented by netaccesscartridge).
+// and cap:lookup-media-spec;fabric, both implemented by fetchcartridge).
 const MEDIA_CAP_URN = 'media:cap-urn;textable';
 const MEDIA_MEDIA_URN = 'media:media-urn;textable';
 const MEDIA_CAP_DEFINITION = 'media:cap-definition;json;record;textable';
@@ -1136,7 +1136,7 @@ const CAP_IDENTITY = 'cap:in=media:;out=media:';
 // Cartridges that inspect file content override this with a handler that returns {"media_urns": [...]}.
 const CAP_ADAPTER_SELECTION = 'cap:in="media:";out="media:adapter-selection;json;record"';
 
-// Fabric registry lookup caps. Implemented by netaccesscartridge.
+// Fabric registry lookup caps. Implemented by fetchcartridge.
 // CAP_LOOKUP_CAP_FABRIC resolves a canonical cap URN to its full flattened
 // cap definition; CAP_LOOKUP_MEDIA_SPEC_FABRIC does the same for media specs.
 const CAP_LOOKUP_CAP_FABRIC = 'cap:in="media:cap-urn;textable";fabric;lookup-cap;out="media:cap-definition;json;record;textable"';
@@ -2118,9 +2118,9 @@ class CapArg {
     this.required = required;
     this.is_sequence = options.is_sequence || false;
     this.sources = sources;  // Array of ArgSource
-    this.arg_description = options.arg_description || null;
+    this.arg_description = options.arg_description !== undefined ? options.arg_description : null;
     this.default_value = options.default_value !== undefined ? options.default_value : null;
-    this.metadata = options.metadata || null;
+    this.metadata = options.metadata !== undefined ? options.metadata : null;
   }
 
   /**
@@ -2154,11 +2154,15 @@ class CapArg {
       sources: this.sources.map(s => s.toJSON())
     };
     if (this.is_sequence) result.is_sequence = true;
-    if (this.arg_description) result.arg_description = this.arg_description;
+    if (this.arg_description !== null && this.arg_description !== undefined) {
+      result.arg_description = this.arg_description;
+    }
     if (this.default_value !== null && this.default_value !== undefined) {
       result.default_value = this.default_value;
     }
-    if (this.metadata) result.metadata = this.metadata;
+    if (this.metadata !== null && this.metadata !== undefined) {
+      result.metadata = this.metadata;
+    }
     return result;
   }
 
@@ -2618,10 +2622,10 @@ class CapManifest {
    * @param {CapGroup[]} capGroups - Cap groups (all caps must be in a group)
    */
   constructor(name, version, channel, registryUrl, description, capGroups = []) {
-    if (!name || typeof name !== 'string') {
+    if (typeof name !== 'string') {
       throw new Error('CapManifest name is required and must be a string');
     }
-    if (!version || typeof version !== 'string') {
+    if (typeof version !== 'string') {
       throw new Error('CapManifest version is required and must be a string');
     }
     if (channel !== 'release' && channel !== 'nightly') {
@@ -2630,7 +2634,7 @@ class CapManifest {
     if (registryUrl !== null && registryUrl !== undefined && typeof registryUrl !== 'string') {
       throw new Error("CapManifest registry_url must be null (dev build) or a string");
     }
-    if (!description || typeof description !== 'string') {
+    if (typeof description !== 'string') {
       throw new Error('CapManifest description is required and must be a string');
     }
 
@@ -2664,10 +2668,10 @@ class CapManifest {
    * @throws {Error} If required fields are missing or invalid
    */
   static fromJSON(json) {
-    if (!json.name) throw new Error('CapManifest missing required field: name');
-    if (!json.version) throw new Error('CapManifest missing required field: version');
-    if (!json.channel) throw new Error('CapManifest missing required field: channel');
-    if (!json.description) throw new Error('CapManifest missing required field: description');
+    if (!Object.prototype.hasOwnProperty.call(json, 'name')) throw new Error('CapManifest missing required field: name');
+    if (!Object.prototype.hasOwnProperty.call(json, 'version')) throw new Error('CapManifest missing required field: version');
+    if (!Object.prototype.hasOwnProperty.call(json, 'channel')) throw new Error('CapManifest missing required field: channel');
+    if (!Object.prototype.hasOwnProperty.call(json, 'description')) throw new Error('CapManifest missing required field: description');
     if (!Array.isArray(json.cap_groups)) throw new Error('CapManifest missing required field: cap_groups');
 
     // registry_url must be present as a key (may be null for dev builds)
@@ -2700,10 +2704,16 @@ class CapManifest {
       capGroups
     );
 
-    if (json.author && typeof json.author === 'string') {
+    if (Object.prototype.hasOwnProperty.call(json, 'author')) {
+      if (typeof json.author !== 'string') {
+        throw new Error('CapManifest author must be a string when present');
+      }
       manifest.author = json.author;
     }
-    if (json.page_url && typeof json.page_url === 'string') {
+    if (Object.prototype.hasOwnProperty.call(json, 'page_url')) {
+      if (typeof json.page_url !== 'string') {
+        throw new Error('CapManifest page_url must be a string when present');
+      }
       manifest.page_url = json.page_url;
     }
 
@@ -2723,8 +2733,8 @@ class CapManifest {
       description: this.description,
       cap_groups: this.cap_groups.map(g => g.toJSON())
     };
-    if (this.author) result.author = this.author;
-    if (this.page_url) result.page_url = this.page_url;
+    if (this.author !== null && this.author !== undefined) result.author = this.author;
+    if (this.page_url !== null && this.page_url !== undefined) result.page_url = this.page_url;
     return result;
   }
 }

package/capdag.test.js

@@ -5,7 +5,7 @@
 const {
   CapUrn, CapKind, CapUrnBuilder, CapMatcher, CapUrnError, ErrorCodes,
   MediaUrn, MediaUrnError, MediaUrnErrorCodes,
-  Cap, MediaSpec, MediaSpecError, MediaSpecErrorCodes,
+  Cap, CapGroup, CapManifest, MediaSpec, MediaSpecError, MediaSpecErrorCodes,
   resolveMediaUrn, buildExtensionIndex, mediaUrnsForExtension, getExtensionMappings,
   CartridgeInfo, CartridgeCapSummary, CartridgeSuggestion, CartridgeRepoClient, CartridgeRepoServer,
   CapFabEdge, CapFabStats, CapFab,
@@ -1209,6 +1209,152 @@ function test110_multipleExtensions() {
   assertEqual(resolved.extensions[1], 'jpeg', 'Second extension should be jpeg');
 }
 
+// TEST115: Test CapArg serialization and deserialization with multiple sources
+function test115_capArgSerialization() {
+  const arg = new CapArg(
+    MEDIA_STRING,
+    true,
+    [new ArgSource({ cli_flag: '--name' }), new ArgSource({ position: 0 })],
+    {
+      arg_description: 'The name argument',
+      default_value: 400,
+      metadata: { kind: 'example', flags: [true, false] }
+    }
+  );
+
+  const json = arg.toJSON();
+  assertEqual(json.media_urn, MEDIA_STRING, 'media_urn must serialize');
+  assertEqual(json.required, true, 'required must serialize');
+  assertEqual(json.arg_description, 'The name argument', 'arg_description must serialize');
+  assertEqual(json.default_value, 400, 'numeric default_value must serialize as number');
+  assertEqual(JSON.stringify(json.metadata), JSON.stringify({ kind: 'example', flags: [true, false] }),
+    'metadata must serialize as arbitrary JSON');
+
+  const roundTripped = CapArg.fromJSON(JSON.parse(JSON.stringify(json)));
+  assertEqual(roundTripped.media_urn, arg.media_urn, 'media_urn must round-trip');
+  assertEqual(roundTripped.required, arg.required, 'required must round-trip');
+  assertEqual(roundTripped.arg_description, arg.arg_description, 'arg_description must round-trip');
+  assertEqual(roundTripped.default_value, 400, 'numeric default_value must round-trip');
+  assertEqual(JSON.stringify(roundTripped.metadata), JSON.stringify({ kind: 'example', flags: [true, false] }),
+    'metadata must round-trip');
+  assertEqual(roundTripped.sources.length, 2, 'sources length must round-trip');
+  assertEqual(roundTripped.sources[0].cli_flag, '--name', 'cli_flag source must round-trip');
+  assertEqual(roundTripped.sources[1].position, 0, 'position source must round-trip');
+}
+
+// TEST116: Test CapArg constructor methods basic and with_description create args correctly
+function test116_capArgConstructors() {
+  const basicArg = new CapArg(
+    MEDIA_STRING,
+    true,
+    [new ArgSource({ cli_flag: '--name' })]
+  );
+  assertEqual(basicArg.media_urn, MEDIA_STRING, 'basic arg media_urn must match');
+  assertEqual(basicArg.required, true, 'basic arg required must match');
+  assertEqual(basicArg.sources.length, 1, 'basic arg must keep one source');
+  assertEqual(basicArg.arg_description, null, 'basic arg arg_description must be absent');
+  assertEqual(basicArg.default_value, null, 'basic arg default_value must be absent');
+
+  const describedArg = new CapArg(
+    MEDIA_INTEGER,
+    false,
+    [new ArgSource({ position: 0 })],
+    {
+      arg_description: 'The count argument',
+      default_value: 10
+    }
+  );
+  assertEqual(describedArg.media_urn, MEDIA_INTEGER, 'described arg media_urn must match');
+  assertEqual(describedArg.required, false, 'described arg required must match');
+  assertEqual(describedArg.arg_description, 'The count argument', 'described arg description must match');
+  assertEqual(describedArg.default_value, 10, 'described arg default_value must match');
+}
+
+// TEST150: JSON roundtrip
+function test150_capManifestJsonSerialization() {
+  const capUrn = CapUrn.fromString(testUrn('extract;target=metadata'));
+  const cap = new Cap(capUrn, 'Extract Metadata', 'extract-metadata');
+  cap.addArg(new CapArg('media:pdf', true, [new ArgSource({ stdin: 'media:pdf' })]));
+  cap.addArg(new CapArg(
+    'media:chunk-size;textable;numeric',
+    false,
+    [new ArgSource({ cli_flag: '--chunk-size' })],
+    {
+      arg_description: 'Chunk size',
+      default_value: 400,
+      metadata: { unit: 'words' }
+    }
+  ));
+  cap.addArg(new CapArg(
+    'media:timestamps;textable;bool',
+    false,
+    [new ArgSource({ cli_flag: '--timestamps' })],
+    {
+      arg_description: 'Include timestamps',
+      default_value: false
+    }
+  ));
+
+  const manifest = new CapManifest(
+    'TestComponent',
+    '0.1.0',
+    'release',
+    null,
+    'A test component',
+    [new CapGroup('default', [cap], [])]
+  );
+
+  manifest.author = 'Test Author';
+
+  const json = manifest.toJSON();
+  assertEqual(json.name, 'TestComponent', 'manifest name must serialize');
+  assertEqual(json.author, 'Test Author', 'author must serialize');
+  assert(Array.isArray(json.cap_groups), 'cap_groups must serialize');
+  assertEqual(json.cap_groups.length, 1, 'cap_groups length must serialize');
+  assertEqual(json.cap_groups[0].caps[0].args[1].default_value, 400, 'numeric default must serialize as number');
+  assertEqual(json.cap_groups[0].caps[0].args[1].metadata.unit, 'words', 'metadata must serialize');
+  assertEqual(json.cap_groups[0].caps[0].args[2].default_value, false, 'boolean default must serialize as boolean');
+
+  const roundTripped = CapManifest.fromJSON(JSON.parse(JSON.stringify(json)));
+  const decodedCap = roundTripped.allCaps()[0];
+  assertEqual(roundTripped.name, manifest.name, 'manifest name must round-trip');
+  assertEqual(roundTripped.author, 'Test Author', 'author must round-trip');
+  assertEqual(roundTripped.cap_groups.length, 1, 'cap_groups length must round-trip');
+  assertEqual(decodedCap.args[1].default_value, 400, 'numeric default must round-trip');
+  assertEqual(JSON.stringify(decodedCap.args[1].metadata), JSON.stringify({ unit: 'words' }),
+    'metadata must round-trip');
+  assertEqual(decodedCap.args[2].default_value, false, 'boolean default must round-trip');
+}
+
+// TEST597: CapArg::with_full_definition stores all fields including optional ones
+function test597_capArgWithFullDefinition() {
+  const arg = new CapArg(
+    MEDIA_STRING,
+    true,
+    [new ArgSource({ cli_flag: '--name' })],
+    {
+      arg_description: 'User name',
+      default_value: { chunk_size: 400, timestamps: false },
+      metadata: { hint: 'enter name' }
+    }
+  );
+
+  assertEqual(arg.media_urn, MEDIA_STRING, 'media_urn must match');
+  assertEqual(arg.required, true, 'required must match');
+  assertEqual(arg.arg_description, 'User name', 'arg_description must match');
+  assertEqual(JSON.stringify(arg.default_value), JSON.stringify({ chunk_size: 400, timestamps: false }),
+    'object default_value must be preserved');
+  assertEqual(JSON.stringify(arg.metadata), JSON.stringify({ hint: 'enter name' }),
+    'metadata must be preserved');
+
+  const roundTripped = CapArg.fromJSON(JSON.parse(JSON.stringify(arg.toJSON())));
+  assertEqual(roundTripped.arg_description, 'User name', 'arg_description must round-trip');
+  assertEqual(JSON.stringify(roundTripped.default_value), JSON.stringify({ chunk_size: 400, timestamps: false }),
+    'object default_value must round-trip');
+  assertEqual(JSON.stringify(roundTripped.metadata), JSON.stringify({ hint: 'enter name' }),
+    'metadata must round-trip');
+}
+
 // ============================================================================
 // cap_fab: browse-mode API used by cap-fab-renderer.js
 //
@@ -5785,6 +5931,10 @@ async function runTests() {
   runTest('TEST108: extensions_serialization', test108_extensionsSerialization);
   runTest('TEST109: extensions_with_metadata_and_validation', test109_extensionsWithMetadataAndValidation);
   runTest('TEST110: multiple_extensions', test110_multipleExtensions);
+  runTest('TEST115: cap_arg_serialization', test115_capArgSerialization);
+  runTest('TEST116: cap_arg_constructors', test116_capArgConstructors);
+  runTest('TEST150: cap_manifest_json_serialization', test150_capManifestJsonSerialization);
+  runTest('TEST597: cap_arg_with_full_definition', test597_capArgWithFullDefinition);
 
   // cap-fab-renderer.js uses CapFab in browse mode (static registry from
   // /api/capabilities). These tests guard the minimal API the renderer relies

package/package.json

@@ -40,5 +40,5 @@
     "pretest": "npm run build:parser",
     "test": "node capdag.test.js"
   },
-  "version": "0.177.441"
+  "version": "0.180.452"
 }