project-tiny-context-harness 0.8.17 → 0.12.0

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

@@ -1,138 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { descendantsOf, liveProcessInstances, processInstanceKey, processInstanceMatches, processSnapshot, rootProcessAlive, uniqueProcessInstances, } from "./long-task-process-table.js";
-export { processInstanceMatches } from "./long-task-process-table.js";
-const PROCESS_TREE_GRACE_MS = 1_000;
-const execFileAsync = promisify(execFile);
-export function createProcessTreeObserver(rootPid) {
-    let stopped = false;
-    let rootInstance = null;
-    const observed = new Map();
-    const monitor = observe();
-    return {
-        stop() {
-            stopped = true;
-        },
-        wait() {
-            return monitor;
-        },
-        terminate(force) {
-            return terminateProcessTree(rootPid, rootInstance, force, [...observed.values()], true);
-        },
-        forceQuiescence() {
-            return forceProcessTreeQuiescence(rootPid, rootInstance, observed);
-        },
-        assertQuiescent() {
-            return assertProcessTreeQuiescent(rootPid, rootInstance, observed);
-        },
-    };
-    async function observe() {
-        do {
-            const snapshot = await processSnapshot();
-            const currentRoot = snapshot.find((entry) => entry.pid === rootPid);
-            if (currentRoot &&
-                (!rootInstance || processInstanceMatches(rootInstance, currentRoot))) {
-                rootInstance ??= currentRoot;
-                for (const descendant of descendantsOf(rootPid, snapshot))
-                    observed.set(processInstanceKey(descendant), descendant);
-            }
-            if (stopped)
-                return;
-            await delay(process.platform === "win32" ? 100 : 25);
-        } while (!stopped);
-    }
-}
-async function forceProcessTreeQuiescence(rootPid, rootInstance, observed) {
-    await terminateProcessTree(rootPid, rootInstance, true, [...observed.values()], true);
-    const deadline = Date.now() + PROCESS_TREE_GRACE_MS;
-    while (Date.now() < deadline) {
-        const snapshot = await processSnapshot();
-        const rootAlive = rootProcessAlive(rootPid, rootInstance, snapshot);
-        const descendantsAlive = liveProcessInstances([...observed.values()], snapshot).length;
-        const groupAlive = process.platform !== "win32" && processGroupExists(rootPid);
-        if (!rootAlive && descendantsAlive === 0 && !groupAlive)
-            return;
-        await delay(process.platform === "win32" ? 100 : 25);
-    }
-    throw new Error("process_observer_descendant_process_alive");
-}
-async function assertProcessTreeQuiescent(rootPid, rootInstance, observed) {
-    const snapshot = await processSnapshot();
-    const currentRoot = snapshot.find((entry) => entry.pid === rootPid);
-    const finalDescendants = currentRoot &&
-        (!rootInstance || processInstanceMatches(rootInstance, currentRoot))
-        ? descendantsOf(rootPid, snapshot)
-        : [];
-    const candidates = uniqueProcessInstances([
-        ...observed.values(),
-        ...finalDescendants,
-    ]);
-    const descendants = liveProcessInstances(candidates, snapshot);
-    const processGroupAlive = process.platform !== "win32" && processGroupExists(rootPid);
-    if (!descendants.length && !processGroupAlive)
-        return;
-    await terminateProcessTree(rootPid, rootInstance, true, descendants, false);
-    throw new Error("process_observer_descendant_process_alive");
-}
-async function terminateProcessTree(rootPid, rootInstance, force, knownDescendants, includeRoot) {
-    if (!Number.isSafeInteger(rootPid) || rootPid <= 0)
-        return;
-    if (process.platform === "win32") {
-        const snapshot = await processSnapshot();
-        const currentRoot = snapshot.find((entry) => entry.pid === rootPid);
-        const rootTarget = includeRoot &&
-            currentRoot &&
-            (!rootInstance || processInstanceMatches(rootInstance, currentRoot))
-            ? currentRoot
-            : null;
-        const currentDescendants = rootTarget
-            ? descendantsOf(rootPid, snapshot)
-            : [];
-        const descendants = liveProcessInstances(uniqueProcessInstances([...knownDescendants, ...currentDescendants]), snapshot).reverse();
-        const targets = rootTarget ? [...descendants, rootTarget] : descendants;
-        for (const target of targets)
-            await execFileAsync("taskkill.exe", ["/PID", String(target.pid), "/T", "/F"], {
-                windowsHide: true,
-                timeout: PROCESS_TREE_GRACE_MS,
-            }).catch(() => undefined);
-        return;
-    }
-    const signal = force ? "SIGKILL" : "SIGTERM";
-    if (includeRoot)
-        try {
-            process.kill(-rootPid, signal);
-        }
-        catch (error) {
-            if (nodeErrorCode(error) !== "ESRCH")
-                throw error;
-        }
-    const snapshot = await processSnapshot();
-    const descendants = liveProcessInstances(knownDescendants, snapshot);
-    for (const descendant of descendants.reverse())
-        try {
-            process.kill(descendant.pid, signal);
-        }
-        catch (error) {
-            if (nodeErrorCode(error) !== "ESRCH")
-                throw error;
-        }
-}
-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 delay(milliseconds) {
-    return new Promise((resolve) => setTimeout(resolve, milliseconds));
-}

package/dist/lib/long-task-product-shape.d.ts

@@ -1,8 +0,0 @@
-import type { DeliveryControlRelationClosureV2, DeliveryControlRelationV2, DeliveryControlV2, DeliveryObligationV2, DeliveryOwnerV2, KeyedPathV2, KeyedStatementV2 } from "./long-task-delivery-types.js";
-export declare function parseKeyedStatements(value: unknown, label: string): KeyedStatementV2[];
-export declare function parseKeyedPaths(value: unknown, label: string): KeyedPathV2[];
-export declare function parseControls(value: unknown, label: string): DeliveryControlV2[];
-export declare function parseControlRelations(value: unknown, label: string): DeliveryControlRelationV2[];
-export declare function parseControlRelationClosure(value: unknown, label: string): DeliveryControlRelationClosureV2;
-export declare function parseOwner(value: unknown, label: string): DeliveryOwnerV2;
-export declare function parseObligations(value: unknown, label: string): DeliveryObligationV2[];

package/dist/lib/long-task-product-shape.js

@@ -1,197 +0,0 @@
-import { CONTROL_FIELD_NAMES } from "./long-task-control-fields.js";
-import { parseKeyRefs } from "./long-task-applicability-shape.js";
-import { parseRequiredProofSurfaces } from "./long-task-required-proof-surfaces.js";
-import { array, fail, key, literal, object, repositoryFiles, repositoryPattern, repositoryPatterns, string, text, } from "./long-task-shape-primitives.js";
-export function parseKeyedStatements(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, ["key", "statement"]);
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            statement: string(row.statement, `${itemLabel}.statement`),
-        };
-    });
-}
-export function parseKeyedPaths(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, ["key", "path"]);
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            path: repositoryPattern(row.path, `${itemLabel}.path`),
-        };
-    });
-}
-export function parseControls(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, ["key", "field_coverage"], [
-            "surface",
-            "region",
-            "location",
-            "control_type",
-            "label_content",
-            "user_task",
-            "visibility",
-            "availability",
-            "trigger",
-            "input",
-            "validation",
-            "default_value",
-            "interaction",
-            "navigation_result",
-            "loading_state",
-            "empty_state",
-            "success_state",
-            "failure_state",
-            "recovery",
-            "permission",
-            "feedback",
-            "accessibility",
-        ]);
-        const control = {
-            key: key(row.key, `${itemLabel}.key`),
-            surface: optionalText(row, "surface", itemLabel),
-            region: optionalText(row, "region", itemLabel),
-            location: optionalText(row, "location", itemLabel),
-            control_type: optionalText(row, "control_type", itemLabel),
-            label_content: optionalText(row, "label_content", itemLabel),
-            user_task: optionalText(row, "user_task", itemLabel),
-            visibility: optionalText(row, "visibility", itemLabel),
-            availability: optionalText(row, "availability", itemLabel),
-            trigger: optionalText(row, "trigger", itemLabel),
-            input: optionalText(row, "input", itemLabel),
-            validation: optionalText(row, "validation", itemLabel),
-            default_value: optionalText(row, "default_value", itemLabel),
-            interaction: optionalText(row, "interaction", itemLabel),
-            navigation_result: optionalText(row, "navigation_result", itemLabel),
-            loading_state: optionalText(row, "loading_state", itemLabel),
-            empty_state: optionalText(row, "empty_state", itemLabel),
-            success_state: optionalText(row, "success_state", itemLabel),
-            failure_state: optionalText(row, "failure_state", itemLabel),
-            recovery: optionalText(row, "recovery", itemLabel),
-            permission: optionalText(row, "permission", itemLabel),
-            feedback: optionalText(row, "feedback", itemLabel),
-            accessibility: optionalText(row, "accessibility", itemLabel),
-            field_coverage: parseControlFieldCoverage(row.field_coverage, `${itemLabel}.field_coverage`),
-        };
-        validateControlFieldCoverage(control, itemLabel);
-        return control;
-    });
-}
-export function parseControlRelations(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "statement",
-            "control_refs",
-            "required_proof_surfaces",
-            "applicability_refs",
-        ]);
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            statement: string(row.statement, `${itemLabel}.statement`),
-            control_refs: parseKeyRefs(row.control_refs, `${itemLabel}.control_refs`),
-            required_proof_surfaces: parseRequiredProofSurfaces(row.required_proof_surfaces, `${itemLabel}.required_proof_surfaces`),
-            applicability_refs: parseKeyRefs(row.applicability_refs, `${itemLabel}.applicability_refs`),
-        };
-    });
-}
-export function parseControlRelationClosure(value, label) {
-    const row = object(value, label, ["state", "statement"], ["applicability_refs"]);
-    const state = literal(row.state, ["specified", "not_applicable", "unresolved"], `${label}.state`);
-    return {
-        state,
-        statement: string(row.statement, `${label}.statement`),
-        applicability_refs: state === "unresolved"
-            ? Object.hasOwn(row, "applicability_refs")
-                ? parseKeyRefs(row.applicability_refs, `${label}.applicability_refs`)
-                : []
-            : parseKeyRefs(row.applicability_refs, `${label}.applicability_refs`),
-    };
-}
-export function parseOwner(value, label) {
-    const row = object(value, label, ["label", "context_refs", "path_globs"]);
-    return {
-        label: string(row.label, `${label}.label`),
-        context_refs: repositoryFiles(row.context_refs, `${label}.context_refs`),
-        path_globs: repositoryPatterns(row.path_globs, `${label}.path_globs`),
-    };
-}
-export function parseObligations(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "statement",
-            "required_proof_surfaces",
-            "applicability_refs",
-        ]);
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            statement: string(row.statement, `${itemLabel}.statement`),
-            required_proof_surfaces: parseRequiredProofSurfaces(row.required_proof_surfaces, `${itemLabel}.required_proof_surfaces`),
-            applicability_refs: parseKeyRefs(row.applicability_refs, `${itemLabel}.applicability_refs`),
-        };
-    });
-}
-function parseControlFieldCoverage(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, ["fields", "state"], ["statement", "applicability_refs"]);
-        const fields = array(row.fields, `${itemLabel}.fields`).map((field, fieldIndex) => literal(field, CONTROL_FIELD_NAMES, `${itemLabel}.fields[${fieldIndex}]`));
-        if (!fields.length)
-            fail(`${itemLabel}.fields`, "must not be empty");
-        const state = literal(row.state, ["specified", "not_applicable", "unresolved"], `${itemLabel}.state`);
-        if (state === "specified") {
-            if (Object.hasOwn(row, "statement"))
-                fail(`${itemLabel}.statement`, "forbidden for specified fields");
-            return {
-                fields,
-                state,
-                applicability_refs: parseRequiredApplicabilityRefs(row, itemLabel),
-            };
-        }
-        const statement = string(row.statement, `${itemLabel}.statement`);
-        if (state === "not_applicable")
-            return {
-                fields,
-                state,
-                statement,
-                applicability_refs: parseRequiredApplicabilityRefs(row, itemLabel),
-            };
-        if (Object.hasOwn(row, "applicability_refs") &&
-            array(row.applicability_refs, `${itemLabel}.applicability_refs`).length)
-            fail(`${itemLabel}.applicability_refs`, "must be empty while unresolved");
-        return { fields, state, statement, applicability_refs: [] };
-    });
-}
-function parseRequiredApplicabilityRefs(row, label) {
-    const refs = parseKeyRefs(row.applicability_refs, `${label}.applicability_refs`);
-    if (!refs.length)
-        fail(`${label}.applicability_refs`, "must not be empty");
-    return refs;
-}
-function validateControlFieldCoverage(control, label) {
-    const owners = new Map();
-    for (const [index, entry] of control.field_coverage.entries()) {
-        for (const field of entry.fields) {
-            const previous = owners.get(field);
-            if (previous !== undefined)
-                fail(`${label}.field_coverage[${index}].fields`, `field ${field} already owned by entry ${previous}`);
-            owners.set(field, index);
-            const hasStatement = Boolean(control[field].trim());
-            if (entry.state === "specified" && !hasStatement)
-                fail(`${label}.${field}`, "must be non-empty when field state is specified");
-            if (entry.state !== "specified" && hasStatement)
-                fail(`${label}.${field}`, `must be empty when field state is ${entry.state}`);
-        }
-    }
-    const missing = CONTROL_FIELD_NAMES.filter((field) => !owners.has(field));
-    if (missing.length)
-        fail(`${label}.field_coverage`, `missing fields ${missing.join(",")}`);
-}
-function optionalText(row, field, label) {
-    return Object.hasOwn(row, field) ? text(row[field], `${label}.${field}`) : "";
-}

package/dist/lib/long-task-progress.d.ts

@@ -1,4 +0,0 @@
-import type { CheckExecutionResultV2, CompiledCheckV2, CompiledDeliveryContractV2, ProgressRecordV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-export declare function createProgressRecord(compiled: CompiledDeliveryContractV2, manifest: WorkspaceManifestV2, check: CompiledCheckV2, result: CheckExecutionResultV2): ProgressRecordV2;
-export declare function progressRecordFresh(record: ProgressRecordV2, compiled: CompiledDeliveryContractV2, manifest: WorkspaceManifestV2, check: CompiledCheckV2): boolean;
-export declare function checkIdentity(check: CompiledCheckV2): string;

package/dist/lib/long-task-progress.js

@@ -1,120 +0,0 @@
-import { outcomeAuthorityHash } from "./long-task-authority.js";
-import { contextAuthorityProjection } from "./long-task-context-authority.js";
-import { matchesRepoPattern } from "./long-task-paths.js";
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-export function createProgressRecord(compiled, manifest, check, result) {
-    const outcome = check.outcome_key
-        ? (compiled.outcomes.find((item) => item.key === check.outcome_key) ?? null)
-        : null;
-    return {
-        schema_version: "long-task-progress-record-v2",
-        compiled_identity: compiled.compiled_identity,
-        outcome_authority_hash: progressAuthorityHash(compiled, outcome ?? null),
-        check_identity: checkIdentity(check),
-        check_internal_id: check.internal_id,
-        outcome_key: check.outcome_key,
-        check_key: check.key,
-        runner_verifier_identity: runnerVerifierIdentity(compiled, check),
-        relevant_context_identity: contextIdentity(compiled),
-        resolved_input_path_hashes: hashPatterns(manifest, check.input_paths),
-        binding_carrier_path_hashes: hashPatterns(manifest, progressBindingCarrierPatterns(compiled, check, outcome)),
-        dependency_interface_identities: dependencyInterfaceIdentities(compiled, manifest, outcome?.depends_on ?? []),
-        result: result.status,
-        check_result: result,
-        findings: result.findings,
-        completed_at: new Date().toISOString(),
-    };
-}
-export function progressRecordFresh(record, compiled, manifest, check) {
-    const outcome = check.outcome_key
-        ? (compiled.outcomes.find((item) => item.key === check.outcome_key) ?? null)
-        : null;
-    const expectedOutcomeAuthority = progressAuthorityHash(compiled, outcome ?? null);
-    return (record.check_internal_id === check.internal_id &&
-        record.check_identity === checkIdentity(check) &&
-        record.outcome_authority_hash === expectedOutcomeAuthority &&
-        record.runner_verifier_identity ===
-            runnerVerifierIdentity(compiled, check) &&
-        record.relevant_context_identity === contextIdentity(compiled) &&
-        same(record.resolved_input_path_hashes, hashPatterns(manifest, check.input_paths)) &&
-        same(record.binding_carrier_path_hashes, hashPatterns(manifest, progressBindingCarrierPatterns(compiled, check, outcome))) &&
-        same(record.dependency_interface_identities, dependencyInterfaceIdentities(compiled, manifest, outcome?.depends_on ?? [])));
-}
-function progressBindingCarrierPatterns(compiled, check, outcome) {
-    if (outcome)
-        return outcome.technical.bindings.flatMap((binding) => binding.carrier_paths);
-    const references = (compiled.global.acceptance.counterfactual_controls ?? [])
-        .filter((control) => control.check_key === check.key)
-        .map((control) => control.binding_ref);
-    return references.flatMap((reference) => {
-        const [outcomeKey, bindingKey] = reference.split(".");
-        return (compiled.outcomes
-            .find((item) => item.key === outcomeKey)
-            ?.technical.bindings.find((binding) => binding.key === bindingKey)
-            ?.carrier_paths ?? []);
-    });
-}
-function progressAuthorityHash(compiled, outcome) {
-    return sha256Hex(canonicalValueJson({
-        source: compiled.authority_hashes.source_authority_hash,
-        product: compiled.authority_hashes.product_authority_hash,
-        acceptance: compiled.authority_hashes.acceptance_authority_hash,
-        risk: compiled.authority_hashes.risk_authority_hash,
-        outcome: outcome ? outcomeAuthorityHash(outcome) : null,
-    }));
-}
-export function checkIdentity(check) {
-    return sha256Hex(canonicalValueJson({
-        internal_id: check.internal_id,
-        proof_surface: check.proof_surface,
-        evidence_adapter: check.evidence_adapter,
-        runner: check.runner.execution_identity,
-        raw_execution: check.raw_execution_identity,
-        verification_input_hashes: check.verification_input_hashes,
-        input_paths: check.input_paths,
-        expected_output_paths: check.expected_output_paths,
-        artifact_globs: check.artifact_globs,
-        positive_assertions: check.positive_assertions,
-        negative_assertions: check.negative_assertions,
-        journey_roles: check.journey_roles,
-        execution_target: check.execution_target,
-        execution_target_definition: check.execution_target_definition,
-        scenario: check.scenario,
-        environment_requirements: check.environment_requirements,
-        observation_authorities: check.observation_authorities,
-        process_runtime_closure: check.process_runtime_closure,
-    }));
-}
-function runnerVerifierIdentity(compiled, check) {
-    return sha256Hex(canonicalValueJson({
-        runner: check.raw_execution_identity,
-        verifier: compiled.verifier_identity.bundle_sha256,
-    }));
-}
-function contextIdentity(compiled) {
-    return sha256Hex(canonicalValueJson(contextAuthorityProjection(compiled.context_snapshot)));
-}
-function dependencyInterfaceIdentities(compiled, manifest, dependencies) {
-    const result = {};
-    for (const key of dependencies) {
-        const dependency = compiled.outcomes.find((outcome) => outcome.key === key);
-        if (!dependency)
-            continue;
-        result[key] = sha256Hex(canonicalValueJson({
-            authority: outcomeAuthorityHash(dependency),
-            carriers: hashPatterns(manifest, dependency.technical.bindings.flatMap((binding) => binding.carrier_paths)),
-        }));
-    }
-    return Object.fromEntries(Object.entries(result).sort(([a], [b]) => a.localeCompare(b)));
-}
-function hashPatterns(manifest, patterns) {
-    const result = {};
-    for (const pattern of patterns)
-        for (const file of manifest.files)
-            if (matchesRepoPattern(file.path, pattern))
-                result[file.path] = file.sha256;
-    return Object.fromEntries(Object.entries(result).sort(([a], [b]) => a.localeCompare(b)));
-}
-function same(left, right) {
-    return canonicalValueJson(left) === canonicalValueJson(right);
-}

package/dist/lib/long-task-protected-files.d.ts

@@ -1 +0,0 @@
-export { assertProtectedRepositoryDirectory, assertProtectedRepositoryFile, } from "./repository-path-safety.js";

package/dist/lib/long-task-protected-files.js

@@ -1 +0,0 @@
-export { assertProtectedRepositoryDirectory, assertProtectedRepositoryFile, } from "./repository-path-safety.js";

package/dist/lib/long-task-required-proof-surfaces.d.ts

@@ -1,2 +0,0 @@
-import type { ProofSurface } from "./long-task-delivery-types.js";
-export declare function parseRequiredProofSurfaces(value: unknown, label: string): ProofSurface[];

package/dist/lib/long-task-required-proof-surfaces.js

@@ -1,13 +0,0 @@
-import { array, fail, literal, PROOF_SURFACES, } from "./long-task-shape-primitives.js";
-export function parseRequiredProofSurfaces(value, label) {
-    const surfaces = array(value, label).map((surface, index) => literal(surface, PROOF_SURFACES, `${label}[${index}]`));
-    if (!surfaces.length)
-        fail("required_proof_surfaces_empty", label);
-    const seen = new Set();
-    for (const surface of surfaces) {
-        if (seen.has(surface))
-            fail("required_proof_surface_duplicate", `${label}:${surface}`);
-        seen.add(surface);
-    }
-    return surfaces;
-}

package/dist/lib/long-task-requirement-shape.d.ts

@@ -1,2 +0,0 @@
-import type { DeliveryOutcomeV2 } from "./long-task-delivery-types.js";
-export declare function parseRequirements(value: unknown, label: string): DeliveryOutcomeV2["product"]["requirements"];

package/dist/lib/long-task-requirement-shape.js

@@ -1,21 +0,0 @@
-import { parseKeyRefs } from "./long-task-applicability-shape.js";
-import { parseRequiredProofSurfaces } from "./long-task-required-proof-surfaces.js";
-import { array, key, object, string } from "./long-task-shape-primitives.js";
-export function parseRequirements(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "statement",
-            "required_proof_surfaces",
-            "applicability_refs",
-        ]);
-        const surfaces = parseRequiredProofSurfaces(row.required_proof_surfaces, `${itemLabel}.required_proof_surfaces`);
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            statement: string(row.statement, `${itemLabel}.statement`),
-            required_proof_surfaces: surfaces,
-            applicability_refs: parseKeyRefs(row.applicability_refs, `${itemLabel}.applicability_refs`),
-        };
-    });
-}

package/dist/lib/long-task-risk-surfaces.d.ts

@@ -1,2 +0,0 @@
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
-export declare function validateActualRiskSurfaces(repository: string, changedPaths: string[], contract: DeliveryContractV2): Promise<void>;

package/dist/lib/long-task-risk-surfaces.js

@@ -1,60 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { matchesRepoPattern } from "./long-task-paths.js";
-import { parseStrictYaml } from "./strict-codec.js";
-export async function validateActualRiskSurfaces(repository, changedPaths, contract) {
-    const inferred = new Set();
-    const surfaces = await readRiskSurfaces(repository);
-    for (const surface of surfaces)
-        if (changedPaths.some((changed) => surface.paths.some((pattern) => matchesRepoPattern(changed, pattern)))) {
-            if (surface.risk === "classification_required")
-                throw new Error("risk_classification_required");
-            inferred.add(surface.risk);
-        }
-    for (const fact of inferred)
-        if (contract.risk.facts[fact].length === 0)
-            throw new Error(`risk_fact_underdeclared:${fact}`);
-}
-async function readRiskSurfaces(repository) {
-    const file = path.join(repository, "project_context", "risk-surfaces.yaml");
-    let raw;
-    try {
-        raw = await readFile(file, "utf8");
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return [];
-        throw error;
-    }
-    const value = parseStrictYaml(raw);
-    if (!Array.isArray(value))
-        throw new Error("risk_surfaces_invalid:root");
-    const facts = new Set([
-        "public_api_or_schema_change",
-        "persistent_data_change",
-        "data_migration",
-        "security_boundary_change",
-        "permission_boundary_change",
-        "irreversible_external_effect",
-        "critical_user_path",
-        "full_population_operation",
-        "multi_repository_change",
-        "weak_observability",
-        "classification_required",
-    ]);
-    return value.map((item, index) => {
-        if (!item || typeof item !== "object" || Array.isArray(item))
-            throw new Error(`risk_surfaces_invalid:${index}`);
-        const row = item;
-        if (Object.keys(row).some((key) => !["risk", "paths"].includes(key)) ||
-            typeof row.risk !== "string" ||
-            !facts.has(row.risk) ||
-            !Array.isArray(row.paths) ||
-            row.paths.some((value) => typeof value !== "string" || !value))
-            throw new Error(`risk_surfaces_invalid:${index}`);
-        return {
-            risk: row.risk,
-            paths: row.paths,
-        };
-    });
-}

package/dist/lib/long-task-risk-types.d.ts

@@ -1,5 +0,0 @@
-export type RequestedRiskLevel = "auto" | "standard" | "strict";
-export type EffectiveRiskLevel = "standard" | "strict";
-export declare const RISK_FACT_NAMES: readonly ["public_api_or_schema_change", "persistent_data_change", "data_migration", "security_boundary_change", "permission_boundary_change", "irreversible_external_effect", "critical_user_path", "full_population_operation", "multi_repository_change", "weak_observability"];
-export type RiskFactName = (typeof RISK_FACT_NAMES)[number];
-export type LongTaskRiskFacts = Record<RiskFactName, string[]>;

package/dist/lib/long-task-risk-types.js

@@ -1,12 +0,0 @@
-export const RISK_FACT_NAMES = [
-    "public_api_or_schema_change",
-    "persistent_data_change",
-    "data_migration",
-    "security_boundary_change",
-    "permission_boundary_change",
-    "irreversible_external_effect",
-    "critical_user_path",
-    "full_population_operation",
-    "multi_repository_change",
-    "weak_observability",
-];

package/dist/lib/long-task-risk.d.ts

@@ -1,9 +0,0 @@
-import type { DeliveryContractV2, EffectiveRiskLevel, RiskFactName } from "./long-task-delivery-types.js";
-export interface RiskDecisionV2 {
-    effective_level: EffectiveRiskLevel;
-    minimum_level: EffectiveRiskLevel;
-    reasons: string[];
-    reasons_by_outcome: Record<string, RiskFactName[]>;
-}
-export declare function classifyLongTaskRisk(contract: DeliveryContractV2): RiskDecisionV2;
-export declare function validateRiskProof(contract: DeliveryContractV2, decision: RiskDecisionV2): void;