project-tiny-context-harness 0.8.8 → 0.8.10

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

@@ -0,0 +1,171 @@
+import { lstat, mkdtemp, readFile, readdir, realpath, rename, rm, writeFile, } from "node:fs/promises";
+import path from "node:path";
+import { parseDesignResourceHandoffMarkdown } from "./design-resource-handoff-parser.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 { sha256Hex } from "./strict-codec.js";
+export async function publishDesignResourceHandoffBundle(options) {
+    const repository = path.resolve(options.repository);
+    const draftDirectory = normalizeBundleDirectory(options.draft_directory, "design_resource_bundle_draft_directory");
+    const outputDirectory = normalizeBundleDirectory(options.output_directory, "design_resource_bundle_output_directory");
+    if (!Number.isSafeInteger(options.max_handoff_bytes) ||
+        options.max_handoff_bytes <= 0)
+        invalid("max_handoff_bytes", String(options.max_handoff_bytes));
+    const manifestPaths = normalizeManifestPaths(options.manifest_paths);
+    const declaredManifestPaths = new Set(manifestPaths);
+    const draftAbsolute = await assertSafeDirectory(repository, draftDirectory, "draft_directory");
+    const outputAbsolute = resolveInsideRepository(repository, outputDirectory, "design_resource_bundle_output_directory");
+    if (await lstat(outputAbsolute).catch(() => null))
+        invalid("output_directory_exists", outputDirectory);
+    const outputParentRelative = path.posix.dirname(outputDirectory);
+    const outputParent = await assertSafeDirectory(repository, outputParentRelative === "." ? "." : outputParentRelative, "output_parent");
+    const temporary = await mkdtemp(path.join(outputParent, `.${path.basename(outputAbsolute)}.tmp-`));
+    try {
+        const draftEntries = (await readdir(draftAbsolute, {
+            withFileTypes: true,
+        })).sort((left, right) => compareText(left.name, right.name));
+        if (!draftEntries.length)
+            invalid("draft_directory_empty", draftDirectory);
+        for (const entry of draftEntries)
+            if (!entry.isFile() ||
+                entry.isSymbolicLink() ||
+                path.extname(entry.name).toLowerCase() !== ".md")
+                invalid("draft_entry_not_markdown_file", entry.name);
+        const handoffs = [];
+        const seenTargets = new Set();
+        const seenManifestPaths = new Set();
+        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);
+            if (!declaredManifestPaths.has(manifestResource.path))
+                invalid("target_manifest_not_declared", `${declaredTarget.key}:${manifestResource.path}`);
+            const preflight = await preflightParsedDesignResourceHandoff(repository, parsed);
+            handoffSetIntegrity.consume(preflight);
+            const targetKey = preflight.handoff.targets[0].key;
+            if (seenTargets.has(targetKey))
+                invalid("target_duplicate", targetKey);
+            seenTargets.add(targetKey);
+            const manifestIdentity = preflight.manifest_identities[0];
+            if (manifestIdentity.target_key !== targetKey ||
+                manifestIdentity.path !== manifestResource.path ||
+                manifestIdentity.sha256 !== manifestResource.sha256)
+                invalid("target_manifest_identity_mismatch", targetKey);
+            seenManifestPaths.add(manifestIdentity.path);
+            manifests.set(targetKey, {
+                path: manifestIdentity.path,
+                sha256: manifestIdentity.sha256,
+                scope_key: manifestIdentity.scope_key,
+                target_key: manifestIdentity.target_key,
+                collections: manifestIdentity.collections.map((collection) => ({
+                    ...collection,
+                })),
+            });
+            handoffs.push({
+                path: `${outputDirectory}/${entry.name}`,
+                sha256: sha256Hex(bytes),
+                bytes: bytes.length,
+                scope_key: preflight.handoff.scope.key,
+                target_key: targetKey,
+            });
+        }
+        handoffSetIntegrity.finish();
+        assertSameSet(seenManifestPaths, declaredManifestPaths, "manifest_path_set_mismatch");
+        const result = {
+            status: "published",
+            output_directory: outputDirectory,
+            handoffs,
+            manifests: [...manifests.values()]
+                .map((baseline) => ({
+                path: baseline.path,
+                sha256: baseline.sha256,
+                scope_key: baseline.scope_key,
+                target_key: baseline.target_key,
+                collections: baseline.collections.map((collection) => ({
+                    ...collection,
+                })),
+            }))
+                .sort((left, right) => compareText(left.target_key, right.target_key)),
+        };
+        await rename(temporary, outputAbsolute);
+        return result;
+    }
+    catch (error) {
+        try {
+            await rm(temporary, { recursive: true, force: true });
+        }
+        catch (cleanupError) {
+            throw new AggregateError([error, cleanupError], "design_resource_handoff_bundle_cleanup_failed");
+        }
+        throw error;
+    }
+}
+function normalizeManifestPaths(values) {
+    if (!values.length)
+        invalid("manifest_paths_required", "");
+    const normalized = values.map((value) => normalizeRepositoryFile(value, "design_resource_bundle_manifest"));
+    if (new Set(normalized).size !== normalized.length)
+        invalid("manifest_path_duplicate", normalized.join(","));
+    return normalized.sort(compareText);
+}
+async function assertSafeDirectory(repository, relative, label) {
+    const absolute = resolveInsideRepository(repository, relative, label);
+    const info = await lstat(absolute).catch(() => null);
+    if (!info)
+        invalid(`${label}_not_found`, relative);
+    if (info.isSymbolicLink() || !info.isDirectory())
+        invalid(`${label}_not_directory`, relative);
+    const root = await realpath(repository);
+    const resolved = await realpath(absolute);
+    const outside = path.relative(root, resolved);
+    if (outside === ".." ||
+        outside.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(outside))
+        invalid(`${label}_outside_repository`, relative);
+    return resolved;
+}
+function normalizeBundleDirectory(value, label) {
+    const normalized = normalizeRepositoryCwd(value, label);
+    if (normalized === ".")
+        invalid("repository_root_directory_forbidden", label);
+    return normalized;
+}
+function assertSameSet(actual, expected, code) {
+    const left = [...actual].sort(compareText);
+    const right = [...expected].sort(compareText);
+    if (left.length !== right.length ||
+        left.some((value, index) => value !== right[index]))
+        invalid(code, `${left.join(",")}:${right.join(",")}`);
+}
+function invalid(code, detail) {
+    throw new Error(`design_resource_handoff_bundle_invalid:${code}${detail ? `:${detail}` : ""}`);
+}
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

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

@@ -1,2 +1,2 @@
 import type { ParsedDesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
-export declare function validateDesignResourceFiles(repository: string, parsed: ParsedDesignResourceHandoffV1): Promise<void>;
+export declare function validateDesignResourceFiles(parsed: ParsedDesignResourceHandoffV1, contents: Map<string, Buffer>): void;

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

@@ -1,17 +1,9 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
 import { isTextResource, } from "./design-resource-handoff-file-primitives.js";
 import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
 import { resolveDesignResourceLocatorValue } from "./design-resource-fact-locator-validation.js";
 import { validateDesignResourceImplementationDependencyClosure } from "./design-resource-handoff-web-dependency-validation.js";
-import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
-export async function validateDesignResourceFiles(repository, parsed) {
+export function validateDesignResourceFiles(parsed, contents) {
     const resources = new Map(parsed.handoff.resources.map((resource) => [resource.key, resource]));
-    const contents = new Map();
-    for (const resource of parsed.handoff.resources) {
-        const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...resource.path.split("/")), `design_resource:${resource.key}`);
-        contents.set(resource.key, await readFile(file));
-    }
     for (const evidence of parsed.handoff.evidence)
         validateLocator(evidence, resources.get(evidence.resource_ref), contents.get(evidence.resource_ref));
     for (const target of parsed.handoff.targets)

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

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

package/dist/lib/design-resource-handoff-manifest-projection.js

@@ -0,0 +1,37 @@
+import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
+export function hydrateManifestBackedDesignResourceHandoff(descriptor, manifests) {
+    if (descriptor.targets.length !== 1)
+        invalidDesignResourceHandoff("manifest_backed_one_target_required", String(descriptor.targets.length));
+    const target = descriptor.targets[0];
+    const manifest = manifests.get(target.key);
+    if (!manifest)
+        invalidDesignResourceHandoff("fact_manifest_target_missing", target.key);
+    return {
+        schema_version: descriptor.schema_version,
+        intent: descriptor.intent,
+        scope: descriptor.scope,
+        provenance: descriptor.provenance,
+        resources: descriptor.resources,
+        axis_dispositions: manifest.axis_dispositions,
+        condition_exclusions: manifest.condition_exclusions,
+        conditions: manifest.conditions,
+        subjects: manifest.subjects,
+        variation_axis_dispositions: manifest.variation_axis_dispositions,
+        variation_exclusions: manifest.variation_exclusions,
+        variations: manifest.variations,
+        properties: manifest.properties,
+        lineage_nodes: manifest.lineage_nodes,
+        targets: descriptor.targets,
+        evidence: manifest.evidence,
+        fact_cells: manifest.fact_cells,
+        facts: manifest.facts,
+        proof_obligations: manifest.proof_obligations,
+        oracles: manifest.oracles,
+        environments: manifest.environments,
+        asset_bindings: manifest.asset_bindings,
+        resource_fact_closure: descriptor.resource_fact_closure,
+        coverage: descriptor.coverage,
+        acceptance_blockers: manifest.acceptance_blockers,
+        proposal: descriptor.proposal,
+    };
+}

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

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

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

@@ -1,23 +1,43 @@
-import { parseDesignResourceHandoffShape } from "./design-resource-handoff-shape.js";
-import { parseSourceItems } from "./long-task-source-item-parser.js";
-import { parseStrictYaml } from "./strict-codec.js";
-const FENCE = /^```yaml[ \t]+design-resource-handoff-v1[ \t]*\r?\n([\s\S]*?)^```[ \t]*$/gmu;
+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 FORMAL_BLOCK_END = /^```[ \t]*$/u;
 export function containsDesignResourceHandoff(content) {
-    FENCE.lastIndex = 0;
-    return FENCE.test(content);
+    return scanDesignResourceHandoffBlocks(content).length > 0;
+}
+export function scanDesignResourceHandoffBlocks(content) {
+    const blocks = [];
+    let bodyStartOffset = null;
+    forEachSourceLine(content, (line, startOffset, _endOffset, nextOffset) => {
+        if (bodyStartOffset === null) {
+            if (DESIGN_RESOURCE_START.test(line))
+                bodyStartOffset = nextOffset;
+            return;
+        }
+        if (!FORMAL_BLOCK_END.test(line))
+            return;
+        blocks.push({
+            bodyStartOffset,
+            bodyEndOffset: startOffset,
+        });
+        bodyStartOffset = null;
+    });
+    return blocks;
 }
 export function parseDesignResourceHandoffMarkdown(handoffPath, content) {
-    FENCE.lastIndex = 0;
-    const blocks = [...content.matchAll(FENCE)];
+    const blocks = scanDesignResourceHandoffBlocks(content);
     if (blocks.length !== 1)
         throw new Error(`design_resource_handoff_invalid:block_count:${handoffPath}:${blocks.length}`);
     try {
-        const sourceItems = parseSourceItems(handoffPath, content);
+        const parsedSource = parseSourceDocument(handoffPath, content);
+        const handoff = parsedSource.designResourceHandoff;
+        if (!handoff)
+            throw new Error("design-resource-handoff-v1 block was not decoded");
         return {
             handoff_path: handoffPath,
-            handoff: parseDesignResourceHandoffShape(parseStrictYaml(blocks[0][1])),
-            source_item_keys: sourceItems.map((item) => item.key),
-            source_item_kinds: Object.fromEntries(sourceItems.map((item) => [item.key, item.kind])),
+            handoff,
+            source_item_keys: parsedSource.items.map((item) => item.key),
+            source_item_kinds: Object.fromEntries(parsedSource.items.map((item) => [item.key, item.kind])),
         };
     }
     catch (error) {

package/dist/lib/design-resource-handoff-set-integrity.d.ts

@@ -0,0 +1,8 @@
+import type { DesignResourceHandoffPreflightV1 } from "./design-resource-handoff-types.js";
+type HandoffSetFailure = (code: string, detail: string) => never;
+export interface DesignResourceHandoffSetIntegrity {
+    consume(preflight: DesignResourceHandoffPreflightV1): void;
+    finish(): void;
+}
+export declare function createDesignResourceHandoffSetIntegrity(fail: HandoffSetFailure): DesignResourceHandoffSetIntegrity;
+export {};

package/dist/lib/design-resource-handoff-set-integrity.js

@@ -0,0 +1,93 @@
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+export function createDesignResourceHandoffSetIntegrity(fail) {
+    const scopes = new Map();
+    const sourceItems = new Set();
+    let issue = null;
+    function record(code, detail) {
+        issue ??= { code, detail };
+    }
+    function sharedHeader(scope, name, value) {
+        const digest = canonicalDigest(value);
+        const previous = scope.headers.get(name);
+        if (previous && previous !== digest)
+            record("handoff_set_header_conflict", name);
+        else
+            scope.headers.set(name, digest);
+    }
+    function sharedCollection(scope, name, rows) {
+        const index = scope.sharedRows.get(name) ?? new Map();
+        scope.sharedRows.set(name, index);
+        for (const row of rows) {
+            const digest = canonicalDigest(row);
+            const previous = index.get(row.key);
+            if (previous && previous !== digest)
+                record("handoff_set_shared_row_conflict", `${name}:${row.key}`);
+            else
+                index.set(row.key, digest);
+        }
+    }
+    return {
+        consume(preflight) {
+            if (issue)
+                return;
+            const handoff = preflight.handoff;
+            const scope = scopeIndex(scopes, handoff.scope.key);
+            sharedHeader(scope, "provenance", handoff.provenance);
+            sharedHeader(scope, "proposal", handoff.proposal);
+            sharedCollection(scope, "resources", handoff.resources);
+            sharedCollection(scope, "conditions", handoff.conditions);
+            sharedCollection(scope, "properties", handoff.properties);
+            sharedCollection(scope, "resource_fact_closure", handoff.resource_fact_closure);
+            for (const closure of handoff.resource_fact_closure) {
+                const digest = canonicalDigest(closure);
+                const previous = scope.resourceClosures.get(closure.resource_ref);
+                if (previous &&
+                    (previous.key !== closure.key || previous.digest !== digest))
+                    record("handoff_set_resource_closure_conflict", `${closure.resource_ref}:${previous.key}:${closure.key}`);
+                else
+                    scope.resourceClosures.set(closure.resource_ref, {
+                        key: closure.key,
+                        digest,
+                    });
+            }
+            for (const resource of handoff.resources) {
+                const digest = canonicalDigest(resource);
+                const previous = scope.resourcePaths.get(resource.path);
+                if (previous &&
+                    (previous.key !== resource.key || previous.digest !== digest))
+                    record("handoff_set_resource_path_conflict", `${resource.path}:${previous.key}:${resource.key}`);
+                else
+                    scope.resourcePaths.set(resource.path, {
+                        key: resource.key,
+                        digest,
+                    });
+            }
+            for (const sourceItem of preflight.source_item_keys) {
+                if (sourceItems.has(sourceItem))
+                    record("handoff_set_source_item_duplicate", sourceItem);
+                else
+                    sourceItems.add(sourceItem);
+            }
+        },
+        finish() {
+            if (issue)
+                fail(issue.code, issue.detail);
+        },
+    };
+}
+function scopeIndex(scopes, key) {
+    const existing = scopes.get(key);
+    if (existing)
+        return existing;
+    const created = {
+        headers: new Map(),
+        sharedRows: new Map(),
+        resourcePaths: new Map(),
+        resourceClosures: new Map(),
+    };
+    scopes.set(key, created);
+    return created;
+}
+function canonicalDigest(value) {
+    return sha256Hex(canonicalValueJson(value));
+}

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

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

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

@@ -3,6 +3,14 @@ import { parseDesignResourceHandoffBlockers, parseDesignResourceHandoffCoverage,
 import { contractKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
 import { parseDesignResourceHandoffConditions, parseDesignResourceHandoffResources, parseDesignResourceHandoffSubjects, parseDesignResourceHandoffTargets, } from "./design-resource-handoff-shape-structure.js";
 import { literal, object, repositoryFile, string, strings, } from "./long-task-shape-primitives.js";
+export function parseDesignResourceHandoffInputShape(value) {
+    if (value &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        value.representation === "manifest_backed")
+        return parseManifestBackedDesignResourceHandoffShape(value);
+    return parseDesignResourceHandoffShape(value);
+}
 export function parseDesignResourceHandoffShape(value) {
     const root = object(value, "design_resource_handoff", [
         "schema_version",
@@ -102,3 +110,57 @@ export function parseDesignResourceHandoffShape(value) {
         },
     };
 }
+function parseManifestBackedDesignResourceHandoffShape(value) {
+    const root = object(value, "design_resource_handoff", [
+        "schema_version",
+        "representation",
+        "intent",
+        "scope",
+        "provenance",
+        "resources",
+        "targets",
+        "resource_fact_closure",
+        "coverage",
+        "proposal",
+    ]);
+    const parsed = parseDesignResourceHandoffShape({
+        schema_version: root.schema_version,
+        intent: root.intent,
+        scope: root.scope,
+        provenance: root.provenance,
+        resources: root.resources,
+        axis_dispositions: [],
+        condition_exclusions: [],
+        conditions: [],
+        subjects: [],
+        variation_axis_dispositions: [],
+        variation_exclusions: [],
+        variations: [],
+        properties: [],
+        lineage_nodes: [],
+        targets: root.targets,
+        evidence: [],
+        fact_cells: [],
+        facts: [],
+        proof_obligations: [],
+        oracles: [],
+        environments: [],
+        asset_bindings: [],
+        resource_fact_closure: root.resource_fact_closure,
+        coverage: root.coverage,
+        acceptance_blockers: [],
+        proposal: root.proposal,
+    });
+    return {
+        schema_version: parsed.schema_version,
+        representation: literal(root.representation, ["manifest_backed"], "design_resource_handoff.representation"),
+        intent: parsed.intent,
+        scope: parsed.scope,
+        provenance: parsed.provenance,
+        resources: parsed.resources,
+        targets: parsed.targets,
+        resource_fact_closure: parsed.resource_fact_closure,
+        coverage: parsed.coverage,
+        proposal: parsed.proposal,
+    };
+}

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

@@ -0,0 +1,6 @@
+import type { ParsedDesignResourceHandoffInputV1 } from "./design-resource-handoff-types.js";
+export interface DesignResourceSnapshot {
+    contents: Map<string, Buffer>;
+    hashes: Record<string, string>;
+}
+export declare function readDesignResourceSnapshot(repository: string, parsed: ParsedDesignResourceHandoffInputV1): Promise<DesignResourceSnapshot>;

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

@@ -0,0 +1,21 @@
+import { readFile } from "node:fs/promises";
+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";
+export async function readDesignResourceSnapshot(repository, parsed) {
+    const contents = new Map();
+    const hashes = {};
+    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}`);
+        const bytes = await readFile(file);
+        const digest = sha256Hex(bytes);
+        if (digest !== resource.sha256)
+            invalidDesignResourceHandoff("resource_digest_mismatch", `${resource.key}:${resource.sha256}:${digest}`);
+        contents.set(resource.key, bytes);
+        hashes[resource.key] = digest;
+    }
+    return { contents, hashes };
+}

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

@@ -1,5 +1,5 @@
 import type { ExecutionTargetCapabilityV2 } from "./execution-target-capabilities.js";
-import type { DesignResourceAssetBindingV1, DesignResourceAxisDispositionV1, DesignResourceConditionCombinationDispositionV1, DesignResourceEnvironmentV1, DesignResourceFactCellV1, DesignResourceFactV1, DesignResourceLineageNodeV1, DesignResourceOracleV1, DesignResourcePropertyDefinitionV1, DesignResourceProofObligationV1, DesignResourceRelationEndpointV1, DesignResourceSubjectKind, DesignResourceSubjectPresenceKind, DesignResourceSubjectVariationV1, DesignResourceVariationAxisDispositionV1, DesignResourceVariationCombinationDispositionV1 } from "./design-resource-fact-manifest-types.js";
+import type { DesignResourceAssetBindingV1, DesignResourceAxisDispositionV1, DesignResourceConditionCombinationDispositionV1, DesignResourceEnvironmentV1, DesignResourceFactCellV1, DesignResourceFactV1, DesignResourceLineageNodeV1, DesignResourceManifestCollectionName, DesignResourceOracleV1, DesignResourcePropertyDefinitionV1, DesignResourceProofObligationV1, DesignResourceRelationEndpointV1, DesignResourceSubjectKind, DesignResourceSubjectPresenceKind, DesignResourceSubjectVariationV1, DesignResourceVariationAxisDispositionV1, DesignResourceVariationCombinationDispositionV1 } from "./design-resource-fact-manifest-types.js";
 export declare const DESIGN_RESOURCE_DIMENSIONS: readonly ["surface_flow", "visual_content", "component_control", "state_interaction", "motion", "adaptation_input", "accessibility", "assets"];
 export type DesignResourceDimension = (typeof DESIGN_RESOURCE_DIMENSIONS)[number];
 export declare const DESIGN_RESOURCE_EVIDENCE_KINDS: readonly ["frame", "component_variant", "prototype_state", "prototype_transition", "motion_spec", "motion_capture", "responsive_spec", "input_spec", "accessibility_spec", "semantic_tree", "token_spec", "asset", "annotation", "localization_spec", "system_ui_spec", "haptic_spec", "sound_spec", "sound_capture", "render_environment", "relation_spec"];
@@ -57,6 +57,10 @@ 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";
@@ -216,10 +220,28 @@ 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";
     resource_hashes: Record<string, string>;
+    manifest_identities: Array<{
+        resource_ref: string;
+        path: string;
+        sha256: string;
+        scope_key: string;
+        target_key: string;
+        collections: Array<{
+            name: DesignResourceManifestCollectionName;
+            expected_count: number;
+            identity_sha256: string;
+        }>;
+    }>;
     counts: {
         resources: number;
         manifests: number;

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

@@ -1,3 +1,4 @@
-import type { DesignResourceHandoffPreflightV1, ParsedDesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
+import type { DesignResourceHandoffPreflightV1, ParsedDesignResourceHandoffInputV1, ParsedDesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
 export declare function preflightDesignResourceHandoff(repository: string, handoffPath: string): Promise<DesignResourceHandoffPreflightV1>;
+export declare function preflightParsedDesignResourceHandoff(repository: string, parsed: ParsedDesignResourceHandoffInputV1): Promise<DesignResourceHandoffPreflightV1>;
 export declare function validateDesignResourceHandoffSemantics(parsed: ParsedDesignResourceHandoffV1): void;