project-tiny-context-harness 0.8.10 → 0.8.12

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-manifest-validation.d.ts

@@ -1,4 +1,5 @@
 import type { DesignResourceObservableFactManifestV1 } from "./design-resource-fact-manifest-types.js";
-import type { ParsedDesignResourceHandoffInputV1, ParsedDesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+import type { ParsedDesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+import type { ParsedDesignResourceHandoffInputV1 } from "./design-resource-handoff-input-types.js";
 export declare function parseDesignResourceFactManifests(parsed: ParsedDesignResourceHandoffInputV1, contents: Map<string, Buffer>): Map<string, DesignResourceObservableFactManifestV1>;
 export declare function validateDesignResourceFactManifests(parsed: ParsedDesignResourceHandoffV1, contents: Map<string, Buffer>, manifests: Map<string, DesignResourceObservableFactManifestV1>, validateProjection: boolean): void;

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.d.ts

@@ -0,0 +1,11 @@
+import type { ParsedDesignResourceHandoffInputV1 } from "./design-resource-handoff-input-types.js";
+import type { DesignResourceHandoffResourceV1, DesignResourceHandoffTargetV1 } from "./design-resource-handoff-types.js";
+type BundleFailure = (code: string, detail: string) => never;
+export interface StagedDesignResourceHandoffDraft {
+    bytes: Buffer;
+    parsed: ParsedDesignResourceHandoffInputV1;
+    target: DesignResourceHandoffTargetV1;
+    manifest_resource: DesignResourceHandoffResourceV1;
+}
+export declare function stageDesignResourceHandoffDraft(repository: string, draftDirectory: string, temporaryDirectory: string, entryName: string, maxBytes: number, fail: BundleFailure): Promise<StagedDesignResourceHandoffDraft>;
+export {};

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

@@ -0,0 +1,40 @@
+import { lstat, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { parseDesignResourceHandoffMarkdown } from "./design-resource-handoff-parser.js";
+import { repoRelative } from "./long-task-workspace.js";
+export async function stageDesignResourceHandoffDraft(repository, draftDirectory, temporaryDirectory, entryName, maxBytes, fail) {
+    const draftFile = path.join(draftDirectory, entryName);
+    const info = await lstat(draftFile);
+    if (typeof info.nlink === "number" && info.nlink > 1)
+        fail("draft_hardlink_not_allowed", entryName);
+    assertByteLimit(entryName, info.size, maxBytes, fail);
+    const bytes = await readFile(draftFile);
+    assertByteLimit(entryName, bytes.length, maxBytes, fail);
+    const content = bytes.toString("utf8");
+    if (!Buffer.from(content, "utf8").equals(bytes))
+        fail("handoff_utf8_invalid", entryName);
+    const stagedFile = path.join(temporaryDirectory, entryName);
+    await writeFile(stagedFile, bytes, { flag: "wx" });
+    const stagedPath = repoRelative(repository, stagedFile);
+    const parsed = parseDesignResourceHandoffMarkdown(stagedPath, content);
+    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}`);
+    const target = parsed.handoff.targets[0];
+    const manifestResource = parsed.handoff.resources.find((resource) => resource.key === target.source_profile.fact_manifest_resource_ref);
+    if (!manifestResource)
+        fail("target_manifest_resource_missing", target.key);
+    return {
+        bytes,
+        parsed: parsed,
+        target,
+        manifest_resource: manifestResource,
+    };
+}
+function assertByteLimit(entryName, actual, maximum, fail) {
+    if (actual > maximum)
+        fail("handoff_byte_limit_exceeded", `${entryName}:${actual}:${maximum}`);
+}

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

@@ -1,10 +1,10 @@
-import { lstat, mkdtemp, readFile, readdir, realpath, rename, rm, writeFile, } from "node:fs/promises";
+import { lstat, mkdtemp, readdir, realpath, rename, rm, } from "node:fs/promises";
 import path from "node:path";
-import { parseDesignResourceHandoffMarkdown } from "./design-resource-handoff-parser.js";
+import { stageDesignResourceHandoffDraft } from "./design-resource-handoff-bundle-draft.js";
 import { createDesignResourceHandoffSetIntegrity } from "./design-resource-handoff-set-integrity.js";
 import { preflightParsedDesignResourceHandoff } from "./design-resource-handoff-validation.js";
 import { normalizeRepositoryCwd, normalizeRepositoryFile, } from "./long-task-paths.js";
-import { repoRelative, resolveInsideRepository, } from "./long-task-workspace.js";
+import { resolveInsideRepository } from "./long-task-workspace.js";
 import { sha256Hex } from "./strict-codec.js";
 export async function publishDesignResourceHandoffBundle(options) {
     const repository = path.resolve(options.repository);
@@ -39,31 +39,7 @@ export async function publishDesignResourceHandoffBundle(options) {
         const manifests = new Map();
         const handoffSetIntegrity = createDesignResourceHandoffSetIntegrity((code, detail) => invalid(code, detail));
         for (const entry of draftEntries) {
-            const draftFile = path.join(draftAbsolute, entry.name);
-            const info = await lstat(draftFile);
-            if (typeof info.nlink === "number" && info.nlink > 1)
-                invalid("draft_hardlink_not_allowed", entry.name);
-            if (info.size > options.max_handoff_bytes)
-                invalid("handoff_byte_limit_exceeded", `${entry.name}:${info.size}:${options.max_handoff_bytes}`);
-            const bytes = await readFile(draftFile);
-            if (bytes.length > options.max_handoff_bytes)
-                invalid("handoff_byte_limit_exceeded", `${entry.name}:${bytes.length}:${options.max_handoff_bytes}`);
-            const content = bytes.toString("utf8");
-            if (!Buffer.from(content, "utf8").equals(bytes))
-                invalid("handoff_utf8_invalid", entry.name);
-            const stagedFile = path.join(temporary, entry.name);
-            await writeFile(stagedFile, bytes, { flag: "wx" });
-            const stagedPath = repoRelative(repository, stagedFile);
-            const parsed = parseDesignResourceHandoffMarkdown(stagedPath, content);
-            if (!("representation" in parsed.handoff))
-                invalid("manifest_backed_representation_required", entry.name);
-            if (parsed.handoff.targets.length !== 1)
-                invalid("one_target_per_handoff_required", `${entry.name}:${parsed.handoff.targets.length}`);
-            const declaredTarget = parsed.handoff.targets[0];
-            const manifestResource = parsed.handoff.resources.find((resource) => resource.key ===
-                declaredTarget.source_profile.fact_manifest_resource_ref);
-            if (!manifestResource)
-                invalid("target_manifest_resource_missing", declaredTarget.key);
+            const { bytes, parsed, target: declaredTarget, manifest_resource: manifestResource, } = await stageDesignResourceHandoffDraft(repository, draftAbsolute, temporary, entry.name, options.max_handoff_bytes, invalid);
             if (!declaredManifestPaths.has(manifestResource.path))
                 invalid("target_manifest_not_declared", `${declaredTarget.key}:${manifestResource.path}`);
             const preflight = await preflightParsedDesignResourceHandoff(repository, parsed);

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

@@ -0,0 +1,14 @@
+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";
+};
+export type DesignResourceHandoffInputV1 = DesignResourceHandoffV1 | DesignResourceHandoffManifestBackedV1;
+export interface ParsedDesignResourceHandoffInputV1 {
+    handoff_path: string;
+    handoff: DesignResourceHandoffInputV1;
+    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-input-types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/design-resource-handoff-manifest-projection.d.ts

@@ -1,3 +1,4 @@
 import type { DesignResourceObservableFactManifestV1 } from "./design-resource-fact-manifest-types.js";
-import type { DesignResourceHandoffManifestBackedV1, DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+import type { DesignResourceHandoffManifestBackedV1 } from "./design-resource-handoff-input-types.js";
+import type { DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
 export declare function hydrateManifestBackedDesignResourceHandoff(descriptor: DesignResourceHandoffManifestBackedV1, manifests: Map<string, DesignResourceObservableFactManifestV1>): DesignResourceHandoffV1;

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

@@ -1,8 +1,8 @@
-import type { ParsedDesignResourceHandoffInputV1 } from "./design-resource-handoff-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,3 +1,6 @@
-import type { DesignResourceHandoffInputV1, DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+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.d.ts

@@ -1,4 +1,4 @@
-import type { ParsedDesignResourceHandoffInputV1 } from "./design-resource-handoff-types.js";
+import type { ParsedDesignResourceHandoffInputV1 } from "./design-resource-handoff-input-types.js";
 export interface DesignResourceSnapshot {
     contents: Map<string, Buffer>;
     hashes: Record<string, string>;

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-types.d.ts

@@ -57,10 +57,6 @@ export interface DesignResourceHandoffV1 {
         revision: string;
     };
 }
-export type DesignResourceHandoffManifestBackedV1 = Pick<DesignResourceHandoffV1, "schema_version" | "intent" | "scope" | "provenance" | "resources" | "targets" | "resource_fact_closure" | "coverage" | "proposal"> & {
-    representation: "manifest_backed";
-};
-export type DesignResourceHandoffInputV1 = DesignResourceHandoffV1 | DesignResourceHandoffManifestBackedV1;
 export interface DesignResourceHandoffResourceV1 {
     key: string;
     role: "exact_target" | "constraint" | "supporting";
@@ -220,12 +216,6 @@ export interface ParsedDesignResourceHandoffV1 {
     source_item_keys: string[];
     source_item_kinds: Record<string, string>;
 }
-export interface ParsedDesignResourceHandoffInputV1 {
-    handoff_path: string;
-    handoff: DesignResourceHandoffInputV1;
-    source_item_keys: string[];
-    source_item_kinds: Record<string, string>;
-}
 export interface DesignResourceHandoffPreflightV1 extends ParsedDesignResourceHandoffV1 {
     schema_version: "design-resource-handoff-preflight-v1";
     status: "ready";

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

@@ -1,4 +1,8 @@
-import type { DesignResourceHandoffPreflightV1, ParsedDesignResourceHandoffInputV1, ParsedDesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
-export declare function preflightDesignResourceHandoff(repository: string, handoffPath: string): Promise<DesignResourceHandoffPreflightV1>;
+import type { ParsedDesignResourceHandoffInputV1 } from "./design-resource-handoff-input-types.js";
+import type { DesignResourceHandoffPreflightV1, ParsedDesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+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-symbolic-applicability-authority.d.ts

@@ -0,0 +1,7 @@
+import type { SymbolicManifestIndexes } from "./design-resource-symbolic-indexes.js";
+export declare function validateSymbolicApplicabilityAuthorityRefs(row: {
+    census_refs: string[];
+    source_item_refs: string[];
+    basis_refs: string[];
+    rationale: string;
+}, indexes: SymbolicManifestIndexes, artifactRefs: ReadonlySet<string>, label: string): void;

package/dist/lib/design-resource-symbolic-applicability-authority.js

@@ -0,0 +1,19 @@
+import { isKnownSymbolicApplicabilityPolicyRef } from "./design-resource-symbolic-applicability-policy.js";
+import { invalid, requireKnownRefs, unique, } from "./design-resource-symbolic-validation-support.js";
+export function validateSymbolicApplicabilityAuthorityRefs(row, indexes, artifactRefs, label) {
+    if (!row.census_refs.length ||
+        !row.source_item_refs.length ||
+        !row.basis_refs.length ||
+        !row.rationale.trim())
+        invalid("v2_applicability_authority_incomplete", label);
+    unique(row.census_refs, `v2_applicability_census_duplicate:${label}`);
+    unique(row.source_item_refs, `v2_applicability_source_item_duplicate:${label}`);
+    unique(row.basis_refs, `v2_applicability_basis_duplicate:${label}`);
+    requireKnownRefs(row.census_refs, indexes.census, "v2_applicability_census_unknown");
+    requireKnownRefs(row.source_item_refs, indexes.sourceItems, "v2_applicability_source_item_unknown");
+    for (const basisRef of row.basis_refs)
+        if (!isKnownSymbolicApplicabilityPolicyRef(basisRef) &&
+            !indexes.census.has(basisRef) &&
+            !artifactRefs.has(basisRef))
+            invalid("v2_applicability_basis_authority_unknown", `${label}:${basisRef}`);
+}

package/dist/lib/design-resource-symbolic-applicability-policy.d.ts

@@ -0,0 +1,12 @@
+import type { DesignResourceInspectorCensusEntryV1 } from "./design-resource-fact-manifest-model.js";
+import type { DesignResourceHandoffSubjectV1 } from "./design-resource-handoff-types.js";
+export declare const DESIGN_RESOURCE_SYMBOLIC_APPLICABILITY_POLICY_VERSION: "package-subject-capability-algebra-v1";
+export interface DerivedSymbolicStandardApplicabilityV1 {
+    property_refs: string[];
+    policy_basis_refs: string[];
+}
+export declare function symbolicApplicabilitySubjectPolicyRef(kind: string): string;
+export declare function symbolicApplicabilityCensusPolicyRef(kind: string): string;
+export declare const SYMBOLIC_APPLICABILITY_POPULATION_POLICY_REF: "package-policy.subject-population.v1";
+export declare function deriveRequiredSymbolicStandardApplicability(subject: DesignResourceHandoffSubjectV1, census: ReadonlyMap<string, DesignResourceInspectorCensusEntryV1>): DerivedSymbolicStandardApplicabilityV1;
+export declare function isKnownSymbolicApplicabilityPolicyRef(value: string): boolean;