capns 0.83.18915 → 0.85.19364

package/capns.js

@@ -349,8 +349,10 @@ class CapUrn {
     }
 
     // Direction specs: TaggedUrn semantic matching via MediaUrn
-    // Check in_urn: cap's input spec (pattern) accepts request's input (instance)
-    if (this.inSpec !== '*' && request.inSpec !== '*') {
+    // Check in_urn: cap's input spec (pattern) accepts request's input (instance).
+    // "media:" on the PATTERN side (this.inSpec) means "I accept any input" — skip check.
+    // "*" is also treated as wildcard. "media:" on the instance side still participates.
+    if (this.inSpec !== '*' && this.inSpec !== 'media:' && request.inSpec !== '*') {
       const capIn = TaggedUrn.fromString(this.inSpec);
       const requestIn = TaggedUrn.fromString(request.inSpec);
       if (!capIn.accepts(requestIn)) {
@@ -358,8 +360,10 @@ class CapUrn {
       }
     }
 
-    // Check out_urn: cap's output (instance) conforms to request's output (pattern)
-    if (this.outSpec !== '*' && request.outSpec !== '*') {
+    // Check out_urn: cap's output (instance) conforms to request's output (pattern).
+    // "media:" on the PATTERN side (this.outSpec) means "I accept any output" — skip check.
+    // "*" is also treated as wildcard. "media:" on the instance side still participates.
+    if (this.outSpec !== '*' && this.outSpec !== 'media:' && request.outSpec !== '*') {
       const capOut = TaggedUrn.fromString(this.outSpec);
       const requestOut = TaggedUrn.fromString(request.outSpec);
       if (!capOut.conformsTo(requestOut)) {
@@ -728,18 +732,18 @@ const MEDIA_INTEGER_ARRAY = 'media:integer;textable;numeric;form=list';
 const MEDIA_NUMBER_ARRAY = 'media:textable;numeric;form=list';
 const MEDIA_BOOLEAN_ARRAY = 'media:bool;textable;form=list';
 const MEDIA_OBJECT_ARRAY = 'media:form=list;textable';
-const MEDIA_BINARY = 'media:bytes';
+const MEDIA_BINARY = 'media:';
 const MEDIA_VOID = 'media:void';
 // Semantic content types
-const MEDIA_PNG = 'media:image;png;bytes';
-const MEDIA_AUDIO = 'media:wav;audio;bytes;';
-const MEDIA_VIDEO = 'media:video;bytes';
+const MEDIA_PNG = 'media:image;png';
+const MEDIA_AUDIO = 'media:wav;audio';
+const MEDIA_VIDEO = 'media:video';
 // Semantic AI input types
-const MEDIA_AUDIO_SPEECH = 'media:audio;wav;bytes;speech';
-const MEDIA_IMAGE_THUMBNAIL = 'media:image;png;bytes;thumbnail';
+const MEDIA_AUDIO_SPEECH = 'media:audio;wav;speech';
+const MEDIA_IMAGE_THUMBNAIL = 'media:image;png;thumbnail';
 // Document types (PRIMARY naming - type IS the format)
-const MEDIA_PDF = 'media:pdf;bytes';
-const MEDIA_EPUB = 'media:epub;bytes';
+const MEDIA_PDF = 'media:pdf';
+const MEDIA_EPUB = 'media:epub';
 // Text format types (PRIMARY naming - type IS the format)
 const MEDIA_MD = 'media:md;textable';
 const MEDIA_TXT = 'media:txt;textable';
@@ -767,6 +771,12 @@ const MEDIA_PATH_OUTPUT = 'media:model-path;textable;form=map';
 // Semantic output types - inference
 const MEDIA_EMBEDDING_VECTOR = 'media:embedding-vector;textable;form=map';
 const MEDIA_LLM_INFERENCE_OUTPUT = 'media:generated-text;textable;form=map';
+// File path types
+const MEDIA_FILE_PATH = 'media:file-path;textable;form=scalar';
+const MEDIA_FILE_PATH_ARRAY = 'media:file-path;textable;form=list';
+// Collection types
+const MEDIA_COLLECTION = 'media:collection;textable;form=map';
+const MEDIA_COLLECTION_LIST = 'media:collection;textable;form=list';
 
 // =============================================================================
 // STANDARD CAP URN CONSTANTS
@@ -815,7 +825,7 @@ class MediaUrn {
 
   /**
    * Parse a media URN string. Validates the prefix is 'media'.
-   * @param {string} str - The media URN string (e.g., "media:bytes")
+   * @param {string} str - The media URN string (e.g., "media:pdf")
    * @returns {MediaUrn}
    * @throws {MediaUrnError} If prefix is not 'media'
    */
@@ -824,8 +834,8 @@ class MediaUrn {
     return new MediaUrn(urn);
   }
 
-  /** @returns {boolean} True if the "bytes" marker tag is present */
-  isBinary() { return this._urn.getTag('bytes') !== undefined; }
+  /** @returns {boolean} True if the "textable" marker tag is NOT present (binary = not textable) */
+  isBinary() { return this._urn.getTag('textable') === undefined; }
 
   /** @returns {boolean} True if form=map tag is present */
   isMap() { return this._urn.hasTag('form', 'map'); }
@@ -848,6 +858,33 @@ class MediaUrn {
   /** @returns {boolean} True if the "void" marker tag is present */
   isVoid() { return this._urn.getTag('void') !== undefined; }
 
+  /** @returns {boolean} True if the "image" marker tag is present */
+  isImage() { return this._urn.getTag('image') !== undefined; }
+
+  /** @returns {boolean} True if the "audio" marker tag is present */
+  isAudio() { return this._urn.getTag('audio') !== undefined; }
+
+  /** @returns {boolean} True if the "video" marker tag is present */
+  isVideo() { return this._urn.getTag('video') !== undefined; }
+
+  /** @returns {boolean} True if the "numeric" marker tag is present */
+  isNumeric() { return this._urn.getTag('numeric') !== undefined; }
+
+  /** @returns {boolean} True if the "bool" marker tag is present */
+  isBool() { return this._urn.getTag('bool') !== undefined; }
+
+  /** @returns {boolean} True if "file-path" marker tag is present AND NOT form=list */
+  isFilePath() { return this._urn.getTag('file-path') !== undefined && !this.isList(); }
+
+  /** @returns {boolean} True if "file-path" marker tag is present AND form=list */
+  isFilePathArray() { return this._urn.getTag('file-path') !== undefined && this.isList(); }
+
+  /** @returns {boolean} True if "file-path" marker tag is present (single or array) */
+  isAnyFilePath() { return this.isFilePath() || this.isFilePathArray(); }
+
+  /** @returns {boolean} True if the "collection" marker tag is present */
+  isCollection() { return this._urn.getTag('collection') !== undefined; }
+
   /**
    * Check if this media URN conforms to another (pattern).
    * @param {MediaUrn} pattern
@@ -1036,7 +1073,7 @@ class MediaSpec {
     return this._parsedMediaUrn;
   }
 
-  /** @returns {boolean} True if binary (bytes marker tag present) */
+  /** @returns {boolean} True if binary (textable marker tag absent) */
   isBinary() {
     const mu = this.parsedMediaUrn();
     return mu ? mu.isBinary() : false;
@@ -1243,7 +1280,7 @@ function buildExtensionIndex(mediaSpecs) {
  *
  * @example
  * const urns = mediaUrnsForExtension('pdf', mediaSpecs);
- * // May return ['media:pdf;bytes']
+ * // May return ['media:pdf']
  */
 function mediaUrnsForExtension(extension, mediaSpecs) {
   const index = buildExtensionIndex(mediaSpecs);
@@ -4123,6 +4160,12 @@ module.exports = {
   // Semantic output types - inference
   MEDIA_EMBEDDING_VECTOR,
   MEDIA_LLM_INFERENCE_OUTPUT,
+  // File path types
+  MEDIA_FILE_PATH,
+  MEDIA_FILE_PATH_ARRAY,
+  // Collection types
+  MEDIA_COLLECTION,
+  MEDIA_COLLECTION_LIST,
   // Unified argument type
   CapArgumentValue,
   // Standard cap URN builders

package/capns.test.js

@@ -21,7 +21,11 @@ const {
   MEDIA_PDF, MEDIA_EPUB, MEDIA_MD, MEDIA_TXT, MEDIA_RST, MEDIA_LOG,
   MEDIA_HTML, MEDIA_XML, MEDIA_JSON, MEDIA_YAML, MEDIA_JSON_SCHEMA,
   MEDIA_MODEL_SPEC, MEDIA_AVAILABILITY_OUTPUT, MEDIA_PATH_OUTPUT,
-  MEDIA_LLM_INFERENCE_OUTPUT
+  MEDIA_LLM_INFERENCE_OUTPUT,
+  MEDIA_FILE_PATH, MEDIA_FILE_PATH_ARRAY,
+  MEDIA_COLLECTION, MEDIA_COLLECTION_LIST,
+  MEDIA_DECISION, MEDIA_DECISION_ARRAY,
+  MEDIA_AUDIO_SPEECH, MEDIA_IMAGE_THUMBNAIL
 } = require('./capns.js');
 
 // ============================================================================
@@ -437,12 +441,12 @@ function test025_bestMatch() {
 // TEST026: merge combines tags, subset keeps only specified
 function test026_mergeAndSubset() {
   const cap1 = CapUrn.fromString(testUrn('op=generate'));
-  const cap2 = CapUrn.fromString('cap:in="media:textable;form=scalar";ext=pdf;format=binary;out="media:bytes"');
+  const cap2 = CapUrn.fromString('cap:in="media:textable;form=scalar";ext=pdf;format=binary;out="media:"');
 
   // Merge (other takes precedence)
   const merged = cap1.merge(cap2);
   assertEqual(merged.getInSpec(), 'media:textable;form=scalar', 'Merge should take inSpec from other');
-  assertEqual(merged.getOutSpec(), 'media:bytes', 'Merge should take outSpec from other');
+  assertEqual(merged.getOutSpec(), 'media:', 'Merge should take outSpec from other');
   assertEqual(merged.getTag('op'), 'generate', 'Merge should keep original tags');
   assertEqual(merged.getTag('ext'), 'pdf', 'Merge should add other tags');
 
@@ -643,8 +647,8 @@ function test046_matchingSemanticsFallbackPattern() {
 
 // TEST047: Thumbnail with void input matches specific ext request
 function test047_matchingSemanticsThumbnailVoidInput() {
-  const cap = CapUrn.fromString('cap:in="media:void";op=generate_thumbnail;out="media:image;png;bytes;thumbnail"');
-  const request = CapUrn.fromString('cap:ext=pdf;in="media:void";op=generate_thumbnail;out="media:image;bytes"');
+  const cap = CapUrn.fromString('cap:in="media:void";op=generate_thumbnail;out="media:image;png;thumbnail"');
+  const request = CapUrn.fromString('cap:ext=pdf;in="media:void";op=generate_thumbnail;out="media:image"');
   assert(cap.accepts(request), 'Void input cap should accept request; cap output conforms to less-specific request output');
 }
 
@@ -662,7 +666,7 @@ function test049_matchingSemanticsCrossDimension() {
   assert(cap.accepts(request), 'Independent tags should not block matching');
 }
 
-// TEST050: media:string vs media:bytes -> no match
+// TEST050: media:string vs media: (wildcard) -> no match
 function test050_matchingSemanticsDirectionMismatch() {
   const cap = CapUrn.fromString(
     `cap:in="${MEDIA_STRING}";op=generate;out="${MEDIA_OBJECT}"`
@@ -673,79 +677,79 @@ function test050_matchingSemanticsDirectionMismatch() {
   assert(!cap.accepts(request), 'Incompatible direction types should not match');
 }
 
-// TEST051: Generic media:bytes provider accepts media:pdf;bytes request;
-//          specific pdf cap rejects generic bytes request;
+// TEST051: Generic media: (wildcard) provider accepts media:pdf request;
+//          specific pdf cap rejects generic wildcard request;
 //          output direction: more specific output satisfies less specific request
 function test051_directionSemanticMatching() {
-  // Generic bytes cap accepts specific pdf;bytes request
+  // Generic wildcard cap accepts specific pdf request
   const genericCap = CapUrn.fromString(
-    'cap:in="media:bytes";op=generate_thumbnail;out="media:image;png;bytes;thumbnail"'
+    'cap:in="media:";op=generate_thumbnail;out="media:image;png;thumbnail"'
   );
   const pdfRequest = CapUrn.fromString(
-    'cap:in="media:pdf;bytes";op=generate_thumbnail;out="media:image;png;bytes;thumbnail"'
+    'cap:in="media:pdf";op=generate_thumbnail;out="media:image;png;thumbnail"'
   );
-  assert(genericCap.accepts(pdfRequest), 'Generic bytes cap must accept pdf;bytes request');
+  assert(genericCap.accepts(pdfRequest), 'Generic wildcard cap must accept pdf request');
 
-  // Also accepts epub;bytes
+  // Also accepts epub
   const epubRequest = CapUrn.fromString(
-    'cap:in="media:epub;bytes";op=generate_thumbnail;out="media:image;png;bytes;thumbnail"'
+    'cap:in="media:epub";op=generate_thumbnail;out="media:image;png;thumbnail"'
   );
-  assert(genericCap.accepts(epubRequest), 'Generic bytes cap must accept epub;bytes request');
+  assert(genericCap.accepts(epubRequest), 'Generic wildcard cap must accept epub request');
 
   // Reverse: specific pdf cap does NOT accept generic bytes request
   const pdfCap = CapUrn.fromString(
-    'cap:in="media:pdf;bytes";op=generate_thumbnail;out="media:image;png;bytes;thumbnail"'
+    'cap:in="media:pdf";op=generate_thumbnail;out="media:image;png;thumbnail"'
   );
   const genericRequest = CapUrn.fromString(
-    'cap:in="media:bytes";op=generate_thumbnail;out="media:image;png;bytes;thumbnail"'
+    'cap:in="media:";op=generate_thumbnail;out="media:image;png;thumbnail"'
   );
-  assert(!pdfCap.accepts(genericRequest), 'Specific pdf cap must NOT accept generic bytes request');
+  assert(!pdfCap.accepts(genericRequest), 'Specific pdf cap must NOT accept generic wildcard request');
 
   // PDF cap does NOT accept epub request
   assert(!pdfCap.accepts(epubRequest), 'PDF cap must NOT accept epub request');
 
   // Output direction: cap producing more specific output satisfies less specific request
   const specificOutCap = CapUrn.fromString(
-    'cap:in="media:bytes";op=generate_thumbnail;out="media:image;png;bytes;thumbnail"'
+    'cap:in="media:";op=generate_thumbnail;out="media:image;png;thumbnail"'
   );
   const genericOutRequest = CapUrn.fromString(
-    'cap:in="media:bytes";op=generate_thumbnail;out="media:image;bytes"'
+    'cap:in="media:";op=generate_thumbnail;out="media:image"'
   );
   assert(specificOutCap.accepts(genericOutRequest),
-    'Cap producing image;png;bytes;thumbnail must satisfy request for image;bytes');
+    'Cap producing image;png;thumbnail must satisfy request for image');
 
   // Reverse output: generic output cap does NOT satisfy specific output request
   const genericOutCap = CapUrn.fromString(
-    'cap:in="media:bytes";op=generate_thumbnail;out="media:image;bytes"'
+    'cap:in="media:";op=generate_thumbnail;out="media:image"'
   );
   const specificOutRequest = CapUrn.fromString(
-    'cap:in="media:bytes";op=generate_thumbnail;out="media:image;png;bytes;thumbnail"'
+    'cap:in="media:";op=generate_thumbnail;out="media:image;png;thumbnail"'
   );
   assert(!genericOutCap.accepts(specificOutRequest),
     'Generic output cap must NOT satisfy specific output request');
 }
 
-// TEST052: Specificity: media:bytes(1 tag) + image;png;bytes;thumbnail(4 tags) + op(1) = 6;
-//          pdf;bytes(2) = 7; CapMatcher prefers higher
+// TEST052: Specificity: media:(0 tags) + image;png;thumbnail(3 tags) + op(1) = 4;
+//          pdf(1) + image;png;thumbnail(3) + op(1) = 5; CapMatcher prefers higher
 function test052_directionSemanticSpecificity() {
   const genericCap = CapUrn.fromString(
-    'cap:in="media:bytes";op=generate_thumbnail;out="media:image;png;bytes;thumbnail"'
+    'cap:in="media:";op=generate_thumbnail;out="media:image;png;thumbnail"'
   );
   const specificCap = CapUrn.fromString(
-    'cap:in="media:pdf;bytes";op=generate_thumbnail;out="media:image;png;bytes;thumbnail"'
+    'cap:in="media:pdf";op=generate_thumbnail;out="media:image;png;thumbnail"'
   );
 
-  assertEqual(genericCap.specificity(), 6, 'bytes(1) + image;png;bytes;thumbnail(4) + op(1) = 6');
-  assertEqual(specificCap.specificity(), 7, 'pdf;bytes(2) + image;png;bytes;thumbnail(4) + op(1) = 7');
-  assert(specificCap.specificity() > genericCap.specificity(), 'pdf;bytes should be more specific');
+  assertEqual(genericCap.specificity(), 4, 'media:(0) + image;png;thumbnail(3) + op(1) = 4');
+  assertEqual(specificCap.specificity(), 5, 'pdf(1) + image;png;thumbnail(3) + op(1) = 5');
+  assert(specificCap.specificity() > genericCap.specificity(), 'pdf should be more specific');
 
   // CapMatcher should prefer more specific
   const pdfRequest = CapUrn.fromString(
-    'cap:in="media:pdf;bytes";op=generate_thumbnail;out="media:image;png;bytes;thumbnail"'
+    'cap:in="media:pdf";op=generate_thumbnail;out="media:image;png;thumbnail"'
   );
   const best = CapMatcher.findBestMatch([genericCap, specificCap], pdfRequest);
   assert(best !== null, 'Should find a match');
-  assertEqual(best.getInSpec(), 'media:pdf;bytes', 'Should prefer more specific pdf;bytes cap');
+  assertEqual(best.getInSpec(), 'media:pdf', 'Should prefer more specific pdf cap');
 }
 
 // ============================================================================
@@ -807,13 +811,20 @@ function test060_wrongPrefixFails() {
   );
 }
 
-// TEST061: isBinary true for media:bytes, MEDIA_PNG, MEDIA_PDF, MEDIA_BINARY; false for media:textable
+// TEST061: isBinary true when textable tag is absent (binary = not textable)
 function test061_isBinary() {
-  assert(MediaUrn.fromString('media:bytes').isBinary(), 'media:bytes should be binary');
+  // Binary types: no textable tag
+  assert(MediaUrn.fromString(MEDIA_BINARY).isBinary(), 'MEDIA_BINARY (media:) should be binary');
   assert(MediaUrn.fromString(MEDIA_PNG).isBinary(), 'MEDIA_PNG should be binary');
   assert(MediaUrn.fromString(MEDIA_PDF).isBinary(), 'MEDIA_PDF should be binary');
-  assert(MediaUrn.fromString(MEDIA_BINARY).isBinary(), 'MEDIA_BINARY should be binary');
+  assert(MediaUrn.fromString('media:video').isBinary(), 'media:video should be binary');
+  assert(MediaUrn.fromString('media:epub').isBinary(), 'media:epub should be binary');
+  // Textable types: is_binary is false
   assert(!MediaUrn.fromString('media:textable').isBinary(), 'media:textable should not be binary');
+  assert(!MediaUrn.fromString('media:textable;form=map').isBinary(), 'textable map should not be binary');
+  assert(!MediaUrn.fromString(MEDIA_STRING).isBinary(), 'MEDIA_STRING should not be binary');
+  assert(!MediaUrn.fromString(MEDIA_JSON).isBinary(), 'MEDIA_JSON should not be binary');
+  assert(!MediaUrn.fromString(MEDIA_MD).isBinary(), 'MEDIA_MD should not be binary');
 }
 
 // TEST062: isMap true for MEDIA_OBJECT (form=map); false for MEDIA_STRING (form=scalar), MEDIA_STRING_ARRAY (form=list)
@@ -907,7 +918,7 @@ function test072_constantsParse() {
 
 // TEST073: N/A for JS (Rust has binary_media_urn_for_ext/text_media_urn_for_ext)
 
-// TEST074: MEDIA_PDF (media:pdf;bytes) conformsTo media:pdf; MEDIA_MD conformsTo media:md; same URNs conform
+// TEST074: MEDIA_PDF (media:pdf) conformsTo media:pdf; MEDIA_MD conformsTo media:md; same URNs conform
 function test074_mediaUrnMatching() {
   const pdfUrn = MediaUrn.fromString(MEDIA_PDF);
   const pdfPattern = MediaUrn.fromString('media:pdf');
@@ -934,11 +945,11 @@ function test075_accepts() {
 
 // TEST076: More tags = higher specificity
 function test076_specificity() {
-  const s1 = MediaUrn.fromString('media:bytes');
-  const s2 = MediaUrn.fromString('media:pdf;bytes');
-  const s3 = MediaUrn.fromString('media:image;png;bytes;thumbnail');
-  assert(s2.specificity() > s1.specificity(), 'pdf;bytes should be more specific than bytes');
-  assert(s3.specificity() > s2.specificity(), 'image;png;bytes;thumbnail should be more specific than pdf;bytes');
+  const s1 = MediaUrn.fromString('media:');
+  const s2 = MediaUrn.fromString('media:pdf');
+  const s3 = MediaUrn.fromString('media:image;png;thumbnail');
+  assert(s2.specificity() > s1.specificity(), 'pdf should be more specific than wildcard');
+  assert(s3.specificity() > s2.specificity(), 'image;png;thumbnail should be more specific than pdf');
 }
 
 // TEST077: N/A for JS (Rust serde) - but we test JSON.stringify round-trip
@@ -1011,7 +1022,7 @@ function test093_resolveUnresolvableFailsHard() {
 // TEST097: N/A for JS (Rust validation function)
 // TEST098: N/A for JS
 
-// TEST099: MediaSpec with media:bytes -> isBinary() true
+// TEST099: MediaSpec with media: (no textable tag) -> isBinary() true
 function test099_resolvedIsBinary() {
   const spec = new MediaSpec('application/octet-stream', null, null, 'Binary', null, MEDIA_BINARY);
   assert(spec.isBinary(), 'Resolved binary spec should be binary');
@@ -1093,13 +1104,13 @@ function test106_metadataWithValidation() {
 function test107_extensionsPropagation() {
   const mediaSpecs = [
     {
-      urn: 'media:pdf;bytes',
+      urn: 'media:pdf',
       media_type: 'application/pdf',
       title: 'PDF Document',
       extensions: ['pdf']
     }
   ];
-  const resolved = resolveMediaUrn('media:pdf;bytes', mediaSpecs);
+  const resolved = resolveMediaUrn('media:pdf', mediaSpecs);
   assert(Array.isArray(resolved.extensions), 'Extensions should be an array');
   assertEqual(resolved.extensions.length, 1, 'Should have one extension');
   assertEqual(resolved.extensions[0], 'pdf', 'Should have pdf extension');
@@ -1108,7 +1119,7 @@ function test107_extensionsPropagation() {
 // TEST108: N/A for JS (Rust serde) - but we test MediaSpec with extensions
 function test108_extensionsSerialization() {
   // Test that MediaSpec can hold extensions correctly
-  const spec = new MediaSpec('application/pdf', null, null, 'PDF', null, 'media:pdf;bytes', null, null, ['pdf']);
+  const spec = new MediaSpec('application/pdf', null, null, 'PDF', null, 'media:pdf', null, null, ['pdf']);
   assert(Array.isArray(spec.extensions), 'Extensions should be array');
   assertEqual(spec.extensions[0], 'pdf', 'Should have pdf extension');
 }
@@ -1136,13 +1147,13 @@ function test109_extensionsWithMetadataAndValidation() {
 function test110_multipleExtensions() {
   const mediaSpecs = [
     {
-      urn: 'media:image;jpeg;bytes',
+      urn: 'media:image;jpeg',
       media_type: 'image/jpeg',
       title: 'JPEG Image',
       extensions: ['jpg', 'jpeg']
     }
   ];
-  const resolved = resolveMediaUrn('media:image;jpeg;bytes', mediaSpecs);
+  const resolved = resolveMediaUrn('media:image;jpeg', mediaSpecs);
   assertEqual(resolved.extensions.length, 2, 'Should have two extensions');
   assertEqual(resolved.extensions[0], 'jpg', 'First extension should be jpg');
   assertEqual(resolved.extensions[1], 'jpeg', 'Second extension should be jpeg');
@@ -1520,7 +1531,7 @@ function test157_stdinSourceFromFileReference() {
   const trackedFileId = 'tracked-file-123';
   const originalPath = '/path/to/original.pdf';
   const securityBookmark = new Uint8Array([0x62, 0x6f, 0x6f, 0x6b]);
-  const mediaUrn = 'media:pdf;bytes';
+  const mediaUrn = 'media:pdf';
 
   const source = StdinSource.fromFileReference(trackedFileId, originalPath, securityBookmark, mediaUrn);
   assert(source !== null, 'Should create source');
@@ -1576,7 +1587,7 @@ function test276_capArgumentValueAsStrValid() {
 
 // TEST277: CapArgumentValue.valueAsStr fails for non-UTF-8 binary data
 function test277_capArgumentValueAsStrInvalidUtf8() {
-  const arg = new CapArgumentValue('media:pdf;bytes', new Uint8Array([0xFF, 0xFE, 0x80]));
+  const arg = new CapArgumentValue('media:pdf', new Uint8Array([0xFF, 0xFE, 0x80]));
   let threw = false;
   try {
     arg.valueAsStr();
@@ -1607,7 +1618,7 @@ function test283_capArgumentValueLargeBinary() {
   for (let i = 0; i < 10000; i++) {
     data[i] = i % 256;
   }
-  const arg = new CapArgumentValue('media:pdf;bytes', data);
+  const arg = new CapArgumentValue('media:pdf', data);
   assertEqual(arg.value.length, 10000, 'large binary must preserve all bytes');
   assertEqual(arg.value[0], 0, 'first byte check');
   assertEqual(arg.value[255], 255, 'byte 255 check');
@@ -1625,7 +1636,7 @@ function test304_mediaAvailabilityOutputConstant() {
   const urn = TaggedUrn.fromString(MEDIA_AVAILABILITY_OUTPUT);
   assert(urn.getTag('textable') !== undefined, 'model-availability must be textable');
   assertEqual(urn.getTag('form'), 'map', 'model-availability must be form=map');
-  assert(urn.getTag('bytes') === undefined, 'model-availability must not be binary');
+  assert(urn.getTag('textable') !== undefined, 'model-availability must not be binary (has textable)');
   const reparsed = TaggedUrn.fromString(urn.toString());
   assert(urn.conformsTo(reparsed), 'roundtrip must match original');
 }
@@ -1635,7 +1646,7 @@ function test305_mediaPathOutputConstant() {
   const urn = TaggedUrn.fromString(MEDIA_PATH_OUTPUT);
   assert(urn.getTag('textable') !== undefined, 'model-path must be textable');
   assertEqual(urn.getTag('form'), 'map', 'model-path must be form=map');
-  assert(urn.getTag('bytes') === undefined, 'model-path must not be binary');
+  assert(urn.getTag('textable') !== undefined, 'model-path must not be binary (has textable)');
   const reparsed = TaggedUrn.fromString(urn.toString());
   assert(urn.conformsTo(reparsed), 'roundtrip must match original');
 }
@@ -1727,8 +1738,8 @@ function test312_allUrnBuildersProduceValidUrns() {
 
 function testJS_buildExtensionIndex() {
   const mediaSpecs = [
-    { urn: 'media:pdf;bytes', media_type: 'application/pdf', extensions: ['pdf'] },
-    { urn: 'media:image;jpeg;bytes', media_type: 'image/jpeg', extensions: ['jpg', 'jpeg'] },
+    { urn: 'media:pdf', media_type: 'application/pdf', extensions: ['pdf'] },
+    { urn: 'media:image;jpeg', media_type: 'image/jpeg', extensions: ['jpg', 'jpeg'] },
     { urn: 'media:json;textable', media_type: 'application/json', extensions: ['json'] }
   ];
   const index = buildExtensionIndex(mediaSpecs);
@@ -1738,12 +1749,12 @@ function testJS_buildExtensionIndex() {
   assert(index.has('jpg'), 'Should have jpg');
   assert(index.has('jpeg'), 'Should have jpeg');
   assert(index.has('json'), 'Should have json');
-  assertEqual(index.get('pdf')[0], 'media:pdf;bytes', 'pdf should map correctly');
+  assertEqual(index.get('pdf')[0], 'media:pdf', 'pdf should map correctly');
 }
 
 function testJS_mediaUrnsForExtension() {
   const mediaSpecs = [
-    { urn: 'media:pdf;bytes', media_type: 'application/pdf', extensions: ['pdf'] },
+    { urn: 'media:pdf', media_type: 'application/pdf', extensions: ['pdf'] },
     { urn: 'media:json;textable;form=map', media_type: 'application/json', extensions: ['json'] },
     { urn: 'media:json;textable;form=list', media_type: 'application/json', extensions: ['json'] }
   ];
@@ -1771,8 +1782,8 @@ function testJS_mediaUrnsForExtension() {
 
 function testJS_getExtensionMappings() {
   const mediaSpecs = [
-    { urn: 'media:pdf;bytes', media_type: 'application/pdf', extensions: ['pdf'] },
-    { urn: 'media:image;jpeg;bytes', media_type: 'image/jpeg', extensions: ['jpg', 'jpeg'] }
+    { urn: 'media:pdf', media_type: 'application/pdf', extensions: ['pdf'] },
+    { urn: 'media:image;jpeg', media_type: 'image/jpeg', extensions: ['jpg', 'jpeg'] }
   ];
   const mappings = getExtensionMappings(mediaSpecs);
   assert(Array.isArray(mappings), 'Should return an array');
@@ -1881,7 +1892,7 @@ function testJS_binaryArgPassedToExecuteCap() {
   const cube = new CapBlock();
   cube.addRegistry('test', registry);
 
-  const binaryArg = new CapArgumentValue('media:pdf;bytes', new Uint8Array([0x89, 0x50, 0x4E, 0x47]));
+  const binaryArg = new CapArgumentValue('media:pdf', new Uint8Array([0x89, 0x50, 0x4E, 0x47]));
   const { compositeHost } = cube.can('cap:in="media:void";op=test;out="media:string"');
 
   return compositeHost.executeCap(
@@ -1889,7 +1900,7 @@ function testJS_binaryArgPassedToExecuteCap() {
     [binaryArg]
   ).then(() => {
     assert(receivedArgs !== null, 'Should receive arguments');
-    assertEqual(receivedArgs[0].mediaUrn, 'media:pdf;bytes', 'Correct mediaUrn');
+    assertEqual(receivedArgs[0].mediaUrn, 'media:pdf', 'Correct mediaUrn');
     assertEqual(receivedArgs[0].value[0], 0x89, 'First byte check');
     assertEqual(receivedArgs[0].value.length, 4, 'Correct data length');
   });
@@ -1926,12 +1937,12 @@ const sampleRegistry = {
       tags: ['pdf', 'extractor'],
       caps: [
         {
-          urn: 'cap:in="media:pdf;bytes";op=disbind;out="media:disbound-page;textable;form=list"',
+          urn: 'cap:in="media:pdf";op=disbind;out="media:disbound-page;textable;form=list"',
           title: 'Disbind PDF',
           description: 'Extract pages'
         },
         {
-          urn: 'cap:in="media:pdf;bytes";op=extract_metadata;out="media:file-metadata;textable;form=map"',
+          urn: 'cap:in="media:pdf";op=extract_metadata;out="media:file-metadata;textable;form=map"',
           title: 'Extract Metadata',
           description: 'Get PDF metadata'
         }
@@ -2139,13 +2150,13 @@ function test328_pluginRepoServerGetByCategory() {
 function test329_pluginRepoServerGetByCap() {
   const server = new PluginRepoServer(sampleRegistry);
 
-  const disbindCap = 'cap:in="media:pdf;bytes";op=disbind;out="media:disbound-page;textable;form=list"';
+  const disbindCap = 'cap:in="media:pdf";op=disbind;out="media:disbound-page;textable;form=list"';
   const plugins = server.getPluginsByCap(disbindCap);
 
   assert(plugins.length === 1, 'Should find 1 plugin with this cap');
   assert(plugins[0].id === 'pdfcartridge', 'Should be pdfcartridge');
 
-  const metadataCap = 'cap:in="media:pdf;bytes";op=extract_metadata;out="media:file-metadata;textable;form=map"';
+  const metadataCap = 'cap:in="media:pdf";op=extract_metadata;out="media:file-metadata;textable;form=map"';
   const metadataPlugins = server.getPluginsByCap(metadataCap);
   assert(metadataPlugins.length === 1, 'Should find metadata cap');
 }
@@ -2172,7 +2183,7 @@ function test331_pluginRepoClientGetSuggestions() {
 
   client.updateCache('https://example.com/api/plugins', plugins);
 
-  const disbindCap = 'cap:in="media:pdf;bytes";op=disbind;out="media:disbound-page;textable;form=list"';
+  const disbindCap = 'cap:in="media:pdf";op=disbind;out="media:disbound-page;textable;form=list"';
   const suggestions = client.getSuggestionsForCap(disbindCap);
 
   assert(suggestions.length === 1, 'Should find 1 suggestion');
@@ -2250,7 +2261,7 @@ function test335_pluginRepoServerClientIntegration() {
   assert(plugin.hasBinary(), 'Plugin should have binary');
 
   // Client can get suggestions
-  const capUrn = 'cap:in="media:pdf;bytes";op=disbind;out="media:disbound-page;textable;form=list"';
+  const capUrn = 'cap:in="media:pdf";op=disbind;out="media:disbound-page;textable;form=list"';
   const suggestions = client.getSuggestionsForCap(capUrn);
   assert(suggestions.length === 1, 'Should get suggestions');
   assert(suggestions[0].pluginId === 'pdfcartridge', 'Should suggest correct plugin');
@@ -2261,6 +2272,344 @@ function test335_pluginRepoServerClientIntegration() {
   assert(searchResults[0].id === plugin.id, 'Search and client should agree');
 }
 
+// ============================================================================
+// media_urn.rs: TEST546-TEST558 (MediaUrn predicates)
+// ============================================================================
+
+// TEST546: isImage returns true only when image marker tag is present
+function test546_isImage() {
+  assert(MediaUrn.fromString(MEDIA_PNG).isImage(), 'MEDIA_PNG should be image');
+  assert(MediaUrn.fromString(MEDIA_IMAGE_THUMBNAIL).isImage(), 'MEDIA_IMAGE_THUMBNAIL should be image');
+  assert(MediaUrn.fromString('media:image;jpg').isImage(), 'media:image;jpg should be image');
+  // Non-image types
+  assert(!MediaUrn.fromString(MEDIA_PDF).isImage(), 'MEDIA_PDF should not be image');
+  assert(!MediaUrn.fromString(MEDIA_STRING).isImage(), 'MEDIA_STRING should not be image');
+  assert(!MediaUrn.fromString(MEDIA_AUDIO).isImage(), 'MEDIA_AUDIO should not be image');
+  assert(!MediaUrn.fromString(MEDIA_VIDEO).isImage(), 'MEDIA_VIDEO should not be image');
+}
+
+// TEST547: isAudio returns true only when audio marker tag is present
+function test547_isAudio() {
+  assert(MediaUrn.fromString(MEDIA_AUDIO).isAudio(), 'MEDIA_AUDIO should be audio');
+  assert(MediaUrn.fromString(MEDIA_AUDIO_SPEECH).isAudio(), 'MEDIA_AUDIO_SPEECH should be audio');
+  assert(MediaUrn.fromString('media:audio;mp3').isAudio(), 'media:audio;mp3 should be audio');
+  // Non-audio types
+  assert(!MediaUrn.fromString(MEDIA_VIDEO).isAudio(), 'MEDIA_VIDEO should not be audio');
+  assert(!MediaUrn.fromString(MEDIA_PNG).isAudio(), 'MEDIA_PNG should not be audio');
+  assert(!MediaUrn.fromString(MEDIA_STRING).isAudio(), 'MEDIA_STRING should not be audio');
+}
+
+// TEST548: isVideo returns true only when video marker tag is present
+function test548_isVideo() {
+  assert(MediaUrn.fromString(MEDIA_VIDEO).isVideo(), 'MEDIA_VIDEO should be video');
+  assert(MediaUrn.fromString('media:video;mp4').isVideo(), 'media:video;mp4 should be video');
+  // Non-video types
+  assert(!MediaUrn.fromString(MEDIA_AUDIO).isVideo(), 'MEDIA_AUDIO should not be video');
+  assert(!MediaUrn.fromString(MEDIA_PNG).isVideo(), 'MEDIA_PNG should not be video');
+  assert(!MediaUrn.fromString(MEDIA_STRING).isVideo(), 'MEDIA_STRING should not be video');
+}
+
+// TEST549: isNumeric returns true only when numeric marker tag is present
+function test549_isNumeric() {
+  assert(MediaUrn.fromString(MEDIA_INTEGER).isNumeric(), 'MEDIA_INTEGER should be numeric');
+  assert(MediaUrn.fromString(MEDIA_NUMBER).isNumeric(), 'MEDIA_NUMBER should be numeric');
+  assert(MediaUrn.fromString(MEDIA_INTEGER_ARRAY).isNumeric(), 'MEDIA_INTEGER_ARRAY should be numeric');
+  assert(MediaUrn.fromString(MEDIA_NUMBER_ARRAY).isNumeric(), 'MEDIA_NUMBER_ARRAY should be numeric');
+  // Non-numeric types
+  assert(!MediaUrn.fromString(MEDIA_STRING).isNumeric(), 'MEDIA_STRING should not be numeric');
+  assert(!MediaUrn.fromString(MEDIA_BOOLEAN).isNumeric(), 'MEDIA_BOOLEAN should not be numeric');
+  assert(!MediaUrn.fromString(MEDIA_BINARY).isNumeric(), 'MEDIA_BINARY should not be numeric');
+}
+
+// TEST550: isBool returns true only when bool marker tag is present
+function test550_isBool() {
+  assert(MediaUrn.fromString(MEDIA_BOOLEAN).isBool(), 'MEDIA_BOOLEAN should be bool');
+  assert(MediaUrn.fromString(MEDIA_BOOLEAN_ARRAY).isBool(), 'MEDIA_BOOLEAN_ARRAY should be bool');
+  assert(MediaUrn.fromString(MEDIA_DECISION).isBool(), 'MEDIA_DECISION should be bool');
+  assert(MediaUrn.fromString(MEDIA_DECISION_ARRAY).isBool(), 'MEDIA_DECISION_ARRAY should be bool');
+  // Non-bool types
+  assert(!MediaUrn.fromString(MEDIA_STRING).isBool(), 'MEDIA_STRING should not be bool');
+  assert(!MediaUrn.fromString(MEDIA_INTEGER).isBool(), 'MEDIA_INTEGER should not be bool');
+  assert(!MediaUrn.fromString(MEDIA_BINARY).isBool(), 'MEDIA_BINARY should not be bool');
+}
+
+// TEST551: isFilePath returns true for scalar file-path, false for array
+function test551_isFilePath() {
+  assert(MediaUrn.fromString(MEDIA_FILE_PATH).isFilePath(), 'MEDIA_FILE_PATH should be file-path');
+  // Array file-path is NOT isFilePath (it's isFilePathArray)
+  assert(!MediaUrn.fromString(MEDIA_FILE_PATH_ARRAY).isFilePath(), 'MEDIA_FILE_PATH_ARRAY should not be isFilePath');
+  // Non-file-path types
+  assert(!MediaUrn.fromString(MEDIA_STRING).isFilePath(), 'MEDIA_STRING should not be file-path');
+  assert(!MediaUrn.fromString(MEDIA_BINARY).isFilePath(), 'MEDIA_BINARY should not be file-path');
+}
+
+// TEST552: isFilePathArray returns true for list file-path, false for scalar
+function test552_isFilePathArray() {
+  assert(MediaUrn.fromString(MEDIA_FILE_PATH_ARRAY).isFilePathArray(), 'MEDIA_FILE_PATH_ARRAY should be file-path-array');
+  // Scalar file-path is NOT isFilePathArray
+  assert(!MediaUrn.fromString(MEDIA_FILE_PATH).isFilePathArray(), 'MEDIA_FILE_PATH should not be isFilePathArray');
+  // Non-file-path types
+  assert(!MediaUrn.fromString(MEDIA_STRING_ARRAY).isFilePathArray(), 'MEDIA_STRING_ARRAY should not be file-path-array');
+}
+
+// TEST553: isAnyFilePath returns true for both scalar and array file-path
+function test553_isAnyFilePath() {
+  assert(MediaUrn.fromString(MEDIA_FILE_PATH).isAnyFilePath(), 'MEDIA_FILE_PATH should be any-file-path');
+  assert(MediaUrn.fromString(MEDIA_FILE_PATH_ARRAY).isAnyFilePath(), 'MEDIA_FILE_PATH_ARRAY should be any-file-path');
+  // Non-file-path types
+  assert(!MediaUrn.fromString(MEDIA_STRING).isAnyFilePath(), 'MEDIA_STRING should not be any-file-path');
+  assert(!MediaUrn.fromString(MEDIA_STRING_ARRAY).isAnyFilePath(), 'MEDIA_STRING_ARRAY should not be any-file-path');
+}
+
+// TEST554: isCollection returns true when collection marker tag is present
+function test554_isCollection() {
+  assert(MediaUrn.fromString(MEDIA_COLLECTION).isCollection(), 'MEDIA_COLLECTION should be collection');
+  assert(MediaUrn.fromString(MEDIA_COLLECTION_LIST).isCollection(), 'MEDIA_COLLECTION_LIST should be collection');
+  // Non-collection types
+  assert(!MediaUrn.fromString(MEDIA_OBJECT).isCollection(), 'MEDIA_OBJECT should not be collection');
+  assert(!MediaUrn.fromString(MEDIA_STRING_ARRAY).isCollection(), 'MEDIA_STRING_ARRAY should not be collection');
+}
+
+// TEST555: N/A for JS (with_tag/without_tag on MediaUrn - JS MediaUrn does not have these methods)
+
+// TEST556: N/A for JS (image_media_urn_for_ext helper not in JS)
+
+// TEST557: N/A for JS (audio_media_urn_for_ext helper not in JS)
+
+// TEST558: predicates are consistent with constants - every constant triggers exactly the expected predicates
+function test558_predicateConstantConsistency() {
+  // MEDIA_INTEGER must be numeric, text, scalar, NOT binary/bool/image/audio/video
+  const intUrn = MediaUrn.fromString(MEDIA_INTEGER);
+  assert(intUrn.isNumeric(), 'MEDIA_INTEGER must be numeric');
+  assert(intUrn.isText(), 'MEDIA_INTEGER must be text');
+  assert(intUrn.isScalar(), 'MEDIA_INTEGER must be scalar');
+  assert(!intUrn.isBinary(), 'MEDIA_INTEGER must not be binary');
+  assert(!intUrn.isBool(), 'MEDIA_INTEGER must not be bool');
+  assert(!intUrn.isImage(), 'MEDIA_INTEGER must not be image');
+  assert(!intUrn.isList(), 'MEDIA_INTEGER must not be list');
+
+  // MEDIA_BOOLEAN must be bool, text, scalar, NOT numeric
+  const boolUrn = MediaUrn.fromString(MEDIA_BOOLEAN);
+  assert(boolUrn.isBool(), 'MEDIA_BOOLEAN must be bool');
+  assert(boolUrn.isText(), 'MEDIA_BOOLEAN must be text');
+  assert(boolUrn.isScalar(), 'MEDIA_BOOLEAN must be scalar');
+  assert(!boolUrn.isNumeric(), 'MEDIA_BOOLEAN must not be numeric');
+
+  // MEDIA_JSON must be json, text, map, structured, NOT binary
+  const jsonUrn = MediaUrn.fromString(MEDIA_JSON);
+  assert(jsonUrn.isJson(), 'MEDIA_JSON must be json');
+  assert(jsonUrn.isText(), 'MEDIA_JSON must be text');
+  assert(jsonUrn.isMap(), 'MEDIA_JSON must be map');
+  assert(jsonUrn.isStructured(), 'MEDIA_JSON must be structured');
+  assert(!jsonUrn.isBinary(), 'MEDIA_JSON must not be binary');
+  assert(!jsonUrn.isList(), 'MEDIA_JSON must not be list');
+
+  // MEDIA_VOID is void, NOT text/numeric — but IS binary (no textable tag)
+  const voidUrn = MediaUrn.fromString(MEDIA_VOID);
+  assert(voidUrn.isVoid(), 'MEDIA_VOID must be void');
+  assert(!voidUrn.isText(), 'MEDIA_VOID must not be text');
+  assert(voidUrn.isBinary(), 'MEDIA_VOID must be binary (no textable tag)');
+  assert(!voidUrn.isNumeric(), 'MEDIA_VOID must not be numeric');
+}
+
+// ============================================================================
+// cap_urn.rs: TEST559-TEST567 (CapUrn tier tests)
+// ============================================================================
+
+// TEST559: withoutTag removes tag, ignores in/out, case-insensitive for keys
+function test559_withoutTag() {
+  const cap = CapUrn.fromString('cap:in="media:void";op=test;ext=pdf;out="media:void"');
+  const removed = cap.withoutTag('ext');
+  assertEqual(removed.getTag('ext'), undefined, 'withoutTag should remove ext');
+  assertEqual(removed.getTag('op'), 'test', 'withoutTag should preserve op');
+
+  // Case-insensitive removal
+  const removed2 = cap.withoutTag('EXT');
+  assertEqual(removed2.getTag('ext'), undefined, 'withoutTag should be case-insensitive');
+
+  // Removing in/out is silently ignored
+  const same = cap.withoutTag('in');
+  assertEqual(same.getInSpec(), 'media:void', 'withoutTag must not remove in');
+  const same2 = cap.withoutTag('out');
+  assertEqual(same2.getOutSpec(), 'media:void', 'withoutTag must not remove out');
+
+  // Removing non-existent tag is no-op
+  const same3 = cap.withoutTag('nonexistent');
+  assert(same3.equals(cap), 'Removing non-existent tag is no-op');
+}
+
+// TEST560: withInSpec and withOutSpec change direction specs
+function test560_withInOutSpec() {
+  const cap = CapUrn.fromString('cap:in="media:void";op=test;out="media:void"');
+
+  const changedIn = cap.withInSpec('media:');
+  assertEqual(changedIn.getInSpec(), 'media:', 'withInSpec should change inSpec');
+  assertEqual(changedIn.getOutSpec(), 'media:void', 'withInSpec should preserve outSpec');
+  assertEqual(changedIn.getTag('op'), 'test', 'withInSpec should preserve tags');
+
+  const changedOut = cap.withOutSpec('media:string');
+  assertEqual(changedOut.getInSpec(), 'media:void', 'withOutSpec should preserve inSpec');
+  assertEqual(changedOut.getOutSpec(), 'media:string', 'withOutSpec should change outSpec');
+
+  // Chain both
+  const changedBoth = cap.withInSpec('media:pdf').withOutSpec('media:txt;textable');
+  assertEqual(changedBoth.getInSpec(), 'media:pdf', 'Chain should set inSpec');
+  assertEqual(changedBoth.getOutSpec(), 'media:txt;textable', 'Chain should set outSpec');
+}
+
+// TEST561: N/A for JS (in_media_urn/out_media_urn not in JS CapUrn)
+
+// TEST562: N/A for JS (canonical_option not in JS CapUrn)
+
+// TEST563: CapMatcher.findAllMatches returns all matching caps sorted by specificity
+function test563_findAllMatches() {
+  const caps = [
+    CapUrn.fromString('cap:in="media:void";op=test;out="media:void"'),
+    CapUrn.fromString('cap:in="media:void";op=test;ext=pdf;out="media:void"'),
+    CapUrn.fromString('cap:in="media:void";op=different;out="media:void"'),
+  ];
+
+  const request = CapUrn.fromString('cap:in="media:void";op=test;out="media:void"');
+  const matches = CapMatcher.findAllMatches(caps, request);
+
+  // Should find 2 matches (op=test and op=test;ext=pdf), not op=different
+  assertEqual(matches.length, 2, 'Should find 2 matches');
+  // Sorted by specificity descending: ext=pdf first (more specific)
+  assert(matches[0].specificity() >= matches[1].specificity(), 'First match should be more specific');
+  assertEqual(matches[0].getTag('ext'), 'pdf', 'Most specific match should have ext=pdf');
+}
+
+// TEST564: CapMatcher.areCompatible detects bidirectional overlap
+function test564_areCompatible() {
+  const caps1 = [
+    CapUrn.fromString('cap:in="media:void";op=test;out="media:void"'),
+  ];
+  const caps2 = [
+    CapUrn.fromString('cap:in="media:void";op=test;ext=pdf;out="media:void"'),
+  ];
+  const caps3 = [
+    CapUrn.fromString('cap:in="media:void";op=different;out="media:void"'),
+  ];
+
+  // caps1 (op=test) accepts caps2 (op=test;ext=pdf) -> compatible
+  assert(CapMatcher.areCompatible(caps1, caps2), 'caps1 and caps2 should be compatible');
+
+  // caps1 (op=test) vs caps3 (op=different) -> not compatible
+  assert(!CapMatcher.areCompatible(caps1, caps3), 'caps1 and caps3 should not be compatible');
+
+  // Empty sets are not compatible
+  assert(!CapMatcher.areCompatible([], caps1), 'Empty vs non-empty should not be compatible');
+  assert(!CapMatcher.areCompatible(caps1, []), 'Non-empty vs empty should not be compatible');
+}
+
+// TEST565: N/A for JS (tags_to_string not in JS CapUrn)
+
+// TEST566: withTag silently ignores in/out keys
+function test566_withTagIgnoresInOut() {
+  const cap = CapUrn.fromString('cap:in="media:void";op=test;out="media:void"');
+  // Attempting to set in/out via withTag is silently ignored
+  const same = cap.withTag('in', 'media:');
+  assertEqual(same.getInSpec(), 'media:void', 'withTag must not change in_spec');
+
+  const same2 = cap.withTag('out', 'media:');
+  assertEqual(same2.getOutSpec(), 'media:void', 'withTag must not change out_spec');
+}
+
+// TEST567: N/A for JS (conforms_to_str/accepts_str not in JS CapUrn)
+
+// ============================================================================
+// cap_urn.rs: TEST639-TEST653 (Cap URN wildcard tests)
+// ============================================================================
+
+// Note: Rust allows missing in/out to default to "media:" wildcard.
+// JS currently requires in/out (throws MISSING_IN_SPEC/MISSING_OUT_SPEC).
+// The following tests cover the wildcard behavior that IS applicable to JS.
+
+// TEST639-642: N/A for JS (JS requires in/out, does not default to media: wildcard)
+
+// TEST643: cap:in=*;out=* treated as wildcards
+function test643_explicitAsteriskIsWildcard() {
+  const cap = CapUrn.fromString('cap:in=*;out=*');
+  assertEqual(cap.getInSpec(), '*', 'in=* should be stored as wildcard');
+  assertEqual(cap.getOutSpec(), '*', 'out=* should be stored as wildcard');
+}
+
+// TEST644: cap:in=media:;out=* has specific in, wildcard out
+function test644_specificInWildcardOut() {
+  const cap = CapUrn.fromString('cap:in=media:;out=*');
+  assertEqual(cap.getInSpec(), 'media:', 'Should have specific in');
+  assertEqual(cap.getOutSpec(), '*', 'Should have wildcard out');
+}
+
+// TEST645: cap:in=*;out=media:text has wildcard in, specific out
+function test645_wildcardInSpecificOut() {
+  const cap = CapUrn.fromString('cap:in=*;out=media:text');
+  assertEqual(cap.getInSpec(), '*', 'Should have wildcard in');
+  assertEqual(cap.getOutSpec(), 'media:text', 'Should have specific out');
+}
+
+// TEST646: N/A for JS (JS allows in=foo since it just checks for media: or *)
+// TEST647: N/A for JS (JS allows out=bar since it just checks for media: or *)
+
+// TEST648: Wildcard in/out match specific caps
+function test648_wildcardAcceptsSpecific() {
+  const wildcard = CapUrn.fromString('cap:in=*;out=*');
+  const specific = CapUrn.fromString('cap:in="media:";out="media:text"');
+
+  assert(wildcard.accepts(specific), 'Wildcard should accept specific');
+  assert(specific.conformsTo(wildcard), 'Specific should conform to wildcard');
+}
+
+// TEST649: Specificity - wildcard has 0, specific has tag count
+function test649_specificityScoring() {
+  const wildcard = CapUrn.fromString('cap:in=*;out=*');
+  const specific = CapUrn.fromString('cap:in="media:";out="media:text"');
+
+  assertEqual(wildcard.specificity(), 0, 'Wildcard cap should have 0 specificity');
+  assert(specific.specificity() > 0, 'Specific cap should have non-zero specificity');
+}
+
+// TEST650: N/A for JS (JS requires in/out, cap:in;out;op=test would fail parsing)
+
+// TEST651: All identity forms with explicit wildcards produce the same CapUrn
+function test651_identityFormsEquivalent() {
+  const forms = [
+    'cap:in=*;out=*',
+    'cap:in="media:";out="media:"',
+  ];
+
+  const first = CapUrn.fromString(forms[0]);
+  // All forms should produce equivalent caps (wildcard behavior)
+  for (let i = 1; i < forms.length; i++) {
+    const cap = CapUrn.fromString(forms[i]);
+    // Both should accept specific caps
+    const specific = CapUrn.fromString('cap:in="media:";out="media:text"');
+    assert(first.accepts(specific), `Form 0 should accept specific`);
+    assert(cap.accepts(specific), `Form ${i} should accept specific`);
+  }
+}
+
+// TEST652: N/A for JS (CAP_IDENTITY constant not in JS)
+
+// TEST653: Identity (no extra tags) does not steal routes from specific handlers
+function test653_identityRoutingIsolation() {
+  const identity = CapUrn.fromString('cap:in=*;out=*');
+  const specificRequest = CapUrn.fromString('cap:in="media:void";op=test;out="media:void"');
+
+  // Identity has specificity 0 (no tags, wildcard directions)
+  assertEqual(identity.specificity(), 0, 'Identity specificity should be 0');
+
+  // Specific request has higher specificity
+  assert(specificRequest.specificity() > identity.specificity(),
+    'Specific request should have higher specificity than identity');
+
+  // CapMatcher should prefer specific over identity
+  const specificCap = CapUrn.fromString('cap:in="media:void";op=test;out="media:void"');
+  const best = CapMatcher.findBestMatch([identity, specificCap], specificRequest);
+  assert(best !== null, 'Should find a match');
+  assertEqual(best.getTag('op'), 'test', 'CapMatcher should prefer specific cap over identity');
+}
+
 // ============================================================================
 // Test runner
 // ============================================================================
@@ -2455,6 +2804,48 @@ async function runTests() {
   runTest('TEST334: plugin_repo_client_needs_sync', test334_pluginRepoClientNeedsSync);
   runTest('TEST335: plugin_repo_server_client_integration', test335_pluginRepoServerClientIntegration);
 
+  // media_urn.rs: TEST546-TEST558 (MediaUrn predicates)
+  console.log('\n--- media_urn.rs (predicates) ---');
+  runTest('TEST546: is_image', test546_isImage);
+  runTest('TEST547: is_audio', test547_isAudio);
+  runTest('TEST548: is_video', test548_isVideo);
+  runTest('TEST549: is_numeric', test549_isNumeric);
+  runTest('TEST550: is_bool', test550_isBool);
+  runTest('TEST551: is_file_path', test551_isFilePath);
+  runTest('TEST552: is_file_path_array', test552_isFilePathArray);
+  runTest('TEST553: is_any_file_path', test553_isAnyFilePath);
+  runTest('TEST554: is_collection', test554_isCollection);
+  console.log('  SKIP TEST555: N/A for JS (with_tag/without_tag on MediaUrn)');
+  console.log('  SKIP TEST556: N/A for JS (image_media_urn_for_ext helper)');
+  console.log('  SKIP TEST557: N/A for JS (audio_media_urn_for_ext helper)');
+  runTest('TEST558: predicate_constant_consistency', test558_predicateConstantConsistency);
+
+  // cap_urn.rs: TEST559-TEST567 (CapUrn tier tests)
+  console.log('\n--- cap_urn.rs (tier tests) ---');
+  runTest('TEST559: without_tag', test559_withoutTag);
+  runTest('TEST560: with_in_out_spec', test560_withInOutSpec);
+  console.log('  SKIP TEST561: N/A for JS (in_media_urn/out_media_urn)');
+  console.log('  SKIP TEST562: N/A for JS (canonical_option)');
+  runTest('TEST563: find_all_matches', test563_findAllMatches);
+  runTest('TEST564: are_compatible', test564_areCompatible);
+  console.log('  SKIP TEST565: N/A for JS (tags_to_string)');
+  runTest('TEST566: with_tag_ignores_in_out', test566_withTagIgnoresInOut);
+  console.log('  SKIP TEST567: N/A for JS (conforms_to_str/accepts_str)');
+
+  // cap_urn.rs: TEST639-TEST653 (Cap URN wildcard tests)
+  console.log('\n--- cap_urn.rs (wildcard tests) ---');
+  console.log('  SKIP TEST639-642: N/A for JS (implicit wildcard defaults)');
+  runTest('TEST643: explicit_asterisk_is_wildcard', test643_explicitAsteriskIsWildcard);
+  runTest('TEST644: specific_in_wildcard_out', test644_specificInWildcardOut);
+  runTest('TEST645: wildcard_in_specific_out', test645_wildcardInSpecificOut);
+  console.log('  SKIP TEST646-647: N/A for JS (invalid spec validation differs)');
+  runTest('TEST648: wildcard_accepts_specific', test648_wildcardAcceptsSpecific);
+  runTest('TEST649: specificity_scoring', test649_specificityScoring);
+  console.log('  SKIP TEST650: N/A for JS (requires in/out)');
+  runTest('TEST651: identity_forms_equivalent', test651_identityFormsEquivalent);
+  console.log('  SKIP TEST652: N/A for JS (CAP_IDENTITY constant)');
+  runTest('TEST653: identity_routing_isolation', test653_identityRoutingIsolation);
+
   // Summary
   console.log(`\n${passCount + failCount} tests: ${passCount} passed, ${failCount} failed`);
   if (failCount > 0) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "author": "Bahram Joharshamshiri",
   "dependencies": {
-    "tagged-urn": "^0.26.4740"
+    "tagged-urn": "^0.28.4918"
   },
   "description": "JavaScript implementation of Cap URN (Capability Uniform Resource Names) with strict validation and matching",
   "engines": {
@@ -32,5 +32,5 @@
   "scripts": {
     "test": "node capns.test.js"
   },
-  "version": "0.83.18915"
+  "version": "0.85.19364"
 }