project-tiny-context-harness 0.8.11 → 0.8.13

package/dist/lib/compact-shared-structure-validation.js

@@ -0,0 +1,159 @@
+import { createCompactSharedStructures } from "./compact-shared-structures.js";
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+const STABLE_BOUNDARY = /^[a-z0-9][a-z0-9._:-]*$/u;
+const STRUCTURE_KEY = /^structure\.[a-f0-9]{24}$/u;
+export function materializeCanonicalCompactSharedStructures(targets, catalogInput, label) {
+    const catalog = parseCatalog(catalogInput, `${label}.shared_structures`);
+    const encodedSlots = targets.map((target, index) => ({
+        boundary: validBoundary(target.boundary, `${label}.slots[${index}]`),
+        value: structuredClone(target.read()),
+    }));
+    const catalogByKey = new Map(catalog.map((item) => [item.key, item]));
+    const materializedSlots = encodedSlots.map((slot, index) => ({
+        boundary: slot.boundary,
+        value: resolveReference(slot.value, slot.boundary, catalogByKey, `${label}.slots[${index}]`),
+    }));
+    const canonical = createCompactSharedStructures(materializedSlots);
+    if (canonicalValueJson(canonical.catalog) !== canonicalValueJson(catalog) ||
+        canonicalValueJson(canonical.slots) !== canonicalValueJson(encodedSlots))
+        fail(label, "shared structure catalog is not canonical");
+    materializedSlots.forEach((slot, index) => targets[index].write(slot.value));
+    return canonical.statistics;
+}
+function parseCatalog(value, label) {
+    if (!Array.isArray(value))
+        fail(label, "must be an array");
+    const seen = new Set();
+    return value.map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            fail(itemLabel, "must be an object");
+        const row = item;
+        const fields = ["key", "digest", "boundary", "parameter_count", "template"];
+        const unknown = Object.keys(row).filter((key) => !fields.includes(key));
+        const missing = fields.filter((key) => !Object.hasOwn(row, key));
+        if (unknown.length)
+            fail(itemLabel, `unknown keys: ${unknown.join(",")}`);
+        if (missing.length)
+            fail(itemLabel, `missing keys: ${missing.join(",")}`);
+        if (typeof row.key !== "string" || !STRUCTURE_KEY.test(row.key))
+            fail(`${itemLabel}.key`, "must be a canonical structure key");
+        if (seen.has(row.key))
+            fail(itemLabel, `duplicate key: ${row.key}`);
+        seen.add(row.key);
+        if (typeof row.digest !== "string" || !/^[a-f0-9]{64}$/u.test(row.digest))
+            fail(`${itemLabel}.digest`, "must be a lowercase SHA-256");
+        const boundary = validBoundary(row.boundary, `${itemLabel}.boundary`);
+        if (!Number.isInteger(row.parameter_count) ||
+            Number(row.parameter_count) < 0)
+            fail(`${itemLabel}.parameter_count`, "must be an integer >= 0");
+        const parameterCount = Number(row.parameter_count);
+        const used = validateTemplate(row.template, parameterCount, itemLabel);
+        for (let parameter = 0; parameter < parameterCount; parameter += 1)
+            if (!used.has(parameter))
+                fail(`${itemLabel}.template`, `unused parameter: ${parameter}`);
+        const digest = sha256Hex(canonicalValueJson({
+            boundary,
+            parameter_count: parameterCount,
+            template: row.template,
+        }));
+        if (row.digest !== digest)
+            fail(`${itemLabel}.digest`, `digest mismatch: ${row.digest}:${digest}`);
+        if (row.key !== `structure.${digest.slice(0, 24)}`)
+            fail(`${itemLabel}.key`, "key does not match digest");
+        return {
+            key: row.key,
+            digest,
+            boundary,
+            parameter_count: parameterCount,
+            template: structuredClone(row.template),
+        };
+    });
+}
+function validateTemplate(value, parameterCount, label) {
+    const used = new Set();
+    const visit = (item, path) => {
+        if (Array.isArray(item)) {
+            item.forEach((child, index) => visit(child, `${path}[${index}]`));
+            return;
+        }
+        if (!item || typeof item !== "object") {
+            leafKind(item);
+            return;
+        }
+        const row = item;
+        if (Object.hasOwn(row, "structure_ref"))
+            fail(path, "templates cannot contain structure references");
+        if (Object.hasOwn(row, "parameter_index")) {
+            if (Object.keys(row).length !== 1 ||
+                !Number.isInteger(row.parameter_index) ||
+                Number(row.parameter_index) < 0 ||
+                Number(row.parameter_index) >= parameterCount)
+                fail(path, "invalid parameter placeholder");
+            used.add(Number(row.parameter_index));
+            return;
+        }
+        for (const [key, child] of Object.entries(row))
+            visit(child, `${path}.${key}`);
+    };
+    visit(value, `${label}.template`);
+    return used;
+}
+function resolveReference(value, boundary, catalog, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return structuredClone(value);
+    const row = value;
+    if (!Object.hasOwn(row, "structure_ref"))
+        return structuredClone(value);
+    if (Object.keys(row).length !== 2 ||
+        !Object.hasOwn(row, "arguments") ||
+        typeof row.structure_ref !== "string")
+        fail(label, "structure reference must contain only structure_ref/arguments");
+    const template = catalog.get(row.structure_ref);
+    if (!template)
+        fail(label, `unknown structure: ${String(row.structure_ref)}`);
+    if (template.boundary !== boundary)
+        fail(label, `structure boundary mismatch: ${template.boundary}:${boundary}`);
+    if (!Array.isArray(row.arguments))
+        fail(`${label}.arguments`, "must be an array");
+    if (row.arguments.length !== template.parameter_count)
+        fail(`${label}.arguments`, `parameter count mismatch: ${row.arguments.length}:${template.parameter_count}`);
+    row.arguments.forEach((argument, index) => {
+        if (argument && typeof argument === "object")
+            fail(`${label}.arguments[${index}]`, "arguments must be scalar");
+        leafKind(argument);
+    });
+    return instantiateTemplate(template.template, row.arguments);
+}
+function instantiateTemplate(template, arguments_) {
+    if (Array.isArray(template))
+        return template.map((item) => instantiateTemplate(item, arguments_));
+    if (!template || typeof template !== "object")
+        return structuredClone(template);
+    const row = template;
+    if (Object.keys(row).length === 1 && Object.hasOwn(row, "parameter_index"))
+        return structuredClone(arguments_[Number(row.parameter_index)]);
+    return Object.fromEntries(Object.entries(row).map(([key, value]) => [
+        key,
+        instantiateTemplate(value, arguments_),
+    ]));
+}
+function leafKind(value) {
+    if (value === null)
+        return "null";
+    if (typeof value === "string")
+        return "string";
+    if (typeof value === "boolean")
+        return "boolean";
+    if (typeof value === "number" && Number.isFinite(value))
+        return "number";
+    fail("value", `unsupported scalar: ${typeof value}`);
+}
+function validBoundary(value, label) {
+    if (typeof value !== "string" || !STABLE_BOUNDARY.test(value))
+        fail(label, "must be a stable lowercase boundary");
+    return value;
+}
+function fail(label, message) {
+    throw new Error(`compact_shared_structure_invalid:${label}:${message}`);
+}

package/dist/lib/compact-shared-structures.d.ts

@@ -0,0 +1,3 @@
+import type { CompactSharedStructureEncoding, CompactSharedStructureSlot } from "./compact-shared-structure-types.js";
+export type { CompactSharedStructureEncoding, CompactSharedStructureFamilyStatistic, CompactSharedStructureSlot, CompactSharedStructureStatistics, CompactSharedStructureTarget, CompactSharedStructureTemplate, } from "./compact-shared-structure-types.js";
+export declare function createCompactSharedStructures(slotsInput: CompactSharedStructureSlot[]): CompactSharedStructureEncoding;

package/dist/lib/compact-shared-structures.js

@@ -0,0 +1,204 @@
+import { Buffer } from "node:buffer";
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+const STABLE_BOUNDARY = /^[a-z0-9][a-z0-9._:-]*$/u;
+const MINIMUM_NET_SAVING_BYTES = 32;
+export function createCompactSharedStructures(slotsInput) {
+    const slots = slotsInput.map((slot, index) => ({
+        boundary: validBoundary(slot.boundary, `slots[${index}].boundary`),
+        value: structuredClone(slot.value),
+    }));
+    const grouped = new Map();
+    for (const [slotIndex, slot] of slots.entries()) {
+        if (!isCandidateComposite(slot.value))
+            continue;
+        const descriptor = describeStructure(slot.value);
+        const identity = `${slot.boundary}\0${canonicalValueJson(descriptor.shape)}`;
+        const occurrences = grouped.get(identity) ?? [];
+        occurrences.push({
+            slot_index: slotIndex,
+            value: slot.value,
+            leaves: descriptor.leaves,
+            original_bytes: byteLength(slot.value),
+        });
+        grouped.set(identity, occurrences);
+    }
+    const candidateClusters = [...grouped.values()]
+        .filter((occurrences) => occurrences.length > 1)
+        .flatMap(partitionStableCandidateFamilies)
+        .filter((group) => group.occurrences.length > 1);
+    const candidates = candidateClusters
+        .map(({ occurrences, parameter_positions }) => buildCandidate(slots, occurrences, parameter_positions))
+        .filter((candidate) => candidate !== null)
+        .sort((left, right) => left.row.key.localeCompare(right.row.key));
+    const bySlot = new Map();
+    for (const candidate of candidates)
+        for (const occurrence of candidate.occurrences)
+            bySlot.set(occurrence.slot_index, candidate);
+    for (const [slotIndex, candidate] of bySlot) {
+        const occurrenceIndex = candidate.occurrences.findIndex((item) => item.slot_index === slotIndex);
+        slots[slotIndex].value = structuredClone(candidate.references[occurrenceIndex]);
+    }
+    const catalog = candidates.map((candidate) => candidate.row);
+    const originalPayloadBytes = slotsInput.reduce((sum, slot) => sum + byteLength(slot.value), 0);
+    const encodedPayloadBytes = slots.reduce((sum, slot) => sum + byteLength(slot.value), 0);
+    const catalogBytes = byteLength(catalog);
+    const familyStatistics = candidates
+        .map((candidate) => candidate.statistic)
+        .sort((left, right) => right.saved_bytes - left.saved_bytes ||
+        left.key.localeCompare(right.key));
+    return {
+        slots,
+        catalog,
+        statistics: {
+            slot_count: slots.length,
+            composite_slot_count: slotsInput.filter((slot) => isCandidateComposite(slot.value)).length,
+            candidate_family_count: candidateClusters.length,
+            emitted_family_count: catalog.length,
+            exact_family_count: catalog.filter((item) => item.parameter_count === 0)
+                .length,
+            parameterized_family_count: catalog.filter((item) => item.parameter_count > 0).length,
+            reference_count: candidates.reduce((sum, candidate) => sum + candidate.occurrences.length, 0),
+            argument_count: candidates.reduce((sum, candidate) => sum + candidate.occurrences.length * candidate.row.parameter_count, 0),
+            original_payload_bytes: originalPayloadBytes,
+            encoded_payload_bytes: encodedPayloadBytes,
+            catalog_bytes: catalogBytes,
+            saved_bytes: originalPayloadBytes - encodedPayloadBytes - catalogBytes,
+            remaining_beneficial_candidates: 0,
+            families: familyStatistics,
+        },
+    };
+}
+function buildCandidate(slots, occurrences, parameterPositions) {
+    const boundary = slots[occurrences[0].slot_index].boundary;
+    const parameterByPosition = new Map(parameterPositions.map((position, index) => [position, index]));
+    const template = buildTemplate(occurrences[0].value, parameterByPosition);
+    const parameterCount = parameterPositions.length;
+    const digest = sha256Hex(canonicalValueJson({ boundary, parameter_count: parameterCount, template }));
+    const key = `structure.${digest.slice(0, 24)}`;
+    const row = {
+        key,
+        digest,
+        boundary,
+        parameter_count: parameterCount,
+        template,
+    };
+    const references = occurrences.map((occurrence) => ({
+        structure_ref: key,
+        arguments: parameterPositions.map((position) => structuredClone(occurrence.leaves[position])),
+    }));
+    const originalBytes = occurrences.reduce((sum, occurrence) => sum + occurrence.original_bytes, 0);
+    const encodedBytes = byteLength(row) +
+        references.reduce((sum, reference) => sum + byteLength(reference), 0);
+    const savedBytes = originalBytes - encodedBytes;
+    if (savedBytes < MINIMUM_NET_SAVING_BYTES)
+        return null;
+    return {
+        boundary,
+        occurrences,
+        parameter_positions: parameterPositions,
+        template,
+        row,
+        references,
+        statistic: {
+            key,
+            boundary,
+            occurrences: occurrences.length,
+            parameter_count: parameterCount,
+            original_bytes: originalBytes,
+            encoded_bytes: encodedBytes,
+            saved_bytes: savedBytes,
+        },
+    };
+}
+function partitionStableCandidateFamilies(occurrences) {
+    const leafCount = occurrences[0].leaves.length;
+    const parameterPositions = [];
+    const constantPositions = [];
+    for (let index = 0; index < leafCount; index += 1) {
+        const distinct = new Set(occurrences.map((occurrence) => canonicalValueJson(occurrence.leaves[index]))).size;
+        if (distinct >= 3 && distinct / occurrences.length >= 0.2)
+            parameterPositions.push(index);
+        else
+            constantPositions.push(index);
+    }
+    const clusters = new Map();
+    for (const occurrence of occurrences) {
+        const identity = canonicalValueJson(constantPositions.map((position) => occurrence.leaves[position]));
+        const cluster = clusters.get(identity) ?? [];
+        cluster.push(occurrence);
+        clusters.set(identity, cluster);
+    }
+    return [...clusters.values()].map((cluster) => ({
+        occurrences: cluster,
+        parameter_positions: parameterPositions,
+    }));
+}
+function describeStructure(value) {
+    const leaves = [];
+    const visit = (item) => {
+        if (Array.isArray(item))
+            return ["array", item.map(visit)];
+        if (item && typeof item === "object")
+            return [
+                "object",
+                Object.keys(item)
+                    .sort()
+                    .map((key) => [key, visit(item[key])]),
+            ];
+        leaves.push(item);
+        return ["leaf", leafKind(item)];
+    };
+    return { shape: visit(value), leaves };
+}
+function buildTemplate(value, parameterByPosition) {
+    let leafIndex = 0;
+    const visit = (item) => {
+        if (Array.isArray(item))
+            return item.map(visit);
+        if (item && typeof item === "object")
+            return Object.fromEntries(Object.keys(item)
+                .sort()
+                .map((key) => [key, visit(item[key])]));
+        const parameterIndex = parameterByPosition.get(leafIndex);
+        leafIndex += 1;
+        return parameterIndex === undefined
+            ? structuredClone(item)
+            : { parameter_index: parameterIndex };
+    };
+    return visit(value);
+}
+function isCandidateComposite(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    if (!Array.isArray(value)) {
+        const row = value;
+        if (Object.keys(row).length === 1 &&
+            (Object.hasOwn(row, "selector_ref") ||
+                Object.hasOwn(row, "structure_ref") ||
+                Object.hasOwn(row, "parameter_index")))
+            return false;
+    }
+    return true;
+}
+function leafKind(value) {
+    if (value === null)
+        return "null";
+    if (typeof value === "string")
+        return "string";
+    if (typeof value === "boolean")
+        return "boolean";
+    if (typeof value === "number" && Number.isFinite(value))
+        return "number";
+    fail("value", `unsupported scalar: ${typeof value}`);
+}
+function validBoundary(value, label) {
+    if (typeof value !== "string" || !STABLE_BOUNDARY.test(value))
+        fail(label, "must be a stable lowercase boundary");
+    return value;
+}
+function byteLength(value) {
+    return Buffer.byteLength(canonicalValueJson(value), "utf8");
+}
+function fail(label, message) {
+    throw new Error(`compact_shared_structure_invalid:${label}:${message}`);
+}

package/dist/lib/design-resource-fact-enums.d.ts

@@ -16,5 +16,9 @@ export declare const DESIGN_RESOURCE_COMPARATORS: readonly ["exact_value", "nume
 export type DesignResourceComparator = (typeof DESIGN_RESOURCE_COMPARATORS)[number];
 export declare const DESIGN_RESOURCE_INSPECTOR_CAPABILITIES: readonly ["html_dom", "css_cascade", "javascript_static", "json", "svg", "markdown", "assets", "design_tokens", "component_anatomy", "prototype_transitions", "responsive_rules", "input_rules", "accessibility", "motion", "localization", "system_ui", "haptics", "audio", "render_capture", "geometry_measurement", "custom_properties", "relations", "dynamic_population"];
 export type DesignResourceInspectorCapability = (typeof DESIGN_RESOURCE_INSPECTOR_CAPABILITIES)[number];
+export declare const DESIGN_RESOURCE_SYMBOLIC_NONINTERFERENCE_ORACLE_CAPABILITIES: readonly ["symbolic_noninterference.source.closed_world_static_dependency_closure", "symbolic_noninterference.source.restricted_ir_symbolic_equivalence", "symbolic_noninterference.source.finite_complete_domain_exhaustive_equivalence", "symbolic_noninterference.production.closed_world_static_dependency_closure", "symbolic_noninterference.production.restricted_ir_symbolic_equivalence", "symbolic_noninterference.production.finite_complete_domain_exhaustive_equivalence"];
+export type DesignResourceSymbolicNoninterferenceOracleCapability = (typeof DESIGN_RESOURCE_SYMBOLIC_NONINTERFERENCE_ORACLE_CAPABILITIES)[number];
+export declare const DESIGN_RESOURCE_ORACLE_CAPABILITIES: readonly ["html_dom", "css_cascade", "javascript_static", "json", "svg", "markdown", "assets", "design_tokens", "component_anatomy", "prototype_transitions", "responsive_rules", "input_rules", "accessibility", "motion", "localization", "system_ui", "haptics", "audio", "render_capture", "geometry_measurement", "custom_properties", "relations", "dynamic_population", "symbolic_noninterference.source.closed_world_static_dependency_closure", "symbolic_noninterference.source.restricted_ir_symbolic_equivalence", "symbolic_noninterference.source.finite_complete_domain_exhaustive_equivalence", "symbolic_noninterference.production.closed_world_static_dependency_closure", "symbolic_noninterference.production.restricted_ir_symbolic_equivalence", "symbolic_noninterference.production.finite_complete_domain_exhaustive_equivalence"];
+export type DesignResourceOracleCapability = (typeof DESIGN_RESOURCE_ORACLE_CAPABILITIES)[number];
 export declare const DESIGN_RESOURCE_CENSUS_KINDS: readonly ["resource", "node", "declaration", "token", "asset_reference", "relation", "custom_property", "variant", "state", "interaction_phase", "dynamic_population"];
 export type DesignResourceCensusKind = (typeof DESIGN_RESOURCE_CENSUS_KINDS)[number];

package/dist/lib/design-resource-fact-enums.js

@@ -155,6 +155,18 @@ export const DESIGN_RESOURCE_INSPECTOR_CAPABILITIES = [
     "relations",
     "dynamic_population",
 ];
+export const DESIGN_RESOURCE_SYMBOLIC_NONINTERFERENCE_ORACLE_CAPABILITIES = [
+    "symbolic_noninterference.source.closed_world_static_dependency_closure",
+    "symbolic_noninterference.source.restricted_ir_symbolic_equivalence",
+    "symbolic_noninterference.source.finite_complete_domain_exhaustive_equivalence",
+    "symbolic_noninterference.production.closed_world_static_dependency_closure",
+    "symbolic_noninterference.production.restricted_ir_symbolic_equivalence",
+    "symbolic_noninterference.production.finite_complete_domain_exhaustive_equivalence",
+];
+export const DESIGN_RESOURCE_ORACLE_CAPABILITIES = [
+    ...DESIGN_RESOURCE_INSPECTOR_CAPABILITIES,
+    ...DESIGN_RESOURCE_SYMBOLIC_NONINTERFERENCE_ORACLE_CAPABILITIES,
+];
 export const DESIGN_RESOURCE_CENSUS_KINDS = [
     "resource",
     "node",

package/dist/lib/design-resource-fact-manifest-shape-evidence.js

@@ -1,4 +1,4 @@
-import { DESIGN_RESOURCE_INSPECTOR_CAPABILITIES, } from "./design-resource-fact-manifest-types.js";
+import { DESIGN_RESOURCE_ORACLE_CAPABILITIES, } from "./design-resource-fact-manifest-types.js";
 import { parseDesignResourceLocatedDigest } from "./design-resource-fact-shape-primitives.js";
 import { contractKeys, sha256, stableKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
 import { array, literal, nullable, object, string, } from "./long-task-shape-primitives.js";
@@ -19,7 +19,7 @@ export function parseDesignResourceOracles(value, label = "design_resource_hando
             identity: string(row.identity, `${itemLabel}.identity`),
             version: string(row.version, `${itemLabel}.version`),
             sha256: nullable(row.sha256, (item) => sha256(item, `${itemLabel}.sha256`)),
-            capability_refs: array(row.capability_refs, `${itemLabel}.capability_refs`).map((capability, capabilityIndex) => literal(capability, DESIGN_RESOURCE_INSPECTOR_CAPABILITIES, `${itemLabel}.capability_refs[${capabilityIndex}]`)),
+            capability_refs: array(row.capability_refs, `${itemLabel}.capability_refs`).map((capability, capabilityIndex) => literal(capability, DESIGN_RESOURCE_ORACLE_CAPABILITIES, `${itemLabel}.capability_refs[${capabilityIndex}]`)),
         };
     });
 }

package/dist/lib/design-resource-fact-policy.d.ts

@@ -1,5 +1,5 @@
 import type { DesignResourceDimension, DesignResourceEvidenceKind, DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
-import type { DesignResourceInspectorCapability } from "./design-resource-fact-manifest-types.js";
+import type { DesignResourceOracleCapability } from "./design-resource-fact-manifest-types.js";
 export declare const DESIGN_RESOURCE_FACT_INVARIANTS: Readonly<{
     readonly complete_observable_design_fact_delivery: true;
     readonly resource_fact_inventory_closure_required: true;
@@ -40,4 +40,4 @@ export declare function designFactMethodIsCompatible(dimension: DesignResourceDi
 export declare function designFactEvidenceIsCompatible(dimension: DesignResourceDimension, kind: DesignResourceEvidenceKind): boolean;
 export declare function designFactEvidenceSupportsMethod(method: DesignResourceVerificationMethod, kind: DesignResourceEvidenceKind): boolean;
 export declare function designFactComparatorSupportsMethod(method: DesignResourceVerificationMethod, comparator: string): boolean;
-export declare function designFactOracleSupportsMethod(method: DesignResourceVerificationMethod, capabilities: readonly DesignResourceInspectorCapability[]): boolean;
+export declare function designFactOracleSupportsMethod(method: DesignResourceVerificationMethod, capabilities: readonly DesignResourceOracleCapability[]): boolean;

package/dist/lib/design-resource-fact-types.d.ts

@@ -1,5 +1,5 @@
 import type { DesignResourceCoverageDisposition, DesignResourceDimension, DesignResourceLocatorKind, DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
-import type { DesignResourceComparator, DesignResourceInspectorCapability, DesignResourceLineageNodeKind, DesignResourcePropertyFamily, DesignResourceStandardConditionAxis, DesignResourceSubjectKind, DesignResourceSubjectPresenceKind, DesignResourceValueKind, DesignResourceVariationAxis } from "./design-resource-fact-enums.js";
+import type { DesignResourceComparator, DesignResourceInspectorCapability, DesignResourceLineageNodeKind, DesignResourceOracleCapability, DesignResourcePropertyFamily, DesignResourceStandardConditionAxis, DesignResourceSubjectKind, DesignResourceSubjectPresenceKind, DesignResourceValueKind, DesignResourceVariationAxis } from "./design-resource-fact-enums.js";
 export interface DesignResourceTypedLocatorV1 {
     resource_ref: string;
     kind: DesignResourceLocatorKind;
@@ -131,7 +131,7 @@ export interface DesignResourceOracleV1 {
     identity: string;
     version: string;
     sha256: string | null;
-    capability_refs: DesignResourceInspectorCapability[];
+    capability_refs: DesignResourceOracleCapability[];
 }
 export interface DesignResourceEnvironmentV1 {
     key: string;

package/dist/lib/design-resource-handoff-bundle-draft.js

@@ -17,7 +17,9 @@ export async function stageDesignResourceHandoffDraft(repository, draftDirectory
     await writeFile(stagedFile, bytes, { flag: "wx" });
     const stagedPath = repoRelative(repository, stagedFile);
     const parsed = parseDesignResourceHandoffMarkdown(stagedPath, content);
-    if (!("representation" in parsed.handoff))
+    if (parsed.handoff.schema_version !== "design-resource-handoff-v1" ||
+        !("representation" in parsed.handoff) ||
+        parsed.handoff.representation !== "manifest_backed")
         fail("manifest_backed_representation_required", entryName);
     if (parsed.handoff.targets.length !== 1)
         fail("one_target_per_handoff_required", `${entryName}:${parsed.handoff.targets.length}`);
@@ -27,7 +29,7 @@ export async function stageDesignResourceHandoffDraft(repository, draftDirectory
         fail("target_manifest_resource_missing", target.key);
     return {
         bytes,
-        parsed,
+        parsed: parsed,
         target,
         manifest_resource: manifestResource,
     };

package/dist/lib/design-resource-handoff-input-types.d.ts

@@ -1,4 +1,5 @@
 import type { DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+import type { DesignResourceHandoffV2, ParsedDesignResourceHandoffV2 } from "./design-resource-symbolic-fact-types.js";
 export type DesignResourceHandoffManifestBackedV1 = Pick<DesignResourceHandoffV1, "schema_version" | "intent" | "scope" | "provenance" | "resources" | "targets" | "resource_fact_closure" | "coverage" | "proposal"> & {
     representation: "manifest_backed";
 };
@@ -9,3 +10,5 @@ export interface ParsedDesignResourceHandoffInputV1 {
     source_item_keys: string[];
     source_item_kinds: Record<string, string>;
 }
+export type DesignResourceHandoffInput = DesignResourceHandoffInputV1 | DesignResourceHandoffV2;
+export type ParsedDesignResourceHandoffInput = ParsedDesignResourceHandoffInputV1 | ParsedDesignResourceHandoffV2;

package/dist/lib/design-resource-handoff-parser.d.ts

@@ -1,8 +1,8 @@
-import type { ParsedDesignResourceHandoffInputV1 } from "./design-resource-handoff-input-types.js";
+import type { ParsedDesignResourceHandoffInput } from "./design-resource-handoff-input-types.js";
 export interface DesignResourceHandoffBlockSpan {
     bodyStartOffset: number;
     bodyEndOffset: number;
 }
 export declare function containsDesignResourceHandoff(content: string): boolean;
 export declare function scanDesignResourceHandoffBlocks(content: string): DesignResourceHandoffBlockSpan[];
-export declare function parseDesignResourceHandoffMarkdown(handoffPath: string, content: string): ParsedDesignResourceHandoffInputV1;
+export declare function parseDesignResourceHandoffMarkdown(handoffPath: string, content: string): ParsedDesignResourceHandoffInput;

package/dist/lib/design-resource-handoff-parser.js

@@ -1,6 +1,6 @@
 import { parseSourceDocument } from "./long-task-source-item-parser.js";
 import { forEachSourceLine } from "./source-line-scanner.js";
-const DESIGN_RESOURCE_START = /^```yaml[ \t]+design-resource-handoff-v1[ \t]*$/u;
+const DESIGN_RESOURCE_START = /^```yaml[ \t]+design-resource-handoff-(?:v1|v2)[ \t]*$/u;
 const FORMAL_BLOCK_END = /^```[ \t]*$/u;
 export function containsDesignResourceHandoff(content) {
     return scanDesignResourceHandoffBlocks(content).length > 0;
@@ -32,7 +32,7 @@ export function parseDesignResourceHandoffMarkdown(handoffPath, content) {
         const parsedSource = parseSourceDocument(handoffPath, content);
         const handoff = parsedSource.designResourceHandoff;
         if (!handoff)
-            throw new Error("design-resource-handoff-v1 block was not decoded");
+            throw new Error("design-resource-handoff block was not decoded");
         return {
             handoff_path: handoffPath,
             handoff,

package/dist/lib/design-resource-handoff-shape.d.ts

@@ -1,4 +1,6 @@
 import type { DesignResourceHandoffInputV1 } from "./design-resource-handoff-input-types.js";
+import type { DesignResourceHandoffInput } from "./design-resource-handoff-input-types.js";
 import type { DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
 export declare function parseDesignResourceHandoffInputShape(value: unknown): DesignResourceHandoffInputV1;
+export declare function parseAnyDesignResourceHandoffInputShape(value: unknown): DesignResourceHandoffInput;
 export declare function parseDesignResourceHandoffShape(value: unknown): DesignResourceHandoffV1;

package/dist/lib/design-resource-handoff-shape.js

@@ -1,3 +1,4 @@
+import { parseDesignResourceSymbolicHandoffShape } from "./design-resource-symbolic-fact-shape.js";
 import { parseDesignResourceAssetBindings, parseDesignResourceAxisDispositions, parseDesignResourceConditionExclusions, parseDesignResourceEnvironments, parseDesignResourceFactCells, parseDesignResourceLineageNodes, parseDesignResourceOracles, parseDesignResourceProofObligations, parseDesignResourceProperties, parseDesignResourceVariationAxisDispositions, parseDesignResourceVariationExclusions, parseDesignResourceVariations, } from "./design-resource-fact-manifest-shape.js";
 import { parseDesignResourceHandoffBlockers, parseDesignResourceHandoffCoverage, parseDesignResourceHandoffEvidence, parseDesignResourceHandoffFacts, parseDesignResourceHandoffResourceFactClosure, } from "./design-resource-handoff-shape-evidence.js";
 import { contractKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
@@ -11,6 +12,15 @@ export function parseDesignResourceHandoffInputShape(value) {
         return parseManifestBackedDesignResourceHandoffShape(value);
     return parseDesignResourceHandoffShape(value);
 }
+export function parseAnyDesignResourceHandoffInputShape(value) {
+    if (value &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        value.schema_version ===
+            "design-resource-handoff-v2")
+        return parseDesignResourceSymbolicHandoffShape(value);
+    return parseDesignResourceHandoffInputShape(value);
+}
 export function parseDesignResourceHandoffShape(value) {
     const root = object(value, "design_resource_handoff", [
         "schema_version",

package/dist/lib/design-resource-handoff-snapshot.js

@@ -3,13 +3,17 @@ import path from "node:path";
 import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
 import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
 import { sha256Hex } from "./strict-codec.js";
+import { assertDesignResourceV1ManifestCapacity } from "./design-resource-v1-capacity.js";
 export async function readDesignResourceSnapshot(repository, parsed) {
     const contents = new Map();
     const hashes = {};
+    const manifestResourceRefs = new Set(parsed.handoff.targets.map((target) => target.source_profile.fact_manifest_resource_ref));
     for (const resource of parsed.handoff.resources) {
         if (resource.path === parsed.handoff_path)
             invalidDesignResourceHandoff("resource_must_not_be_handoff", resource.key);
         const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...resource.path.split("/")), `design_resource:${resource.key}`);
+        if (manifestResourceRefs.has(resource.key))
+            await assertDesignResourceV1ManifestCapacity(file);
         const bytes = await readFile(file);
         const digest = sha256Hex(bytes);
         if (digest !== resource.sha256)

package/dist/lib/design-resource-handoff-validation.d.ts

@@ -1,5 +1,8 @@
 import type { ParsedDesignResourceHandoffInputV1 } from "./design-resource-handoff-input-types.js";
 import type { DesignResourceHandoffPreflightV1, ParsedDesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
-export declare function preflightDesignResourceHandoff(repository: string, handoffPath: string): Promise<DesignResourceHandoffPreflightV1>;
+import type { DesignResourceHandoffPreflightV2 } from "./design-resource-symbolic-fact-types.js";
+import type { ParsedDesignResourceHandoffInput } from "./design-resource-handoff-input-types.js";
+export declare function preflightDesignResourceHandoff(repository: string, handoffPath: string): Promise<DesignResourceHandoffPreflightV1 | DesignResourceHandoffPreflightV2>;
+export declare function preflightParsedDesignResourceHandoffAny(repository: string, parsed: ParsedDesignResourceHandoffInput): Promise<DesignResourceHandoffPreflightV1 | DesignResourceHandoffPreflightV2>;
 export declare function preflightParsedDesignResourceHandoff(repository: string, parsed: ParsedDesignResourceHandoffInputV1): Promise<DesignResourceHandoffPreflightV1>;
 export declare function validateDesignResourceHandoffSemantics(parsed: ParsedDesignResourceHandoffV1): void;

package/dist/lib/design-resource-handoff-validation.js

@@ -6,15 +6,26 @@ import { parseDesignResourceFactManifests, validateDesignResourceFactManifests,
 import { hydrateManifestBackedDesignResourceHandoff } from "./design-resource-handoff-manifest-projection.js";
 import { readDesignResourceSnapshot } from "./design-resource-handoff-snapshot.js";
 import { validateDesignResourceFacts } from "./design-resource-handoff-validation-facts.js";
+import { preflightParsedDesignResourceSymbolicHandoff } from "./design-resource-symbolic-fact-validation.js";
 import { validateDesignResourceBlockers, validateDesignResourceCoverage, validateDesignResourceReachability, } from "./design-resource-handoff-validation-coverage.js";
 import { indexDesignResourceItems, invalidDesignResourceHandoff, requireNonemptyDesignResourceValues, requireUniqueDesignResourceObjects, requireUniqueDesignResourceValues, } from "./design-resource-handoff-validation-primitives.js";
 import { validateDesignResourceConditions, validateDesignResourceEvidence, validateDesignResourceScope, validateDesignResourceSubjects, validateDesignResourceTargets, } from "./design-resource-handoff-validation-structure.js";
 import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
+import { assertDesignResourceV1HandoffCapacity } from "./design-resource-v1-capacity.js";
 export async function preflightDesignResourceHandoff(repository, handoffPath) {
     const handoffFile = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...handoffPath.split("/")), "design_resource_handoff");
+    await assertDesignResourceV1HandoffCapacity(handoffFile);
     const parsed = parseDesignResourceHandoffMarkdown(handoffPath, await readFile(handoffFile, "utf8"));
+    return preflightParsedDesignResourceHandoffAny(repository, parsed);
+}
+export async function preflightParsedDesignResourceHandoffAny(repository, parsed) {
+    if (isParsedSymbolicHandoff(parsed))
+        return preflightParsedDesignResourceSymbolicHandoff(repository, parsed);
     return preflightParsedDesignResourceHandoff(repository, parsed);
 }
+function isParsedSymbolicHandoff(parsed) {
+    return parsed.handoff.schema_version === "design-resource-handoff-v2";
+}
 export async function preflightParsedDesignResourceHandoff(repository, parsed) {
     const inputHandoff = parsed.handoff;
     if (isManifestBacked(inputHandoff) && inputHandoff.targets.length !== 1)

package/dist/lib/design-resource-handoff-web-dependency-validation.d.ts

@@ -1,4 +1,6 @@
-import type { ParsedDesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
 import { type DesignResource } from "./design-resource-handoff-file-primitives.js";
-export declare function validateDesignResourceImplementationDependencyClosure(target: ParsedDesignResourceHandoffV1["handoff"]["targets"][number], resources: Map<string, DesignResource>, contents: Map<string, Buffer>): void;
+export declare function validateDesignResourceImplementationDependencyClosure(target: {
+    key: string;
+    resource_refs: string[];
+}, resources: Map<string, DesignResource>, contents: Map<string, Buffer>): void;
 export declare const validateDesignResourceWebDependencyClosure: typeof validateDesignResourceImplementationDependencyClosure;

package/dist/lib/design-resource-reconciliation-codec.d.ts

@@ -0,0 +1,2 @@
+import type { DesignResourceReconciliationAudit } from "./design-resource-reconciliation-types.js";
+export declare function parseDesignResourceReconciliationAudit(content: string): DesignResourceReconciliationAudit;