project-tiny-context-harness 0.8.13 → 0.8.17

package/dist/lib/long-task-check-runner.js

@@ -1,17 +1,13 @@
-import { execFile, spawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { access, realpath } from "node:fs/promises";
 import net from "node:net";
 import path from "node:path";
-import { promisify } from "node:util";
 import { decodeCheckEvidence, invalidEvidence, } from "./long-task-check-evidence-decoder.js";
+import { spawnCommandOnce } from "./long-task-command-process.js";
 import { declaredEnvironmentValues, outputContainsDeclaredEnvironmentValue, runnerEnvironment, } from "./long-task-runner-environment.js";
 import { decodeProductObservationEnvelope } from "./long-task-process-observation.js";
 import { resolveInsideRepository } from "./long-task-workspace.js";
 import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-const OUTPUT_LIMIT = 2 * 1024 * 1024;
-const PROCESS_TREE_GRACE_MS = 1_000;
-const execFileAsync = promisify(execFile);
 export async function executeCheckRunner(check, snapshotRoot, context) {
     const started = Date.now();
     let processAuthorities;
@@ -112,7 +108,7 @@ async function runOnce(check, snapshotRoot, processAuthorities, snapshotSha256,
         : runner.executable;
     const argv = [...runner.executable_argv_prefix, ...runner.argv];
     if (!processAuthorities.length) {
-        const execution = await spawnOnce(executable, argv, cwd, runner.timeout_ms, runnerEnvironment(check.environment_requirements), false);
+        const execution = await spawnCommandOnce(executable, argv, cwd, runner.timeout_ms, runnerEnvironment(check.environment_requirements), false);
         return {
             ...execution,
             process_observation: null,
@@ -120,7 +116,7 @@ async function runOnce(check, snapshotRoot, processAuthorities, snapshotSha256,
         };
     }
     const executionNonce = randomBytes(32).toString("hex");
-    const execution = await spawnOnce(executable, argv, cwd, runner.timeout_ms, runnerEnvironment(check.environment_requirements, "product_observation"), true);
+    const execution = await spawnCommandOnce(executable, argv, cwd, runner.timeout_ms, runnerEnvironment(check.environment_requirements, "product_observation"), true);
     const processObservation = decodeProductObservationEnvelope({
         bytes: execution.stdout,
         authorities: processAuthorities,
@@ -160,295 +156,6 @@ async function runOnce(check, snapshotRoot, processAuthorities, snapshotSha256,
         },
     };
 }
-async function spawnOnce(executable, argv, cwd, timeoutMs, environment, containProcessTree) {
-    return new Promise((resolve, reject) => {
-        const startedAt = new Date().toISOString();
-        const child = spawn(executable, argv, {
-            cwd,
-            shell: false,
-            windowsHide: true,
-            env: environment,
-            detached: containProcessTree && process.platform !== "win32",
-        });
-        const pid = child.pid ?? -1;
-        let stopTreeMonitor = false;
-        let treeMonitorError = null;
-        const observedDescendants = new Set();
-        const treeMonitor = containProcessTree && pid > 0
-            ? observeDescendantProcesses(pid, observedDescendants, () => stopTreeMonitor).catch((error) => {
-                treeMonitorError = error;
-            })
-            : Promise.resolve();
-        const stdout = [];
-        const stderr = [];
-        let size = 0;
-        let settled = false;
-        let terminationReason = null;
-        let terminationTask = null;
-        let forceTimer = null;
-        let abandonTimer = null;
-        const capture = (target) => (chunk) => {
-            size += chunk.length;
-            if (size > OUTPUT_LIMIT) {
-                terminate("command_output_limit_exceeded");
-                return;
-            }
-            target.push(Buffer.from(chunk));
-        };
-        child.stdout.on("data", capture(stdout));
-        child.stderr.on("data", capture(stderr));
-        child.on("error", (error) => {
-            if (!settled) {
-                settled = true;
-                stopTreeMonitor = true;
-                clearTimeout(timer);
-                if (forceTimer)
-                    clearTimeout(forceTimer);
-                if (abandonTimer)
-                    clearTimeout(abandonTimer);
-                const spawnError = new Error(`command_spawn_error:${message(error)}`);
-                if (containProcessTree && pid > 0)
-                    void terminateProcessTree(pid, true, [...observedDescendants])
-                        .catch(() => undefined)
-                        .finally(() => reject(spawnError));
-                else
-                    reject(spawnError);
-            }
-        });
-        const timer = setTimeout(() => {
-            terminate("command_timeout");
-        }, timeoutMs);
-        if (pid < 0)
-            terminate("command_spawn_pid_unavailable");
-        child.on("close", async (code) => {
-            stopTreeMonitor = true;
-            clearTimeout(timer);
-            if (forceTimer)
-                clearTimeout(forceTimer);
-            if (abandonTimer)
-                clearTimeout(abandonTimer);
-            if (settled)
-                return;
-            settled = true;
-            if (terminationReason) {
-                try {
-                    await terminationTask;
-                    await treeMonitor;
-                    if (containProcessTree)
-                        await forceProcessTreeQuiescence(pid, observedDescendants);
-                }
-                catch {
-                    // The original bounded termination reason remains the public error;
-                    // cleanup is best-effort after the hard process-tree kill attempt.
-                }
-                reject(terminationReason);
-                return;
-            }
-            if (containProcessTree) {
-                try {
-                    await treeMonitor;
-                    if (treeMonitorError)
-                        throw treeMonitorError;
-                    await assertProcessTreeQuiescent(pid, observedDescendants);
-                }
-                catch (error) {
-                    await terminateProcessTree(pid, true, [...observedDescendants]).catch(() => undefined);
-                    reject(error);
-                    return;
-                }
-            }
-            resolve({
-                exit_code: code ?? -1,
-                stdout: Buffer.concat(stdout),
-                stderr: Buffer.concat(stderr),
-                pid,
-                started_at: startedAt,
-                completed_at: new Date().toISOString(),
-            });
-        });
-        function terminate(reason) {
-            if (settled || terminationReason)
-                return;
-            terminationReason = new Error(reason);
-            stopTreeMonitor = true;
-            if (containProcessTree)
-                terminationTask = terminateProcessTree(pid, false).catch((error) => {
-                    treeMonitorError ??= error;
-                });
-            else {
-                child.kill();
-                terminationTask = Promise.resolve();
-            }
-            forceTimer = setTimeout(() => {
-                if (containProcessTree)
-                    terminationTask = terminateProcessTree(pid, true, [
-                        ...observedDescendants,
-                    ]).catch((error) => {
-                        treeMonitorError ??= error;
-                    });
-                else
-                    child.kill("SIGKILL");
-            }, PROCESS_TREE_GRACE_MS);
-            forceTimer.unref();
-            abandonTimer = setTimeout(() => {
-                if (settled)
-                    return;
-                settled = true;
-                child.stdout.destroy();
-                child.stderr.destroy();
-                const cleanup = containProcessTree
-                    ? forceProcessTreeQuiescence(pid, observedDescendants).catch(() => undefined)
-                    : Promise.resolve();
-                void cleanup.finally(() => reject(terminationReason));
-            }, PROCESS_TREE_GRACE_MS * 2);
-            abandonTimer.unref();
-        }
-    });
-}
-async function forceProcessTreeQuiescence(rootPid, observed) {
-    await terminateProcessTree(rootPid, true, [...observed]);
-    const deadline = Date.now() + PROCESS_TREE_GRACE_MS;
-    while (Date.now() < deadline) {
-        const liveObserved = [rootPid, ...observed].some(processIdExists);
-        const groupAlive = process.platform !== "win32" && processGroupExists(rootPid);
-        if (!liveObserved && !groupAlive)
-            return;
-        await new Promise((resolve) => setTimeout(resolve, process.platform === "win32" ? 100 : 25));
-    }
-    throw new Error("process_observer_descendant_process_alive");
-}
-async function observeDescendantProcesses(rootPid, observed, stopped) {
-    do {
-        for (const pid of await descendantProcessIds(rootPid))
-            observed.add(pid);
-        if (stopped())
-            return;
-        await new Promise((resolve) => setTimeout(resolve, process.platform === "win32" ? 100 : 25));
-    } while (!stopped());
-}
-async function assertProcessTreeQuiescent(rootPid, observed) {
-    const finalDescendants = await descendantProcessIds(rootPid);
-    const descendants = [...new Set([...observed, ...finalDescendants])].filter(processIdExists);
-    const processGroupAlive = process.platform !== "win32" && processGroupExists(rootPid);
-    if (!descendants.length && !processGroupAlive)
-        return;
-    await terminateProcessTree(rootPid, true, descendants);
-    throw new Error("process_observer_descendant_process_alive");
-}
-function processIdExists(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        if (nodeErrorCode(error) === "ESRCH")
-            return false;
-        throw error;
-    }
-}
-async function terminateProcessTree(rootPid, force, knownDescendants) {
-    if (!Number.isSafeInteger(rootPid) || rootPid <= 0)
-        return;
-    if (process.platform === "win32") {
-        const targets = [
-            rootPid,
-            ...[...new Set(knownDescendants ?? [])]
-                .filter((pid) => pid !== rootPid)
-                .reverse(),
-        ];
-        for (const pid of targets)
-            await execFileAsync("taskkill.exe", ["/PID", String(pid), "/T", "/F"], {
-                windowsHide: true,
-                timeout: PROCESS_TREE_GRACE_MS,
-            }).catch(() => undefined);
-        return;
-    }
-    const signal = force ? "SIGKILL" : "SIGTERM";
-    try {
-        process.kill(-rootPid, signal);
-    }
-    catch (error) {
-        if (nodeErrorCode(error) !== "ESRCH")
-            throw error;
-    }
-    const descendants = knownDescendants ?? (await descendantProcessIds(rootPid));
-    for (const pid of [...descendants].reverse())
-        try {
-            process.kill(pid, signal);
-        }
-        catch (error) {
-            if (nodeErrorCode(error) !== "ESRCH")
-                throw error;
-        }
-}
-async function descendantProcessIds(rootPid) {
-    let stdout;
-    try {
-        const result = process.platform === "win32"
-            ? await execFileAsync("powershell.exe", [
-                "-NoLogo",
-                "-NoProfile",
-                "-NonInteractive",
-                "-Command",
-                'Get-CimInstance Win32_Process | ForEach-Object { "$($_.ProcessId) $($_.ParentProcessId)" }',
-            ], {
-                encoding: "utf8",
-                windowsHide: true,
-                timeout: 5_000,
-                maxBuffer: OUTPUT_LIMIT,
-            })
-            : await execFileAsync("ps", ["-A", "-o", "pid=,ppid="], {
-                encoding: "utf8",
-                timeout: 5_000,
-                maxBuffer: OUTPUT_LIMIT,
-            });
-        stdout = result.stdout;
-    }
-    catch (error) {
-        throw new Error(`process_observer_process_tree_inspection_unavailable:${message(error)}`);
-    }
-    const children = new Map();
-    for (const line of stdout.split(/\r?\n/u)) {
-        const [pidText, parentText] = line.trim().split(/\s+/u);
-        const pid = Number.parseInt(pidText ?? "", 10);
-        const parent = Number.parseInt(parentText ?? "", 10);
-        if (!Number.isSafeInteger(pid) || !Number.isSafeInteger(parent))
-            continue;
-        const row = children.get(parent);
-        if (row)
-            row.push(pid);
-        else
-            children.set(parent, [pid]);
-    }
-    const result = [];
-    const pending = [...(children.get(rootPid) ?? [])];
-    const seen = new Set();
-    while (pending.length) {
-        const pid = pending.shift();
-        if (seen.has(pid))
-            continue;
-        seen.add(pid);
-        result.push(pid);
-        pending.push(...(children.get(pid) ?? []));
-    }
-    return result;
-}
-function processGroupExists(rootPid) {
-    try {
-        process.kill(-rootPid, 0);
-        return true;
-    }
-    catch (error) {
-        if (nodeErrorCode(error) === "ESRCH")
-            return false;
-        throw error;
-    }
-}
-function nodeErrorCode(error) {
-    return error && typeof error === "object" && "code" in error
-        ? String(error.code)
-        : null;
-}
 function validateProcessObserverActivation(check, snapshotRoot, authorities, context) {
     if (!authorities.length)
         return null;

package/dist/lib/long-task-command-process.d.ts

@@ -0,0 +1,9 @@
+export interface SpawnedCommandExecution {
+    exit_code: number;
+    stdout: Buffer;
+    stderr: Buffer;
+    pid: number;
+    started_at: string;
+    completed_at: string;
+}
+export declare function spawnCommandOnce(executable: string, argv: string[], cwd: string, timeoutMs: number, environment: NodeJS.ProcessEnv, containProcessTree: boolean): Promise<SpawnedCommandExecution>;

package/dist/lib/long-task-command-process.js

@@ -0,0 +1,175 @@
+import { spawn } from "node:child_process";
+import { createProcessTreeObserver, } from "./long-task-process-tree.js";
+const OUTPUT_LIMIT = 2 * 1024 * 1024;
+const PROCESS_TREE_GRACE_MS = 1_000;
+export function spawnCommandOnce(executable, argv, cwd, timeoutMs, environment, containProcessTree) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(executable, argv, {
+            cwd,
+            shell: false,
+            windowsHide: true,
+            env: environment,
+            detached: containProcessTree && process.platform !== "win32",
+        });
+        const pid = child.pid ?? -1;
+        const processTree = containProcessTree && pid > 0 ? createProcessTreeObserver(pid) : null;
+        const state = {
+            child,
+            pid,
+            processTree,
+            treeMonitor: Promise.resolve(),
+            treeMonitorError: null,
+            stdout: [],
+            stderr: [],
+            size: 0,
+            settled: false,
+            terminationReason: null,
+            terminationTask: null,
+            timer: null,
+            forceTimer: null,
+            abandonTimer: null,
+            startedAt: new Date().toISOString(),
+            resolve,
+            reject,
+        };
+        if (processTree)
+            state.treeMonitor = processTree.wait().catch((error) => {
+                state.treeMonitorError = error;
+            });
+        child.stdout.on("data", captureOutput(state, state.stdout));
+        child.stderr.on("data", captureOutput(state, state.stderr));
+        child.on("error", (error) => handleSpawnError(state, error));
+        child.on("close", (code) => void handleClose(state, code));
+        state.timer = setTimeout(() => terminateExecution(state, "command_timeout"), timeoutMs);
+        if (pid < 0)
+            terminateExecution(state, "command_spawn_pid_unavailable");
+    });
+}
+function captureOutput(state, target) {
+    return (chunk) => {
+        state.size += chunk.length;
+        if (state.size > OUTPUT_LIMIT) {
+            terminateExecution(state, "command_output_limit_exceeded");
+            return;
+        }
+        target.push(Buffer.from(chunk));
+    };
+}
+function handleSpawnError(state, error) {
+    if (state.settled)
+        return;
+    state.settled = true;
+    state.processTree?.stop();
+    clearExecutionTimers(state);
+    const spawnError = new Error(`command_spawn_error:${message(error)}`);
+    if (!state.processTree) {
+        state.reject(spawnError);
+        return;
+    }
+    void state.processTree
+        .terminate(true)
+        .catch(() => undefined)
+        .finally(() => state.reject(spawnError));
+}
+async function handleClose(state, code) {
+    state.processTree?.stop();
+    clearExecutionTimers(state);
+    if (state.settled)
+        return;
+    state.settled = true;
+    if (state.terminationReason) {
+        await finishBoundedTermination(state);
+        state.reject(state.terminationReason);
+        return;
+    }
+    if (!(await assertTreeClosure(state)))
+        return;
+    state.resolve({
+        exit_code: code ?? -1,
+        stdout: Buffer.concat(state.stdout),
+        stderr: Buffer.concat(state.stderr),
+        pid: state.pid,
+        started_at: state.startedAt,
+        completed_at: new Date().toISOString(),
+    });
+}
+async function finishBoundedTermination(state) {
+    try {
+        await state.terminationTask;
+        await state.treeMonitor;
+        if (state.processTree)
+            await state.processTree.forceQuiescence();
+    }
+    catch {
+        // Preserve the original bounded termination reason after the hard cleanup.
+    }
+}
+async function assertTreeClosure(state) {
+    if (!state.processTree)
+        return true;
+    try {
+        await state.treeMonitor;
+        if (state.treeMonitorError)
+            throw state.treeMonitorError;
+        await state.processTree.assertQuiescent();
+        return true;
+    }
+    catch (error) {
+        await state.processTree.terminate(true).catch(() => undefined);
+        state.reject(error);
+        return false;
+    }
+}
+function terminateExecution(state, reason) {
+    if (state.settled || state.terminationReason)
+        return;
+    state.terminationReason = new Error(reason);
+    state.processTree?.stop();
+    startGracefulTermination(state);
+    state.forceTimer = setTimeout(() => startForcedTermination(state), PROCESS_TREE_GRACE_MS);
+    state.forceTimer.unref();
+    state.abandonTimer = setTimeout(() => abandonExecution(state), PROCESS_TREE_GRACE_MS * 2);
+    state.abandonTimer.unref();
+}
+function startGracefulTermination(state) {
+    if (state.processTree)
+        state.terminationTask = state.processTree
+            .terminate(false)
+            .catch((error) => {
+            state.treeMonitorError ??= error;
+        });
+    else {
+        state.child.kill();
+        state.terminationTask = Promise.resolve();
+    }
+}
+function startForcedTermination(state) {
+    if (state.processTree)
+        state.terminationTask = state.processTree.terminate(true).catch((error) => {
+            state.treeMonitorError ??= error;
+        });
+    else
+        state.child.kill("SIGKILL");
+}
+function abandonExecution(state) {
+    if (state.settled)
+        return;
+    state.settled = true;
+    state.child.stdout.destroy();
+    state.child.stderr.destroy();
+    const cleanup = state.processTree
+        ? state.processTree.forceQuiescence().catch(() => undefined)
+        : Promise.resolve();
+    void cleanup.finally(() => state.reject(state.terminationReason));
+}
+function clearExecutionTimers(state) {
+    if (state.timer)
+        clearTimeout(state.timer);
+    if (state.forceTimer)
+        clearTimeout(state.forceTimer);
+    if (state.abandonTimer)
+        clearTimeout(state.abandonTimer);
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/lib/long-task-delivery-validation.d.ts

@@ -1,3 +1,6 @@
 import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
-export declare function validateDeliveryContractStructure(contract: DeliveryContractV2): void;
-export declare function deliveryContractStructureDiagnostics(contract: DeliveryContractV2): string[];
+export interface DeliveryContractStructureValidationOptions {
+    allowDeferredDesignComponentBindingClosure?: boolean;
+}
+export declare function validateDeliveryContractStructure(contract: DeliveryContractV2, options?: DeliveryContractStructureValidationOptions): void;
+export declare function deliveryContractStructureDiagnostics(contract: DeliveryContractV2, options?: DeliveryContractStructureValidationOptions): string[];

package/dist/lib/long-task-delivery-validation.js

@@ -10,7 +10,7 @@ import { validateExecutionTargets, validateExternalConfirmationImpacts, } from "
 import { validateUiSurfaceBindings } from "./long-task-ui-surface-policy.js";
 import { controlFieldFacts } from "./long-task-control-fields.js";
 import { validateSemanticAssuranceShape } from "./long-task-semantic-assurance-policy.js";
-export function validateDeliveryContractStructure(contract) {
+export function validateDeliveryContractStructure(contract, options = {}) {
     validateUniqueKeys(contract);
     validateDependencies(contract);
     validateControlClosure(contract);
@@ -21,7 +21,7 @@ export function validateDeliveryContractStructure(contract) {
         allow_uncovered: true,
     });
     validateSourceClaimMappings(contract, claims);
-    validateUiSurfaceBindings(contract, claims);
+    validateUiSurfaceBindings(contract, claims, undefined, options);
     assertCompiledClaimsCovered(claims);
     validateDeliveryStages(contract);
     validateExecutionTargets(contract);
@@ -29,7 +29,7 @@ export function validateDeliveryContractStructure(contract) {
     validateEvidenceCapabilityDeclarations(contract);
     validateExternalConfirmationImpacts(contract, claims);
 }
-export function deliveryContractStructureDiagnostics(contract) {
+export function deliveryContractStructureDiagnostics(contract, options = {}) {
     const diagnostics = [];
     const report = (message) => diagnostics.push(message);
     validateUniqueKeys(contract, report);
@@ -48,7 +48,7 @@ export function deliveryContractStructureDiagnostics(contract) {
     });
     if (claims) {
         validateSourceClaimMappings(contract, claims, report);
-        validateUiSurfaceBindings(contract, claims, report);
+        validateUiSurfaceBindings(contract, claims, report, options);
         validateExternalConfirmationImpacts(contract, claims, report);
         capture(diagnostics, () => assertCompiledClaimsCovered(claims));
     }

package/dist/lib/long-task-design-feasibility-binding-owners.d.ts

@@ -0,0 +1,6 @@
+import type { DesignResourceImplementationFeasibilityV1 } from "./design-resource-implementation-feasibility-types.js";
+import type { DeliveryBindingV2 } from "./long-task-delivery-types.js";
+type FeasibleRealization = DesignResourceImplementationFeasibilityV1["component_family_cells"][number]["feasible_realizations"][number];
+export declare function matchingFeasibilityBindingKeys(realization: FeasibleRealization, bindings: DeliveryBindingV2[]): Set<string>;
+export declare function validateFeasibilityBindingOwnerRoots(document: DesignResourceImplementationFeasibilityV1, componentBindings: DeliveryBindingV2[], routeBinding: DeliveryBindingV2): void;
+export {};

package/dist/lib/long-task-design-feasibility-binding-owners.js

@@ -0,0 +1,52 @@
+import { invalid } from "./long-task-design-resource-method-binding.js";
+import { matchesRepoPattern, proveRepositoryPatternSubset, } from "./long-task-paths.js";
+export function matchingFeasibilityBindingKeys(realization, bindings) {
+    const result = new Set();
+    for (const owner of realization.owner_candidates)
+        for (const binding of bindings) {
+            if (binding.existence !== owner.existence)
+                continue;
+            const matches = owner.kind === "planned_logical_owner"
+                ? binding.key === owner.locator || binding.target === owner.locator
+                : (binding.kind === "file" && binding.target === owner.locator) ||
+                    binding.carrier_paths.some((pattern) => matchesRepoPattern(owner.locator, pattern));
+            if (matches)
+                result.add(binding.key);
+        }
+    return result;
+}
+export function validateFeasibilityBindingOwnerRoots(document, componentBindings, routeBinding) {
+    const componentRoots = observedOwnerRoots(document, "component_owner_roots");
+    const routeRoots = observedOwnerRoots(document, "route_owner_roots");
+    if (componentBindings.length && componentRoots.length === 0)
+        invalid("feasibility_component_owner_roots_required", document.target_ref);
+    for (const binding of componentBindings) {
+        if (binding.existence === "planned" && binding.carrier_paths.length === 0)
+            invalid("feasibility_planned_binding_carrier_required", binding.key);
+        proveBindingPathUniverseWithinObservedRoots(binding, componentRoots, "feasibility_component_binding_outside_owner_roots");
+    }
+    if (routeRoots.length === 0)
+        invalid("feasibility_route_owner_roots_required", document.target_ref);
+    proveBindingPathUniverseWithinObservedRoots(routeBinding, routeRoots, "feasibility_route_binding_outside_owner_roots");
+}
+function proveBindingPathUniverseWithinObservedRoots(binding, roots, errorCode) {
+    for (const candidate of bindingPathUniverse(binding)) {
+        const proofs = roots.map((root) => proveRepositoryPatternSubset(candidate, `${root.replace(/\/+$/u, "")}/**`));
+        if (proofs.some((proof) => proof.status === "proven_subset"))
+            continue;
+        const proof = proofs[0];
+        invalid(errorCode, `${binding.key}:${candidate}:${proof?.status ?? "unknown"}:${proof?.reason ?? "owner_roots_empty"}:${roots.join(",")}`);
+    }
+}
+function observedOwnerRoots(document, kind) {
+    const observation = document.substrate_observations.find((candidate) => candidate.kind === kind);
+    return observation?.disposition === "observed" &&
+        observation.value?.kind === "repository_paths"
+        ? observation.value.paths
+        : [];
+}
+function bindingPathUniverse(binding) {
+    return binding.kind === "verified"
+        ? [...binding.carrier_paths]
+        : [binding.target, ...binding.carrier_paths];
+}

package/dist/lib/long-task-design-feasibility-binding.d.ts

@@ -0,0 +1,13 @@
+import type { DesignResourceHandoffPreflightV1 } from "./design-resource-handoff-types.js";
+import type { DesignResourceHandoffPreflightV2 } from "./design-resource-symbolic-fact-types.js";
+import type { CompiledSourceItemV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
+import type { ContractDesignTarget } from "./long-task-design-resource-handoff.js";
+type DesignResourcePreflight = DesignResourceHandoffPreflightV1 | DesignResourceHandoffPreflightV2;
+export interface LongTaskDesignFeasibilityBindingValidationResult {
+    consumed_component_binding_refs: string[];
+}
+export interface LongTaskDesignFeasibilityBindingValidationOptions {
+    deferComponentBindingAttribution?: boolean;
+}
+export declare function validateLongTaskDesignFeasibilityBindings(contract: DeliveryContractV2, contractTarget: ContractDesignTarget, preflight: DesignResourcePreflight, sourceItems: CompiledSourceItemV2[], options?: LongTaskDesignFeasibilityBindingValidationOptions): LongTaskDesignFeasibilityBindingValidationResult;
+export {};