project-tiny-context-harness 0.8.17 → 0.12.0

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

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

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

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

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

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

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

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

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