project-tiny-context-harness 0.8.10 → 0.8.12

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

@@ -0,0 +1,12 @@
+import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
+import type { SemanticFactRevisionIdentityV1 } from "./semantic-fact-compact-carrier.js";
+export declare function compactClaimProjection(outcomeRef: string, kind: "requirement" | "obligation" | "forbidden_shortcut" | "non_completing_outcome", row: {
+    key: string;
+    statement: string;
+    applicability_refs: string[];
+    required_proof_surfaces?: string[];
+}, claimsByStatement: Map<string, string>): Record<string, unknown>;
+export declare function compactAssertionProjection(outcomeRef: string, checkRef: string, position: number, assertion: Record<string, unknown>, claimsByStatement: Map<string, string>, facts: Map<string, string>): Record<string, unknown> | null;
+export declare function compactRevisionMap(rows: SemanticFactRevisionIdentityV1[], label: string): Map<string, string>;
+export declare function compactUniqueClaimStatements(claims: DeliveryContractV2["source_claims"]): Map<string, string>;
+export declare function assertSameCompactKeys(left: string[], right: string[], label: string): void;

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

@@ -0,0 +1,67 @@
+import { canonicalValueJson } from "./strict-codec.js";
+import { compactWithoutFields } from "./compact-authoring-support.js";
+export function compactClaimProjection(outcomeRef, kind, row, claimsByStatement) {
+    const claimKey = claimsByStatement.get(row.statement) ?? null;
+    return {
+        outcome_ref: outcomeRef,
+        projection_kind: kind,
+        projection_key: row.key,
+        claim_key: claimKey,
+        statement: claimKey ? null : row.statement,
+        required_proof_surfaces: row.required_proof_surfaces ?? null,
+        applicability_refs: row.applicability_refs,
+    };
+}
+export function compactAssertionProjection(outcomeRef, checkRef, position, assertion, claimsByStatement, facts) {
+    const criterion = String(assertion.criterion ?? "");
+    const claimRef = claimsByStatement.get(criterion);
+    let criterionKind;
+    let criterionRef;
+    if (claimRef) {
+        criterionKind = "claim_statement";
+        criterionRef = claimRef;
+    }
+    else {
+        const match = /^The current candidate satisfies the exact Source Fact (fact\.[a-z0-9._:-]+)\.$/u.exec(criterion);
+        if (!match || !facts.has(match[1]))
+            return null;
+        criterionKind = "semantic_fact";
+        criterionRef = match[1];
+    }
+    return {
+        outcome_ref: outcomeRef,
+        check_ref: checkRef,
+        position,
+        criterion_kind: criterionKind,
+        criterion_ref: criterionRef,
+        ...compactWithoutFields(assertion, ["criterion"]),
+    };
+}
+export function compactRevisionMap(rows, label) {
+    const result = new Map();
+    for (const row of rows) {
+        if (result.has(row.key))
+            throw new Error(`long_task_compact_authoring_invalid:${label}_revision_duplicate:${row.key}`);
+        result.set(row.key, row.revision_digest);
+    }
+    return result;
+}
+export function compactUniqueClaimStatements(claims) {
+    const result = new Map();
+    const duplicates = new Set();
+    for (const claim of claims) {
+        if (result.has(claim.statement)) {
+            result.delete(claim.statement);
+            duplicates.add(claim.statement);
+        }
+        else if (!duplicates.has(claim.statement))
+            result.set(claim.statement, claim.key);
+    }
+    return result;
+}
+export function assertSameCompactKeys(left, right, label) {
+    const a = [...new Set(left)].sort();
+    const b = [...new Set(right)].sort();
+    if (canonicalValueJson(a) !== canonicalValueJson(b))
+        throw new Error(`long_task_compact_authoring_invalid:${label}:${a.length}:${b.length}`);
+}

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

@@ -0,0 +1,3 @@
+import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
+import type { SemanticFactRevisionIdentityV1 } from "./semantic-fact-compact-carrier.js";
+export declare function createLongTaskCompactContract(contractInput: DeliveryContractV2, factRevisions: SemanticFactRevisionIdentityV1[], obligationRevisions: SemanticFactRevisionIdentityV1[]): Record<string, unknown>;

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

@@ -0,0 +1,173 @@
+import { Buffer } from "node:buffer";
+import { applyCompactAuthoringSelectors, compactAuthoringTable, compactCapacityBudget, compactDeterministicTemplates, compactWithoutFields as withoutFields, } from "./compact-authoring-support.js";
+import { applyCompactSharedStructures } from "./compact-shared-structure-authoring.js";
+import { longTaskCompactSharedStructureTargets } from "./long-task-compact-primitives.js";
+import { canonicalValueJson } from "./strict-codec.js";
+import { assertSameCompactKeys as assertSameKeys, compactAssertionProjection as assertionProjection, compactClaimProjection as claimProjection, compactRevisionMap as revisionMap, compactUniqueClaimStatements as uniqueClaimStatements, } from "./long-task-compact-authoring-projections.js";
+export function createLongTaskCompactContract(contractInput, factRevisions, obligationRevisions) {
+    const contract = structuredClone(contractInput);
+    const factRevisionByKey = revisionMap(factRevisions, "fact");
+    const obligationRevisionByKey = revisionMap(obligationRevisions, "obligation");
+    const sourceClaims = structuredClone(contract.source_claims);
+    const revisionedContract = structuredClone(contractInput);
+    for (const outcome of revisionedContract.outcomes) {
+        for (const binding of outcome.semantic_fact_bindings.facts) {
+            const digest = factRevisionByKey.get(binding.fact_ref);
+            if (digest)
+                binding.fact_revision_digest = digest;
+        }
+        for (const binding of outcome.semantic_fact_bindings.proofs) {
+            const digest = obligationRevisionByKey.get(binding.proof_ref);
+            if (digest)
+                binding.obligation_revision_digest = digest;
+        }
+    }
+    const claimByStatement = uniqueClaimStatements(contract.source_claims);
+    const claimProjections = [];
+    const facts = [];
+    const proofBindings = [];
+    const assertionProjections = [];
+    const base = contract;
+    delete base.source_claims;
+    for (const outcome of contract.outcomes) {
+        for (const row of outcome.product.requirements)
+            claimProjections.push(claimProjection(outcome.key, "requirement", row, claimByStatement));
+        for (const row of outcome.technical.obligations)
+            claimProjections.push(claimProjection(outcome.key, "obligation", row, claimByStatement));
+        for (const row of outcome.technical.forbidden_shortcuts)
+            claimProjections.push(claimProjection(outcome.key, "forbidden_shortcut", row, claimByStatement));
+        for (const row of outcome.product.non_completing_outcomes)
+            claimProjections.push(claimProjection(outcome.key, "non_completing_outcome", row, claimByStatement));
+        delete outcome.product.requirements;
+        delete outcome.product
+            .non_completing_outcomes;
+        delete outcome.technical
+            .obligations;
+        delete outcome.technical
+            .forbidden_shortcuts;
+        for (const binding of outcome.semantic_fact_bindings.facts) {
+            const revision = factRevisionByKey.get(binding.fact_ref);
+            if (!revision)
+                throw new Error(`long_task_compact_authoring_invalid:fact_revision_missing:${binding.fact_ref}`);
+            facts.push({
+                outcome_ref: outcome.key,
+                manifest_ref: outcome.semantic_fact_bindings.manifest_ref,
+                fact_key: binding.fact_ref,
+                fact_revision_digest: revision,
+                claim_ref: binding.claim_ref,
+                applicability_ref: binding.applicability_ref,
+            });
+        }
+        for (const binding of outcome.semantic_fact_bindings.proofs) {
+            const revision = obligationRevisionByKey.get(binding.proof_ref);
+            if (!revision)
+                throw new Error(`long_task_compact_authoring_invalid:obligation_revision_missing:${binding.proof_ref}`);
+            proofBindings.push({
+                outcome_ref: outcome.key,
+                obligation_key: binding.proof_ref,
+                obligation_revision_digest: revision,
+                fact_key: binding.fact_ref,
+                ...withoutFields(binding, [
+                    "proof_ref",
+                    "fact_ref",
+                    "obligation_revision_digest",
+                ]),
+            });
+        }
+        delete outcome
+            .semantic_fact_bindings;
+        for (const check of outcome.acceptance.checks) {
+            const retained = [];
+            for (const [position, assertion] of check.positive_assertions.entries()) {
+                const projection = assertionProjection(outcome.key, check.key, position, assertion, claimByStatement, factRevisionByKey);
+                if (projection)
+                    assertionProjections.push(projection);
+                else
+                    retained.push(assertion);
+            }
+            check.positive_assertions = retained;
+        }
+    }
+    assertSameKeys([...factRevisionByKey.keys()], facts.map((fact) => String(fact.fact_key)), "fact_set");
+    assertSameKeys([...obligationRevisionByKey.keys()], proofBindings.map((proof) => String(proof.obligation_key)), "obligation_set");
+    const proofTemplateExcludedFields = [
+        "outcome_ref",
+        "obligation_key",
+        "obligation_revision_digest",
+        "fact_key",
+        "assertion_ref",
+        "confirmation_ref",
+    ];
+    const proofFamilies = compactDeterministicTemplates(proofBindings, proofTemplateExcludedFields, "proof-template");
+    const proofFamilyByKey = new Map(proofFamilies.templates.map((template) => [template.key, template.value]));
+    const obligationRows = proofBindings.map((proof, index) => ({
+        outcome_ref: proof.outcome_ref,
+        obligation_key: proof.obligation_key,
+        obligation_revision_digest: proof.obligation_revision_digest,
+        fact_key: proof.fact_key,
+        template_ref: proofFamilies.template_refs[index],
+        overrides: withoutFields(proof, [
+            "outcome_ref",
+            "obligation_key",
+            "obligation_revision_digest",
+            "fact_key",
+            ...Object.keys(proofFamilyByKey.get(proofFamilies.template_refs[index])),
+        ]),
+    }));
+    const exceptions = claimProjections
+        .filter((row) => canonicalValueJson(row.required_proof_surfaces) !==
+        canonicalValueJson(["runtime_behavior"]) &&
+        row.required_proof_surfaces !== null)
+        .map((row) => ({
+        key: `exception.claim-projection.${row.projection_key}`,
+        target_ref: row.projection_key,
+        rationale: "This projection explicitly retains a non-default required proof-surface set.",
+    }));
+    base.compact_semantic_carrier = {
+        schema_version: "long-task-compact-carrier-v1",
+        capacity: {},
+        selectors: [],
+        shared_structures: [],
+        claim_catalog: compactAuthoringTable(sourceClaims),
+        claim_projections: compactAuthoringTable(claimProjections),
+        fact_sets: [
+            {
+                key: "fact-set.complete-contract",
+                ...compactAuthoringTable(facts),
+            },
+        ],
+        proof_templates: proofFamilies.templates.map((template) => ({
+            key: template.key,
+            binding: template.value,
+        })),
+        obligations: compactAuthoringTable(obligationRows),
+        assertion_projections: compactAuthoringTable(assertionProjections),
+        exceptions,
+    };
+    const { value, selectors } = applyCompactAuthoringSelectors(base);
+    const carrier = value.compact_semantic_carrier;
+    carrier.selectors = selectors;
+    const structures = applyCompactSharedStructures(longTaskCompactSharedStructureTargets(value, carrier));
+    carrier.shared_structures = structures.catalog;
+    const measured = {
+        claims: sourceClaims.length,
+        claim_projections: claimProjections.length,
+        selector_members: selectors.reduce((sum, selector) => sum + selector.members.length, 0),
+        structure_families: structures.statistics.emitted_family_count,
+        structure_references: structures.statistics.reference_count,
+        structure_arguments: structures.statistics.argument_count,
+        facts: facts.length,
+        obligations: obligationRows.length,
+        assertions: assertionProjections.length,
+        canonical_bytes: Buffer.byteLength(canonicalValueJson(revisionedContract), "utf8"),
+    };
+    carrier.capacity = {
+        theoretical_ground_universe: "not_materialized",
+        measured,
+        maximum: Object.fromEntries(Object.entries(measured).map(([name, count]) => [
+            name,
+            compactCapacityBudget(name, count),
+        ])),
+    };
+    return value;
+}

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

@@ -0,0 +1,7 @@
+import { type LongTaskCompactCapacityCounts } from "./long-task-compact-primitives.js";
+export interface MaterializedLongTaskCompactCarrierV1 {
+    root: Record<string, unknown>;
+    measured: LongTaskCompactCapacityCounts;
+}
+export declare function materializeLongTaskCompactCarrier(rootInput: Record<string, unknown>): MaterializedLongTaskCompactCarrierV1;
+export declare function materializeLongTaskCompactCarrierForMigration(rootInput: Record<string, unknown>): MaterializedLongTaskCompactCarrierV1;

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

@@ -0,0 +1,132 @@
+import { Buffer } from "node:buffer";
+import { canonicalValueJson } from "./strict-codec.js";
+import { materializeCanonicalCompactSharedStructures } from "./compact-shared-structure-validation.js";
+import { parseLongTaskCompactCapacity, parseLongTaskCompactExceptions, parseLongTaskCompactFactSets, parseLongTaskCompactProofTemplates, parseLongTaskCompactSelectors, parseLongTaskCompactTable, } from "./long-task-compact-parser.js";
+import { materializeLongTaskCompactAssertions, materializeLongTaskCompactClaimProjections, materializeLongTaskCompactFactBindings, prepareLongTaskCompactOutcomeTargets, } from "./long-task-compact-projections.js";
+import { compactArray, compactFail, compactPlainObject, compactResolveSelectors, compactStableRef, compactStrictObject, compactUniqueRows, longTaskCompactSharedStructureTargets, validateLongTaskCompactCapacity, validateLongTaskCompactDeclaredMaximum, } from "./long-task-compact-primitives.js";
+const VERSION = "long-task-compact-carrier-v1";
+export function materializeLongTaskCompactCarrier(rootInput) {
+    return materializeLongTaskCompactCarrierInternal(rootInput, false);
+}
+export function materializeLongTaskCompactCarrierForMigration(rootInput) {
+    return materializeLongTaskCompactCarrierInternal(rootInput, true);
+}
+function materializeLongTaskCompactCarrierInternal(rootInput, allowLegacyCarrier) {
+    const label = "compact_semantic_carrier";
+    if (!Object.hasOwn(rootInput, label))
+        compactFail(label, "missing carrier");
+    if (Object.hasOwn(rootInput, "source_claims"))
+        compactFail(label, "expanded source_claims cannot coexist with compact carrier");
+    if (!Object.hasOwn(rootInput, "outcomes"))
+        compactFail(label, "v1 compact carrier requires inline outcomes");
+    const working = structuredClone(rootInput);
+    const carrierInput = compactPlainObject(working[label], label);
+    const hadSharedStructures = Object.hasOwn(carrierInput, "shared_structures");
+    if (!hadSharedStructures) {
+        if (!allowLegacyCarrier)
+            compactFail(`${label}.shared_structures`, "missing canonical catalog");
+        carrierInput.shared_structures = [];
+        addLegacyStructureCapacityFields(carrierInput.capacity);
+    }
+    const carrier = compactStrictObject(carrierInput, label, [
+        "schema_version",
+        "capacity",
+        "selectors",
+        "shared_structures",
+        "claim_catalog",
+        "claim_projections",
+        "fact_sets",
+        "proof_templates",
+        "obligations",
+        "assertion_projections",
+        "exceptions",
+    ]);
+    if (carrier.schema_version !== VERSION)
+        compactFail(`${label}.schema_version`, `must be ${VERSION}`);
+    const capacity = parseLongTaskCompactCapacity(carrier.capacity, `${label}.capacity`);
+    validateLongTaskCompactDeclaredMaximum(capacity.maximum, label);
+    const structureStatistics = hadSharedStructures
+        ? materializeCanonicalCompactSharedStructures(longTaskCompactSharedStructureTargets(working, carrier), carrier.shared_structures, label)
+        : {
+            emitted_family_count: 0,
+            reference_count: 0,
+            argument_count: 0,
+        };
+    const selectors = parseLongTaskCompactSelectors(carrier.selectors, `${label}.selectors`);
+    const claims = parseLongTaskCompactTable(carrier.claim_catalog, selectors, `${label}.claim_catalog`);
+    compactUniqueRows(claims, "key", `${label}.claim_catalog`);
+    const claimByKey = new Map(claims.map((claim) => [
+        compactStableRef(claim.key, `${label}.claim.key`),
+        claim,
+    ]));
+    const claimProjections = parseLongTaskCompactTable(carrier.claim_projections, selectors, `${label}.claim_projections`);
+    const facts = parseLongTaskCompactFactSets(carrier.fact_sets, selectors, `${label}.fact_sets`);
+    compactUniqueRows(facts, "fact_key", `${label}.facts`);
+    const factByKey = new Map(facts.map((fact) => [
+        compactStableRef(fact.fact_key, `${label}.fact.fact_key`),
+        fact,
+    ]));
+    const proofTemplates = parseLongTaskCompactProofTemplates(carrier.proof_templates, selectors, `${label}.proof_templates`);
+    const obligations = parseLongTaskCompactTable(carrier.obligations, selectors, `${label}.obligations`);
+    compactUniqueRows(obligations, "obligation_key", `${label}.obligations`);
+    const assertions = parseLongTaskCompactTable(carrier.assertion_projections, selectors, `${label}.assertion_projections`);
+    const exceptions = parseLongTaskCompactExceptions(carrier.exceptions, `${label}.exceptions`);
+    validateCompactProjectionExceptions(claimProjections, exceptions, `${label}.exceptions`);
+    const { compact_semantic_carrier: _carrier, ...base } = working;
+    const expanded = compactPlainObject(compactResolveSelectors(structuredClone(base), selectors, "$"), "$");
+    expanded.source_claims = claims;
+    const outcomes = compactArray(expanded.outcomes, "outcomes").map((item, index) => compactPlainObject(item, `outcomes[${index}]`));
+    const outcomeByKey = new Map(outcomes.map((outcome, index) => [
+        compactStableRef(outcome.key, `outcomes[${index}].key`),
+        outcome,
+    ]));
+    prepareLongTaskCompactOutcomeTargets(outcomes);
+    materializeLongTaskCompactClaimProjections(claimProjections, claimByKey, outcomeByKey);
+    materializeLongTaskCompactFactBindings(facts, obligations, factByKey, proofTemplates, outcomeByKey);
+    materializeLongTaskCompactAssertions(assertions, claimByKey, factByKey, outcomeByKey);
+    expanded.outcomes = outcomes;
+    const measured = {
+        claims: claims.length,
+        claim_projections: claimProjections.length,
+        selector_members: [...selectors.values()].reduce((sum, members) => sum + members.length, 0),
+        structure_families: structureStatistics.emitted_family_count,
+        structure_references: structureStatistics.reference_count,
+        structure_arguments: structureStatistics.argument_count,
+        facts: facts.length,
+        obligations: obligations.length,
+        assertions: assertions.length,
+        canonical_bytes: Buffer.byteLength(canonicalValueJson(expanded), "utf8"),
+    };
+    validateLongTaskCompactCapacity(capacity, measured, label);
+    return { root: expanded, measured };
+}
+function addLegacyStructureCapacityFields(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return;
+    const capacity = value;
+    for (const field of ["measured", "maximum"]) {
+        const counts = capacity[field];
+        if (!counts || typeof counts !== "object" || Array.isArray(counts))
+            continue;
+        const row = counts;
+        row.structure_families = 0;
+        row.structure_references = 0;
+        row.structure_arguments = 0;
+    }
+}
+function validateCompactProjectionExceptions(projections, exceptions, label) {
+    const expected = projections
+        .filter((projection) => {
+        const surfaces = projection.required_proof_surfaces;
+        return (surfaces !== null &&
+            (!Array.isArray(surfaces) ||
+                surfaces.length !== 1 ||
+                surfaces[0] !== "runtime_behavior"));
+    })
+        .map((projection, index) => compactStableRef(projection.projection_key, `${label}.projection[${index}].projection_key`))
+        .sort();
+    const actual = exceptions.map((item) => item.target_ref).sort();
+    if (new Set(actual).size !== actual.length ||
+        canonicalValueJson(expected) !== canonicalValueJson(actual))
+        compactFail(label, `projection target set mismatch: ${actual.length}:${expected.length}`);
+}

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;