project-tiny-context-harness 0.11.0 → 0.12.1

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

@@ -1,152 +0,0 @@
-import { lstat, mkdtemp, readdir, realpath, rename, rm, } from "node:fs/promises";
-import path from "node:path";
-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 { 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 { 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);
-            const publishedTarget = preflight.handoff.targets[0];
-            if ((publishedTarget.source_profile.kind === "implementation_web" ||
-                publishedTarget.source_profile.kind === "implementation_app") &&
-                preflight.technical_feasibility_identities.length !== 1)
-                invalid("implementation_feasibility_input_required", `${publishedTarget.key}:${preflight.technical_feasibility_identities.length}`);
-            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-primitives.d.ts

@@ -1,4 +0,0 @@
-import type { ParsedDesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
-export type DesignResource = ParsedDesignResourceHandoffV1["handoff"]["resources"][number];
-export declare function htmlAttributes(source: string): Map<string, string>;
-export declare function isTextResource(resource: DesignResource): boolean;

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

@@ -1,16 +0,0 @@
-export function htmlAttributes(source) {
-    const attributes = new Map();
-    for (const match of source.matchAll(/([A-Za-z_:][A-Za-z0-9_.:-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/gu))
-        attributes.set(match[1].toLowerCase(), match[2] ?? match[3] ?? match[4] ?? "");
-    return attributes;
-}
-export function isTextResource(resource) {
-    return (resource.media_type.startsWith("text/") ||
-        [
-            "application/javascript",
-            "application/json",
-            "application/typescript",
-            "application/xhtml+xml",
-            "image/svg+xml",
-        ].includes(resource.media_type));
-}

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

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

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

@@ -1,47 +0,0 @@
-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";
-export function validateDesignResourceFiles(parsed, contents) {
-    const resources = new Map(parsed.handoff.resources.map((resource) => [resource.key, resource]));
-    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)
-        if (target.source_profile.kind === "implementation_web" ||
-            target.source_profile.kind === "implementation_app")
-            validateDesignResourceImplementationDependencyClosure(target, resources, contents);
-}
-function validateLocator(evidence, resource, bytes) {
-    const { kind, value } = evidence.locator;
-    const label = `${evidence.key}:${resource.key}:${kind}:${value}`;
-    validateEvidenceResourceCompatibility(evidence, resource);
-    if (kind === "whole_resource") {
-        if (value !== ".")
-            invalidDesignResourceHandoff("locator_whole_resource_value", label);
-        if (resource.media_type.startsWith("text/") &&
-            !["asset", "motion_capture", "frame"].includes(evidence.kind))
-            invalidDesignResourceHandoff("locator_whole_resource_too_broad", label);
-        return;
-    }
-    resolveDesignResourceLocatorValue({ resource_ref: resource.key, kind, value }, resource, bytes, `evidence.${evidence.key}`);
-}
-function validateEvidenceResourceCompatibility(evidence, resource) {
-    const machineReadableKinds = new Set([
-        "prototype_transition",
-        "motion_spec",
-        "responsive_spec",
-        "input_spec",
-        "accessibility_spec",
-        "semantic_tree",
-        "token_spec",
-        "annotation",
-        "localization_spec",
-        "system_ui_spec",
-        "haptic_spec",
-        "sound_spec",
-        "render_environment",
-        "relation_spec",
-    ]);
-    if (machineReadableKinds.has(evidence.kind) && !isTextResource(resource))
-        invalidDesignResourceHandoff("evidence_resource_media_type_incompatible", `${evidence.key}:${evidence.kind}:${resource.media_type}`);
-}

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

@@ -1,14 +0,0 @@
-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" | "project_design_authority" | "technical_feasibility_inputs" | "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

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

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

@@ -1,4 +0,0 @@
-import type { DesignResourceObservableFactManifestV1 } from "./design-resource-fact-manifest-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-manifest-projection.js

@@ -1,41 +0,0 @@
-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,
-        ...(descriptor.project_design_authority === undefined
-            ? {}
-            : { project_design_authority: descriptor.project_design_authority }),
-        technical_feasibility_inputs: descriptor.technical_feasibility_inputs,
-        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,8 +0,0 @@
-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): ParsedDesignResourceHandoffInput;

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

@@ -1,49 +0,0 @@
-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|v2)[ \t]*$/u;
-const FORMAL_BLOCK_END = /^```[ \t]*$/u;
-export function containsDesignResourceHandoff(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) {
-    const blocks = scanDesignResourceHandoffBlocks(content);
-    if (blocks.length !== 1)
-        throw new Error(`design_resource_handoff_invalid:block_count:${handoffPath}:${blocks.length}`);
-    try {
-        const parsedSource = parseSourceDocument(handoffPath, content);
-        const handoff = parsedSource.designResourceHandoff;
-        if (!handoff)
-            throw new Error("design-resource-handoff block was not decoded");
-        return {
-            handoff_path: handoffPath,
-            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) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (message.startsWith("design_resource_handoff_invalid:"))
-            throw error;
-        throw new Error(`design_resource_handoff_invalid:shape:${message}`);
-    }
-}

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

@@ -1,4 +0,0 @@
-import type { DesignResourceDimension, DesignResourceEvidenceKind, DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
-export declare const DESIGN_RESOURCE_EVIDENCE_BY_DIMENSION: Record<DesignResourceDimension, readonly DesignResourceEvidenceKind[]>;
-export declare const DESIGN_RESOURCE_METHODS_BY_DIMENSION: Record<DesignResourceDimension, readonly DesignResourceVerificationMethod[]>;
-export declare const DESIGN_RESOURCE_EVIDENCE_BY_METHOD: Record<DesignResourceVerificationMethod, readonly DesignResourceEvidenceKind[]>;

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

@@ -1,143 +0,0 @@
-export const DESIGN_RESOURCE_EVIDENCE_BY_DIMENSION = {
-    surface_flow: [
-        "frame",
-        "prototype_state",
-        "prototype_transition",
-        "relation_spec",
-        "annotation",
-    ],
-    visual_content: [
-        "frame",
-        "component_variant",
-        "token_spec",
-        "localization_spec",
-        "render_environment",
-        "annotation",
-    ],
-    component_control: [
-        "frame",
-        "component_variant",
-        "prototype_state",
-        "token_spec",
-        "relation_spec",
-        "annotation",
-    ],
-    state_interaction: [
-        "component_variant",
-        "prototype_state",
-        "prototype_transition",
-        "input_spec",
-        "haptic_spec",
-        "sound_spec",
-        "sound_capture",
-        "system_ui_spec",
-    ],
-    motion: [
-        "prototype_transition",
-        "motion_spec",
-        "motion_capture",
-        "haptic_spec",
-        "sound_spec",
-        "sound_capture",
-    ],
-    adaptation_input: [
-        "responsive_spec",
-        "input_spec",
-        "localization_spec",
-        "system_ui_spec",
-        "render_environment",
-    ],
-    accessibility: ["accessibility_spec", "semantic_tree", "input_spec", "frame"],
-    assets: ["asset", "token_spec", "annotation"],
-};
-export const DESIGN_RESOURCE_METHODS_BY_DIMENSION = {
-    surface_flow: [
-        "layout_geometry",
-        "design_token",
-        "interaction_trace",
-        "scroll_navigation",
-    ],
-    visual_content: [
-        "layout_geometry",
-        "visual_pixel",
-        "design_token",
-        "content",
-        "responsive_reflow",
-        "localization",
-    ],
-    component_control: [
-        "layout_geometry",
-        "visual_pixel",
-        "design_token",
-        "component_state",
-    ],
-    state_interaction: [
-        "component_state",
-        "interaction_trace",
-        "gesture_trace",
-        "scroll_navigation",
-        "input_method",
-        "system_ui",
-        "haptic_feedback",
-        "sound_feedback",
-    ],
-    motion: ["motion_timeline", "haptic_feedback", "sound_feedback"],
-    adaptation_input: [
-        "layout_geometry",
-        "responsive_reflow",
-        "input_method",
-        "scroll_navigation",
-        "localization",
-        "system_ui",
-    ],
-    accessibility: [
-        "accessibility_semantics",
-        "accessibility_navigation",
-        "accessibility_visual",
-    ],
-    assets: ["asset_integrity"],
-};
-export const DESIGN_RESOURCE_EVIDENCE_BY_METHOD = {
-    layout_geometry: [
-        "frame",
-        "component_variant",
-        "responsive_spec",
-        "relation_spec",
-        "annotation",
-    ],
-    visual_pixel: ["frame", "component_variant", "render_environment"],
-    design_token: ["token_spec", "component_variant", "annotation"],
-    content: ["frame", "component_variant", "localization_spec", "annotation"],
-    component_state: [
-        "component_variant",
-        "prototype_state",
-        "prototype_transition",
-    ],
-    interaction_trace: [
-        "prototype_transition",
-        "input_spec",
-        "system_ui_spec",
-        "haptic_spec",
-    ],
-    motion_timeline: ["prototype_transition", "motion_spec", "motion_capture"],
-    responsive_reflow: [
-        "responsive_spec",
-        "component_variant",
-        "render_environment",
-    ],
-    input_method: ["input_spec", "prototype_transition"],
-    accessibility_semantics: ["accessibility_spec", "semantic_tree"],
-    accessibility_navigation: [
-        "accessibility_spec",
-        "semantic_tree",
-        "input_spec",
-    ],
-    accessibility_visual: ["accessibility_spec", "frame"],
-    gesture_trace: ["input_spec", "prototype_transition", "motion_capture"],
-    scroll_navigation: ["prototype_transition", "responsive_spec", "input_spec"],
-    localization: ["localization_spec", "component_variant", "frame"],
-    system_ui: ["system_ui_spec", "prototype_transition"],
-    haptic_feedback: ["haptic_spec", "prototype_transition"],
-    sound_feedback: ["sound_spec", "sound_capture", "prototype_transition"],
-    asset_integrity: ["asset"],
-};

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

@@ -1,8 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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, "technical_feasibility_inputs", handoff.technical_feasibility_inputs);
-            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-evidence.d.ts

@@ -1,6 +0,0 @@
-import type { DesignResourceHandoffBlockerV1, DesignResourceHandoffCoverageV1, DesignResourceHandoffEvidenceV1, DesignResourceHandoffFactV1, DesignResourceHandoffResourceFactClosureV1 } from "./design-resource-handoff-types.js";
-export declare function parseDesignResourceHandoffEvidence(value: unknown): DesignResourceHandoffEvidenceV1[];
-export declare function parseDesignResourceHandoffCoverage(value: unknown): DesignResourceHandoffCoverageV1[];
-export declare function parseDesignResourceHandoffFacts(value: unknown): DesignResourceHandoffFactV1[];
-export declare function parseDesignResourceHandoffResourceFactClosure(value: unknown): DesignResourceHandoffResourceFactClosureV1[];
-export declare function parseDesignResourceHandoffBlockers(value: unknown): DesignResourceHandoffBlockerV1[];