@slicedearth/whoisleuth-cli 1.47.4 → 2.0.0

package/packages/contracts/investigation-portability.mjs

@@ -0,0 +1,331 @@
+import { defineSchemaCompatibility } from "./schema-compatibility.mjs";
+import { defineSchemaLifecycleFamily } from "./schema-lifecycle.mjs";
+export const INVESTIGATION_PORTABILITY_CONTRACT_OWNER = 'packages/contracts/investigation-portability.mts';
+export const MAX_INVESTIGATION_PORTABLE_BYTES = 15 * 1024 * 1024;
+export const ACQUISITION_DECISION_PACKET_SCHEMA = 'whoisleuth.acquisition-decision';
+export const ACQUISITION_DECISION_PACKET_VERSION = 2;
+export const SUPPORTED_ACQUISITION_DECISION_PACKET_VERSIONS = Object.freeze([ACQUISITION_DECISION_PACKET_VERSION]);
+export const LOOKUP_CLAIM_READINESS_VERSION = 2;
+export const LOOKUP_CLAIM_PASSPORT_SCHEMA = 'whoisleuth.lookup-claim-passport';
+export const LOOKUP_CLAIM_PASSPORT_VERSION = 1;
+export const MAX_LOOKUP_CLAIM_PASSPORT_BYTES = 64 * 1024;
+export const MAX_LOOKUP_CLAIM_PASSPORT_REQUIREMENTS = 16;
+export const MAX_LOOKUP_CLAIM_PASSPORT_LIMITATIONS = 16;
+export const LOOKUP_CLAIM_PASSPORT_TARGET_TYPES = Object.freeze(['domain', 'ipv4', 'ipv6', 'asn']);
+export const BULK_DOMAIN_COMPARISON_SCHEMA = 'whoisleuth.domain-comparison';
+export const BULK_DOMAIN_COMPARISON_VERSION = 3;
+export const BULK_DOMAIN_COMPARISON_EXPORT_VERSION = 4;
+export const SUPPORTED_BULK_DOMAIN_COMPARISON_EXPORT_VERSIONS = Object.freeze([BULK_DOMAIN_COMPARISON_EXPORT_VERSION]);
+export const BULK_MAIL_EXPOSURE_SCHEMA = 'whoisleuth.bulk-mail-exposure';
+export const BULK_MAIL_EXPOSURE_VERSION = 1;
+export const BULK_MAIL_EXPOSURE_EXPORT_VERSION = 2;
+export const SUPPORTED_BULK_MAIL_EXPOSURE_EXPORT_VERSIONS = Object.freeze([BULK_MAIL_EXPOSURE_EXPORT_VERSION]);
+export const MAX_BULK_MAIL_EXPOSURE_ROWS = 2_000;
+export const BULK_REVIEW_MANIFEST_SCHEMA = 'whoisleuth.bulk-review-manifest';
+export const BULK_REVIEW_MANIFEST_VERSION = 2;
+export const SUPPORTED_BULK_REVIEW_MANIFEST_VERSIONS = Object.freeze([BULK_REVIEW_MANIFEST_VERSION]);
+export const INVESTIGATION_CAPSULE_SCHEMA = 'whoisleuth.investigation-capsule';
+export const INVESTIGATION_CAPSULE_VERSION = 3;
+export const PUBLIC_INVESTIGATION_CAPSULE_VERSION = 2;
+export const SUPPORTED_INVESTIGATION_CAPSULE_VERSIONS = Object.freeze([
+    PUBLIC_INVESTIGATION_CAPSULE_VERSION,
+    INVESTIGATION_CAPSULE_VERSION,
+]);
+export const INVESTIGATION_CAPSULE_ANALYST_RECORDS_SCHEMA = 'whoisleuth.case-analyst-records';
+export const INVESTIGATION_CAPSULE_ANALYST_RECORDS_VERSION = 1;
+export const LOOKUP_INVESTIGATION_BRIEF_SCHEMA = 'whoisleuth.investigation-brief';
+export const LOOKUP_INVESTIGATION_BRIEF_VERSION = 2;
+export const PUBLIC_LOOKUP_INVESTIGATION_BRIEF_VERSION = 1;
+export const SUPPORTED_LOOKUP_INVESTIGATION_BRIEF_VERSIONS = Object.freeze([
+    PUBLIC_LOOKUP_INVESTIGATION_BRIEF_VERSION,
+    LOOKUP_INVESTIGATION_BRIEF_VERSION,
+]);
+export const MAX_LOOKUP_INVESTIGATION_BRIEF_BYTES = 128 * 1024;
+export const LOOKUP_ASSET_GRAPH_SCHEMA = 'whoisleuth.lookup-asset-graph';
+export const LOOKUP_ASSET_GRAPH_VERSION = 2;
+export const INVESTIGATION_DOMAIN_COMPATIBILITY_FACADES = Object.freeze([
+    ['frontend/src/lib/analysis/acquisition-decision-packet.ts', 'packages/investigation/acquisition-decision-packet.mts'],
+    ['frontend/src/lib/analysis/acquisition-due-diligence.ts', 'packages/investigation/acquisition-due-diligence.mts'],
+    ['frontend/src/lib/analysis/bulk-domain-comparison.ts', 'packages/investigation/bulk-domain-comparison.mts'],
+    ['frontend/src/lib/analysis/bulk-mail-exposure.ts', 'packages/investigation/bulk-mail-exposure.mts'],
+    ['frontend/src/lib/analysis/bulk-review-export.ts', 'packages/investigation/bulk-review-export.mts'],
+    ['frontend/src/lib/analysis/evidence-coverage-ledger.ts', 'packages/investigation/evidence-coverage-ledger.mts'],
+    ['frontend/src/lib/analysis/investigation-capsule.ts', 'packages/investigation/investigation-capsule.mts'],
+    ['frontend/src/lib/analysis/lookup-asset-graph.ts', 'packages/investigation/lookup-asset-graph.mts'],
+    ['frontend/src/lib/analysis/lookup-claim-passport.ts', 'packages/investigation/lookup-claim-passport.mts'],
+    ['frontend/src/lib/analysis/lookup-claim-readiness.ts', 'packages/investigation/lookup-claim-readiness.mts'],
+    ['frontend/src/lib/analysis/lookup-investigation-brief.ts', 'packages/investigation/lookup-investigation-brief.mts'],
+]);
+export const ACQUISITION_DECISION_PACKET_COMPATIBILITY = defineSchemaCompatibility({
+    id: 'export.acquisition-decision', kind: 'export', schema: ACQUISITION_DECISION_PACKET_SCHEMA,
+    currentVersion: ACQUISITION_DECISION_PACKET_VERSION, supportedVersions: SUPPORTED_ACQUISITION_DECISION_PACKET_VERSIONS,
+    acceptsUnversionedLegacy: false, futureVersionBehavior: 'reject', migration: 'read_only', writeSemantics: 'read_only',
+    byteBudget: MAX_INVESTIGATION_PORTABLE_BYTES, owner: INVESTIGATION_PORTABILITY_CONTRACT_OWNER,
+    note: 'The v1.47.4 current writer and v2 both use version 2 with deterministic sorted-json-v2 integrity for a bounded acquisition review without making an availability, eligibility, ownership, valuation, or purchase determination.',
+});
+export const LOOKUP_CLAIM_PASSPORT_COMPATIBILITY = defineSchemaCompatibility({
+    id: 'export.lookup-claim-passport', kind: 'export', schema: LOOKUP_CLAIM_PASSPORT_SCHEMA,
+    currentVersion: LOOKUP_CLAIM_PASSPORT_VERSION, supportedVersions: [LOOKUP_CLAIM_PASSPORT_VERSION],
+    acceptsUnversionedLegacy: false, futureVersionBehavior: 'reject', migration: 'read_only', writeSemantics: 'read_only',
+    byteBudget: MAX_LOOKUP_CLAIM_PASSPORT_BYTES, owner: INVESTIGATION_PORTABILITY_CONTRACT_OWNER,
+    note: 'Explicit local export of one typed Evidence Readiness projection with exact evidence requirement IDs, retained source states, bounded limitations, and deterministic sorted-json-v2 integrity; raw source payloads and browser-local records are excluded.',
+});
+export const BULK_DOMAIN_COMPARISON_COMPATIBILITY = defineSchemaCompatibility({
+    id: 'export.domain-comparison', kind: 'export', schema: BULK_DOMAIN_COMPARISON_SCHEMA,
+    currentVersion: BULK_DOMAIN_COMPARISON_EXPORT_VERSION, supportedVersions: SUPPORTED_BULK_DOMAIN_COMPARISON_EXPORT_VERSIONS,
+    acceptsUnversionedLegacy: false, futureVersionBehavior: 'reject', migration: 'read_only', writeSemantics: 'read_only',
+    byteBudget: MAX_INVESTIGATION_PORTABLE_BYTES, owner: INVESTIGATION_PORTABILITY_CONTRACT_OWNER,
+    note: 'Export version 4 uses deterministic sorted-json-v2 integrity while its nested comparison remains version 3 and preserves distinct evidence states.',
+});
+export const BULK_MAIL_EXPOSURE_COMPATIBILITY = defineSchemaCompatibility({
+    id: 'export.bulk-mail-exposure', kind: 'export', schema: BULK_MAIL_EXPOSURE_SCHEMA,
+    currentVersion: BULK_MAIL_EXPOSURE_EXPORT_VERSION, supportedVersions: SUPPORTED_BULK_MAIL_EXPOSURE_EXPORT_VERSIONS,
+    acceptsUnversionedLegacy: false, futureVersionBehavior: 'reject', migration: 'read_only', writeSemantics: 'read_only',
+    byteBudget: MAX_INVESTIGATION_PORTABLE_BYTES, owner: INVESTIGATION_PORTABILITY_CONTRACT_OWNER,
+    note: 'Export version 2 uses deterministic sorted-json-v2 integrity while its nested report remains version 1 and incomplete DNS evidence remains inconclusive.',
+});
+export const BULK_REVIEW_MANIFEST_COMPATIBILITY = defineSchemaCompatibility({
+    id: 'export.bulk-review-manifest', kind: 'export', schema: BULK_REVIEW_MANIFEST_SCHEMA,
+    currentVersion: BULK_REVIEW_MANIFEST_VERSION, supportedVersions: SUPPORTED_BULK_REVIEW_MANIFEST_VERSIONS,
+    acceptsUnversionedLegacy: false, futureVersionBehavior: 'reject', migration: 'read_only', writeSemantics: 'read_only',
+    byteBudget: MAX_INVESTIGATION_PORTABLE_BYTES, owner: INVESTIGATION_PORTABILITY_CONTRACT_OWNER,
+    note: 'Version 2 uses deterministic sorted-json-v2 integrity for one bounded Bulk review selection while excluding raw payloads, contacts, notes, and transient request state.',
+});
+export const INVESTIGATION_CAPSULE_COMPATIBILITY = defineSchemaCompatibility({
+    id: 'export.investigation-capsule', kind: 'export', schema: INVESTIGATION_CAPSULE_SCHEMA,
+    currentVersion: INVESTIGATION_CAPSULE_VERSION, supportedVersions: SUPPORTED_INVESTIGATION_CAPSULE_VERSIONS,
+    acceptsUnversionedLegacy: false, futureVersionBehavior: 'reject', migration: 'read_only', writeSemantics: 'read_only',
+    byteBudget: MAX_INVESTIGATION_PORTABLE_BYTES, owner: INVESTIGATION_PORTABILITY_CONTRACT_OWNER,
+    note: 'Version 3 embeds investigation brief v2 with canonical Decision Facts; the v1.47.4 version 2 and v2 version 3 retain whole-capsule sorted-json-v2 integrity.',
+});
+export const LOOKUP_ASSET_GRAPH_COMPATIBILITY = defineSchemaCompatibility({
+    id: 'derived.lookup-asset-graph', kind: 'derived', schema: LOOKUP_ASSET_GRAPH_SCHEMA,
+    tier: 'durable_interchange',
+    currentVersion: LOOKUP_ASSET_GRAPH_VERSION, supportedVersions: [LOOKUP_ASSET_GRAPH_VERSION],
+    acceptsUnversionedLegacy: false, futureVersionBehavior: 'reject', migration: 'exact_current_only', writeSemantics: 'read_only',
+    byteBudget: null, owner: INVESTIGATION_PORTABILITY_CONTRACT_OWNER,
+    note: 'Bounded relationship projection embedded in investigation capsules; source attribution and incomplete evidence remain explicit.',
+});
+export const INVESTIGATION_CAPSULE_ANALYST_RECORDS_COMPATIBILITY = defineSchemaCompatibility({
+    id: 'derived.case-analyst-records', kind: 'derived', schema: INVESTIGATION_CAPSULE_ANALYST_RECORDS_SCHEMA,
+    tier: 'durable_interchange',
+    currentVersion: INVESTIGATION_CAPSULE_ANALYST_RECORDS_VERSION, supportedVersions: [INVESTIGATION_CAPSULE_ANALYST_RECORDS_VERSION],
+    acceptsUnversionedLegacy: false, futureVersionBehavior: 'reject', migration: 'exact_current_only', writeSemantics: 'read_only',
+    byteBudget: null, owner: INVESTIGATION_PORTABILITY_CONTRACT_OWNER,
+    note: 'Optional bounded analyst-decision and assertion projection embedded only after deliberate selection for an investigation capsule.',
+});
+export const LOOKUP_INVESTIGATION_BRIEF_COMPATIBILITY = defineSchemaCompatibility({
+    id: 'derived.lookup-investigation-brief', kind: 'derived', schema: LOOKUP_INVESTIGATION_BRIEF_SCHEMA,
+    tier: 'durable_interchange',
+    currentVersion: LOOKUP_INVESTIGATION_BRIEF_VERSION, supportedVersions: SUPPORTED_LOOKUP_INVESTIGATION_BRIEF_VERSIONS,
+    acceptsUnversionedLegacy: false, futureVersionBehavior: 'reject', migration: 'read_only', writeSemantics: 'none',
+    byteBudget: MAX_LOOKUP_INVESTIGATION_BRIEF_BYTES, owner: INVESTIGATION_PORTABILITY_CONTRACT_OWNER,
+    note: 'Version 2 replaces the public version-1 summary and decision-entry arrays with one bounded canonical Decision Fact projection; public version 1 remains structurally verified when embedded in supported capsule versions.',
+});
+export const INVESTIGATION_PORTABILITY_COMPATIBILITY = Object.freeze([
+    ACQUISITION_DECISION_PACKET_COMPATIBILITY,
+    LOOKUP_CLAIM_PASSPORT_COMPATIBILITY,
+    BULK_DOMAIN_COMPARISON_COMPATIBILITY,
+    BULK_MAIL_EXPOSURE_COMPATIBILITY,
+    BULK_REVIEW_MANIFEST_COMPATIBILITY,
+    INVESTIGATION_CAPSULE_COMPATIBILITY,
+    LOOKUP_ASSET_GRAPH_COMPATIBILITY,
+    INVESTIGATION_CAPSULE_ANALYST_RECORDS_COMPATIBILITY,
+    LOOKUP_INVESTIGATION_BRIEF_COMPATIBILITY,
+]);
+const INVESTIGATION_FIXTURES = Object.freeze([
+    { id: 'acquisition-decision-v2', path: 'test/fixtures/investigation-portability/acquisition-decision-v2.json', bytes: 6_278, sha256: '1c1b5c2fcea2886dae5661085f605d95317b89bb6d9774cb8967a754ef8165bf', schema: ACQUISITION_DECISION_PACKET_SCHEMA, version: 2, role: 'current' },
+    { id: 'lookup-claim-passport-v1', path: 'test/fixtures/investigation-portability/lookup-claim-passport-v1.json', bytes: 2_011, sha256: 'dbf1c3975282e340b6639162a0555aeaed42c06abe92ed3b354409ce73c284a4', schema: LOOKUP_CLAIM_PASSPORT_SCHEMA, version: 1, role: 'current' },
+    { id: 'bulk-domain-comparison-v4', path: 'test/fixtures/investigation-portability/bulk-domain-comparison-v4.json', bytes: 17_079, sha256: 'b718af34c8f5f1ba4427807cd149561bc1b7e605a6e74206a694beaee078cc2d', schema: BULK_DOMAIN_COMPARISON_SCHEMA, version: 4, role: 'current' },
+    { id: 'bulk-mail-exposure-v2', path: 'test/fixtures/investigation-portability/bulk-mail-exposure-v2.json', bytes: 2_582, sha256: '9ff6c4c9f2dda4c5451daf8fb11e36a3ee15b513a09ad3c93515cc37df5d6660', schema: BULK_MAIL_EXPOSURE_SCHEMA, version: 2, role: 'current' },
+    { id: 'bulk-review-manifest-v2', path: 'test/fixtures/investigation-portability/bulk-review-manifest-v2.json', bytes: 1_657, sha256: '1c90f4d0661357fc277360cc924f2464e463f9c8bd815a6b45408e95e1caf7d3', schema: BULK_REVIEW_MANIFEST_SCHEMA, version: 2, role: 'current' },
+    { id: 'investigation-capsule-v2', path: 'test/fixtures/investigation-capsule-v2.json', bytes: 3_286, sha256: 'fb71cb243020d401e3653bb714f9de07a71b81622fcf83c0027599b763dda070', schema: INVESTIGATION_CAPSULE_SCHEMA, version: 2, role: 'historical' },
+    { id: 'investigation-capsule-v3', path: 'test/fixtures/investigation-portability/investigation-capsule-v3.json', bytes: 6_132, sha256: '685123c8bd152ee1a8074441bcd56bbde9fb0304aa4a320ee9b37d02061ed82a', schema: INVESTIGATION_CAPSULE_SCHEMA, version: 3, role: 'current' },
+    { id: 'lookup-asset-graph-v2', path: 'test/fixtures/investigation-portability/lookup-asset-graph-v2.json', bytes: 1_157, sha256: '455397a2b2987180d54657199e76c4dc175e01aed0fa83d945a6f3ec30bdcd49', schema: LOOKUP_ASSET_GRAPH_SCHEMA, version: 2, role: 'current' },
+    { id: 'investigation-analyst-records-v1', path: 'test/fixtures/investigation-portability/investigation-analyst-records-v1.json', bytes: 624, sha256: '0730116afef29e52b448e150f6755e89ec1189c2fbc6ec4ef8cfc4b41f677456', schema: INVESTIGATION_CAPSULE_ANALYST_RECORDS_SCHEMA, version: 1, role: 'current' },
+    { id: 'lookup-investigation-brief-v1', path: 'test/fixtures/investigation-portability/lookup-investigation-brief-v1.json', bytes: 1_651, sha256: 'bc21c886671370659149c3e494c7e6061302569308823c69ef96f0c601dadbab', schema: LOOKUP_INVESTIGATION_BRIEF_SCHEMA, version: 1, role: 'historical' },
+    { id: 'lookup-investigation-brief-v2', path: 'test/fixtures/investigation-portability/lookup-investigation-brief-v2.json', bytes: 1_724, sha256: '25d0133318df8daa00848e6a2c03913478beb30818a4959298ec1500b6aaa0fd', schema: LOOKUP_INVESTIGATION_BRIEF_SCHEMA, version: 2, role: 'current' },
+].map((fixture) => Object.freeze({
+    ...fixture,
+    contentDigestSha256: null,
+    expectation: 'accepted_exact',
+    expectedOutputFixtureId: null,
+    scope: 'repository',
+})));
+function investigationFixtureIds(schema, version) {
+    return Object.freeze(INVESTIGATION_FIXTURES
+        .filter((fixture) => fixture.schema === schema && fixture.version === version)
+        .map((fixture) => fixture.id));
+}
+function investigationContract(input) {
+    return Object.freeze({
+        compatibilityId: input.compatibilityId,
+        schema: input.schema,
+        version: input.version,
+        role: 'document',
+        lifecycle: input.version === input.currentVersion ? 'current' : 'legacy',
+        readable: true,
+        emitted: input.version === input.currentVersion,
+        exactKeys: true,
+        extensionPolicy: 'reject',
+        futureVersionBehaviour: 'reject',
+        migrationTarget: null,
+        canonicalisation: input.canonicalisation,
+        byteBudget: input.byteBudget,
+        fixtureIds: investigationFixtureIds(input.schema, input.version),
+    });
+}
+const INVESTIGATION_CONTRACTS = Object.freeze([
+    ...SUPPORTED_ACQUISITION_DECISION_PACKET_VERSIONS.map((version) => investigationContract({ compatibilityId: ACQUISITION_DECISION_PACKET_COMPATIBILITY.id, schema: ACQUISITION_DECISION_PACKET_SCHEMA, version, currentVersion: ACQUISITION_DECISION_PACKET_VERSION, canonicalisation: 'sorted-json-v2', byteBudget: MAX_INVESTIGATION_PORTABLE_BYTES })),
+    investigationContract({ compatibilityId: LOOKUP_CLAIM_PASSPORT_COMPATIBILITY.id, schema: LOOKUP_CLAIM_PASSPORT_SCHEMA, version: LOOKUP_CLAIM_PASSPORT_VERSION, currentVersion: LOOKUP_CLAIM_PASSPORT_VERSION, canonicalisation: 'sorted-json-v2', byteBudget: MAX_LOOKUP_CLAIM_PASSPORT_BYTES }),
+    ...SUPPORTED_BULK_DOMAIN_COMPARISON_EXPORT_VERSIONS.map((version) => investigationContract({ compatibilityId: BULK_DOMAIN_COMPARISON_COMPATIBILITY.id, schema: BULK_DOMAIN_COMPARISON_SCHEMA, version, currentVersion: BULK_DOMAIN_COMPARISON_EXPORT_VERSION, canonicalisation: 'sorted-json-v2', byteBudget: MAX_INVESTIGATION_PORTABLE_BYTES })),
+    ...SUPPORTED_BULK_MAIL_EXPOSURE_EXPORT_VERSIONS.map((version) => investigationContract({ compatibilityId: BULK_MAIL_EXPOSURE_COMPATIBILITY.id, schema: BULK_MAIL_EXPOSURE_SCHEMA, version, currentVersion: BULK_MAIL_EXPOSURE_EXPORT_VERSION, canonicalisation: 'sorted-json-v2', byteBudget: MAX_INVESTIGATION_PORTABLE_BYTES })),
+    ...SUPPORTED_BULK_REVIEW_MANIFEST_VERSIONS.map((version) => investigationContract({ compatibilityId: BULK_REVIEW_MANIFEST_COMPATIBILITY.id, schema: BULK_REVIEW_MANIFEST_SCHEMA, version, currentVersion: BULK_REVIEW_MANIFEST_VERSION, canonicalisation: 'sorted-json-v2', byteBudget: MAX_INVESTIGATION_PORTABLE_BYTES })),
+    ...SUPPORTED_INVESTIGATION_CAPSULE_VERSIONS.map((version) => investigationContract({ compatibilityId: INVESTIGATION_CAPSULE_COMPATIBILITY.id, schema: INVESTIGATION_CAPSULE_SCHEMA, version, currentVersion: INVESTIGATION_CAPSULE_VERSION, canonicalisation: 'sorted-json-v2', byteBudget: MAX_INVESTIGATION_PORTABLE_BYTES })),
+    investigationContract({ compatibilityId: LOOKUP_ASSET_GRAPH_COMPATIBILITY.id, schema: LOOKUP_ASSET_GRAPH_SCHEMA, version: LOOKUP_ASSET_GRAPH_VERSION, currentVersion: LOOKUP_ASSET_GRAPH_VERSION, canonicalisation: null, byteBudget: null }),
+    investigationContract({ compatibilityId: INVESTIGATION_CAPSULE_ANALYST_RECORDS_COMPATIBILITY.id, schema: INVESTIGATION_CAPSULE_ANALYST_RECORDS_SCHEMA, version: INVESTIGATION_CAPSULE_ANALYST_RECORDS_VERSION, currentVersion: INVESTIGATION_CAPSULE_ANALYST_RECORDS_VERSION, canonicalisation: null, byteBudget: null }),
+    ...SUPPORTED_LOOKUP_INVESTIGATION_BRIEF_VERSIONS.map((version) => investigationContract({ compatibilityId: LOOKUP_INVESTIGATION_BRIEF_COMPATIBILITY.id, schema: LOOKUP_INVESTIGATION_BRIEF_SCHEMA, version, currentVersion: LOOKUP_INVESTIGATION_BRIEF_VERSION, canonicalisation: null, byteBudget: MAX_LOOKUP_INVESTIGATION_BRIEF_BYTES })),
+]);
+function investigationShape(id, schema, versions, requiredKeys, normalisation) {
+    return Object.freeze({
+        id,
+        schema,
+        versions,
+        objects: [{ path: '$', requiredKeys, optionalKeys: [], unknownKeys: 'reject' }],
+        fixedArrays: [],
+        normalisation,
+        target: null,
+    });
+}
+const INVESTIGATION_SHAPES = Object.freeze([
+    investigationShape('investigation.acquisition.v2', ACQUISITION_DECISION_PACKET_SCHEMA, [...SUPPORTED_ACQUISITION_DECISION_PACKET_VERSIONS], ['schema', 'version', 'generatedAt', 'target', 'synthetic', 'evidenceObservedAt', 'analystReview', 'evidenceReview', 'limitations', 'integrity'], 'preserve_signed_document'),
+    investigationShape('investigation.claim-passport.v1', LOOKUP_CLAIM_PASSPORT_SCHEMA, [LOOKUP_CLAIM_PASSPORT_VERSION], ['schema', 'version', 'generatedAt', 'application', 'target', 'observation', 'claim', 'models', 'limitations', 'integrity'], 'preserve_signed_document'),
+    investigationShape('investigation.domain-comparison.v4', BULK_DOMAIN_COMPARISON_SCHEMA, [...SUPPORTED_BULK_DOMAIN_COMPARISON_EXPORT_VERSIONS], ['schema', 'version', 'generatedAt', 'comparison', 'integrity'], 'preserve_signed_document'),
+    investigationShape('investigation.mail-exposure.v2', BULK_MAIL_EXPOSURE_SCHEMA, [...SUPPORTED_BULK_MAIL_EXPOSURE_EXPORT_VERSIONS], ['schema', 'version', 'report', 'integrity'], 'preserve_signed_document'),
+    investigationShape('investigation.bulk-review.v2', BULK_REVIEW_MANIFEST_SCHEMA, [...SUPPORTED_BULK_REVIEW_MANIFEST_VERSIONS], ['schema', 'version', 'generatedAt', 'observedAt', 'lookupProfile', 'selection', 'view', 'rows', 'limitations', 'integrity'], 'preserve_signed_document'),
+    investigationShape('investigation.capsule.v2-v3', INVESTIGATION_CAPSULE_SCHEMA, [...SUPPORTED_INVESTIGATION_CAPSULE_VERSIONS], ['schema', 'schemaVersion', 'generatedAt', 'application', 'target', 'sourceContracts', 'investigationBrief', 'graphSnapshot', 'analystRecords', 'limitations', 'integrity'], 'preserve_signed_document'),
+    investigationShape('investigation.asset-graph.v2', LOOKUP_ASSET_GRAPH_SCHEMA, [LOOKUP_ASSET_GRAPH_VERSION], ['version', 'targetId', 'nodes', 'edges', 'sources', 'truncated', 'limitations'], 'preserve_document'),
+    investigationShape('investigation.analyst-records.v1', INVESTIGATION_CAPSULE_ANALYST_RECORDS_SCHEMA, [INVESTIGATION_CAPSULE_ANALYST_RECORDS_VERSION], ['caseId', 'status', 'disposition', 'decisions', 'assertions'], 'preserve_document'),
+    investigationShape('investigation.brief.v1', LOOKUP_INVESTIGATION_BRIEF_SCHEMA, [PUBLIC_LOOKUP_INVESTIGATION_BRIEF_VERSION], ['schema', 'schemaVersion', 'generatedAt', 'target', 'targetType', 'task', 'taskLabel', 'question', 'summary', 'observation', 'verifiedFacts', 'contradictions', 'unknowns', 'nextActions', 'relationships', 'limitations'], 'preserve_document'),
+    investigationShape('investigation.brief.v2', LOOKUP_INVESTIGATION_BRIEF_SCHEMA, [LOOKUP_INVESTIGATION_BRIEF_VERSION], ['schema', 'schemaVersion', 'generatedAt', 'target', 'targetType', 'task', 'taskLabel', 'question', 'summary', 'observation', 'decisionFacts', 'relationships', 'limitations'], 'preserve_document'),
+]);
+const investigationConsumerCommon = Object.freeze({
+    expiryPolicyId: 'investigation.expiry.not-applicable',
+    requestMode: 'none',
+    bindingState: 'declared_unenforced',
+    policyState: 'current',
+});
+export const INVESTIGATION_PORTABILITY_LIFECYCLE_FAMILY = defineSchemaLifecycleFamily({
+    id: 'investigation-portability',
+    owner: INVESTIGATION_PORTABILITY_CONTRACT_OWNER,
+    privacy: 'analyst_authored_sensitive',
+    compatibility: INVESTIGATION_PORTABILITY_COMPATIBILITY,
+    contracts: INVESTIGATION_CONTRACTS,
+    fixtures: INVESTIGATION_FIXTURES,
+    metadata: {
+        metadataVersion: 3,
+        enforcement: 'declarative_only',
+        shapes: INVESTIGATION_SHAPES,
+        boundProfiles: [
+            { id: 'investigation.portable.bounds', bounds: [
+                    { id: 'raw-bytes', path: '$', phase: 'raw_intake', unit: 'bytes', minimum: 1, maximum: MAX_INVESTIGATION_PORTABLE_BYTES, handling: 'reject' },
+                    { id: 'serialised-bytes', path: '$', phase: 'serialised', unit: 'bytes', minimum: 1, maximum: MAX_INVESTIGATION_PORTABLE_BYTES, handling: 'reject' },
+                ] },
+            { id: 'investigation.passport.bounds', bounds: [
+                    { id: 'raw-bytes', path: '$', phase: 'raw_intake', unit: 'bytes', minimum: 1, maximum: MAX_LOOKUP_CLAIM_PASSPORT_BYTES, handling: 'reject' },
+                    { id: 'serialised-bytes', path: '$', phase: 'serialised', unit: 'bytes', minimum: 1, maximum: MAX_LOOKUP_CLAIM_PASSPORT_BYTES, handling: 'reject' },
+                ] },
+            { id: 'investigation.brief.bounds', bounds: [
+                    { id: 'raw-bytes', path: '$', phase: 'raw_intake', unit: 'bytes', minimum: 1, maximum: MAX_LOOKUP_INVESTIGATION_BRIEF_BYTES, handling: 'reject' },
+                    { id: 'serialised-bytes', path: '$', phase: 'serialised', unit: 'bytes', minimum: 1, maximum: MAX_LOOKUP_INVESTIGATION_BRIEF_BYTES, handling: 'reject' },
+                ] },
+            { id: 'investigation.derived.bounds', bounds: [
+                    { id: 'projection-items', path: '$', phase: 'normalised', unit: 'items', minimum: 0, maximum: 2_000, handling: 'truncate' },
+                ] },
+        ],
+        hooks: [
+            { id: 'investigation.offline.structure', role: 'structure_validator', runtime: 'cli', module: 'cli/artifact-structure.mts', exportName: 'validateOfflineArtifactStructure' },
+            { id: 'investigation.offline.verify', role: 'integrity_verifier', runtime: 'cli', module: 'cli/artifact-verify.mts', exportName: 'verifyOfflineArtifact' },
+            { id: 'investigation.acquisition.build', role: 'builder', runtime: 'shared', module: 'packages/investigation/acquisition-decision-packet.mts', exportName: 'buildAcquisitionDecisionPacket' },
+            { id: 'investigation.passport.build', role: 'builder', runtime: 'shared', module: 'packages/investigation/lookup-claim-passport.mts', exportName: 'buildLookupClaimPassport' },
+            { id: 'investigation.domain-comparison.build', role: 'builder', runtime: 'shared', module: 'packages/investigation/bulk-domain-comparison.mts', exportName: 'buildBulkDomainComparisonExport' },
+            { id: 'investigation.mail-exposure.build', role: 'builder', runtime: 'shared', module: 'packages/investigation/bulk-mail-exposure.mts', exportName: 'buildBulkMailExposureExport' },
+            { id: 'investigation.bulk-review.build', role: 'builder', runtime: 'shared', module: 'packages/investigation/bulk-review-export.mts', exportName: 'buildBulkReviewManifest' },
+            { id: 'investigation.capsule.build', role: 'builder', runtime: 'shared', module: 'packages/investigation/investigation-capsule.mts', exportName: 'buildInvestigationCapsule' },
+            { id: 'investigation.capsule.verify', role: 'integrity_verifier', runtime: 'shared', module: 'packages/investigation/investigation-capsule.mts', exportName: 'verifyInvestigationCapsule' },
+            { id: 'investigation.capsule.serialise', role: 'serialiser', runtime: 'shared', module: 'packages/investigation/investigation-capsule.mts', exportName: 'serializeInvestigationCapsule' },
+            { id: 'investigation.graph.build', role: 'builder', runtime: 'shared', module: 'packages/investigation/lookup-asset-graph.mts', exportName: 'buildLookupAssetGraph' },
+            { id: 'investigation.brief.build', role: 'builder', runtime: 'shared', module: 'packages/investigation/lookup-investigation-brief.mts', exportName: 'buildLookupInvestigationBrief' },
+        ],
+        serialisationProfiles: [{
+                id: 'investigation.capsule.json.v2-v3',
+                schema: INVESTIGATION_CAPSULE_SCHEMA,
+                versions: [...SUPPORTED_INVESTIGATION_CAPSULE_VERSIONS],
+                mediaType: 'application/json',
+                encoding: 'utf-8',
+                bom: false,
+                indentSpaces: 2,
+                terminalLf: true,
+                propertyOrder: 'normalised_fixed',
+                canonicalisation: null,
+                integrity: 'structural_only_requires_separate_verification',
+                serializerHookId: 'investigation.capsule.serialise',
+                verifierHookIds: ['investigation.capsule.verify'],
+            }],
+        privacyProfiles: [
+            { id: 'investigation.privacy.input', classification: 'analyst_authored_sensitive', projection: 'browser_import', includedCategories: ['bounded-investigation-projections', 'source-qualified-evidence-states', 'declared-integrity'], excludedCategories: ['raw-upstream-payloads', 'expanded-contacts', 'credentials', 'cookies', 'query-bearing-urls'], notePolicy: 'allowed_bounded', retention: 'deliberate_local_file', network: 'none', sharingReview: 'required' },
+            { id: 'investigation.privacy.output', classification: 'analyst_authored_sensitive', projection: 'browser_export', includedCategories: ['bounded-investigation-projections', 'source-qualified-evidence-states', 'declared-integrity'], excludedCategories: ['raw-upstream-payloads', 'expanded-contacts', 'credentials', 'cookies', 'query-bearing-urls'], notePolicy: 'allowed_bounded', retention: 'operator_controlled_output', network: 'none', sharingReview: 'required' },
+        ],
+        expiryProfiles: [{ id: 'investigation.expiry.not-applicable', field: null, anchor: null, handling: 'not_applicable', phase: 'not_applicable', maximumLifetimeDays: null }],
+        consumerEdges: [
+            {
+                id: 'investigation.consumer.offline-verify', plane: 'cli', operation: 'validate-structure-and-integrity',
+                acceptedContracts: [
+                    { schema: ACQUISITION_DECISION_PACKET_SCHEMA, versions: [...SUPPORTED_ACQUISITION_DECISION_PACKET_VERSIONS], mode: 'direct' },
+                    { schema: LOOKUP_CLAIM_PASSPORT_SCHEMA, versions: [LOOKUP_CLAIM_PASSPORT_VERSION], mode: 'direct' },
+                    { schema: BULK_DOMAIN_COMPARISON_SCHEMA, versions: [...SUPPORTED_BULK_DOMAIN_COMPARISON_EXPORT_VERSIONS], mode: 'direct' },
+                    { schema: BULK_MAIL_EXPOSURE_SCHEMA, versions: [...SUPPORTED_BULK_MAIL_EXPOSURE_EXPORT_VERSIONS], mode: 'direct' },
+                    { schema: BULK_REVIEW_MANIFEST_SCHEMA, versions: [...SUPPORTED_BULK_REVIEW_MANIFEST_VERSIONS], mode: 'direct' },
+                    { schema: INVESTIGATION_CAPSULE_SCHEMA, versions: [...SUPPORTED_INVESTIGATION_CAPSULE_VERSIONS], mode: 'direct' },
+                ],
+                emittedContract: null,
+                shapeIds: ['investigation.acquisition.v2', 'investigation.claim-passport.v1', 'investigation.domain-comparison.v4', 'investigation.mail-exposure.v2', 'investigation.bulk-review.v2', 'investigation.capsule.v2-v3'],
+                boundProfileIds: ['investigation.portable.bounds', 'investigation.passport.bounds'],
+                hookIds: ['investigation.offline.structure', 'investigation.offline.verify'],
+                serialisationProfileId: null,
+                privacyProfileId: 'investigation.privacy.input', retentionEffect: 'deliberate_local_file', ...investigationConsumerCommon,
+            },
+            {
+                id: 'investigation.consumer.capsule-compose', plane: 'shared', operation: 'compose-and-verify-capsule',
+                acceptedContracts: [
+                    { schema: LOOKUP_ASSET_GRAPH_SCHEMA, versions: [LOOKUP_ASSET_GRAPH_VERSION], mode: 'embedded' },
+                    { schema: INVESTIGATION_CAPSULE_ANALYST_RECORDS_SCHEMA, versions: [INVESTIGATION_CAPSULE_ANALYST_RECORDS_VERSION], mode: 'embedded' },
+                    { schema: LOOKUP_INVESTIGATION_BRIEF_SCHEMA, versions: [...SUPPORTED_LOOKUP_INVESTIGATION_BRIEF_VERSIONS], mode: 'embedded' },
+                ],
+                emittedContract: { schema: INVESTIGATION_CAPSULE_SCHEMA, version: INVESTIGATION_CAPSULE_VERSION },
+                shapeIds: ['investigation.asset-graph.v2', 'investigation.analyst-records.v1', 'investigation.brief.v1', 'investigation.brief.v2', 'investigation.capsule.v2-v3'],
+                boundProfileIds: ['investigation.portable.bounds', 'investigation.brief.bounds', 'investigation.derived.bounds'],
+                hookIds: ['investigation.capsule.build', 'investigation.capsule.verify', 'investigation.capsule.serialise'],
+                serialisationProfileId: 'investigation.capsule.json.v2-v3',
+                privacyProfileId: 'investigation.privacy.output', retentionEffect: 'operator_controlled_output', ...investigationConsumerCommon,
+            },
+            ...[
+                ['investigation.consumer.acquisition-build', ACQUISITION_DECISION_PACKET_SCHEMA, ACQUISITION_DECISION_PACKET_VERSION, 'investigation.acquisition.v2', 'investigation.acquisition.build', 'investigation.portable.bounds'],
+                ['investigation.consumer.passport-build', LOOKUP_CLAIM_PASSPORT_SCHEMA, LOOKUP_CLAIM_PASSPORT_VERSION, 'investigation.claim-passport.v1', 'investigation.passport.build', 'investigation.passport.bounds'],
+                ['investigation.consumer.domain-comparison-build', BULK_DOMAIN_COMPARISON_SCHEMA, BULK_DOMAIN_COMPARISON_EXPORT_VERSION, 'investigation.domain-comparison.v4', 'investigation.domain-comparison.build', 'investigation.portable.bounds'],
+                ['investigation.consumer.mail-exposure-build', BULK_MAIL_EXPOSURE_SCHEMA, BULK_MAIL_EXPOSURE_EXPORT_VERSION, 'investigation.mail-exposure.v2', 'investigation.mail-exposure.build', 'investigation.portable.bounds'],
+                ['investigation.consumer.bulk-review-build', BULK_REVIEW_MANIFEST_SCHEMA, BULK_REVIEW_MANIFEST_VERSION, 'investigation.bulk-review.v2', 'investigation.bulk-review.build', 'investigation.portable.bounds'],
+                ['investigation.consumer.graph-build', LOOKUP_ASSET_GRAPH_SCHEMA, LOOKUP_ASSET_GRAPH_VERSION, 'investigation.asset-graph.v2', 'investigation.graph.build', 'investigation.derived.bounds'],
+                ['investigation.consumer.analyst-records-project', INVESTIGATION_CAPSULE_ANALYST_RECORDS_SCHEMA, INVESTIGATION_CAPSULE_ANALYST_RECORDS_VERSION, 'investigation.analyst-records.v1', 'investigation.capsule.build', 'investigation.derived.bounds'],
+                ['investigation.consumer.brief-build', LOOKUP_INVESTIGATION_BRIEF_SCHEMA, LOOKUP_INVESTIGATION_BRIEF_VERSION, 'investigation.brief.v2', 'investigation.brief.build', 'investigation.brief.bounds'],
+            ].map(([id, schema, version, shapeId, hookId, boundProfileId]) => ({
+                id, plane: 'shared', operation: 'build-current-projection', acceptedContracts: [],
+                emittedContract: { schema, version }, shapeIds: [shapeId], boundProfileIds: [boundProfileId],
+                hookIds: [hookId], serialisationProfileId: null,
+                privacyProfileId: 'investigation.privacy.output', retentionEffect: 'operator_controlled_output',
+                ...investigationConsumerCommon,
+            })),
+        ],
+        consumerRelationships: [],
+    },
+});

package/packages/contracts/offline-comparison.mjs

@@ -0,0 +1,160 @@
+import { defineSchemaCompatibility } from "./schema-compatibility.mjs";
+import { defineSchemaLifecycleFamily } from "./schema-lifecycle.mjs";
+export const OFFLINE_COMPARISON_CONTRACT_OWNER = 'packages/contracts/offline-comparison.mts';
+export const MAX_OFFLINE_COMPARISON_INPUT_BYTES = 8 * 1024 * 1024;
+export const PAGE_COMPARISON_VERSION = 3;
+export const CLI_PAGE_COMPARE_SCHEMA = 'whoisleuth.cli.page-compare';
+export const CLI_PAGE_COMPARE_VERSION = 4;
+export const SUPPORTED_CLI_PAGE_COMPARE_VERSIONS = Object.freeze([CLI_PAGE_COMPARE_VERSION]);
+export const CLI_COMPARISON_LEDGER_SCHEMA = 'whoisleuth.cli.comparison-ledger';
+export const CLI_COMPARISON_LEDGER_VERSION = 1;
+export const MAX_RETAINED_ARTIFACT_DIFF_BYTES = 8 * 1024 * 1024;
+export const RELATIONSHIP_EVIDENCE_SCHEMA = 'whoisleuth.relationship-evidence';
+export const RELATIONSHIP_EVIDENCE_VERSION = 2;
+export const TLS_RELATIONSHIP_PROFILE_VERSION = 2;
+export const SUPPORTED_TLS_RELATIONSHIP_PROFILE_VERSIONS = Object.freeze([TLS_RELATIONSHIP_PROFILE_VERSION]);
+export const OFFLINE_COMPARISON_COMPATIBILITY_FACADES = Object.freeze([
+    ['frontend/src/lib/analysis/comparison-ledger-bulk.ts', 'packages/comparison/comparison-ledger-bulk.mts'],
+    ['frontend/src/lib/analysis/comparison-ledger-contract.ts', 'packages/comparison/comparison-ledger-contract.mts'],
+    ['frontend/src/lib/analysis/comparison-ledger-json.ts', 'packages/comparison/comparison-ledger-json.mts'],
+    ['frontend/src/lib/analysis/comparison-ledger-serialization.ts', 'packages/comparison/comparison-ledger-serialization.mts'],
+    ['frontend/src/lib/analysis/page-similarity.ts', 'packages/comparison/page-similarity.mts'],
+    ['frontend/src/lib/analysis/relationship-evidence.ts', 'packages/comparison/relationship-evidence.mts'],
+]);
+export const CLI_PAGE_COMPARE_COMPATIBILITY = defineSchemaCompatibility({
+    id: 'cli.page-compare', kind: 'cli_document', schema: CLI_PAGE_COMPARE_SCHEMA,
+    currentVersion: CLI_PAGE_COMPARE_VERSION, supportedVersions: SUPPORTED_CLI_PAGE_COMPARE_VERSIONS,
+    acceptsUnversionedLegacy: false, futureVersionBehavior: 'not_applicable', migration: 'read_only', writeSemantics: 'read_only',
+    byteBudget: MAX_OFFLINE_COMPARISON_INPUT_BYTES, owner: OFFLINE_COMPARISON_CONTRACT_OWNER,
+    note: 'Offline comparison of two bounded deep-lookup page identity, technology, favicon, TLS, and response observations; version 3 withholds technology equality for partial sets and version 4 also withholds TLS issuer and public-key conclusions for partial TLS evidence.',
+});
+export const CLI_COMPARISON_LEDGER_COMPATIBILITY = defineSchemaCompatibility({
+    id: 'cli.comparison-ledger', kind: 'cli_document', schema: CLI_COMPARISON_LEDGER_SCHEMA,
+    currentVersion: CLI_COMPARISON_LEDGER_VERSION, supportedVersions: [CLI_COMPARISON_LEDGER_VERSION],
+    acceptsUnversionedLegacy: false, futureVersionBehavior: 'not_applicable', migration: 'read_only', writeSemantics: 'read_only',
+    byteBudget: MAX_RETAINED_ARTIFACT_DIFF_BYTES * 2, owner: OFFLINE_COMPARISON_CONTRACT_OWNER,
+    note: 'Value-free bounded index plus on-demand exact rows for explicitly paired retained Bulk sessions or domain-portfolio reviews.',
+});
+export const OFFLINE_COMPARISON_COMPATIBILITY = Object.freeze([
+    CLI_PAGE_COMPARE_COMPATIBILITY,
+    CLI_COMPARISON_LEDGER_COMPATIBILITY,
+]);
+const OFFLINE_COMPARISON_FIXTURES = Object.freeze([
+    { id: 'cli-page-compare-v4', path: 'test/fixtures/offline-comparison/cli-page-compare-v4.json', bytes: 5_059, sha256: '12bff7f46b852778f0f38926159083f37c34038ccdbbf8c4fc904ce03482360c', schema: CLI_PAGE_COMPARE_SCHEMA, version: 4, role: 'current', expectation: 'accepted_exact', shapeId: 'offline-comparison.page-output.current' },
+    { id: 'cli-comparison-ledger-v1', path: 'test/fixtures/offline-comparison/cli-comparison-ledger-v1.json', bytes: 6_820, sha256: '861a733500dede0af9f2551d94db66dc51b0a2fbdb68e377a71fd4661a51530b', schema: CLI_COMPARISON_LEDGER_SCHEMA, version: 1, role: 'current', expectation: 'accepted_exact', shapeId: 'offline-comparison.ledger-output.current' },
+].map((fixture) => Object.freeze({
+    ...fixture,
+    contentDigestSha256: null,
+    expectedOutputFixtureId: null,
+    scope: 'repository',
+})));
+function offlineFixtureIds(schema, version) {
+    return Object.freeze(OFFLINE_COMPARISON_FIXTURES
+        .filter((fixture) => fixture.schema === schema && fixture.version === version)
+        .map((fixture) => fixture.id));
+}
+const OFFLINE_COMPARISON_CONTRACTS = Object.freeze([
+    ...SUPPORTED_CLI_PAGE_COMPARE_VERSIONS.map((version) => Object.freeze({
+        compatibilityId: CLI_PAGE_COMPARE_COMPATIBILITY.id,
+        schema: CLI_PAGE_COMPARE_SCHEMA,
+        version,
+        role: 'document',
+        lifecycle: version === CLI_PAGE_COMPARE_VERSION ? 'current' : 'retired',
+        readable: false,
+        emitted: version === CLI_PAGE_COMPARE_VERSION,
+        exactKeys: true,
+        extensionPolicy: 'reject',
+        futureVersionBehaviour: 'not_applicable',
+        migrationTarget: null,
+        canonicalisation: null,
+        byteBudget: MAX_OFFLINE_COMPARISON_INPUT_BYTES,
+        fixtureIds: offlineFixtureIds(CLI_PAGE_COMPARE_SCHEMA, version),
+    })),
+    Object.freeze({
+        compatibilityId: CLI_COMPARISON_LEDGER_COMPATIBILITY.id,
+        schema: CLI_COMPARISON_LEDGER_SCHEMA,
+        version: CLI_COMPARISON_LEDGER_VERSION,
+        role: 'document',
+        lifecycle: 'current',
+        readable: false,
+        emitted: true,
+        exactKeys: true,
+        extensionPolicy: 'reject',
+        futureVersionBehaviour: 'not_applicable',
+        migrationTarget: null,
+        canonicalisation: null,
+        byteBudget: MAX_RETAINED_ARTIFACT_DIFF_BYTES * 2,
+        fixtureIds: offlineFixtureIds(CLI_COMPARISON_LEDGER_SCHEMA, CLI_COMPARISON_LEDGER_VERSION),
+    }),
+]);
+function offlineOutputShape(id, schema, versions, requiredKeys) {
+    return Object.freeze({
+        id,
+        schema,
+        versions,
+        objects: [{ path: '$', requiredKeys, optionalKeys: [], alternativeRequiredKeys: [], unknownKeys: 'reject' }],
+        fixedArrays: [],
+        normalisation: 'preserve_document',
+        target: null,
+        discriminator: null,
+    });
+}
+const offlineConsumerCommon = Object.freeze({
+    expiryPolicyId: 'offline-comparison.expiry.not-applicable',
+    requestMode: 'none',
+    retentionEffect: 'transient_report',
+    bindingState: 'declared_unenforced',
+    policyState: 'current',
+});
+export const OFFLINE_COMPARISON_LIFECYCLE_FAMILY = defineSchemaLifecycleFamily({
+    id: 'offline-comparison',
+    owner: OFFLINE_COMPARISON_CONTRACT_OWNER,
+    privacy: 'analyst_authored_sensitive',
+    compatibility: OFFLINE_COMPARISON_COMPATIBILITY,
+    contracts: OFFLINE_COMPARISON_CONTRACTS,
+    fixtures: OFFLINE_COMPARISON_FIXTURES,
+    metadata: {
+        metadataVersion: 4,
+        enforcement: 'declarative_only',
+        shapes: [
+            offlineOutputShape('offline-comparison.page-output.current', CLI_PAGE_COMPARE_SCHEMA, [4], ['schema', 'version', 'generatedAt', 'left', 'right', 'page', 'technology', 'tls', 'limitations']),
+            offlineOutputShape('offline-comparison.ledger-output.current', CLI_COMPARISON_LEDGER_SCHEMA, [1], ['schema', 'version', 'generatedAt', 'artifactFamily', 'left', 'right', 'index', 'details', 'limitations']),
+        ],
+        boundProfiles: [
+            { id: 'offline-comparison.page.bounds', bounds: [
+                    { id: 'serialised-bytes', path: '$', phase: 'serialised', unit: 'bytes', minimum: 1, maximum: MAX_OFFLINE_COMPARISON_INPUT_BYTES, handling: 'reject' },
+                ] },
+            { id: 'offline-comparison.ledger.bounds', bounds: [
+                    { id: 'serialised-bytes', path: '$', phase: 'serialised', unit: 'bytes', minimum: 1, maximum: MAX_RETAINED_ARTIFACT_DIFF_BYTES * 2, handling: 'reject' },
+                ] },
+        ],
+        hooks: [
+            { id: 'offline-comparison.page.build', role: 'builder', runtime: 'cli', module: 'cli/page-compare.mts', exportName: 'buildCliPageComparison' },
+            { id: 'offline-comparison.ledger.build', role: 'builder', runtime: 'cli', module: 'cli/retained-artifact-diff.mts', exportName: 'buildCliRetainedArtifactDiff' },
+            { id: 'offline-comparison.json.serialise', role: 'serialiser', runtime: 'cli', module: 'cli/formatters/json.mts', exportName: 'formatJsonDocument' },
+        ],
+        serialisationProfiles: [
+            { id: 'offline-comparison.page.json.v4', schema: CLI_PAGE_COMPARE_SCHEMA, versions: [CLI_PAGE_COMPARE_VERSION], mediaType: 'application/json', encoding: 'utf-8', bom: false, indentSpaces: 2, terminalLf: true, propertyOrder: 'normalised_fixed', canonicalisation: null, integrity: 'none', serializerHookId: 'offline-comparison.json.serialise', verifierHookIds: [] },
+            { id: 'offline-comparison.ledger.json.v1', schema: CLI_COMPARISON_LEDGER_SCHEMA, versions: [CLI_COMPARISON_LEDGER_VERSION], mediaType: 'application/json', encoding: 'utf-8', bom: false, indentSpaces: 2, terminalLf: true, propertyOrder: 'normalised_fixed', canonicalisation: null, integrity: 'none', serializerHookId: 'offline-comparison.json.serialise', verifierHookIds: [] },
+        ],
+        privacyProfiles: [{ id: 'offline-comparison.privacy.output', classification: 'analyst_authored_sensitive', projection: 'review_output', includedCategories: ['bounded-comparison-states', 'source-completeness', 'limitations'], excludedCategories: ['input-paths', 'raw-upstream-payloads', 'expanded-contacts', 'credentials', 'cookies', 'query-bearing-urls'], notePolicy: 'not_applicable', retention: 'transient_report', network: 'none', sharingReview: 'not_applicable' }],
+        expiryProfiles: [{ id: 'offline-comparison.expiry.not-applicable', field: null, anchor: null, handling: 'not_applicable', phase: 'not_applicable', maximumLifetimeDays: null }],
+        consumerEdges: [
+            {
+                id: 'offline-comparison.consumer.page-output', plane: 'cli', operation: 'build-current-page-comparison', acceptedContracts: [],
+                emittedContract: { schema: CLI_PAGE_COMPARE_SCHEMA, version: CLI_PAGE_COMPARE_VERSION, discriminator: null },
+                shapeIds: ['offline-comparison.page-output.current'], boundProfileIds: ['offline-comparison.page.bounds'],
+                hookIds: ['offline-comparison.page.build', 'offline-comparison.json.serialise'], serialisationProfileId: 'offline-comparison.page.json.v4',
+                privacyProfileId: 'offline-comparison.privacy.output', ...offlineConsumerCommon,
+            },
+            {
+                id: 'offline-comparison.consumer.ledger-output', plane: 'cli', operation: 'build-current-comparison-ledger', acceptedContracts: [],
+                emittedContract: { schema: CLI_COMPARISON_LEDGER_SCHEMA, version: CLI_COMPARISON_LEDGER_VERSION, discriminator: null },
+                shapeIds: ['offline-comparison.ledger-output.current'], boundProfileIds: ['offline-comparison.ledger.bounds'],
+                hookIds: ['offline-comparison.ledger.build', 'offline-comparison.json.serialise'], serialisationProfileId: 'offline-comparison.ledger.json.v1',
+                privacyProfileId: 'offline-comparison.privacy.output', ...offlineConsumerCommon,
+            },
+        ],
+        consumerRelationships: [],
+    },
+});