project-tiny-context-harness 0.8.11 → 0.8.13

package/dist/lib/long-task-codex-agent-profile.js

@@ -0,0 +1,276 @@
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { parse as parseToml } from "smol-toml";
+import { packageAssetPath } from "./paths.js";
+export const LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH = ".codex/agents/long-task-implementation.toml";
+export const LONG_TASK_CODEX_AGENT_PROFILE_MANAGED_MARKER = "# ty-context:managed:long-task-implementation-worker";
+const ASSET_SEGMENTS = ["agents", "long-task-implementation.toml"];
+const PROFILE_ROOT_FIELDS = new Set([
+    "name",
+    "description",
+    "developer_instructions",
+    "model",
+    "model_reasoning_effort",
+    "agents",
+]);
+const PROFILE_AGENT_FIELDS = new Set(["enabled"]);
+const DEFAULT_FILE_OPERATIONS = {
+    lstat: (target) => fs.lstat(target),
+    realpath: (target) => fs.realpath(target),
+    readFile: (target, encoding) => fs.readFile(target, encoding),
+    mkdir: (target, options) => fs.mkdir(target, options),
+    writeFile: (target, content, options) => fs.writeFile(target, content, options),
+    rename: (source, destination) => fs.rename(source, destination),
+    rm: (target, options) => fs.rm(target, options),
+    randomId: () => randomUUID(),
+};
+export function parseAndValidateLongTaskCodexAgentProfile(content) {
+    const errors = [];
+    const normalized = content.replace(/\r\n/gu, "\n");
+    if (!hasManagedMarker(normalized))
+        errors.push("managed_marker_missing_or_invalid");
+    let decoded;
+    try {
+        decoded = parseToml(normalized);
+    }
+    catch {
+        return { valid: false, errors: [...errors, "toml_invalid"] };
+    }
+    const root = record(decoded);
+    if (!root)
+        return { valid: false, errors: [...errors, "profile_not_table"] };
+    for (const key of Object.keys(root).sort())
+        if (!PROFILE_ROOT_FIELDS.has(key))
+            errors.push(`unsupported_field:${key}`);
+    if (root.name !== "long_task_implementation")
+        errors.push("name_must_be_long_task_implementation");
+    if (!nonEmptyString(root.description))
+        errors.push("description_required");
+    if (!nonEmptyString(root.developer_instructions))
+        errors.push("developer_instructions_required");
+    if (!staticString(root.model))
+        errors.push("model_must_be_static_nonempty");
+    if (!staticString(root.model_reasoning_effort))
+        errors.push("model_reasoning_effort_must_be_static_nonempty");
+    const agents = record(root.agents);
+    if (!agents)
+        errors.push("agents_table_required");
+    else {
+        for (const key of Object.keys(agents).sort())
+            if (!PROFILE_AGENT_FIELDS.has(key))
+                errors.push(`unsupported_agents_field:${key}`);
+        if (agents.enabled !== false)
+            errors.push("agents_enabled_must_be_false");
+    }
+    if (errors.length)
+        return { valid: false, errors };
+    return {
+        valid: true,
+        profile: {
+            name: "long_task_implementation",
+            description: root.description,
+            developer_instructions: root.developer_instructions,
+            model: root.model,
+            model_reasoning_effort: root.model_reasoning_effort,
+            agents: { enabled: false },
+        },
+    };
+}
+export async function syncLongTaskCodexAgentProfile(projectRoot, resolvedHarnessRoot, enabled, report, fileOperations = {}) {
+    if (resolvedHarnessRoot !== ".codex")
+        return;
+    const operations = operationsWith(fileOperations);
+    const asset = await readValidPackageProfile(operations);
+    if (!asset.valid) {
+        report.skipped.push(`${LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH}: optional package asset ${asset.reason}`);
+        return;
+    }
+    const destination = path.join(projectRoot, LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH);
+    if (!enabled) {
+        await removeManagedProfile(projectRoot, destination, report, operations);
+        return;
+    }
+    const inspected = await inspectProfileDestination(projectRoot, destination, operations);
+    if (inspected.kind === "conflict") {
+        report.skipped.push(`${LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH}: optional adapter conflict (${inspected.reason})`);
+        return;
+    }
+    let previous = null;
+    if (inspected.kind === "regular") {
+        previous = await operations.readFile(destination, "utf8");
+        if (!hasManagedMarker(previous)) {
+            report.skipped.push(`${LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH}: user-owned (managed marker absent)`);
+            return;
+        }
+        if (previous === asset.content) {
+            report.skipped.push(LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH);
+            return;
+        }
+    }
+    try {
+        await atomicWriteLongTaskCodexAgentProfile(destination, asset.content, operations, async () => {
+            const current = await inspectProfileDestination(projectRoot, destination, operations);
+            if (previous === null && current.kind !== "absent")
+                throw new Error("destination_changed_before_rename");
+            if (previous !== null) {
+                if (current.kind !== "regular")
+                    throw new Error("destination_changed_before_rename");
+                if ((await operations.readFile(destination, "utf8")) !== previous)
+                    throw new Error("destination_content_changed_before_rename");
+            }
+        });
+        report.changed.push(LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH);
+    }
+    catch (error) {
+        report.skipped.push(`${LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH}: optional adapter write failed (${message(error)})`);
+    }
+}
+export async function longTaskCodexAgentProfileBootstrapPaths(projectRoot, resolvedHarnessRoot, enabled, fileOperations = {}) {
+    if (!enabled || resolvedHarnessRoot !== ".codex")
+        return [];
+    const operations = operationsWith(fileOperations);
+    const asset = await readValidPackageProfile(operations);
+    if (!asset.valid)
+        return [];
+    const destination = path.join(projectRoot, LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH);
+    const inspected = await inspectProfileDestination(projectRoot, destination, operations);
+    if (inspected.kind !== "regular")
+        return [];
+    const existing = await operations.readFile(destination, "utf8");
+    return existing === asset.content &&
+        parseAndValidateLongTaskCodexAgentProfile(existing).valid
+        ? [LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH]
+        : [];
+}
+export function isManagedLongTaskCodexAgentProfile(content) {
+    return parseAndValidateLongTaskCodexAgentProfile(content).valid;
+}
+export async function atomicWriteLongTaskCodexAgentProfile(destination, content, operations = DEFAULT_FILE_OPERATIONS, beforeRename = async () => undefined) {
+    await operations.mkdir(path.dirname(destination), { recursive: true });
+    const temp = `${destination}.tmp-${process.pid}-${operations.randomId()}`;
+    let renamed = false;
+    try {
+        await operations.writeFile(temp, content, { flag: "wx" });
+        await beforeRename();
+        await operations.rename(temp, destination);
+        renamed = true;
+    }
+    finally {
+        if (!renamed)
+            await operations.rm(temp, { force: true }).catch(() => { });
+    }
+}
+async function removeManagedProfile(projectRoot, destination, report, operations) {
+    const inspected = await inspectProfileDestination(projectRoot, destination, operations);
+    if (inspected.kind === "absent")
+        return;
+    if (inspected.kind === "conflict") {
+        report.skipped.push(`${LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH}: optional adapter conflict (${inspected.reason})`);
+        return;
+    }
+    const existing = await operations.readFile(destination, "utf8");
+    if (!hasManagedMarker(existing)) {
+        report.skipped.push(`${LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH}: user-owned (managed marker absent)`);
+        return;
+    }
+    const current = await inspectProfileDestination(projectRoot, destination, operations);
+    if (current.kind !== "regular" ||
+        (await operations.readFile(destination, "utf8")) !== existing) {
+        report.skipped.push(`${LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH}: optional adapter changed before disable`);
+        return;
+    }
+    await operations.rm(destination, { force: true });
+    report.changed.push(LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH);
+}
+async function readValidPackageProfile(operations) {
+    const source = packageAssetPath(...ASSET_SEGMENTS);
+    const sourceStat = await lstatOrNull(source, operations);
+    if (!sourceStat)
+        return { valid: false, reason: "unavailable" };
+    if (sourceStat.isSymbolicLink() || !sourceStat.isFile())
+        return { valid: false, reason: "is not a regular file" };
+    const content = await operations.readFile(source, "utf8");
+    const validation = parseAndValidateLongTaskCodexAgentProfile(content);
+    if (!validation.valid)
+        return {
+            valid: false,
+            reason: `is invalid (${validation.errors.join(",")})`,
+        };
+    return { valid: true, content };
+}
+async function inspectProfileDestination(projectRoot, destination, operations) {
+    const lexicalRoot = path.resolve(projectRoot);
+    const canonicalRoot = await operations.realpath(lexicalRoot);
+    let cursor = lexicalRoot;
+    for (const segment of [".codex", "agents"]) {
+        cursor = path.join(cursor, segment);
+        const status = await lstatOrNull(cursor, operations);
+        if (!status)
+            continue;
+        if (status.isSymbolicLink())
+            return { kind: "conflict", reason: `parent_symlink:${segment}` };
+        if (!status.isDirectory())
+            return { kind: "conflict", reason: `parent_not_directory:${segment}` };
+        if (!inside(canonicalRoot, await operations.realpath(cursor)))
+            return {
+                kind: "conflict",
+                reason: `parent_outside_repository:${segment}`,
+            };
+    }
+    const status = await lstatOrNull(destination, operations);
+    if (!status)
+        return { kind: "absent" };
+    if (status.isSymbolicLink())
+        return { kind: "conflict", reason: "destination_symlink" };
+    if (!status.isFile())
+        return { kind: "conflict", reason: "destination_not_regular_file" };
+    if (!inside(canonicalRoot, await operations.realpath(destination)))
+        return { kind: "conflict", reason: "destination_outside_repository" };
+    return { kind: "regular" };
+}
+function operationsWith(overrides) {
+    return { ...DEFAULT_FILE_OPERATIONS, ...overrides };
+}
+async function lstatOrNull(target, operations) {
+    try {
+        return await operations.lstat(target);
+    }
+    catch (error) {
+        if (code(error) === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+function inside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return (relative === "" ||
+        (!relative.startsWith(`..${path.sep}`) &&
+            relative !== ".." &&
+            !path.isAbsolute(relative)));
+}
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function staticString(value) {
+    return (nonEmptyString(value) &&
+        value === value.trim() &&
+        !/[\r\n$%{}]/u.test(value));
+}
+function hasManagedMarker(content) {
+    return (content.replace(/\r\n/gu, "\n").split("\n", 1)[0] ===
+        LONG_TASK_CODEX_AGENT_PROFILE_MANAGED_MARKER);
+}
+function code(error) {
+    return typeof error === "object" && error !== null && "code" in error
+        ? String(error.code)
+        : "";
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

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}`);
+}