capdag 1.241.684 → 1.246.701

package/capdag.js

@@ -949,6 +949,50 @@ class CapUrn {
     return runtimeOut;
   }
 
+  /**
+   * THE effect-audit predicate: does an actually-emitted runtime output
+   * satisfy this cap's declared effect contract for the given runtime
+   * input? Every check of "did the cap emit what its effect promised"
+   * must go through this — never a hand-rolled combination of
+   * inferRuntimeOutputMedia with equality or conformance checks, so the
+   * contract has exactly one definition.
+   *
+   * The condition is deliberately asymmetric per effect:
+   * - effect=none / effect=patch compute an EXACT runtime output type,
+   *   so the emission must be tag-equivalent to the inference. A more
+   *   specific emission would still be a lie: the effect promises the
+   *   type is fully determined by the input.
+   * - effect=declared promises only the declared out=, so an emission
+   *   that is MORE specific than the declaration is legal and desirable;
+   *   the emission must conform to the declared output. A more generic
+   *   emission breaks downstream plan refinement and fails.
+   *
+   * Throws (rather than returning false) when the inference itself is
+   * impossible: the runtime input does not conform to the declared
+   * input, the effect is the unconstrained request form (?effect), or
+   * the URN state is internally inconsistent — those are upstream
+   * contract breaks, not emission mismatches.
+   *
+   * @param {MediaUrn} runtimeInput
+   * @param {MediaUrn} runtimeOutput
+   * @returns {boolean}
+   */
+  isConformantRuntimeOutput(runtimeInput, runtimeOutput) {
+    const inferred = this.inferRuntimeOutputMedia(runtimeInput);
+    switch (this.effectValue) {
+      case CapEffect.NONE:
+      case CapEffect.PATCH:
+        return runtimeOutput.isEquivalent(inferred);
+      case CapEffect.DECLARED:
+        return runtimeOutput.conformsTo(inferred);
+      default:
+        throw new CapUrnError(
+          ErrorCodes.INVALID_EFFECT_APPLICATION,
+          'Cannot audit an emission against an unconstrained effect request'
+        );
+    }
+  }
+
   _validateAdmissible() {
     const inMedia = this.inMediaUrn();
     const outMedia = this.outMediaUrn();
@@ -1561,6 +1605,17 @@ class MediaUrn {
    */
   isFilePath() { return this._hasMarkerTag('file-path'); }
 
+  /**
+   * True if this URN carries the `live` marker tag — a live-feed
+   * REFERENCE (13.2 §Reference Media): the arg value is a selector record
+   * the runtime resolves into an unbounded content stream via a registered
+   * provider, the same transport-resolution family as `media:file-path`.
+   * This is the canonical membership predicate for that family; callers
+   * must not test the `live` tag themselves.
+   * @returns {boolean}
+   */
+  isLiveFeed() { return this._hasMarkerTag('live'); }
+
   /**
    * Check if this represents a collection type.
    * Returns true if the "collection" marker tag is present.

package/capdag.test.js

@@ -2797,6 +2797,16 @@ function test551_isFilePath() {
   assert(!MediaUrn.fromString(MEDIA_IDENTITY).isFilePath(), 'MEDIA_IDENTITY should not be file-path');
 }
 
+// TEST553: is_live_feed returns true for every URN carrying the `live` marker tag (the reference-media family the runtime resolves via providers), false for everything else — including content URNs a feed delivers.
+function test553_isLiveFeed() {
+  assert(MediaUrn.fromString('media:live').isLiveFeed(), 'media:live should be live-feed');
+  assert(MediaUrn.fromString('media:live;synthetic').isLiveFeed(), 'media:live;synthetic should be live-feed');
+  assert(MediaUrn.fromString('media:audio;live;microphone').isLiveFeed(), 'microphone URN should be live-feed');
+  assert(!MediaUrn.fromString(MEDIA_STRING).isLiveFeed(), 'MEDIA_STRING should not be live-feed');
+  assert(!MediaUrn.fromString(MEDIA_FILE_PATH).isLiveFeed(), 'MEDIA_FILE_PATH should not be live-feed');
+  assert(!MediaUrn.fromString('media:audio;pcm').isLiveFeed(), 'feed CONTENT urns should not be live-feed');
+}
+
 // Mirror-specific coverage: isCollection returns true when collection marker tag is present
 // Mirror-specific coverage: N/A for JS (MEDIA_COLLECTION constants removed - no longer exists)
 function test6272_isCollection() {
@@ -3206,6 +3216,80 @@ function test127_invalidEffectNoneFailsHard() {
   );
 }
 
+// TEST8121: isConformantRuntimeOutput — effect=declared accepts a more
+// specific emission, rejects a more generic one
+function test8121_effectConformanceDeclaredAsymmetry() {
+  const cap = CapUrn.fromString('cap:extract;in="media:ext=pdf";out="media:record"');
+  const input = MediaUrn.fromString('media:ext=pdf');
+
+  assert(
+    cap.isConformantRuntimeOutput(input, MediaUrn.fromString('media:record')),
+    'emitting exactly the declared out is conformant'
+  );
+  assert(
+    cap.isConformantRuntimeOutput(input, MediaUrn.fromString('media:fmt=json;record')),
+    'a more specific emission than the declared out is conformant'
+  );
+  assert(
+    !cap.isConformantRuntimeOutput(input, MediaUrn.fromString('media:')),
+    'a more generic emission than the declared out is a violation'
+  );
+  assert(
+    !cap.isConformantRuntimeOutput(input, MediaUrn.fromString('media:ext=png;image')),
+    'an unrelated emission is a violation'
+  );
+}
+
+// TEST8122: isConformantRuntimeOutput — effect=none requires the emission
+// to be tag-equivalent to the runtime input; MORE specific is still a lie
+function test8122_effectConformanceNoneRequiresEquivalence() {
+  const cap = CapUrn.fromString('cap:decimate-sequence;effect=none');
+  const input = MediaUrn.fromString('media:ext=png;image');
+
+  assert(
+    cap.isConformantRuntimeOutput(input, input),
+    'emitting exactly the runtime input type is conformant'
+  );
+  assert(
+    !cap.isConformantRuntimeOutput(input, MediaUrn.fromString('media:ext=png;image;width=64')),
+    'effect=none promises the output type IS the input type; more specific is a lie'
+  );
+  assert(
+    !cap.isConformantRuntimeOutput(input, MediaUrn.fromString('media:image')),
+    'a more generic emission is a violation'
+  );
+
+  const strict = CapUrn.fromString('cap:effect=none;in="media:image";out="media:image"');
+  const nonImage = MediaUrn.fromString('media:ext=pdf');
+  assertThrows(
+    () => strict.isConformantRuntimeOutput(nonImage, nonImage),
+    ErrorCodes.INVALID_EFFECT_APPLICATION,
+    'a nonconforming runtime input is an upstream contract break, surfaced as an error'
+  );
+}
+
+// TEST8123: isConformantRuntimeOutput — effect=patch requires exactly the
+// delta-patched input type
+function test8123_effectConformancePatchRequiresPatchedInput() {
+  const cap = CapUrn.fromString(
+    'cap:convert;effect=patch;in="media:ext=jpeg;image";out="media:ext=png;image"'
+  );
+  const input = MediaUrn.fromString('media:ext=jpeg;image;width=64');
+
+  assert(
+    cap.isConformantRuntimeOutput(input, MediaUrn.fromString('media:ext=png;image;width=64')),
+    'the delta-patched input type (preserved tags intact) is conformant'
+  );
+  assert(
+    !cap.isConformantRuntimeOutput(input, MediaUrn.fromString('media:ext=png;image')),
+    'dropping the preserved width tag violates the patch promise'
+  );
+  assert(
+    !cap.isConformantRuntimeOutput(input, input),
+    'emitting the unpatched input type is a violation'
+  );
+}
+
 // TEST128: omitted effect means declared; unconstrained effect must be explicit
 function test128_effectDispatchRequiresExplicitWildcard() {
   const noneCandidate = CapUrn.fromString('cap:effect=none');
@@ -7234,6 +7318,7 @@ async function runTests() {
   runTest('TEST1315: is_numeric', test549_isNumeric);
   runTest('TEST1298: is_bool', test550_isBool);
   runTest('TEST1299: is_file_path', test551_isFilePath);
+  runTest('TEST553: is_live_feed', test553_isLiveFeed);
   runTest('TEST1302: predicate_constant_consistency', test558_predicateConstantConsistency);
 
   // cap_urn.rs: TEST1303-TEST1307 (CapUrn tier tests)
@@ -7270,6 +7355,9 @@ async function runTests() {
   runTest('TEST655: effect_declared_uses_declared_output', test126_effectDeclaredUsesDeclaredOutput);
   runTest('TEST656: invalid_effect_none_fails_hard', test127_invalidEffectNoneFailsHard);
   runTest('TEST657: effect_dispatch_requires_explicit_wildcard', test128_effectDispatchRequiresExplicitWildcard);
+  runTest('TEST8121: effect_conformance_declared_asymmetry', test8121_effectConformanceDeclaredAsymmetry);
+  runTest('TEST8122: effect_conformance_none_requires_equivalence', test8122_effectConformanceNoneRequiresEquivalence);
+  runTest('TEST8123: effect_conformance_patch_requires_patched_input', test8123_effectConformancePatchRequiresPatchedInput);
 
   // machine module: parser tests (mirrors parser.rs)
   console.log('\n--- machine/parser.rs ---');

package/package.json

@@ -41,5 +41,5 @@
     "pretest": "npm run build:parser",
     "test": "node capdag.test.js"
   },
-  "version": "1.241.684"
+  "version": "1.246.701"
 }