@ornexus/neocortex 4.60.40 → 4.60.42

package/packages/shared/dist/executable-graph-catalog/contracts.js

@@ -0,0 +1,935 @@
+/** P220.15 — pure, versioned catalog/readiness/progress contract authority. */
+import { createHash } from 'node:crypto';
+import { DEFAULT_YOLOOP_OPERATIONAL_BUDGET_LIMITS, MAX_YOLOOP_OPERATIONAL_BUDGET_LIMITS, YOLOOP_OPERATIONAL_BUDGET_DIMENSIONS, } from '../yoloop/operational-budget.js';
+import { yoloopDomainHash } from '../yoloop/canonical.js';
+export const EXECUTABLE_GRAPH_CATALOG_ERROR_CODES = [
+    'CATALOG_SCHEMA_INVALID',
+    'CATALOG_UNKNOWN_FIELD',
+    'CATALOG_VERSION_UNSUPPORTED',
+    'CATALOG_IDENTITY_INVALID',
+    'CATALOG_DUPLICATE_IDENTITY',
+    'CATALOG_CLOSURE_INCOMPLETE',
+    'CATALOG_HASH_MISMATCH',
+    'CATALOG_PROJECTION_LEAK',
+    'CATALOG_BASELINE_DRIFT_UNVERSIONED',
+    'CATALOG_BUDGET_INVALID',
+    'PROGRESS_SCHEMA_INVALID',
+    'PROGRESS_CHAIN_INVALID',
+    'PROGRESS_READINESS_DRIFT',
+    'VALIDATION_MATRIX_INVALID',
+    'VALIDATION_MATRIX_DUPLICATE',
+    'graphspec_v1_1_blocked_requires_migration',
+    'graphspec_version_unsupported',
+];
+export class ExecutableGraphCatalogContractError extends Error {
+    code;
+    field;
+    constructor(code, field = null) {
+        super(code);
+        this.code = code;
+        this.field = field;
+        this.name = 'ExecutableGraphCatalogContractError';
+    }
+}
+const fail = (code, field = null) => {
+    throw new ExecutableGraphCatalogContractError(code, field);
+};
+const compareBytes = (left, right) => Buffer.compare(Buffer.from(left, 'utf8'), Buffer.from(right, 'utf8'));
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function exactKeys(value, expected, code = 'CATALOG_SCHEMA_INVALID') {
+    if (!isRecord(value))
+        fail(code);
+    const record = value;
+    const expectedSet = new Set(expected);
+    const actual = Object.keys(record);
+    const unknown = actual.find((key) => !expectedSet.has(key));
+    if (unknown)
+        fail('CATALOG_UNKNOWN_FIELD', isSafeToken(unknown, 96) ? unknown : 'unknown-field');
+    const missing = expected.find((key) => !Object.hasOwn(record, key));
+    if (missing || actual.length !== expected.length)
+        fail(code, missing ?? null);
+}
+function assertUnicode(value, code) {
+    for (let index = 0; index < value.length; index += 1) {
+        const current = value.charCodeAt(index);
+        if (current >= 0xd800 && current <= 0xdbff) {
+            const next = value.charCodeAt(index + 1);
+            if (!(next >= 0xdc00 && next <= 0xdfff))
+                fail(code);
+            index += 1;
+        }
+        else if (current >= 0xdc00 && current <= 0xdfff)
+            fail(code);
+    }
+}
+/** Strict I-JSON-compatible canonical form with bytewise object-key ordering. */
+export function canonicalizeExecutableGraphJson(value) {
+    if (value === null)
+        return 'null';
+    if (typeof value === 'string') {
+        assertUnicode(value, 'CATALOG_SCHEMA_INVALID');
+        return JSON.stringify(value);
+    }
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value) || (Number.isInteger(value) && !Number.isSafeInteger(value))) {
+            return fail('CATALOG_SCHEMA_INVALID');
+        }
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(canonicalizeExecutableGraphJson).join(',')}]`;
+    }
+    if (!isRecord(value))
+        return fail('CATALOG_SCHEMA_INVALID');
+    const keys = Object.keys(value).sort(compareBytes);
+    for (const key of keys)
+        assertUnicode(key, 'CATALOG_SCHEMA_INVALID');
+    return `{${keys.map((key) => {
+        if (value[key] === undefined)
+            return fail('CATALOG_SCHEMA_INVALID');
+        return `${JSON.stringify(key)}:${canonicalizeExecutableGraphJson(value[key])}`;
+    }).join(',')}}`;
+}
+export function executableGraphDomainHash(domain, value) {
+    if (!isSafeToken(domain, 96))
+        fail('CATALOG_SCHEMA_INVALID', 'domain');
+    return createHash('sha256')
+        .update(`${domain}\0${canonicalizeExecutableGraphJson(value)}`, 'utf8')
+        .digest('hex');
+}
+function deepFreeze(value) {
+    if (value !== null && typeof value === 'object' && !Object.isFrozen(value)) {
+        for (const child of Object.values(value))
+            deepFreeze(child);
+        Object.freeze(value);
+    }
+    return value;
+}
+const HASH = /^[a-f0-9]{64}$/;
+const COMMAND_ID = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+const SAFE_TOKEN = /^[A-Za-z0-9][A-Za-z0-9._:/@+-]*$/;
+const SAFE_RELATIVE_PATH = /^(?!\/)(?![A-Za-z]:[\\/])(?!.*(?:^|\/)\.\.(?:\/|$))[A-Za-z0-9._@+-]+(?:\/[A-Za-z0-9._@+-]+)*$/;
+function isHash(value) {
+    return typeof value === 'string' && HASH.test(value);
+}
+function isSafeToken(value, maxLength = 256) {
+    return typeof value === 'string' && value.length > 0 && value.length <= maxLength
+        && SAFE_TOKEN.test(value);
+}
+function requireToken(value, code, field, maxLength = 256) {
+    if (!isSafeToken(value, maxLength))
+        fail(code, field);
+    return value;
+}
+function requireHash(value, code, field) {
+    if (!isHash(value))
+        fail(code, field);
+    return value;
+}
+function requireIso(value, code, field) {
+    if (typeof value !== 'string' || value.length > 40 || !Number.isFinite(Date.parse(value))) {
+        fail(code, field);
+    }
+    return value;
+}
+function requirePositiveSafeInteger(value, code, field) {
+    if (!Number.isSafeInteger(value) || Number(value) <= 0)
+        fail(code, field);
+    return Number(value);
+}
+function normalizeTokens(value, code, field, options = {}) {
+    if (!Array.isArray(value) || value.length > (options.maxItems ?? 512))
+        fail(code, field);
+    const result = value.map((entry) => requireToken(entry, code, field));
+    if (options.nonEmpty && result.length === 0)
+        fail(code, field);
+    if (new Set(result).size !== result.length)
+        fail(code, field);
+    return Object.freeze(result.sort(compareBytes));
+}
+export const EXECUTABLE_GRAPH_PROJECT_ID = 'neocortex_command_graphs';
+export const EXECUTABLE_GRAPH_ORCHESTRATOR_PROFILE = 'neocortex-command-graphs';
+export const EXECUTABLE_GRAPH_DECISION_PROFILE = 'neocortex-command-graphs-decision';
+export const EXECUTABLE_GRAPH_PROFILE_TARGETS = Object.freeze([
+    '.codex/agents/neocortex-command-graphs.toml',
+    '.codex/agents/neocortex-command-graphs-decision.toml',
+    '.claude/agents/neocortex-command-graphs.md',
+    '.claude/agents/neocortex-command-graphs-decision.md',
+    '.opencode/agents/neocortex-command-graphs.md',
+    '.opencode/agents/neocortex-command-graphs-decision.md',
+]);
+export const EXECUTABLE_GRAPH_PROJECT_IDENTITY = deepFreeze({
+    schemaVersion: 'ExecutableGraphProjectIdentity/1.0',
+    projectId: EXECUTABLE_GRAPH_PROJECT_ID,
+    orchestratorProfile: EXECUTABLE_GRAPH_ORCHESTRATOR_PROFILE,
+    decisionProfile: EXECUTABLE_GRAPH_DECISION_PROFILE,
+    profileTargets: [...EXECUTABLE_GRAPH_PROFILE_TARGETS],
+});
+function normalizeProjectIdentity(value) {
+    exactKeys(value, ['schemaVersion', 'projectId', 'orchestratorProfile', 'decisionProfile', 'profileTargets'], 'CATALOG_IDENTITY_INVALID');
+    const record = value;
+    if (record.schemaVersion !== 'ExecutableGraphProjectIdentity/1.0'
+        || record.projectId !== EXECUTABLE_GRAPH_PROJECT_ID
+        || record.orchestratorProfile !== EXECUTABLE_GRAPH_ORCHESTRATOR_PROFILE
+        || record.decisionProfile !== EXECUTABLE_GRAPH_DECISION_PROFILE
+        || !Array.isArray(record.profileTargets)
+        || record.profileTargets.length !== 6)
+        fail('CATALOG_IDENTITY_INVALID', 'project');
+    const targets = record.profileTargets.map((target) => {
+        if (typeof target !== 'string' || target.length > 256 || !SAFE_RELATIVE_PATH.test(target)
+            || target === '.opencode/agents/neocortex.md')
+            fail('CATALOG_IDENTITY_INVALID', 'profileTargets');
+        return target;
+    });
+    if (new Set(targets).size !== 6
+        || canonicalizeExecutableGraphJson(targets) !== canonicalizeExecutableGraphJson(EXECUTABLE_GRAPH_PROFILE_TARGETS)) {
+        fail('CATALOG_IDENTITY_INVALID', 'profileTargets');
+    }
+    return EXECUTABLE_GRAPH_PROJECT_IDENTITY;
+}
+export const EXECUTABLE_CLOSURE_DIMENSIONS = Object.freeze([
+    'command', 'subcommand', 'aliases', 'handler', 'assets', 'resolvers', 'nodes',
+    'imports', 'gates', 'terminals', 'tests', 'receipts', 'policy', 'recovery',
+    'tier', 'quota', 'billing',
+]);
+export const CATALOG_DESCRIPTIVE_REASON_CODES = Object.freeze([
+    'not-applicable',
+    'not-declared',
+    'external-authority',
+    'future-story-owned',
+    'protected-reference-withheld',
+]);
+export const CATALOG_OPERATIONAL_BASELINE_V1 = deepFreeze({
+    schemaVersion: 'CatalogOperationalBaseline/1.0',
+    defaults: { ...DEFAULT_YOLOOP_OPERATIONAL_BUDGET_LIMITS },
+    ceilings: { ...MAX_YOLOOP_OPERATIONAL_BUDGET_LIMITS },
+    promotionThresholds: {
+        state: 'TBD',
+        latencyP95Ms: null,
+        promotionCostThreshold: null,
+        ownerStoryId: 'P220.44',
+    },
+});
+function normalizeGeneration(value) {
+    exactKeys(value, ['schemaVersion', 'generationId', 'registryVersion', 'registryChecksum', 'sourceHash']);
+    const record = value;
+    if (record.schemaVersion !== 'ExecutableGraphCatalogGeneration/1.0'
+        || typeof record.registryVersion !== 'string'
+        || !/^\d+\.\d+\.\d+$/.test(record.registryVersion))
+        fail('CATALOG_VERSION_UNSUPPORTED', 'generation');
+    return deepFreeze({
+        schemaVersion: 'ExecutableGraphCatalogGeneration/1.0',
+        generationId: requireToken(record.generationId, 'CATALOG_IDENTITY_INVALID', 'generationId'),
+        registryVersion: record.registryVersion,
+        registryChecksum: requireHash(record.registryChecksum, 'CATALOG_HASH_MISMATCH', 'registryChecksum'),
+        sourceHash: requireHash(record.sourceHash, 'CATALOG_HASH_MISMATCH', 'sourceHash'),
+    });
+}
+function normalizeSourceObservation(value) {
+    const keys = [
+        'schemaVersion', 'registryEntries', 'publicCommands', 'publicSubcommands',
+        'manifestRoots', 'declaredNodes', 'literalResolutions', 'unresolvedDeclarations',
+    ];
+    exactKeys(value, keys);
+    const record = value;
+    if (record.schemaVersion !== 'CatalogSourceObservation/1.0')
+        fail('CATALOG_VERSION_UNSUPPORTED', 'sourceObservation');
+    const output = { schemaVersion: 'CatalogSourceObservation/1.0' };
+    for (const key of keys.slice(1)) {
+        if (!Number.isSafeInteger(record[key]) || Number(record[key]) < 0)
+            fail('CATALOG_SCHEMA_INVALID', key);
+        output[key] = Number(record[key]);
+    }
+    if (Number(output.publicCommands) > Number(output.registryEntries)
+        || Number(output.literalResolutions) + Number(output.unresolvedDeclarations) !== Number(output.declaredNodes)) {
+        fail('CATALOG_SCHEMA_INVALID', 'sourceObservation');
+    }
+    return deepFreeze(output);
+}
+function normalizeOperationalBaseline(value) {
+    exactKeys(value, ['schemaVersion', 'defaults', 'ceilings', 'promotionThresholds'], 'CATALOG_BUDGET_INVALID');
+    const record = value;
+    if (record.schemaVersion !== 'CatalogOperationalBaseline/1.0')
+        fail('CATALOG_BUDGET_INVALID', 'schemaVersion');
+    exactKeys(record.defaults, YOLOOP_OPERATIONAL_BUDGET_DIMENSIONS, 'CATALOG_BUDGET_INVALID');
+    exactKeys(record.ceilings, YOLOOP_OPERATIONAL_BUDGET_DIMENSIONS, 'CATALOG_BUDGET_INVALID');
+    const rawDefaults = record.defaults;
+    const rawCeilings = record.ceilings;
+    const defaults = {};
+    const ceilings = {};
+    for (const dimension of YOLOOP_OPERATIONAL_BUDGET_DIMENSIONS) {
+        const fallback = rawDefaults[dimension];
+        const ceiling = rawCeilings[dimension];
+        if (!Number.isSafeInteger(fallback) || Number(fallback) <= 0
+            || !Number.isSafeInteger(ceiling) || Number(ceiling) <= 0
+            || Number(fallback) > Number(ceiling))
+            fail('CATALOG_BUDGET_INVALID', dimension);
+        defaults[dimension] = Number(fallback);
+        ceilings[dimension] = Number(ceiling);
+    }
+    exactKeys(record.promotionThresholds, ['state', 'latencyP95Ms', 'promotionCostThreshold', 'ownerStoryId'], 'CATALOG_BUDGET_INVALID');
+    const thresholds = record.promotionThresholds;
+    if (thresholds.state !== 'TBD'
+        || thresholds.latencyP95Ms !== null
+        || thresholds.promotionCostThreshold !== null
+        || thresholds.ownerStoryId !== 'P220.44')
+        fail('CATALOG_BUDGET_INVALID', 'promotionThresholds');
+    return deepFreeze({
+        schemaVersion: 'CatalogOperationalBaseline/1.0',
+        defaults: defaults,
+        ceilings: ceilings,
+        promotionThresholds: { state: 'TBD', latencyP95Ms: null, promotionCostThreshold: null, ownerStoryId: 'P220.44' },
+    });
+}
+function normalizeClosure(value) {
+    if (!Array.isArray(value) || value.length !== EXECUTABLE_CLOSURE_DIMENSIONS.length) {
+        fail('CATALOG_CLOSURE_INCOMPLETE', 'closure');
+    }
+    const byDimension = new Map();
+    for (const rawValue of value) {
+        const raw = rawValue;
+        exactKeys(raw, ['dimension', 'disposition', 'refs', 'reasonCode'], 'CATALOG_CLOSURE_INCOMPLETE');
+        if (!EXECUTABLE_CLOSURE_DIMENSIONS.includes(raw.dimension)) {
+            fail('CATALOG_CLOSURE_INCOMPLETE', 'dimension');
+        }
+        const dimension = raw.dimension;
+        if (byDimension.has(dimension))
+            fail('CATALOG_CLOSURE_INCOMPLETE', dimension);
+        if (raw.disposition === 'bound') {
+            if (raw.reasonCode !== null)
+                fail('CATALOG_CLOSURE_INCOMPLETE', dimension);
+            const refs = normalizeTokens(raw.refs, 'CATALOG_CLOSURE_INCOMPLETE', dimension, { nonEmpty: true });
+            byDimension.set(dimension, deepFreeze({ dimension, disposition: 'bound', refs: refs, reasonCode: null }));
+        }
+        else if (raw.disposition === 'descriptive') {
+            if (!Array.isArray(raw.refs) || raw.refs.length !== 0
+                || !CATALOG_DESCRIPTIVE_REASON_CODES.includes(raw.reasonCode)) {
+                fail('CATALOG_CLOSURE_INCOMPLETE', dimension);
+            }
+            byDimension.set(dimension, deepFreeze({
+                dimension,
+                disposition: 'descriptive',
+                refs: [],
+                reasonCode: raw.reasonCode,
+            }));
+        }
+        else
+            fail('CATALOG_CLOSURE_INCOMPLETE', dimension);
+    }
+    if (byDimension.size !== EXECUTABLE_CLOSURE_DIMENSIONS.length)
+        fail('CATALOG_CLOSURE_INCOMPLETE', 'closure');
+    return Object.freeze(EXECUTABLE_CLOSURE_DIMENSIONS.map((dimension) => byDimension.get(dimension)));
+}
+function normalizeRouteIdentity(value) {
+    exactKeys(value, ['commandId', 'operationId', 'aliases', 'visibility'], 'CATALOG_IDENTITY_INVALID');
+    const record = value;
+    if (typeof record.commandId !== 'string' || !COMMAND_ID.test(record.commandId)
+        || (record.operationId !== null && (typeof record.operationId !== 'string' || !COMMAND_ID.test(record.operationId)))
+        || (record.visibility !== 'public' && record.visibility !== 'internal'))
+        fail('CATALOG_IDENTITY_INVALID', 'route');
+    if (!Array.isArray(record.aliases) || record.aliases.length > 128)
+        fail('CATALOG_IDENTITY_INVALID', 'aliases');
+    const aliases = Object.freeze(record.aliases.map((alias) => {
+        if (typeof alias !== 'string' || (alias !== '?' && !COMMAND_ID.test(alias))) {
+            fail('CATALOG_IDENTITY_INVALID', 'aliases');
+        }
+        return alias;
+    }).sort(compareBytes));
+    if (new Set(aliases).size !== aliases.length
+        || aliases.some((alias) => alias === record.commandId || alias === record.operationId)) {
+        fail('CATALOG_IDENTITY_INVALID', 'aliases');
+    }
+    return deepFreeze({
+        commandId: record.commandId,
+        operationId: record.operationId,
+        aliases,
+        visibility: record.visibility,
+    });
+}
+function normalizeRow(value) {
+    exactKeys(value, ['schemaVersion', 'identity', 'closure']);
+    const record = value;
+    if (record.schemaVersion !== 'ExecutableGraphCatalogRow/1.0')
+        fail('CATALOG_VERSION_UNSUPPORTED', 'row');
+    return deepFreeze({
+        schemaVersion: 'ExecutableGraphCatalogRow/1.0',
+        identity: normalizeRouteIdentity(record.identity),
+        closure: normalizeClosure(record.closure),
+    });
+}
+function routeKey(identity) {
+    return `${identity.commandId}\0${identity.operationId ?? ''}`;
+}
+function computeCatalogCounts(rows) {
+    const commands = new Set(rows.map((row) => row.identity.commandId));
+    const publicCommands = new Set(rows.filter((row) => row.identity.visibility === 'public').map((row) => row.identity.commandId));
+    const closureBindings = Object.fromEntries(EXECUTABLE_CLOSURE_DIMENSIONS.map((dimension) => [
+        dimension,
+        rows.filter((row) => row.closure.find((entry) => entry.dimension === dimension)?.disposition === 'bound').length,
+    ]));
+    return deepFreeze({
+        schemaVersion: 'ExecutableGraphCatalogCountVector/1.0',
+        routes: rows.length,
+        commands: commands.size,
+        subcommands: rows.filter((row) => row.identity.operationId !== null).length,
+        publicCommands: publicCommands.size,
+        publicSubcommands: rows.filter((row) => row.identity.visibility === 'public' && row.identity.operationId !== null).length,
+        aliases: rows.reduce((total, row) => total + row.identity.aliases.length, 0),
+        boundDimensions: rows.reduce((total, row) => total + row.closure.filter((entry) => entry.disposition === 'bound').length, 0),
+        descriptiveDimensions: rows.reduce((total, row) => total + row.closure.filter((entry) => entry.disposition === 'descriptive').length, 0),
+        closureBindings,
+    });
+}
+export function normalizeExecutableGraphCatalogSourceV1(value) {
+    exactKeys(value, ['schemaVersion', 'project', 'generation', 'rows', 'sourceObservation', 'operationalBaseline', 'evidenceRefs']);
+    const record = value;
+    if (record.schemaVersion !== 'ExecutableGraphCatalogSource/1.0')
+        fail('CATALOG_VERSION_UNSUPPORTED', 'schemaVersion');
+    if (!Array.isArray(record.rows) || record.rows.length === 0 || record.rows.length > 4096)
+        fail('CATALOG_SCHEMA_INVALID', 'rows');
+    const rows = record.rows.map(normalizeRow).sort((left, right) => compareBytes(routeKey(left.identity), routeKey(right.identity)));
+    const routes = new Set();
+    const commandIds = new Set(rows.map((row) => row.identity.commandId));
+    const aliases = new Map();
+    for (const row of rows) {
+        const key = routeKey(row.identity);
+        if (routes.has(key))
+            fail('CATALOG_DUPLICATE_IDENTITY', 'route');
+        routes.add(key);
+        for (const alias of row.identity.aliases) {
+            const owner = aliases.get(alias);
+            if (commandIds.has(alias) || (owner && owner !== key))
+                fail('CATALOG_DUPLICATE_IDENTITY', 'alias');
+            aliases.set(alias, key);
+        }
+    }
+    const base = {
+        schemaVersion: 'ExecutableGraphCatalog/1.0',
+        project: normalizeProjectIdentity(record.project),
+        generation: normalizeGeneration(record.generation),
+        rows: Object.freeze(rows),
+        sourceObservation: normalizeSourceObservation(record.sourceObservation),
+        operationalBaseline: normalizeOperationalBaseline(record.operationalBaseline),
+        evidenceRefs: normalizeTokens(record.evidenceRefs, 'CATALOG_SCHEMA_INVALID', 'evidenceRefs', { nonEmpty: true, maxItems: 128 }),
+        counts: computeCatalogCounts(rows),
+    };
+    return deepFreeze({
+        ...base,
+        catalogHash: executableGraphDomainHash('p220-executable-graph-catalog-v1', base),
+    });
+}
+export function projectExecutableGraphCatalogPublicV1(catalog) {
+    if (!isHash(catalog.catalogHash))
+        fail('CATALOG_HASH_MISMATCH', 'catalogHash');
+    const expectedCatalog = executableGraphDomainHash('p220-executable-graph-catalog-v1', (({ catalogHash: _omitted, ...rest }) => rest)(catalog));
+    if (expectedCatalog !== catalog.catalogHash)
+        fail('CATALOG_HASH_MISMATCH', 'catalogHash');
+    const base = {
+        schemaVersion: 'ExecutableGraphCatalogPublicProjection/1.0',
+        generationId: catalog.generation.generationId,
+        catalogHash: catalog.catalogHash,
+        project: {
+            projectId: catalog.project.projectId,
+            orchestratorProfile: catalog.project.orchestratorProfile,
+            decisionProfile: catalog.project.decisionProfile,
+        },
+        counts: {
+            publicCommands: catalog.counts.publicCommands,
+            publicSubcommands: catalog.counts.publicSubcommands,
+            aliases: catalog.rows.filter((row) => row.identity.visibility === 'public')
+                .reduce((total, row) => total + row.identity.aliases.length, 0),
+        },
+        rows: Object.freeze(catalog.rows
+            .filter((row) => row.identity.visibility === 'public')
+            .map((row) => deepFreeze({
+            commandId: row.identity.commandId,
+            operationId: row.identity.operationId,
+            aliases: Object.freeze([...row.identity.aliases]),
+            closure: Object.freeze(row.closure.map((entry) => deepFreeze({
+                dimension: entry.dimension,
+                disposition: entry.disposition,
+                evidenceCount: entry.refs.length,
+                reasonCode: entry.reasonCode,
+            }))),
+        }))),
+        contractVersions: {
+            progress: 'ProgressSnapshot/1.0',
+            validation: 'ValidationMatrix/1.1',
+            readiness: 'ExecutableGraphReadinessVector/1.0',
+        },
+        evidenceRefs: Object.freeze([...catalog.evidenceRefs]),
+        publicSafe: true,
+    };
+    const projection = deepFreeze({
+        ...base,
+        projectionHash: executableGraphDomainHash('p220-executable-graph-catalog-public-v1', base),
+    });
+    const rendered = canonicalizeExecutableGraphJson(projection);
+    for (const row of catalog.rows) {
+        for (const entry of row.closure) {
+            if (entry.refs.some((ref) => rendered.includes(ref)))
+                fail('CATALOG_PROJECTION_LEAK', entry.dimension);
+        }
+    }
+    return projection;
+}
+export function createCatalogBaselineEvidenceV1(catalog, observedAt) {
+    const projection = projectExecutableGraphCatalogPublicV1(catalog);
+    return deepFreeze({
+        schemaVersion: 'CatalogBaselineEvidence/1.0',
+        sourceSchemaVersion: 'ExecutableGraphCatalogSource/1.0',
+        generationId: catalog.generation.generationId,
+        registryVersion: catalog.generation.registryVersion,
+        registryChecksum: catalog.generation.registryChecksum,
+        sourceHash: catalog.generation.sourceHash,
+        catalogHash: catalog.catalogHash,
+        publicProjectionHash: projection.projectionHash,
+        counts: catalog.counts,
+        sourceObservation: catalog.sourceObservation,
+        observedAt: requireIso(observedAt, 'CATALOG_SCHEMA_INVALID', 'observedAt'),
+        evidenceRefs: Object.freeze([...catalog.evidenceRefs]),
+        publicSafe: true,
+    });
+}
+export function validateCatalogBaselineTransitionV1(previous, next) {
+    const countsChanged = canonicalizeExecutableGraphJson(previous.counts) !== canonicalizeExecutableGraphJson(next.counts)
+        || canonicalizeExecutableGraphJson(previous.sourceObservation) !== canonicalizeExecutableGraphJson(next.sourceObservation);
+    if (countsChanged && (previous.generationId === next.generationId
+        || previous.registryChecksum === next.registryChecksum
+        || previous.sourceHash === next.sourceHash
+        || previous.catalogHash === next.catalogHash
+        || previous.publicProjectionHash === next.publicProjectionHash)) {
+        fail('CATALOG_BASELINE_DRIFT_UNVERSIONED', 'counts');
+    }
+    return true;
+}
+export const PACKAGE_STATUSES = Object.freeze(['DESIGN_READY', 'DESIGN_BLOCKED', 'DESIGN_BUDGET_EXHAUSTED']);
+export const PERSISTENCE_STATUSES = Object.freeze(['PENDING_EXPORT', 'STORED', 'OPTED_OUT']);
+export const MATERIALIZATION_STATUSES = Object.freeze(['NOT_STARTED', 'READY', 'PARTIAL', 'BLOCKED', 'BUDGET_EXHAUSTED']);
+export const PROFILES_STATUSES = Object.freeze(['NOT_INSTALLED', 'INSTALLED']);
+export const OPERATIONAL_STATUSES = Object.freeze(['NOT_OPERATIONAL', 'READY_FOR_EXPLICIT_EXECUTION']);
+const PROGRESS_INPUT_KEYS = [
+    'projectId', 'workflowId', 'runId', 'commandId', 'invocationId', 'sequence',
+    'revision', 'occurredAt', 'parentSnapshotHash', 'stage', 'objective',
+    'progressBasis', 'gates', 'blockers', 'budgets', 'evidenceRefs',
+    'lastAcceptedEvidenceRef', 'readiness', 'readinessEvidence', 'nextAction',
+    'reasonCodes', 'provenance',
+];
+function normalizeReadiness(value) {
+    exactKeys(value, ['schemaVersion', 'packageStatus', 'persistenceStatus', 'materializationStatus', 'profilesStatus', 'operationalStatus', 'graphExecution'], 'PROGRESS_SCHEMA_INVALID');
+    const record = value;
+    if (record.schemaVersion !== 'ExecutableGraphReadinessVector/1.0'
+        || !PACKAGE_STATUSES.includes(record.packageStatus)
+        || !PERSISTENCE_STATUSES.includes(record.persistenceStatus)
+        || !MATERIALIZATION_STATUSES.includes(record.materializationStatus)
+        || !PROFILES_STATUSES.includes(record.profilesStatus)
+        || !OPERATIONAL_STATUSES.includes(record.operationalStatus)
+        || record.graphExecution !== 'NOT_RUN')
+        fail('PROGRESS_SCHEMA_INVALID', 'readiness');
+    return deepFreeze({ ...record });
+}
+const READINESS_EVIDENCE_FIELDS = [
+    'packageStatus', 'persistenceStatus', 'materializationStatus',
+    'profilesStatus', 'operationalStatus', 'graphExecution',
+];
+function normalizeReadinessEvidence(value) {
+    exactKeys(value, ['schemaVersion', ...READINESS_EVIDENCE_FIELDS], 'PROGRESS_SCHEMA_INVALID');
+    const record = value;
+    if (record.schemaVersion !== 'ExecutableGraphReadinessEvidence/1.0')
+        fail('PROGRESS_SCHEMA_INVALID', 'readinessEvidence');
+    return deepFreeze({
+        schemaVersion: 'ExecutableGraphReadinessEvidence/1.0',
+        packageStatus: normalizeTokens(record.packageStatus, 'PROGRESS_SCHEMA_INVALID', 'packageStatus', { nonEmpty: true, maxItems: 32 }),
+        persistenceStatus: normalizeTokens(record.persistenceStatus, 'PROGRESS_SCHEMA_INVALID', 'persistenceStatus', { nonEmpty: true, maxItems: 32 }),
+        materializationStatus: normalizeTokens(record.materializationStatus, 'PROGRESS_SCHEMA_INVALID', 'materializationStatus', { nonEmpty: true, maxItems: 32 }),
+        profilesStatus: normalizeTokens(record.profilesStatus, 'PROGRESS_SCHEMA_INVALID', 'profilesStatus', { nonEmpty: true, maxItems: 32 }),
+        operationalStatus: normalizeTokens(record.operationalStatus, 'PROGRESS_SCHEMA_INVALID', 'operationalStatus', { nonEmpty: true, maxItems: 32 }),
+        graphExecution: normalizeTokens(record.graphExecution, 'PROGRESS_SCHEMA_INVALID', 'graphExecution', { nonEmpty: true, maxItems: 32 }),
+    });
+}
+function normalizeStage(value) {
+    exactKeys(value, ['schemaVersion', 'id', 'label', 'ordinal', 'total', 'completedStageIds', 'remainingStageIds'], 'PROGRESS_SCHEMA_INVALID');
+    const record = value;
+    if (record.schemaVersion !== 'ProgressStage/1.0')
+        fail('PROGRESS_SCHEMA_INVALID', 'stage');
+    const ordinal = requirePositiveSafeInteger(record.ordinal, 'PROGRESS_SCHEMA_INVALID', 'ordinal');
+    const total = requirePositiveSafeInteger(record.total, 'PROGRESS_SCHEMA_INVALID', 'total');
+    if (ordinal > total || typeof record.label !== 'string' || record.label.length === 0 || record.label.length > 128) {
+        fail('PROGRESS_SCHEMA_INVALID', 'stage');
+    }
+    const label = record.label;
+    assertUnicode(label, 'PROGRESS_SCHEMA_INVALID');
+    const completedStageIds = normalizeTokens(record.completedStageIds, 'PROGRESS_SCHEMA_INVALID', 'completedStageIds', { maxItems: 512 });
+    const remainingStageIds = normalizeTokens(record.remainingStageIds, 'PROGRESS_SCHEMA_INVALID', 'remainingStageIds', { nonEmpty: true, maxItems: 512 });
+    if (completedStageIds.some((id) => remainingStageIds.includes(id))
+        || completedStageIds.length + remainingStageIds.length !== total
+        || completedStageIds.length !== ordinal - 1
+        || remainingStageIds.length !== total - ordinal + 1)
+        fail('PROGRESS_SCHEMA_INVALID', 'stage');
+    const id = requireToken(record.id, 'PROGRESS_SCHEMA_INVALID', 'stage.id');
+    if (!completedStageIds.includes(id) && !remainingStageIds.includes(id))
+        fail('PROGRESS_SCHEMA_INVALID', 'stage.id');
+    return deepFreeze({ schemaVersion: 'ProgressStage/1.0', id, label, ordinal, total, completedStageIds, remainingStageIds });
+}
+function normalizeProgressCollection(value, keys, normalize, identity) {
+    if (!Array.isArray(value) || value.length > 128)
+        fail('PROGRESS_SCHEMA_INVALID');
+    const result = value.map((entry) => {
+        exactKeys(entry, keys, 'PROGRESS_SCHEMA_INVALID');
+        return normalize(entry);
+    }).sort((left, right) => compareBytes(identity(left), identity(right)));
+    if (new Set(result.map(identity)).size !== result.length)
+        fail('PROGRESS_SCHEMA_INVALID');
+    return Object.freeze(result);
+}
+function normalizeProgressInput(value) {
+    exactKeys(value, PROGRESS_INPUT_KEYS, 'PROGRESS_SCHEMA_INVALID');
+    const record = value;
+    if (record.projectId !== EXECUTABLE_GRAPH_PROJECT_ID || record.progressBasis !== 'ACCEPTANCE_CRITERIA'
+        || !Number.isSafeInteger(record.sequence) || Number(record.sequence) <= 0
+        || !Number.isSafeInteger(record.revision) || Number(record.revision) <= 0
+        || (record.parentSnapshotHash !== null && !isHash(record.parentSnapshotHash)))
+        fail('PROGRESS_SCHEMA_INVALID');
+    if (typeof record.objective !== 'string' || record.objective.length === 0 || record.objective.length > 512)
+        fail('PROGRESS_SCHEMA_INVALID', 'objective');
+    const objective = record.objective;
+    assertUnicode(objective, 'PROGRESS_SCHEMA_INVALID');
+    const gates = normalizeProgressCollection(record.gates, ['id', 'status', 'evidenceRefs'], (item) => {
+        if (!['pending', 'passed', 'blocked'].includes(item.status))
+            fail('PROGRESS_SCHEMA_INVALID', 'gate.status');
+        return {
+            id: requireToken(item.id, 'PROGRESS_SCHEMA_INVALID', 'gate.id'),
+            status: item.status,
+            evidenceRefs: normalizeTokens(item.evidenceRefs, 'PROGRESS_SCHEMA_INVALID', 'gate.evidenceRefs', { maxItems: 32 }),
+        };
+    }, (item) => item.id);
+    const blockers = normalizeProgressCollection(record.blockers, ['code', 'status', 'evidenceRefs'], (item) => {
+        if (!['active', 'resolved'].includes(item.status))
+            fail('PROGRESS_SCHEMA_INVALID', 'blocker.status');
+        return {
+            code: requireToken(item.code, 'PROGRESS_SCHEMA_INVALID', 'blocker.code'),
+            status: item.status,
+            evidenceRefs: normalizeTokens(item.evidenceRefs, 'PROGRESS_SCHEMA_INVALID', 'blocker.evidenceRefs', { nonEmpty: true, maxItems: 32 }),
+        };
+    }, (item) => item.code);
+    const budgets = normalizeProgressCollection(record.budgets, ['kind', 'status', 'remaining', 'evidenceRefs'], (item) => {
+        if (!['operational', 'entitlement', 'retrieval'].includes(item.kind)
+            || !['available', 'exhausted', 'not-applicable'].includes(item.status)
+            || (item.status === 'not-applicable' ? item.remaining !== null
+                : (!Number.isSafeInteger(item.remaining) || Number(item.remaining) < 0)))
+            fail('PROGRESS_SCHEMA_INVALID', 'budget');
+        return {
+            kind: item.kind,
+            status: item.status,
+            remaining: item.remaining,
+            evidenceRefs: normalizeTokens(item.evidenceRefs, 'PROGRESS_SCHEMA_INVALID', 'budget.evidenceRefs', { nonEmpty: true, maxItems: 32 }),
+        };
+    }, (item) => item.kind);
+    if (canonicalizeExecutableGraphJson(budgets.map(({ kind }) => kind).sort(compareBytes))
+        !== canonicalizeExecutableGraphJson(['entitlement', 'operational', 'retrieval']))
+        fail('PROGRESS_SCHEMA_INVALID', 'budgets');
+    exactKeys(record.nextAction, ['kind', 'reasonCode'], 'PROGRESS_SCHEMA_INVALID');
+    const nextAction = record.nextAction;
+    if (!['none', 'await-evidence', 'continue-eligible', 'retry-eligible', 'blocked', 'cancelled'].includes(nextAction.kind)) {
+        fail('PROGRESS_SCHEMA_INVALID', 'nextAction');
+    }
+    exactKeys(record.provenance, ['producer', 'generationId', 'legacySnapshotHash'], 'PROGRESS_SCHEMA_INVALID');
+    const provenance = record.provenance;
+    if (!['catalog', 'builder', 'materializer', 'runtime', 'migration'].includes(provenance.producer)
+        || (provenance.legacySnapshotHash !== null && !isHash(provenance.legacySnapshotHash)))
+        fail('PROGRESS_SCHEMA_INVALID', 'provenance');
+    const evidenceRefs = normalizeTokens(record.evidenceRefs, 'PROGRESS_SCHEMA_INVALID', 'evidenceRefs', { nonEmpty: true, maxItems: 128 });
+    if (record.lastAcceptedEvidenceRef !== null
+        && (!isSafeToken(record.lastAcceptedEvidenceRef) || !evidenceRefs.includes(record.lastAcceptedEvidenceRef))) {
+        fail('PROGRESS_SCHEMA_INVALID', 'lastAcceptedEvidenceRef');
+    }
+    return deepFreeze({
+        projectId: EXECUTABLE_GRAPH_PROJECT_ID,
+        workflowId: requireToken(record.workflowId, 'PROGRESS_SCHEMA_INVALID', 'workflowId'),
+        runId: requireToken(record.runId, 'PROGRESS_SCHEMA_INVALID', 'runId'),
+        commandId: requireToken(record.commandId, 'PROGRESS_SCHEMA_INVALID', 'commandId'),
+        invocationId: requireToken(record.invocationId, 'PROGRESS_SCHEMA_INVALID', 'invocationId'),
+        sequence: Number(record.sequence),
+        revision: Number(record.revision),
+        occurredAt: requireIso(record.occurredAt, 'PROGRESS_SCHEMA_INVALID', 'occurredAt'),
+        parentSnapshotHash: record.parentSnapshotHash,
+        stage: normalizeStage(record.stage),
+        objective,
+        progressBasis: 'ACCEPTANCE_CRITERIA',
+        gates,
+        blockers,
+        budgets,
+        evidenceRefs,
+        lastAcceptedEvidenceRef: record.lastAcceptedEvidenceRef,
+        readiness: normalizeReadiness(record.readiness),
+        readinessEvidence: normalizeReadinessEvidence(record.readinessEvidence),
+        nextAction: deepFreeze({
+            kind: nextAction.kind,
+            reasonCode: requireToken(nextAction.reasonCode, 'PROGRESS_SCHEMA_INVALID', 'nextAction.reasonCode'),
+        }),
+        reasonCodes: normalizeTokens(record.reasonCodes, 'PROGRESS_SCHEMA_INVALID', 'reasonCodes', { maxItems: 32 }),
+        provenance: deepFreeze({
+            producer: provenance.producer,
+            generationId: requireToken(provenance.generationId, 'PROGRESS_SCHEMA_INVALID', 'generationId'),
+            legacySnapshotHash: provenance.legacySnapshotHash,
+        }),
+    });
+}
+export function buildProgressSnapshotV1(input) {
+    const normalized = normalizeProgressInput(input);
+    const snapshotId = executableGraphDomainHash('p220-progress-snapshot-id-v1', {
+        projectId: normalized.projectId,
+        workflowId: normalized.workflowId,
+        runId: normalized.runId,
+        invocationId: normalized.invocationId,
+        sequence: normalized.sequence,
+    });
+    const base = {
+        schemaVersion: 'ProgressSnapshot/1.0',
+        snapshotId,
+        ...normalized,
+        publicSafe: true,
+    };
+    return deepFreeze({
+        ...base,
+        snapshotHash: executableGraphDomainHash('p220-progress-snapshot-v1', base),
+    });
+}
+export function assertProgressSnapshotV1(value) {
+    exactKeys(value, ['schemaVersion', 'snapshotId', ...PROGRESS_INPUT_KEYS, 'publicSafe', 'snapshotHash'], 'PROGRESS_SCHEMA_INVALID');
+    if (value.schemaVersion !== 'ProgressSnapshot/1.0' || value.publicSafe !== true || !isHash(value.snapshotId) || !isHash(value.snapshotHash)) {
+        fail('PROGRESS_SCHEMA_INVALID');
+    }
+    const input = Object.fromEntries(PROGRESS_INPUT_KEYS.map((key) => [key, value[key]]));
+    const rebuilt = buildProgressSnapshotV1(input);
+    if (rebuilt.snapshotId !== value.snapshotId || rebuilt.snapshotHash !== value.snapshotHash
+        || canonicalizeExecutableGraphJson(rebuilt) !== canonicalizeExecutableGraphJson(value))
+        fail('PROGRESS_CHAIN_INVALID');
+    return rebuilt;
+}
+export function validateProgressSnapshotChainV1(values) {
+    try {
+        assertProgressSnapshotChainV1(values);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function assertProgressSnapshotChainV1(values) {
+    if (!Array.isArray(values) || values.length === 0 || values.length > 4096) {
+        return fail('PROGRESS_CHAIN_INVALID', 'snapshots');
+    }
+    let previous;
+    for (const raw of values) {
+        const snapshot = assertProgressSnapshotV1(raw);
+        if (!previous) {
+            if (snapshot.parentSnapshotHash !== null)
+                fail('PROGRESS_CHAIN_INVALID', 'parentSnapshotHash');
+        }
+        else {
+            if (snapshot.parentSnapshotHash !== previous.snapshotHash
+                || snapshot.sequence <= previous.sequence
+                || snapshot.revision <= previous.revision
+                || Date.parse(snapshot.occurredAt) < Date.parse(previous.occurredAt)
+                || snapshot.projectId !== previous.projectId
+                || snapshot.workflowId !== previous.workflowId
+                || snapshot.runId !== previous.runId
+                || snapshot.stage.total !== previous.stage.total
+                || snapshot.stage.ordinal < previous.stage.ordinal
+                || previous.stage.completedStageIds.some((id) => !snapshot.stage.completedStageIds.includes(id))
+                || snapshot.stage.remainingStageIds.some((id) => !previous.stage.remainingStageIds.includes(id))) {
+                fail('PROGRESS_CHAIN_INVALID', 'snapshot');
+            }
+            for (const field of READINESS_EVIDENCE_FIELDS) {
+                if (snapshot.readiness[field] !== previous.readiness[field]) {
+                    const currentEvidence = snapshot.readinessEvidence[field];
+                    const priorEvidence = previous.readinessEvidence[field];
+                    if (canonicalizeExecutableGraphJson(currentEvidence) === canonicalizeExecutableGraphJson(priorEvidence)
+                        || snapshot.lastAcceptedEvidenceRef === null
+                        || !currentEvidence.includes(snapshot.lastAcceptedEvidenceRef)) {
+                        fail('PROGRESS_READINESS_DRIFT', field);
+                    }
+                }
+            }
+        }
+        previous = snapshot;
+    }
+    return true;
+}
+function validateLegacyYoloopSnapshot(value) {
+    try {
+        exactKeys(value, [
+            'schemaVersion', 'runId', 'snapshotId', 'sequence', 'revision', 'operationId',
+            'boundary', 'phase', 'status', 'occurredAt', 'parentSnapshotHash',
+            'snapshotHash', 'budget', 'reasonCodes', 'publicSafe',
+        ], 'PROGRESS_SCHEMA_INVALID');
+        if (value.schemaVersion !== 'ProgressSnapshot/1.0' || value.publicSafe !== true
+            || !isHash(value.snapshotId) || !isHash(value.snapshotHash))
+            return false;
+        const { snapshotHash, ...hashed } = value;
+        if (snapshotHash !== yoloopDomainHash('p220-yoloop-progress-snapshot-v1', hashed))
+            return false;
+        const expectedId = yoloopDomainHash('p220-yoloop-progress-snapshot-id-v1', {
+            runId: value.runId,
+            operationId: value.operationId,
+            sequence: value.sequence,
+            phase: value.phase,
+        });
+        return value.snapshotId === expectedId;
+    }
+    catch {
+        return false;
+    }
+}
+export function adaptLegacyYoloopProgressSnapshotV1(legacy, context) {
+    if (!validateLegacyYoloopSnapshot(legacy))
+        fail('PROGRESS_SCHEMA_INVALID', 'legacy');
+    let normalizedContext;
+    try {
+        normalizedContext = normalizeProgressInput(context);
+    }
+    catch {
+        return fail('PROGRESS_SCHEMA_INVALID', 'context');
+    }
+    if (normalizedContext.runId !== legacy.runId
+        || normalizedContext.sequence !== legacy.sequence
+        || normalizedContext.revision !== legacy.revision
+        || normalizedContext.occurredAt !== legacy.occurredAt)
+        fail('PROGRESS_SCHEMA_INVALID', 'context');
+    return buildProgressSnapshotV1({
+        ...normalizedContext,
+        provenance: {
+            producer: 'migration',
+            generationId: normalizedContext.provenance.generationId,
+            legacySnapshotHash: legacy.snapshotHash,
+        },
+    });
+}
+export const VALIDATION_MATRIX_CATEGORIES = Object.freeze([
+    'happy', 'partial', 'blocked', 'failure', 'stage-contract', 'retry-exhaustion',
+    'cooperative-cancellation', 'resume-replay', 'stale-or-forged-receipt',
+    'budget-exhaustion', 'unknown-gate', 'missing-protected-asset',
+    'unauthorized-successor', 'protected-data-leak',
+]);
+export function createValidationMatrixReceiptV11(kind, input) {
+    if (kind !== 'isolated' && kind !== 'regression')
+        fail('VALIDATION_MATRIX_INVALID', 'kind');
+    exactKeys(input, ['graphHash', 'elementId', 'caseId', 'category', 'evidenceHash'], 'VALIDATION_MATRIX_INVALID');
+    const record = input;
+    const category = record.category;
+    if (!VALIDATION_MATRIX_CATEGORIES.includes(category))
+        fail('VALIDATION_MATRIX_INVALID', 'category');
+    const body = {
+        schemaVersion: '1.1',
+        kind,
+        graphHash: requireHash(record.graphHash, 'VALIDATION_MATRIX_INVALID', 'graphHash'),
+        elementId: requireToken(record.elementId, 'VALIDATION_MATRIX_INVALID', 'elementId', 96),
+        caseId: requireToken(record.caseId, 'VALIDATION_MATRIX_INVALID', 'caseId', 96),
+        category,
+        evidenceHash: requireHash(record.evidenceHash, 'VALIDATION_MATRIX_INVALID', 'evidenceHash'),
+    };
+    return deepFreeze({
+        ...body,
+        receiptId: executableGraphDomainHash('validation-matrix-receipt-v1.1', body),
+    });
+}
+export function isValidationMatrixReceiptV11(value, expectedKind) {
+    try {
+        exactKeys(value, ['schemaVersion', 'kind', 'receiptId', 'graphHash', 'elementId', 'caseId', 'category', 'evidenceHash'], 'VALIDATION_MATRIX_INVALID');
+        if (value.schemaVersion !== '1.1' || (value.kind !== 'isolated' && value.kind !== 'regression')
+            || (expectedKind && value.kind !== expectedKind))
+            return false;
+        const rebuilt = createValidationMatrixReceiptV11(value.kind, {
+            graphHash: value.graphHash,
+            elementId: value.elementId,
+            caseId: value.caseId,
+            category: value.category,
+            evidenceHash: value.evidenceHash,
+        });
+        return rebuilt.receiptId === value.receiptId
+            && canonicalizeExecutableGraphJson(rebuilt) === canonicalizeExecutableGraphJson(value);
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeValidationRow(value) {
+    exactKeys(value, ['isolated', 'regression'], 'VALIDATION_MATRIX_INVALID');
+    const record = value;
+    if (!isValidationMatrixReceiptV11(record.isolated, 'isolated')
+        || !isValidationMatrixReceiptV11(record.regression, 'regression'))
+        fail('VALIDATION_MATRIX_INVALID');
+    const isolated = record.isolated;
+    const regression = record.regression;
+    if (isolated.graphHash !== regression.graphHash
+        || isolated.elementId !== regression.elementId
+        || isolated.category !== regression.category
+        || isolated.caseId === regression.caseId
+        || isolated.receiptId === regression.receiptId
+        || isolated.evidenceHash === regression.evidenceHash)
+        fail('VALIDATION_MATRIX_INVALID');
+    return deepFreeze({ isolated, regression });
+}
+function validationRowKey(row) {
+    return [
+        row.isolated.graphHash,
+        row.isolated.elementId,
+        row.isolated.category,
+        row.isolated.caseId,
+        row.regression.caseId,
+    ].join('\0');
+}
+export function buildValidationMatrixV11(rowsInput) {
+    if (!Array.isArray(rowsInput) || rowsInput.length === 0 || rowsInput.length > 4096)
+        fail('VALIDATION_MATRIX_INVALID', 'rows');
+    const rows = rowsInput.map(normalizeValidationRow).sort((left, right) => compareBytes(validationRowKey(left), validationRowKey(right)));
+    if (new Set(rows.map(validationRowKey)).size !== rows.length)
+        fail('VALIDATION_MATRIX_DUPLICATE', 'rows');
+    const receiptIds = rows.flatMap((row) => [row.isolated.receiptId, row.regression.receiptId]);
+    if (new Set(receiptIds).size !== receiptIds.length)
+        fail('VALIDATION_MATRIX_DUPLICATE', 'receiptId');
+    const base = {
+        schemaVersion: 'ValidationMatrix/1.1',
+        rows: Object.freeze(rows),
+        publicSafe: true,
+    };
+    return deepFreeze({
+        ...base,
+        matrixHash: executableGraphDomainHash('p220-validation-matrix-v1.1', base),
+    });
+}
+export function validateValidationMatrixV11(value) {
+    try {
+        exactKeys(value, ['schemaVersion', 'rows', 'publicSafe', 'matrixHash'], 'VALIDATION_MATRIX_INVALID');
+        if (value.schemaVersion !== 'ValidationMatrix/1.1' || value.publicSafe !== true || !isHash(value.matrixHash)
+            || !Array.isArray(value.rows))
+            return false;
+        const rebuilt = buildValidationMatrixV11(value.rows);
+        return rebuilt.matrixHash === value.matrixHash
+            && canonicalizeExecutableGraphJson(rebuilt) === canonicalizeExecutableGraphJson(value);
+    }
+    catch {
+        return false;
+    }
+}
+export function admitGraphSpecVersion(version, mode) {
+    if (mode !== 'normal' && mode !== 'read-only-migration')
+        fail('graphspec_version_unsupported', 'mode');
+    if (version === '1.1' && mode === 'normal')
+        fail('graphspec_v1_1_blocked_requires_migration', 'version');
+    if (version !== '1.1' && version !== '1.2')
+        fail('graphspec_version_unsupported', 'version');
+    return deepFreeze({
+        schemaVersion: 'GraphSpecVersionAdmission/1.0',
+        version: version,
+        mode,
+        outcome: version === '1.1' ? 'accepted-read-only' : 'accepted',
+        mutationAllowed: false,
+        readinessClaimed: false,
+    });
+}