project-tiny-context-harness 0.8.11 → 0.8.13

package/dist/lib/long-task-compact-parser.d.ts

@@ -0,0 +1,14 @@
+import { type LongTaskCompactCapacityCounts } from "./long-task-compact-primitives.js";
+export declare function parseLongTaskCompactFactSets(value: unknown, selectors: Map<string, string[]>, label: string): Record<string, unknown>[];
+export declare function parseLongTaskCompactProofTemplates(value: unknown, selectors: Map<string, string[]>, label: string): Map<string, Record<string, unknown>>;
+export declare function parseLongTaskCompactCapacity(value: unknown, label: string): {
+    measured: LongTaskCompactCapacityCounts;
+    maximum: LongTaskCompactCapacityCounts;
+};
+export declare function parseLongTaskCompactSelectors(value: unknown, label: string): Map<string, string[]>;
+export declare function parseLongTaskCompactTable(value: unknown, selectors: Map<string, string[]>, label: string): Record<string, unknown>[];
+export declare function parseLongTaskCompactExceptions(value: unknown, label: string): Array<{
+    key: string;
+    target_ref: string;
+    rationale: string;
+}>;

package/dist/lib/long-task-compact-parser.js

@@ -0,0 +1,123 @@
+import { LONG_TASK_COMPACT_CAPACITY_FIELDS, compactArray, compactFail, compactInteger, compactNonemptyString, compactPlainObject, compactResolveSelectors, compactStableRef, compactStableRefs, compactStrictObject, } from "./long-task-compact-primitives.js";
+export function parseLongTaskCompactFactSets(value, selectors, label) {
+    const result = [];
+    const keys = new Set();
+    for (const [index, item] of compactArray(value, label).entries()) {
+        const itemLabel = `${label}[${index}]`;
+        const row = compactStrictObject(item, itemLabel, [
+            "key",
+            "defaults",
+            "columns",
+            "rows",
+        ]);
+        const key = compactStableRef(row.key, `${itemLabel}.key`);
+        if (keys.has(key))
+            compactFail(itemLabel, `duplicate key: ${key}`);
+        keys.add(key);
+        result.push(...parseLongTaskCompactTable({ defaults: row.defaults, columns: row.columns, rows: row.rows }, selectors, itemLabel));
+    }
+    return result;
+}
+export function parseLongTaskCompactProofTemplates(value, selectors, label) {
+    const result = new Map();
+    for (const [index, item] of compactArray(value, label).entries()) {
+        const itemLabel = `${label}[${index}]`;
+        const row = compactStrictObject(item, itemLabel, ["key", "binding"]);
+        const key = compactStableRef(row.key, `${itemLabel}.key`);
+        if (result.has(key))
+            compactFail(itemLabel, `duplicate key: ${key}`);
+        const binding = compactPlainObject(compactResolveSelectors(row.binding, selectors, `${itemLabel}.binding`), `${itemLabel}.binding`);
+        if (["proof_ref", "fact_ref"].some((field) => Object.hasOwn(binding, field)))
+            compactFail(`${itemLabel}.binding`, "identity fields belong to rows");
+        result.set(key, binding);
+    }
+    return result;
+}
+export function parseLongTaskCompactCapacity(value, label) {
+    const row = compactStrictObject(value, label, [
+        "theoretical_ground_universe",
+        "measured",
+        "maximum",
+    ]);
+    if (row.theoretical_ground_universe !== "not_materialized")
+        compactFail(`${label}.theoretical_ground_universe`, "must be not_materialized");
+    return {
+        measured: capacityCounts(row.measured, `${label}.measured`),
+        maximum: capacityCounts(row.maximum, `${label}.maximum`),
+    };
+}
+function capacityCounts(value, label) {
+    const row = compactStrictObject(value, label, [
+        ...LONG_TASK_COMPACT_CAPACITY_FIELDS,
+    ]);
+    return Object.fromEntries(LONG_TASK_COMPACT_CAPACITY_FIELDS.map((field) => [
+        field,
+        compactInteger(row[field], `${label}.${field}`),
+    ]));
+}
+export function parseLongTaskCompactSelectors(value, label) {
+    const result = new Map();
+    for (const [index, item] of compactArray(value, label).entries()) {
+        const itemLabel = `${label}[${index}]`;
+        const row = compactStrictObject(item, itemLabel, ["key", "members"]);
+        const key = compactStableRef(row.key, `${itemLabel}.key`);
+        const members = compactStableRefs(row.members, `${itemLabel}.members`);
+        if (result.has(key))
+            compactFail(itemLabel, `duplicate key: ${key}`);
+        if (new Set(members).size !== members.length)
+            compactFail(`${itemLabel}.members`, "members must be unique");
+        result.set(key, members);
+    }
+    return result;
+}
+export function parseLongTaskCompactTable(value, selectors, label) {
+    const table = compactStrictObject(value, label, [
+        "defaults",
+        "columns",
+        "rows",
+    ]);
+    const defaults = compactPlainObject(compactResolveSelectors(table.defaults, selectors, `${label}.defaults`), `${label}.defaults`);
+    const columns = compactArray(table.columns, `${label}.columns`).map((item, index) => {
+        const column = compactNonemptyString(item, `${label}.columns[${index}]`);
+        if (!/^[a-z][a-z0-9_]*$/u.test(column))
+            compactFail(`${label}.columns[${index}]`, "invalid column name");
+        return column;
+    });
+    if (new Set(columns).size !== columns.length)
+        compactFail(`${label}.columns`, "columns must be unique");
+    for (const column of columns)
+        if (Object.hasOwn(defaults, column))
+            compactFail(`${label}.columns`, `column duplicates default: ${column}`);
+    return compactArray(table.rows, `${label}.rows`).map((item, index) => {
+        const values = compactArray(item, `${label}.rows[${index}]`);
+        if (values.length !== columns.length)
+            compactFail(`${label}.rows[${index}]`, `column count mismatch: ${values.length}:${columns.length}`);
+        return {
+            ...defaults,
+            ...Object.fromEntries(columns.map((column, columnIndex) => [
+                column,
+                compactResolveSelectors(values[columnIndex], selectors, `${label}.rows[${index}][${columnIndex}]`),
+            ])),
+        };
+    });
+}
+export function parseLongTaskCompactExceptions(value, label) {
+    const result = [];
+    const seen = new Set();
+    for (const [index, item] of compactArray(value, label).entries()) {
+        const itemLabel = `${label}[${index}]`;
+        const row = compactStrictObject(item, itemLabel, [
+            "key",
+            "target_ref",
+            "rationale",
+        ]);
+        const key = compactStableRef(row.key, `${itemLabel}.key`);
+        const targetRef = compactStableRef(row.target_ref, `${itemLabel}.target_ref`);
+        const rationale = compactNonemptyString(row.rationale, `${itemLabel}.rationale`);
+        if (seen.has(key))
+            compactFail(itemLabel, `duplicate key: ${key}`);
+        seen.add(key);
+        result.push({ key, target_ref: targetRef, rationale });
+    }
+    return result;
+}

package/dist/lib/long-task-compact-primitives.d.ts

@@ -0,0 +1,22 @@
+export { longTaskCompactSharedStructureTargets } from "./long-task-compact-structure-targets.js";
+export declare const LONG_TASK_COMPACT_CAPACITY_FIELDS: readonly ["claims", "claim_projections", "selector_members", "structure_families", "structure_references", "structure_arguments", "facts", "obligations", "assertions", "canonical_bytes"];
+type CapacityField = (typeof LONG_TASK_COMPACT_CAPACITY_FIELDS)[number];
+export type LongTaskCompactCapacityCounts = Record<CapacityField, number>;
+export declare function compactRequiredOutcome(value: unknown, outcomes: Map<string, Record<string, unknown>>, label: string): Record<string, unknown>;
+export declare function compactResolveSelectors(value: unknown, selectors: Map<string, string[]>, label: string): unknown;
+export declare function validateLongTaskCompactCapacity(capacity: {
+    measured: LongTaskCompactCapacityCounts;
+    maximum: LongTaskCompactCapacityCounts;
+}, measured: LongTaskCompactCapacityCounts, label: string): void;
+export declare function validateLongTaskCompactDeclaredMaximum(maximum: LongTaskCompactCapacityCounts, label: string): void;
+export declare function compactUniqueRows(rows: Record<string, unknown>[], field: string, label: string): void;
+export declare function compactStrictObject(value: unknown, label: string, fields: string[]): Record<string, unknown>;
+export declare function compactPlainObject(value: unknown, label: string): Record<string, unknown>;
+export declare function compactArray(value: unknown, label: string): unknown[];
+export declare function compactStableRef(value: unknown, label: string): string;
+export declare function compactStableRefs(value: unknown, label: string): string[];
+export declare function compactSha256(value: unknown, label: string): string;
+export declare function compactNonemptyString(value: unknown, label: string): string;
+export declare function compactInteger(value: unknown, label: string): number;
+export declare function compactLiteral<T extends string>(value: unknown, values: readonly T[], label: string): T;
+export declare function compactFail(label: string, message: string): never;

package/dist/lib/long-task-compact-primitives.js

@@ -0,0 +1,132 @@
+const STABLE_REF = /^[a-z0-9][a-z0-9._:-]*$/u;
+const SHA256 = /^[a-f0-9]{64}$/u;
+export { longTaskCompactSharedStructureTargets } from "./long-task-compact-structure-targets.js";
+export const LONG_TASK_COMPACT_CAPACITY_FIELDS = [
+    "claims",
+    "claim_projections",
+    "selector_members",
+    "structure_families",
+    "structure_references",
+    "structure_arguments",
+    "facts",
+    "obligations",
+    "assertions",
+    "canonical_bytes",
+];
+const PACKAGE_MAXIMUM = {
+    claims: 1_000_000,
+    claim_projections: 2_000_000,
+    selector_members: 5_000_000,
+    structure_families: 1_000_000,
+    structure_references: 10_000_000,
+    structure_arguments: 50_000_000,
+    facts: 1_000_000,
+    obligations: 2_000_000,
+    assertions: 5_000_000,
+    canonical_bytes: 256 * 1024 * 1024,
+};
+export function compactRequiredOutcome(value, outcomes, label) {
+    const ref = compactStableRef(value, `${label}.outcome_ref`);
+    const outcome = outcomes.get(ref);
+    if (!outcome)
+        compactFail(`${label}.outcome_ref`, `unknown outcome: ${ref}`);
+    return outcome;
+}
+export function compactResolveSelectors(value, selectors, label) {
+    if (Array.isArray(value))
+        return value.map((item, index) => compactResolveSelectors(item, selectors, `${label}[${index}]`));
+    if (!value || typeof value !== "object")
+        return value;
+    const row = value;
+    if (Object.keys(row).length === 1 && Object.hasOwn(row, "selector_ref")) {
+        const ref = compactStableRef(row.selector_ref, `${label}.selector_ref`);
+        const members = selectors.get(ref);
+        if (!members)
+            compactFail(`${label}.selector_ref`, `unknown selector: ${ref}`);
+        return [...members];
+    }
+    if (Object.hasOwn(row, "selector_ref"))
+        compactFail(label, "selector_ref must be the only key");
+    return Object.fromEntries(Object.entries(row).map(([key, item]) => [
+        key,
+        compactResolveSelectors(item, selectors, `${label}.${key}`),
+    ]));
+}
+export function validateLongTaskCompactCapacity(capacity, measured, label) {
+    for (const field of LONG_TASK_COMPACT_CAPACITY_FIELDS) {
+        if (capacity.maximum[field] > PACKAGE_MAXIMUM[field])
+            compactFail(`${label}.capacity.maximum.${field}`, `exceeds package maximum ${PACKAGE_MAXIMUM[field]}`);
+        if (capacity.measured[field] !== measured[field])
+            compactFail(`${label}.capacity.measured.${field}`, `measured mismatch: ${capacity.measured[field]}:${measured[field]}`);
+        if (measured[field] > capacity.maximum[field])
+            compactFail(`${label}.capacity.maximum.${field}`, `capacity exceeded: ${measured[field]}:${capacity.maximum[field]}`);
+    }
+}
+export function validateLongTaskCompactDeclaredMaximum(maximum, label) {
+    for (const field of LONG_TASK_COMPACT_CAPACITY_FIELDS)
+        if (maximum[field] > PACKAGE_MAXIMUM[field])
+            compactFail(`${label}.capacity.maximum.${field}`, `exceeds package maximum ${PACKAGE_MAXIMUM[field]}`);
+}
+export function compactUniqueRows(rows, field, label) {
+    const seen = new Set();
+    for (const [index, row] of rows.entries()) {
+        const value = compactStableRef(row[field], `${label}.rows[${index}].${field}`);
+        if (seen.has(value))
+            compactFail(label, `duplicate ${field}: ${value}`);
+        seen.add(value);
+    }
+}
+export function compactStrictObject(value, label, fields) {
+    const row = compactPlainObject(value, label);
+    const allowed = new Set(fields);
+    const unknown = Object.keys(row).filter((key) => !allowed.has(key));
+    if (unknown.length)
+        compactFail(label, `unknown keys: ${unknown.join(",")}`);
+    const missing = fields.filter((field) => !Object.hasOwn(row, field));
+    if (missing.length)
+        compactFail(label, `missing keys: ${missing.join(",")}`);
+    return row;
+}
+export function compactPlainObject(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        compactFail(label, "must be an object");
+    return value;
+}
+export function compactArray(value, label) {
+    if (!Array.isArray(value))
+        compactFail(label, "must be an array");
+    return value;
+}
+export function compactStableRef(value, label) {
+    const result = compactNonemptyString(value, label);
+    if (!STABLE_REF.test(result))
+        compactFail(label, "must be a stable reference");
+    return result;
+}
+export function compactStableRefs(value, label) {
+    return compactArray(value, label).map((item, index) => compactStableRef(item, `${label}[${index}]`));
+}
+export function compactSha256(value, label) {
+    const result = compactNonemptyString(value, label);
+    if (!SHA256.test(result))
+        compactFail(label, "must be a lowercase SHA-256");
+    return result;
+}
+export function compactNonemptyString(value, label) {
+    if (typeof value !== "string" || !value.trim())
+        compactFail(label, "must be a non-empty string");
+    return value;
+}
+export function compactInteger(value, label) {
+    if (!Number.isInteger(value) || Number(value) < 0)
+        compactFail(label, "must be an integer >= 0");
+    return Number(value);
+}
+export function compactLiteral(value, values, label) {
+    if (typeof value !== "string" || !values.includes(value))
+        compactFail(label, `must be one of ${values.join(",")}`);
+    return value;
+}
+export function compactFail(label, message) {
+    throw new Error(`long_task_compact_carrier_invalid:${label}:${message}`);
+}

package/dist/lib/long-task-compact-projections.d.ts

@@ -0,0 +1,4 @@
+export declare function prepareLongTaskCompactOutcomeTargets(outcomes: Record<string, unknown>[]): void;
+export declare function materializeLongTaskCompactClaimProjections(projections: Record<string, unknown>[], claims: Map<string, Record<string, unknown>>, outcomes: Map<string, Record<string, unknown>>): void;
+export declare function materializeLongTaskCompactFactBindings(facts: Record<string, unknown>[], obligations: Record<string, unknown>[], factByKey: Map<string, Record<string, unknown>>, templates: Map<string, Record<string, unknown>>, outcomes: Map<string, Record<string, unknown>>): void;
+export declare function materializeLongTaskCompactAssertions(assertions: Record<string, unknown>[], claims: Map<string, Record<string, unknown>>, facts: Map<string, Record<string, unknown>>, outcomes: Map<string, Record<string, unknown>>): void;

package/dist/lib/long-task-compact-projections.js

@@ -0,0 +1,153 @@
+import { compactArray, compactFail, compactInteger, compactLiteral, compactNonemptyString, compactPlainObject, compactRequiredOutcome, compactSha256, compactStableRef, compactStableRefs, } from "./long-task-compact-primitives.js";
+export function prepareLongTaskCompactOutcomeTargets(outcomes) {
+    for (const [index, outcome] of outcomes.entries()) {
+        const label = `outcomes[${index}]`;
+        if (Object.hasOwn(outcome, "semantic_fact_bindings"))
+            compactFail(label, "expanded semantic_fact_bindings cannot coexist");
+        const product = compactPlainObject(outcome.product, `${label}.product`);
+        const technical = compactPlainObject(outcome.technical, `${label}.technical`);
+        for (const field of ["requirements", "non_completing_outcomes"])
+            if (Object.hasOwn(product, field))
+                compactFail(`${label}.product.${field}`, "expanded projection cannot coexist");
+        for (const field of ["obligations", "forbidden_shortcuts"])
+            if (Object.hasOwn(technical, field))
+                compactFail(`${label}.technical.${field}`, "expanded projection cannot coexist");
+        product.requirements = [];
+        product.non_completing_outcomes = [];
+        technical.obligations = [];
+        technical.forbidden_shortcuts = [];
+        outcome.semantic_fact_bindings = {
+            manifest_ref: "",
+            facts: [],
+            proofs: [],
+        };
+    }
+}
+export function materializeLongTaskCompactClaimProjections(projections, claims, outcomes) {
+    for (const [index, projection] of projections.entries()) {
+        const label = `compact_semantic_carrier.claim_projections.rows[${index}]`;
+        const outcome = compactRequiredOutcome(projection.outcome_ref, outcomes, label);
+        const claimKey = projection.claim_key === null
+            ? null
+            : compactStableRef(projection.claim_key, `${label}.claim_key`);
+        const claim = claimKey ? claims.get(claimKey) : null;
+        if (claimKey && !claim)
+            compactFail(`${label}.claim_key`, `unknown claim: ${claimKey}`);
+        const statement = claim
+            ? compactNonemptyString(claim.statement, `${label}.statement`)
+            : compactNonemptyString(projection.statement, `${label}.statement`);
+        const applicabilityRefs = compactStableRefs(projection.applicability_refs, `${label}.applicability_refs`);
+        const kind = compactLiteral(projection.projection_kind, [
+            "requirement",
+            "obligation",
+            "forbidden_shortcut",
+            "non_completing_outcome",
+        ], `${label}.projection_kind`);
+        const product = compactPlainObject(outcome.product, `${label}.product`);
+        const technical = compactPlainObject(outcome.technical, `${label}.technical`);
+        const base = {
+            key: compactStableRef(projection.projection_key ?? projection.claim_key, `${label}.projection_key`),
+            statement,
+            applicability_refs: applicabilityRefs,
+        };
+        if (kind === "requirement" || kind === "obligation") {
+            const requiredProofSurfaces = compactStableRefs(projection.required_proof_surfaces, `${label}.required_proof_surfaces`);
+            const row = { ...base, required_proof_surfaces: requiredProofSurfaces };
+            if (kind === "requirement")
+                product.requirements.push(row);
+            else
+                technical.obligations.push(row);
+        }
+        else {
+            if (projection.required_proof_surfaces !== null)
+                compactFail(`${label}.required_proof_surfaces`, "must be null for statement-only projection");
+            if (kind === "forbidden_shortcut")
+                technical.forbidden_shortcuts.push(base);
+            else
+                product.non_completing_outcomes.push(base);
+        }
+    }
+}
+export function materializeLongTaskCompactFactBindings(facts, obligations, factByKey, templates, outcomes) {
+    for (const [index, fact] of facts.entries()) {
+        const label = `compact_semantic_carrier.facts[${index}]`;
+        const outcome = compactRequiredOutcome(fact.outcome_ref, outcomes, label);
+        const binding = compactPlainObject(outcome.semantic_fact_bindings, `${label}.semantic_fact_bindings`);
+        if (!binding.manifest_ref)
+            binding.manifest_ref = compactStableRef(fact.manifest_ref, `${label}.manifest_ref`);
+        else if (binding.manifest_ref !== fact.manifest_ref)
+            compactFail(`${label}.manifest_ref`, "outcome manifest_ref mismatch");
+        binding.facts.push({
+            fact_ref: compactStableRef(fact.fact_key, `${label}.fact_key`),
+            fact_revision_digest: compactSha256(fact.fact_revision_digest, `${label}.fact_revision_digest`),
+            claim_ref: compactStableRef(fact.claim_ref, `${label}.claim_ref`),
+            applicability_ref: compactStableRef(fact.applicability_ref, `${label}.applicability_ref`),
+        });
+    }
+    for (const [index, obligation] of obligations.entries()) {
+        const label = `compact_semantic_carrier.obligations.rows[${index}]`;
+        const outcome = compactRequiredOutcome(obligation.outcome_ref, outcomes, label);
+        const factKey = compactStableRef(obligation.fact_key, `${label}.fact_key`);
+        if (!factByKey.has(factKey))
+            compactFail(`${label}.fact_key`, `unknown fact: ${factKey}`);
+        const templateRef = compactStableRef(obligation.template_ref, `${label}.template_ref`);
+        const template = templates.get(templateRef);
+        if (!template)
+            compactFail(`${label}.template_ref`, `unknown template: ${templateRef}`);
+        const overrides = compactPlainObject(obligation.overrides, `${label}.overrides`);
+        if (["proof_ref", "fact_ref", "obligation_revision_digest"].some((field) => Object.hasOwn(overrides, field)))
+            compactFail(`${label}.overrides`, "identity fields cannot be overridden");
+        const binding = compactPlainObject(outcome.semantic_fact_bindings, `${label}.semantic_fact_bindings`);
+        binding.proofs.push({
+            ...template,
+            ...overrides,
+            proof_ref: compactStableRef(obligation.obligation_key, `${label}.obligation_key`),
+            obligation_revision_digest: compactSha256(obligation.obligation_revision_digest, `${label}.obligation_revision_digest`),
+            fact_ref: factKey,
+        });
+    }
+}
+export function materializeLongTaskCompactAssertions(assertions, claims, facts, outcomes) {
+    for (const [index, projection] of assertions.entries()) {
+        const label = `compact_semantic_carrier.assertion_projections.rows[${index}]`;
+        const outcome = compactRequiredOutcome(projection.outcome_ref, outcomes, label);
+        const acceptance = compactPlainObject(outcome.acceptance, `${label}.acceptance`);
+        const checkRef = compactStableRef(projection.check_ref, `${label}.check_ref`);
+        const check = compactArray(acceptance.checks, `${label}.checks`)
+            .map((item, checkIndex) => compactPlainObject(item, `${label}.checks[${checkIndex}]`))
+            .find((item) => item.key === checkRef);
+        if (!check)
+            compactFail(`${label}.check_ref`, `unknown check: ${checkRef}`);
+        const criterionKind = compactLiteral(projection.criterion_kind, ["claim_statement", "semantic_fact"], `${label}.criterion_kind`);
+        const criterionRef = compactStableRef(projection.criterion_ref, `${label}.criterion_ref`);
+        let criterion;
+        if (criterionKind === "claim_statement") {
+            const claim = claims.get(criterionRef);
+            if (!claim)
+                compactFail(`${label}.criterion_ref`, `unknown claim: ${criterionRef}`);
+            criterion = compactNonemptyString(claim.statement, `${label}.criterion`);
+        }
+        else {
+            if (!facts.has(criterionRef))
+                compactFail(`${label}.criterion_ref`, `unknown fact: ${criterionRef}`);
+            criterion = `The current candidate satisfies the exact Source Fact ${criterionRef}.`;
+        }
+        const assertion = {
+            key: compactStableRef(projection.key, `${label}.key`),
+            criterion,
+            claims: compactStableRefs(projection.claims, `${label}.claims`),
+            applicability_ref: compactStableRef(projection.applicability_ref, `${label}.applicability_ref`),
+            observation: compactNonemptyString(projection.observation, `${label}.observation`),
+            evidence_capabilities: compactStableRefs(projection.evidence_capabilities, `${label}.evidence_capabilities`),
+            operator: compactNonemptyString(projection.operator, `${label}.operator`),
+            expected: projection.expected,
+        };
+        const positive = compactArray(check.positive_assertions, `${label}.positive_assertions`);
+        if (positive.some((item) => compactPlainObject(item, label).key === assertion.key))
+            compactFail(`${label}.key`, `duplicate assertion: ${assertion.key}`);
+        const position = compactInteger(projection.position, `${label}.position`);
+        if (position > positive.length)
+            compactFail(`${label}.position`, `position exceeds current assertion length: ${position}:${positive.length}`);
+        positive.splice(position, 0, assertion);
+    }
+}

package/dist/lib/long-task-compact-structure-targets.d.ts

@@ -0,0 +1,2 @@
+import type { CompactSharedStructureTarget } from "./compact-shared-structures.js";
+export declare function longTaskCompactSharedStructureTargets(root: Record<string, unknown>, carrier: Record<string, unknown>): CompactSharedStructureTarget[];

package/dist/lib/long-task-compact-structure-targets.js

@@ -0,0 +1,91 @@
+const BASE_STRUCTURE_BOUNDARY_BY_FIELD = {
+    path_globs: "contract.path-set",
+    expected_change_paths: "contract.path-set",
+    input_paths: "contract.check.input-paths",
+    verification_inputs: "contract.check.verification-inputs",
+    scenario: "contract.check.scenario",
+    expected_output_paths: "contract.check.output-paths",
+    mutation: "contract.counterfactual.mutation",
+    execution_target: "contract.check.execution-target",
+    artifact_globs: "contract.check.artifact-globs",
+    journey_roles: "contract.check.journey-roles",
+    carrier_paths: "contract.binding.carrier-paths",
+    preserved_assertions: "contract.counterfactual.preserved-assertions",
+    allowed_fanout_assertions: "contract.counterfactual.allowed-fanout-assertions",
+    expected_assertion_failures: "contract.counterfactual.expected-assertion-failures",
+};
+export function longTaskCompactSharedStructureTargets(root, carrier) {
+    const targets = [];
+    for (const [field, boundary] of [
+        ["claim_catalog", "contract.claim"],
+        ["claim_projections", "contract.claim-projection"],
+        ["obligations", "contract.obligation"],
+        ["assertion_projections", "contract.assertion"],
+    ])
+        addCompactTableTargets(targets, carrier[field], boundary);
+    if (Array.isArray(carrier.fact_sets))
+        for (const factSet of carrier.fact_sets)
+            addCompactTableTargets(targets, factSet, "contract.fact");
+    if (Array.isArray(carrier.proof_templates))
+        for (const template of carrier.proof_templates) {
+            const row = plainRecord(template);
+            if (row && Object.hasOwn(row, "binding"))
+                addTarget(targets, row, "binding", "contract.proof.policy");
+        }
+    for (const [key, value] of Object.entries(root)) {
+        if (key === "compact_semantic_carrier")
+            continue;
+        collectBaseTargets(targets, value);
+    }
+    return targets;
+}
+function collectBaseTargets(targets, value) {
+    if (Array.isArray(value)) {
+        value.forEach((item) => collectBaseTargets(targets, item));
+        return;
+    }
+    const row = plainRecord(value);
+    if (!row)
+        return;
+    for (const [key, child] of Object.entries(row)) {
+        const boundary = BASE_STRUCTURE_BOUNDARY_BY_FIELD[key];
+        if (boundary && child && typeof child === "object") {
+            addTarget(targets, row, key, boundary);
+            continue;
+        }
+        collectBaseTargets(targets, child);
+    }
+}
+function addCompactTableTargets(targets, value, boundary) {
+    const table = plainRecord(value);
+    if (!table || !Array.isArray(table.columns) || !Array.isArray(table.rows))
+        return;
+    const columns = table.columns.map(String);
+    const defaults = plainRecord(table.defaults);
+    if (defaults)
+        for (const key of Object.keys(defaults))
+            if (defaults[key] && typeof defaults[key] === "object")
+                addTarget(targets, defaults, key, `${boundary}.default.${key}`);
+    for (const rowValue of table.rows) {
+        if (!Array.isArray(rowValue) || rowValue.length !== columns.length)
+            continue;
+        for (const [index, column] of columns.entries())
+            if (rowValue[index] && typeof rowValue[index] === "object")
+                addTarget(targets, rowValue, index, `${boundary}.${column}`);
+    }
+}
+function addTarget(targets, parent, key, boundary) {
+    const indexed = parent;
+    targets.push({
+        boundary,
+        read: () => indexed[key],
+        write: (value) => {
+            indexed[key] = value;
+        },
+    });
+}
+function plainRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}

package/dist/lib/long-task-conformance-policy.js

@@ -1,3 +1,4 @@
+import { allOutcomeResultsExternallyBlocked } from "./long-task-claims.js";
 export function semanticConformanceRequired(contract, _effectiveRisk) {
     const productFamilies = new Set(contract.task.execution_targets
         .filter((target) => contract.task.target_profile.required_target_refs.includes(target.key))
@@ -8,7 +9,8 @@ export function semanticConformanceRequired(contract, _effectiveRisk) {
 export function validateSemanticConformance(contract, effectiveRisk, compiledChecks, report) {
     const declared = contract.global.acceptance.checks.filter((check) => check.journey_roles.includes("conformance"));
     if (semanticConformanceRequired(contract, effectiveRisk) &&
-        !declared.length) {
+        !declared.length &&
+        !allOutcomeResultsExternallyBlocked(contract)) {
         issue(report, "semantic_conformance_check_required", contract.task.id);
         return;
     }

package/dist/lib/long-task-counterfactual-claim-policy.d.ts

@@ -1,10 +1,9 @@
 import type { CounterfactualControlV2, DeliveryContractV2, DeliveryBindingV2, DeliveryOutcomeV2, GlobalCounterfactualControlV2 } from "./long-task-delivery-types.js";
+import { type ScopedDeliveryBindingV2 } from "./long-task-scoped-binding.js";
 export declare function validateCounterfactualBindingClaims(outcome: DeliveryOutcomeV2, control: CounterfactualControlV2, binding: DeliveryBindingV2): void;
-export declare function resolveGlobalCounterfactualBinding(contract: DeliveryContractV2, control: GlobalCounterfactualControlV2): {
+export declare function resolveGlobalCounterfactualBinding(contract: DeliveryContractV2, control: GlobalCounterfactualControlV2): ScopedDeliveryBindingV2 & {
     outcome: DeliveryOutcomeV2;
-    binding: DeliveryBindingV2;
 };
-export declare function validateGlobalCounterfactualBindingClaims(contract: DeliveryContractV2, control: GlobalCounterfactualControlV2): {
+export declare function validateGlobalCounterfactualBindingClaims(contract: DeliveryContractV2, control: GlobalCounterfactualControlV2): ScopedDeliveryBindingV2 & {
     outcome: DeliveryOutcomeV2;
-    binding: DeliveryBindingV2;
 };

package/dist/lib/long-task-counterfactual-claim-policy.js

@@ -1,3 +1,4 @@
+import { scopeDeliveryBindings, } from "./long-task-scoped-binding.js";
 export function validateCounterfactualBindingClaims(outcome, control, binding) {
     if (binding.verification_check_key &&
         binding.verification_check_key !== control.check_key)
@@ -21,10 +22,10 @@ export function resolveGlobalCounterfactualBinding(contract, control) {
     const outcome = contract.outcomes.find((item) => item.key === outcomeKey);
     if (!outcome)
         throw new Error(`global_counterfactual_binding_ref_invalid:${control.key}:${control.binding_ref}`);
-    const binding = outcome.technical.bindings.find((item) => item.key === bindingKey);
-    if (!binding)
+    const scoped = scopeDeliveryBindings(outcome.key, outcome.technical.bindings).find((item) => item.binding_ref === control.binding_ref && item.local_key === bindingKey);
+    if (!scoped)
         throw new Error(`global_counterfactual_binding_unknown:${control.key}:${control.binding_ref}`);
-    return { outcome, binding };
+    return { outcome, ...scoped };
 }
 export function validateGlobalCounterfactualBindingClaims(contract, control) {
     const resolved = resolveGlobalCounterfactualBinding(contract, control);
@@ -55,10 +56,17 @@ function validateExpectedAssertions(control, check, unknownPrefix) {
         if (!assertions.has(key))
             throw new Error(`${unknownPrefix}:${key}`);
     const failures = new Set(control.expected_assertion_failures);
+    const preserved = new Set(control.preserved_assertions);
     for (const key of control.preserved_assertions) {
         if (!assertions.has(key))
             throw new Error(`${unknownPrefix}:${key}`);
         if (failures.has(key))
             throw new Error(`counterfactual_preserved_assertion_conflict:${unknownPrefix}:${key}`);
     }
+    for (const key of control.allowed_fanout_assertions) {
+        if (!assertions.has(key))
+            throw new Error(`${unknownPrefix}:${key}`);
+        if (failures.has(key) || preserved.has(key))
+            throw new Error(`counterfactual_fanout_assertion_conflict:${unknownPrefix}:${key}`);
+    }
 }

package/dist/lib/long-task-counterfactual-sandbox.d.ts

@@ -8,6 +8,6 @@ type RemoveTree = (target: string, options: {
     force: true;
 }) => Promise<void>;
 type Wait = (milliseconds: number) => Promise<void>;
-export declare function createCounterfactualSandbox(snapshotRoot: string, check: CompiledCheckV2, control: CounterfactualControlV2 | GlobalCounterfactualControlV2, bindingCarrierPaths: string[], manifest?: WorkspaceManifestV2): Promise<CounterfactualSandboxV2>;
+export declare function createCounterfactualSandbox(snapshotRoot: string, check: CompiledCheckV2, control: CounterfactualControlV2 | GlobalCounterfactualControlV2, bindingCarrierPaths: string[], manifest?: WorkspaceManifestV2, protectedAuthorityPaths?: readonly string[]): Promise<CounterfactualSandboxV2>;
 export declare function removeCounterfactualSandboxRoot(root: string, removeTree?: RemoveTree, wait?: Wait): Promise<void>;
 export {};