@slicedearth/whoisleuth-cli 2.2.0 → 2.4.0

package/packages/contracts/schema-lifecycle.mjs

@@ -1,8 +1,8 @@
 import { defineSchemaCompatibility, isCanonicalLocalSchemaIdentifier, } from "./schema-compatibility.mjs";
+export const SCHEMA_LIFECYCLE_METADATA_VERSION = 4;
 const FAMILY_KEYS = new Set(['id', 'owner', 'privacy', 'compatibility', 'contracts', 'fixtures']);
 const EXTENDED_FAMILY_KEYS = new Set([...FAMILY_KEYS, 'metadata']);
-const METADATA_V1_KEYS = new Set([
-    'metadataVersion',
+const METADATA_KEYS = new Set([
     'enforcement',
     'shapes',
     'boundProfiles',
@@ -11,15 +11,8 @@ const METADATA_V1_KEYS = new Set([
     'privacyProfiles',
     'expiryProfiles',
     'consumerEdges',
-]);
-const METADATA_V2_KEYS = new Set([
-    ...METADATA_V1_KEYS,
     'consumerRelationships',
 ]);
-const METADATA_V3_KEYS = METADATA_V2_KEYS;
-const METADATA_V4_KEYS = new Set([
-    ...METADATA_V2_KEYS,
-]);
 const COMPATIBILITY_KEYS = new Set([
     'id',
     'tier',
@@ -52,7 +45,6 @@ const CONTRACT_KEYS = new Set([
     'fixtureIds',
 ]);
 const TARGET_KEYS = new Set(['schema', 'version']);
-const EMITTED_TARGET_V4_KEYS = new Set([...TARGET_KEYS, 'discriminator']);
 const FIXTURE_KEYS = new Set([
     'id',
     'path',
@@ -66,11 +58,8 @@ const FIXTURE_KEYS = new Set([
     'expectedOutputFixtureId',
     'scope',
 ]);
-const FIXTURE_V4_KEYS = new Set([...FIXTURE_KEYS, 'shapeId']);
 const SHAPE_KEYS = new Set(['id', 'schema', 'versions', 'objects', 'fixedArrays', 'normalisation', 'target']);
-const SHAPE_V4_KEYS = new Set([...SHAPE_KEYS, 'discriminator']);
 const OBJECT_SHAPE_KEYS = new Set(['path', 'requiredKeys', 'optionalKeys', 'unknownKeys']);
-const OBJECT_SHAPE_V4_KEYS = new Set([...OBJECT_SHAPE_KEYS, 'alternativeRequiredKeys']);
 const ALTERNATIVE_REQUIRED_KEYS = new Set(['keys', 'resolution']);
 const FIXED_ARRAY_SHAPE_KEYS = new Set(['path', 'values']);
 const BOUND_PROFILE_KEYS = new Set(['id', 'bounds']);
@@ -86,7 +75,6 @@ const PRIVACY_PROFILE_KEYS = new Set([
 ]);
 const EXPIRY_POLICY_KEYS = new Set(['id', 'field', 'anchor', 'handling', 'phase', 'maximumLifetimeDays']);
 const CONTRACT_REFERENCE_KEYS = new Set(['schema', 'versions', 'mode']);
-const CONTRACT_REFERENCE_V3_KEYS = new Set([...CONTRACT_REFERENCE_KEYS, 'discriminator']);
 const CONSUMER_DISCRIMINATOR_KEYS = new Set(['path', 'values']);
 const CONTRACT_VARIANT_DISCRIMINATOR_KEYS = new Set(['path', 'value']);
 const CONSUMER_KEYS = new Set([
@@ -150,7 +138,7 @@ function consumeMetadataValue(budget, value) {
         }
     }
 }
-function ordinaryRecord(value, keys, label, budget) {
+function ordinaryRecord(value, keys, label, budget, optionalKeys = []) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         throw new TypeError(`${label} must be an ordinary object.`);
     }
@@ -162,12 +150,14 @@ function ordinaryRecord(value, keys, label, budget) {
         ? keys
         : [keys];
     const ownKeys = Reflect.ownKeys(value);
-    const selectedKeys = keySets.find((candidate) => ownKeys.length === candidate.size
-        && ownKeys.every((key) => typeof key === 'string' && candidate.has(key)));
+    const selectedKeys = keySets.find((candidate) => ownKeys.length >= candidate.size
+        && ownKeys.length <= candidate.size + optionalKeys.length
+        && [...candidate].every((key) => ownKeys.includes(key))
+        && ownKeys.every((key) => typeof key === 'string' && (candidate.has(key) || optionalKeys.includes(key))));
     if (!selectedKeys) {
         throw new TypeError(`${label} must use its exact registered fields.`);
     }
-    consumeMetadataSlots(budget, selectedKeys.size + 1);
+    consumeMetadataSlots(budget, ownKeys.length + 1);
     consumeMetadataSerialisedBytes(budget, 2 + Math.max(0, ownKeys.length - 1) + ownKeys
         .reduce((bytes, key) => bytes + utf8Length(JSON.stringify(key)) + 1, 0));
     const result = Object.create(null);
@@ -324,18 +314,18 @@ function copyVariantDiscriminator(value, label, budget) {
         value: boundedText(source.value, `${label} value`),
     });
 }
-function copyEmittedTarget(value, label, budget, metadataVersion) {
+function copyEmittedTarget(value, label, budget) {
     if (value === null)
         return null;
-    const source = ordinaryRecord(value, metadataVersion === 4 ? EMITTED_TARGET_V4_KEYS : TARGET_KEYS, label, budget);
-    const discriminator = metadataVersion === 4 && Object.hasOwn(source, 'discriminator')
+    const source = ordinaryRecord(value, TARGET_KEYS, label, budget, ['discriminator']);
+    const discriminator = Object.hasOwn(source, 'discriminator')
         && source.discriminator !== null
         ? copyVariantDiscriminator(source.discriminator, `${label} discriminator`, budget)
         : null;
     return Object.freeze({
         schema: boundedSchema(source.schema, `${label} schema`),
         version: positiveInteger(source.version, `${label} version`),
-        ...(metadataVersion === 4 ? { discriminator } : {}),
+        discriminator,
     });
 }
 function copyStringArray(value, label) {
@@ -472,7 +462,7 @@ function copyContract(value, index) {
 }
 function copyFixture(value, index) {
     const label = `Schema lifecycle fixture ${index + 1}`;
-    const source = ordinaryRecord(value, [FIXTURE_KEYS, FIXTURE_V4_KEYS], label);
+    const source = ordinaryRecord(value, FIXTURE_KEYS, label, undefined, ['shapeId']);
     const role = source.role;
     const expectation = source.expectation;
     if (role !== 'input' && role !== 'historical' && role !== 'current') {
@@ -520,29 +510,27 @@ function copyFixture(value, index) {
             : {}),
     });
 }
-function copyObjectShape(value, index, shapeLabel, budget, metadataVersion) {
+function copyObjectShape(value, index, shapeLabel, budget) {
     const label = `${shapeLabel} object ${index + 1}`;
-    const source = ordinaryRecord(value, metadataVersion === 4 ? OBJECT_SHAPE_V4_KEYS : OBJECT_SHAPE_KEYS, label, budget);
+    const source = ordinaryRecord(value, OBJECT_SHAPE_KEYS, label, budget, ['alternativeRequiredKeys']);
     const requiredKeys = copyFieldArray(source.requiredKeys, `${label} required keys`, true, budget);
     const optionalKeys = copyFieldArray(source.optionalKeys, `${label} optional keys`, true, budget);
     if (requiredKeys.some((key) => optionalKeys.includes(key))) {
         throw new TypeError(`${label} required and optional keys must not overlap.`);
     }
-    const alternativeRequiredKeys = metadataVersion === 4
+    const alternativeRequiredKeys = Object.hasOwn(source, 'alternativeRequiredKeys')
         ? copyAlternativeRequiredKeys(source.alternativeRequiredKeys, `${label} alternative required keys`, budget)
         : Object.freeze([]);
     if (alternativeRequiredKeys.flatMap((group) => group.keys)
         .some((key) => requiredKeys.includes(key) || optionalKeys.includes(key))) {
         throw new TypeError(`${label} alternative fields must not overlap required or optional keys.`);
     }
-    const unknownKeys = oneOf(source.unknownKeys, metadataVersion === 4
-        ? ['discard_bounded', 'preserve_bounded', 'reject']
-        : ['preserve_bounded', 'reject'], `${label} unknown-key handling`);
+    const unknownKeys = oneOf(source.unknownKeys, ['discard_bounded', 'preserve_bounded', 'reject'], `${label} unknown-key handling`);
     return Object.freeze({
         path: boundedMetadataPath(source.path, `${label} path`),
         requiredKeys,
         optionalKeys,
-        ...(metadataVersion === 4 ? { alternativeRequiredKeys } : {}),
+        alternativeRequiredKeys,
         unknownKeys,
     });
 }
@@ -554,18 +542,16 @@ function copyFixedArrayShape(value, index, shapeLabel, budget) {
         values: copyTextArray(source.values, `${label} values`, false, budget),
     });
 }
-function copyShape(value, index, budget, metadataVersion) {
+function copyShape(value, index, budget) {
     const label = `Schema lifecycle shape ${index + 1}`;
-    const source = ordinaryRecord(value, metadataVersion === 4 ? SHAPE_V4_KEYS : SHAPE_KEYS, label, budget);
-    const objects = Object.freeze(denseArray(source.objects, `${label} objects`, MAX_NESTED_METADATA_COLLECTION, 1, budget).map((item, objectIndex) => copyObjectShape(item, objectIndex, label, budget, metadataVersion)));
+    const source = ordinaryRecord(value, SHAPE_KEYS, label, budget, ['discriminator']);
+    const objects = Object.freeze(denseArray(source.objects, `${label} objects`, MAX_NESTED_METADATA_COLLECTION, 1, budget).map((item, objectIndex) => copyObjectShape(item, objectIndex, label, budget)));
     const fixedArrays = Object.freeze(denseArray(source.fixedArrays, `${label} fixed arrays`, MAX_NESTED_METADATA_COLLECTION, 0, budget).map((item, arrayIndex) => copyFixedArrayShape(item, arrayIndex, label, budget)));
     if (new Set(objects.map((item) => item.path)).size !== objects.length
         || new Set(fixedArrays.map((item) => item.path)).size !== fixedArrays.length) {
         throw new TypeError(`${label} paths must be unique within their shape kind.`);
     }
-    const normalisation = oneOf(source.normalisation, metadataVersion === 4
-        ? ['input_to_current', 'preserve_bounded_document', 'preserve_document', 'preserve_signed_document', 'project_known_fields']
-        : ['input_to_current', 'preserve_bounded_document', 'preserve_document', 'preserve_signed_document'], `${label} normalisation`);
+    const normalisation = oneOf(source.normalisation, ['input_to_current', 'preserve_bounded_document', 'preserve_document', 'preserve_signed_document', 'project_known_fields'], `${label} normalisation`);
     const target = copyTarget(source.target, `${label} target`, budget);
     if ((normalisation === 'input_to_current') !== (target !== null)) {
         throw new TypeError(`${label} input normalisation must name one target and document preservation must not.`);
@@ -578,13 +564,9 @@ function copyShape(value, index, budget, metadataVersion) {
         fixedArrays,
         normalisation,
         target,
-        ...(metadataVersion === 4
-            ? {
-                discriminator: source.discriminator === null
-                    ? null
-                    : copyVariantDiscriminator(source.discriminator, `${label} discriminator`, budget),
-            }
-            : {}),
+        discriminator: !Object.hasOwn(source, 'discriminator') || source.discriminator === null
+            ? null
+            : copyVariantDiscriminator(source.discriminator, `${label} discriminator`, budget),
     });
 }
 function copyBound(value, index, profileLabel, budget) {
@@ -760,30 +742,20 @@ function copyExpiryPolicy(value, index, budget) {
         maximumLifetimeDays,
     });
 }
-function copyContractReference(value, index, consumerLabel, budget, metadataVersion) {
+function copyContractReference(value, index, consumerLabel, budget) {
     const label = `${consumerLabel} accepted contract ${index + 1}`;
-    const source = ordinaryRecord(value, metadataVersion === 4
-        ? CONTRACT_REFERENCE_V3_KEYS
-        : metadataVersion === 3
-            ? [CONTRACT_REFERENCE_KEYS, CONTRACT_REFERENCE_V3_KEYS]
-            : CONTRACT_REFERENCE_KEYS, label, budget);
-    let discriminator;
-    if (metadataVersion >= 3) {
-        if (!Object.hasOwn(source, 'discriminator') || source.discriminator === null) {
-            discriminator = null;
-        }
-        else {
-            discriminator = copyConsumerDiscriminator(source.discriminator, `${label} discriminator`, budget);
-        }
-    }
+    const source = ordinaryRecord(value, CONTRACT_REFERENCE_KEYS, label, budget, ['discriminator']);
+    const discriminator = !Object.hasOwn(source, 'discriminator') || source.discriminator === null
+        ? null
+        : copyConsumerDiscriminator(source.discriminator, `${label} discriminator`, budget);
     return Object.freeze({
         schema: boundedSchema(source.schema, `${label} schema`),
         versions: copyVersionArray(source.versions, `${label} versions`, budget),
         mode: oneOf(source.mode, ['direct', 'embedded'], `${label} mode`),
-        ...(metadataVersion >= 3 ? { discriminator: discriminator ?? null } : {}),
+        discriminator,
     });
 }
-function copyConsumerEdge(value, index, budget, metadataVersion) {
+function copyConsumerEdge(value, index, budget) {
     const label = `Schema lifecycle consumer ${index + 1}`;
     const source = ordinaryRecord(value, CONSUMER_KEYS, label, budget);
     const serialisationProfileId = source.serialisationProfileId;
@@ -794,8 +766,8 @@ function copyConsumerEdge(value, index, budget, metadataVersion) {
         id: boundedId(source.id, `${label} id`),
         plane: oneOf(source.plane, ['browser', 'cli', 'node', 'shared'], `${label} plane`),
         operation: boundedId(source.operation, `${label} operation`),
-        acceptedContracts: Object.freeze(denseArray(source.acceptedContracts, `${label} accepted contracts`, MAX_NESTED_METADATA_COLLECTION, 0, budget).map((item, referenceIndex) => copyContractReference(item, referenceIndex, label, budget, metadataVersion))),
-        emittedContract: copyEmittedTarget(source.emittedContract, `${label} emitted contract`, budget, metadataVersion),
+        acceptedContracts: Object.freeze(denseArray(source.acceptedContracts, `${label} accepted contracts`, MAX_NESTED_METADATA_COLLECTION, 0, budget).map((item, referenceIndex) => copyContractReference(item, referenceIndex, label, budget))),
+        emittedContract: copyEmittedTarget(source.emittedContract, `${label} emitted contract`, budget),
         shapeIds: copyIdArray(source.shapeIds, `${label} shapes`, false, budget),
         boundProfileIds: copyIdArray(source.boundProfileIds, `${label} bound profiles`, false, budget),
         hookIds: copyIdArray(source.hookIds, `${label} hooks`, false, budget),
@@ -1036,9 +1008,6 @@ function utf8Length(value) {
     }
     return bytes;
 }
-function metadataConsumerRelationships(metadata) {
-    return metadata.metadataVersion === 1 ? [] : metadata.consumerRelationships;
-}
 function validateMetadataSerialisedBudget(metadata) {
     const serialised = JSON.stringify(metadata);
     if (utf8Length(serialised) > MAX_METADATA_SERIALISED_BYTES) {
@@ -1046,11 +1015,6 @@ function validateMetadataSerialisedBudget(metadata) {
     }
 }
 function validateMetadataRelations(family, metadata) {
-    if (metadata.metadataVersion < 3 && (metadata.serialisationProfiles.some((profile) => profile.propertyOrder === 'source_insertion')
-        || metadata.privacyProfiles.some((profile) => profile.network === 'explicit_bounded_passive_fast_or_deep')
-        || metadata.consumerEdges.some((edge) => edge.requestMode === 'explicit_bounded_passive_fast_or_deep'))) {
-        throw new TypeError('Schema lifecycle metadata version 3 is required for extensible serialisation and Fast-or-Deep request policy.');
-    }
     const contractPairs = new Map(family.contracts.map((contract) => [`${contract.schema}\u0000${contract.version}`, contract]));
     const shapesById = new Map(metadata.shapes.map((shape) => [shape.id, shape]));
     const boundProfilesById = new Map(metadata.boundProfiles.map((profile) => [profile.id, profile]));
@@ -1059,7 +1023,7 @@ function validateMetadataRelations(family, metadata) {
     const privacyProfilesById = new Map(metadata.privacyProfiles.map((profile) => [profile.id, profile]));
     const expiryProfilesById = new Map(metadata.expiryProfiles.map((profile) => [profile.id, profile]));
     const consumerEdgesById = new Map(metadata.consumerEdges.map((edge) => [edge.id, edge]));
-    const consumerRelationships = metadataConsumerRelationships(metadata);
+    const consumerRelationships = metadata.consumerRelationships;
     const consumerRelationshipsById = new Map(consumerRelationships.map((relationship) => [relationship.id, relationship]));
     const registries = [
         [shapesById, metadata.shapes.length, 'shape'],
@@ -1109,12 +1073,6 @@ function validateMetadataRelations(family, metadata) {
         }
         const preservesExtensions = shape.objects.some((object) => object.unknownKeys === 'preserve_bounded');
         const discardsExtensions = shape.objects.some((object) => object.unknownKeys === 'discard_bounded');
-        if (metadata.metadataVersion < 3 && preservesExtensions) {
-            throw new TypeError(`Schema lifecycle shape ${shape.id} requires metadata version 3 for bounded extensions.`);
-        }
-        if (metadata.metadataVersion !== 4 && discardsExtensions) {
-            throw new TypeError(`Schema lifecycle shape ${shape.id} requires metadata version 4 for bounded projection.`);
-        }
         if (preservesExtensions && discardsExtensions) {
             throw new TypeError(`Schema lifecycle shape ${shape.id} must use one bounded extension policy.`);
         }
@@ -1137,7 +1095,7 @@ function validateMetadataRelations(family, metadata) {
                 && contracts.some((contract) => contract?.canonicalisation !== null))) {
             throw new TypeError(`Schema lifecycle shape ${shape.id} has inconsistent document integrity metadata.`);
         }
-        const discriminator = metadata.metadataVersion === 4 ? shape.discriminator ?? null : null;
+        const discriminator = shape.discriminator ?? null;
         if (discriminator) {
             if (shape.versions.length !== 1) {
                 throw new TypeError(`Schema lifecycle shape ${shape.id} must qualify exactly one contract version.`);
@@ -1176,22 +1134,27 @@ function validateMetadataRelations(family, metadata) {
         throw new TypeError('Every schema lifecycle contract must have at least one shape.');
     }
     const fixtureShapeIds = new Set();
-    if (metadata.metadataVersion === 4) {
-        for (const fixture of family.fixtures) {
-            const shape = fixture.shapeId ? shapesById.get(fixture.shapeId) : null;
-            if (!shape
-                || shape.schema !== fixture.schema
-                || !shape.versions.includes(fixture.version)) {
-                throw new TypeError(`Schema lifecycle fixture ${fixture.id} must name a matching contract shape.`);
-            }
-            fixtureShapeIds.add(shape.id);
+    for (const fixture of family.fixtures) {
+        const candidates = metadata.shapes.filter((shape) => shape.schema === fixture.schema && shape.versions.includes(fixture.version));
+        // A routine fixture has one possible shape. Variants still require an
+        // explicit fixture binding; never choose arbitrarily between them.
+        const shape = fixture.shapeId
+            ? shapesById.get(fixture.shapeId)
+            : fixture.shapeId === undefined && candidates.length === 1 && !candidates[0]?.discriminator
+                ? candidates[0]
+                : null;
+        if (!shape
+            || shape.schema !== fixture.schema
+            || !shape.versions.includes(fixture.version)) {
+            throw new TypeError(`Schema lifecycle fixture ${fixture.id} must name a matching contract shape.`);
         }
-        for (const shape of metadata.shapes) {
-            const contracts = shape.versions.map((version) => contractPairs.get(`${shape.schema}\u0000${version}`));
-            if ((shape.discriminator !== null || contracts.some((contract) => contract?.lifecycle === 'retired'))
-                && !fixtureShapeIds.has(shape.id)) {
-                throw new TypeError(`Schema lifecycle shape ${shape.id} must have an exact repository fixture.`);
-            }
+        fixtureShapeIds.add(shape.id);
+    }
+    for (const shape of metadata.shapes) {
+        const contracts = shape.versions.map((version) => contractPairs.get(`${shape.schema}\u0000${version}`));
+        if ((shape.discriminator !== null || contracts.some((contract) => contract?.lifecycle === 'retired'))
+            && !fixtureShapeIds.has(shape.id)) {
+            throw new TypeError(`Schema lifecycle shape ${shape.id} must have an exact repository fixture.`);
         }
     }
     for (const profile of metadata.boundProfiles) {
@@ -1270,7 +1233,6 @@ function validateMetadataRelations(family, metadata) {
     }
     const acceptedShapeIds = new Set();
     const emittedShapeIds = new Set();
-    const coveredContractPairs = new Set();
     for (const edge of metadata.consumerEdges) {
         if (edge.acceptedContracts.length === 0 && edge.emittedContract === null) {
             throw new TypeError(`Schema lifecycle consumer ${edge.id} must accept or emit a contract.`);
@@ -1298,13 +1260,11 @@ function validateMetadataRelations(family, metadata) {
                     || !contract.readable
                     || acceptedSelections.has(selectionKey)
                     || selectedShapes.some((shape) => acceptedContractShapes.has(`${key}\u0000${shape.id}`))
-                    || (metadata.metadataVersion === 4
-                        && ((qualified && (!reference.discriminator
-                            || selectedShapes.length !== reference.discriminator.values.length))
-                            || (!qualified && reference.discriminator !== null && reference.discriminator !== undefined)))) {
+                    || (qualified && (!reference.discriminator
+                        || selectedShapes.length !== reference.discriminator.values.length))) {
                     throw new TypeError(`Schema lifecycle consumer ${edge.id} references an unreadable or duplicate contract.`);
                 }
-                if (metadata.metadataVersion < 4 && reference.discriminator) {
+                if (!qualified && reference.discriminator) {
                     const parentPath = parentMetadataPath(reference.discriminator.path);
                     const field = metadataPathField(reference.discriminator.path);
                     if (contractShapes.some((shape) => {
@@ -1319,7 +1279,6 @@ function validateMetadataRelations(family, metadata) {
                 }
                 acceptedSelections.add(selectionKey);
                 relevantContractPairs.add(key);
-                coveredContractPairs.add(key);
                 if (selectedShapes.some((shape) => shape.normalisation === 'project_known_fields')) {
                     if (contract.byteBudget === null)
                         projectedContractWithoutByteBudget = true;
@@ -1329,7 +1288,7 @@ function validateMetadataRelations(family, metadata) {
                 for (const shape of selectedShapes) {
                     shapeIds.add(shape.id);
                     acceptedContractShapes.add(`${key}\u0000${shape.id}`);
-                    acceptedShapeIds.add(shape.id);
+                    acceptedShapeIds.add(`${key}\u0000${shape.id}`);
                 }
             }
         }
@@ -1346,17 +1305,15 @@ function validateMetadataRelations(family, metadata) {
                 : contractShapes;
             if (!emitted
                 || !emitted.emitted
-                || (metadata.metadataVersion === 4
-                    && ((qualified && selectedShapes.length !== 1)
-                        || (!qualified && edge.emittedContract.discriminator !== null
-                            && edge.emittedContract.discriminator !== undefined)))) {
+                || (qualified && selectedShapes.length !== 1)
+                || (!qualified && edge.emittedContract.discriminator !== null
+                    && edge.emittedContract.discriminator !== undefined)) {
                 throw new TypeError(`Schema lifecycle consumer ${edge.id} must emit a registered writable contract.`);
             }
             relevantContractPairs.add(key);
-            coveredContractPairs.add(key);
             for (const shape of selectedShapes) {
                 shapeIds.add(shape.id);
-                emittedShapeIds.add(shape.id);
+                emittedShapeIds.add(`${key}\u0000${shape.id}`);
             }
         }
         if (shapeIds.size !== edge.shapeIds.length || edge.shapeIds.some((id) => !shapeIds.has(id))) {
@@ -1446,25 +1403,19 @@ function validateMetadataRelations(family, metadata) {
     }
     for (const contract of family.contracts) {
         const key = `${contract.schema}\u0000${contract.version}`;
-        if (metadata.metadataVersion < 4) {
-            if ((contract.readable || contract.emitted) && !coveredContractPairs.has(key)) {
-                throw new TypeError('Every readable or emitted schema lifecycle contract must have a consumer edge.');
-            }
-            continue;
-        }
         const contractShapeIds = shapeIdsByContract.get(key) ?? new Set();
         if ([...contractShapeIds].some((id) => {
             const shape = shapesById.get(id);
             return shape?.discriminator !== null
                 && shape?.discriminator !== undefined
                 && !(contractPairs.get(key)?.lifecycle === 'retired' && fixtureShapeIds.has(id))
-                && !acceptedShapeIds.has(id)
-                && !emittedShapeIds.has(id);
+                && !acceptedShapeIds.has(`${key}\u0000${id}`)
+                && !emittedShapeIds.has(`${key}\u0000${id}`);
         })) {
             throw new TypeError(`Schema lifecycle contract ${contract.schema} v${contract.version} has an uncovered shape variant.`);
         }
-        const hasReader = [...contractShapeIds].some((id) => acceptedShapeIds.has(id));
-        const hasWriter = [...contractShapeIds].some((id) => emittedShapeIds.has(id));
+        const hasReader = [...contractShapeIds].some((id) => acceptedShapeIds.has(`${key}\u0000${id}`));
+        const hasWriter = [...contractShapeIds].some((id) => emittedShapeIds.has(`${key}\u0000${id}`));
         if (contract.readable !== hasReader || contract.emitted !== hasWriter) {
             throw new TypeError(`Schema lifecycle contract ${contract.schema} v${contract.version} must exactly aggregate its readable and emitted shape variants.`);
         }
@@ -1500,13 +1451,13 @@ export function defineSchemaLifecycleFamily(value) {
     validateFamilyRelations(family);
     if (!metadataDescriptor) {
         if (contracts.some((contract) => contract.extensionPolicy === 'preserve_bounded')) {
-            throw new TypeError('Schema lifecycle metadata version 3 is required for bounded extensions.');
+            throw new TypeError('Schema lifecycle metadata is required for bounded extensions.');
         }
         if (contracts.some((contract) => contract.extensionPolicy === 'discard_bounded'
             || contract.lifecycle === 'retired')
             || fixtures.some((fixture) => Object.hasOwn(fixture, 'shapeId')
                 || fixture.expectation === 'historical_output_exact')) {
-            throw new TypeError('Schema lifecycle metadata version 4 is required for retired or projected contracts.');
+            throw new TypeError('Schema lifecycle metadata is required for retired or projected contracts.');
         }
         return family;
     }
@@ -1515,49 +1466,28 @@ export function defineSchemaLifecycleFamily(value) {
         textCodeUnits: 0,
         serialisedBytes: 0,
     };
-    const metadataSource = ordinaryRecord(source.metadata, [METADATA_V1_KEYS, METADATA_V2_KEYS, METADATA_V3_KEYS, METADATA_V4_KEYS], 'Schema lifecycle metadata', metadataBudget);
+    const metadataSource = ordinaryRecord(source.metadata, METADATA_KEYS, 'Schema lifecycle metadata', metadataBudget, ['metadataVersion']);
     const metadataVersion = metadataSource.metadataVersion;
-    const hasConsumerRelationships = Object.hasOwn(metadataSource, 'consumerRelationships');
-    if ((metadataVersion !== 1 && metadataVersion !== 2 && metadataVersion !== 3 && metadataVersion !== 4)
-        || metadataSource.enforcement !== 'declarative_only'
-        || (metadataVersion === 1 && hasConsumerRelationships)
-        || ((metadataVersion === 2 || metadataVersion === 3 || metadataVersion === 4) && !hasConsumerRelationships)) {
+    if ((Object.hasOwn(metadataSource, 'metadataVersion') && metadataVersion !== SCHEMA_LIFECYCLE_METADATA_VERSION)
+        || metadataSource.enforcement !== 'declarative_only') {
         throw new TypeError('Schema lifecycle metadata must use an exact registered declarative-only version.');
     }
-    const usesVersion4Vocabulary = contracts.some((contract) => contract.extensionPolicy === 'discard_bounded'
-        || contract.lifecycle === 'retired')
-        || fixtures.some((fixture) => Object.hasOwn(fixture, 'shapeId')
-            || fixture.expectation === 'historical_output_exact');
-    if ((metadataVersion === 4) !== usesVersion4Vocabulary
-        || (metadataVersion === 4 && fixtures.some((fixture) => !Object.hasOwn(fixture, 'shapeId')))) {
-        throw new TypeError('Schema lifecycle metadata version 4 must exclusively and completely own its retired or projected vocabulary.');
-    }
     const metadataCommon = {
         enforcement: 'declarative_only',
-        shapes: Object.freeze(denseArray(metadataSource.shapes, 'Schema lifecycle shapes', MAX_METADATA_COLLECTION, 1, metadataBudget).map((item, index) => copyShape(item, index, metadataBudget, metadataVersion))),
+        shapes: Object.freeze(denseArray(metadataSource.shapes, 'Schema lifecycle shapes', MAX_METADATA_COLLECTION, 1, metadataBudget).map((item, index) => copyShape(item, index, metadataBudget))),
         boundProfiles: Object.freeze(denseArray(metadataSource.boundProfiles, 'Schema lifecycle bound profiles', MAX_METADATA_COLLECTION, 1, metadataBudget).map((item, index) => copyBoundProfile(item, index, metadataBudget))),
         hooks: Object.freeze(denseArray(metadataSource.hooks, 'Schema lifecycle hooks', MAX_METADATA_COLLECTION, 1, metadataBudget).map((item, index) => copyHook(item, index, metadataBudget))),
         serialisationProfiles: Object.freeze(denseArray(metadataSource.serialisationProfiles, 'Schema lifecycle serialisation profiles', MAX_METADATA_COLLECTION, 1, metadataBudget).map((item, index) => copySerialisationProfile(item, index, metadataBudget))),
         privacyProfiles: Object.freeze(denseArray(metadataSource.privacyProfiles, 'Schema lifecycle privacy profiles', MAX_METADATA_COLLECTION, 1, metadataBudget).map((item, index) => copyPrivacyProfile(item, index, metadataBudget))),
         expiryProfiles: Object.freeze(denseArray(metadataSource.expiryProfiles, 'Schema lifecycle expiry profiles', MAX_METADATA_COLLECTION, 1, metadataBudget).map((item, index) => copyExpiryPolicy(item, index, metadataBudget))),
-        consumerEdges: Object.freeze(denseArray(metadataSource.consumerEdges, 'Schema lifecycle consumer edges', MAX_METADATA_COLLECTION, 1, metadataBudget).map((item, index) => copyConsumerEdge(item, index, metadataBudget, metadataVersion))),
+        consumerEdges: Object.freeze(denseArray(metadataSource.consumerEdges, 'Schema lifecycle consumer edges', MAX_METADATA_COLLECTION, 1, metadataBudget).map((item, index) => copyConsumerEdge(item, index, metadataBudget))),
     };
-    const consumerRelationships = metadataVersion === 1
-        ? Object.freeze([])
-        : Object.freeze(denseArray(metadataSource.consumerRelationships, 'Schema lifecycle consumer relationships', MAX_METADATA_COLLECTION, 0, metadataBudget).map((item, index) => copyConsumerRelationship(item, index, metadataBudget)));
-    const metadata = metadataVersion === 1
-        ? Object.freeze({ metadataVersion: 1, ...metadataCommon })
-        : metadataVersion === 2
-            ? Object.freeze({ metadataVersion: 2, ...metadataCommon, consumerRelationships })
-            : metadataVersion === 3
-                ? Object.freeze({ metadataVersion: 3, ...metadataCommon, consumerRelationships })
-                : Object.freeze({
-                    metadataVersion: 4,
-                    ...metadataCommon,
-                    shapes: metadataCommon.shapes,
-                    consumerEdges: metadataCommon.consumerEdges,
-                    consumerRelationships,
-                });
+    const consumerRelationships = Object.freeze(denseArray(metadataSource.consumerRelationships, 'Schema lifecycle consumer relationships', MAX_METADATA_COLLECTION, 0, metadataBudget).map((item, index) => copyConsumerRelationship(item, index, metadataBudget)));
+    const metadata = Object.freeze({
+        metadataVersion: SCHEMA_LIFECYCLE_METADATA_VERSION,
+        ...metadataCommon,
+        consumerRelationships,
+    });
     validateMetadataRelations(family, metadata);
     return Object.freeze({ ...family, metadata });
 }
@@ -1586,7 +1516,7 @@ function validateRegistryConsumerRelationships(families) {
         if (!Object.hasOwn(family, 'metadata'))
             continue;
         const metadata = family.metadata;
-        for (const relationship of metadataConsumerRelationships(metadata)) {
+        for (const relationship of metadata.consumerRelationships) {
             const source = consumers.get(relationship.sourceConsumerId);
             const target = consumers.get(relationship.targetConsumerId);
             if (!source || source.familyId !== family.id) {
@@ -1686,7 +1616,7 @@ export function defineSchemaLifecycleRegistry(value) {
                 ...metadata.privacyProfiles.map((item) => item.id),
                 ...metadata.expiryProfiles.map((item) => item.id),
                 ...metadata.consumerEdges.map((item) => item.id),
-                ...metadataConsumerRelationships(metadata).map((item) => item.id),
+                ...metadata.consumerRelationships.map((item) => item.id),
             ];
             for (const id of familyMetadataIds) {
                 if (metadataIds.has(id)) {

package/packages/contracts/selected-file-limits.mjs

@@ -0,0 +1,6 @@
+// A complete 32-MiB workspace's encrypted JSON exceeds 42 MiB. This allowance
+// admits that file and supporting evidence without splitting a selected file.
+export const MAX_SELECTED_FILES = 128;
+export const MAX_SELECTED_FILE_TOTAL_BYTES = 64 * 1024 * 1024;
+export const MAX_SELECTED_FILE_BYTES = MAX_SELECTED_FILE_TOTAL_BYTES;
+export const SELECTED_FILE_MEDIA_TYPES = ['application/json', 'application/octet-stream', 'image/png', 'image/jpeg', 'image/webp', 'image/gif', 'application/pdf'];

package/packages/contracts/vulnerability-identifiers.mjs

@@ -0,0 +1,5 @@
+// Syntax only: an identifier is not evidence that a record exists or applies.
+function isCveIdentifier(value) {
+    return typeof value === 'string' && value.length <= 80 && /^CVE-[0-9]{4}-[0-9]{4,}$/u.test(value);
+}
+export { isCveIdentifier };

package/packages/contracts/web-capture.mjs

@@ -0,0 +1,10 @@
+export { MAX_WEB_CAPTURE_MANIFEST_BYTES, WEB_CAPTURE_MANIFEST_SCHEMA, WEB_CAPTURE_MANIFEST_VERSION, WEB_CAPTURE_SUMMARY_SCHEMA, WEB_CAPTURE_SUMMARY_VERSION, } from "./analyst-interchange.mjs";
+export const WEB_CAPTURE_DOM_DIGEST_SCHEMA = 'whoisleuth.dom-digest';
+export const WEB_CAPTURE_DOM_DIGEST_VERSION = 1;
+export const WEB_CAPTURE_COMPARISON_SCHEMA = 'whoisleuth.web-capture-comparison';
+export const WEB_CAPTURE_COMPARISON_VERSION = 3;
+export const MAX_WEB_CAPTURE_DOM_DIGEST_BYTES = 1024 * 1024;
+export const MAX_WEB_CAPTURE_SCREENSHOT_BYTES = 10 * 1024 * 1024;
+export const MAX_WEB_CAPTURE_DOM_ELEMENTS = 20_000;
+export const MAX_WEB_CAPTURE_DOM_PROJECTION_CHARACTERS = 256 * 1024;
+export const MAX_WEB_CAPTURE_VISIBLE_TEXT_BYTES = 256 * 1024;