project-tiny-context-harness 0.8.10 → 0.8.12

package/dist/commands/design-resource.js

@@ -27,8 +27,15 @@ export async function designResource(args) {
     console.log(`Design resource handoff ready: ${result.handoff_path}`);
     console.log(`Scope: ${result.handoff.scope.key}`);
     console.log(`Targets: ${result.handoff.targets.map((item) => item.key).join(", ")}`);
-    console.log(`Coverage: ${result.counts.subjects} subjects x 8 dimensions (${result.counts.coverage} grouped rows)`);
-    console.log(`Acceptance blockers: ${result.counts.acceptance_blockers}`);
+    if ("metrics" in result) {
+        console.log(`Coverage: ${result.manifest.subjects.length} subjects x ${result.manifest.properties.length} atomic properties (${result.rule_projections.length} symbolic Rules)`);
+        console.log(`Symbolic: ${result.metrics.semantic_obligations} semantic obligations, ${result.metrics.certificate_obligations} certificates, ${result.metrics.canonical_dag_nodes} DAG nodes, ${result.metrics.canonical_bytes} bytes`);
+        console.log(`Acceptance blockers: ${result.manifest.acceptance_blockers.length}`);
+    }
+    else {
+        console.log(`Coverage: ${result.counts.subjects} subjects x 8 dimensions (${result.counts.coverage} grouped rows)`);
+        console.log(`Acceptance blockers: ${result.counts.acceptance_blockers}`);
+    }
 }
 async function bundle(args) {
     const positional = [];

package/dist/commands/enable.js

@@ -9,6 +9,8 @@ export async function enable(args) {
     const sync = await runSync(root);
     console.log(`${result.changed ? "enabled" : "kept enabled"} profile ${profile}`);
     console.log(`sync changed=${sync.changed.length} skipped=${sync.skipped.length} blocked=${sync.blocked.length}`);
+    for (const notice of sync.notices ?? [])
+        console.log(notice);
     if (sync.blocked.length)
         throw new Error(sync.blocked.join("\n"));
 }

package/dist/commands/index.js

@@ -39,7 +39,7 @@ export function help() {
     console.log(`ty-context commands:
   init [--adopt] [--harness-folder <path>]
                        Initialize/adopt a project; without --harness-folder, choose target agent first
-  enable long-task     Install Long-Task Skill, Source Plan pointer, Stop Hook and templates
+  enable long-task     Install Long-Task Skill, lifecycle Hooks, templates and optional Codex worker
   disable long-task    Remove only package-owned long-task profile assets
   sync                 Refresh managed assets; does not run migrations
   upgrade [--check] [--json]

package/dist/commands/long-task-revision.js

@@ -90,7 +90,7 @@ function printCompileResult(compiled, previous, preserveProgress, revisionPropos
             ? projectAuthorityRevisionDecision(revisionProposal)
             : null,
         next_action: firstAuthorityLock
-            ? "End this turn now and ask the user to choose continue_current_model or switch_model_then_resume. Do not implement, edit files, build, or test until an explicit task-specific model strategy is received; generic continue or resume language does not satisfy this checkpoint."
+            ? "End this turn now. Do not implement, edit files, build, or test. After the user handles the model change in the host, wait for [continue]. Harness cannot observe or verify the model change."
             : authorityChanged
                 ? "Run status or resume, then continue rolling implementation or repair under the adopted Authority Revision."
                 : "Continue rolling implementation or repair under the active Authority.",
@@ -157,18 +157,19 @@ function executionModelCheckpoint(firstAuthorityLock) {
     return {
         required: true,
         phase: "post_authority_lock_pre_implementation",
-        options: ["continue_current_model", "switch_model_then_resume"],
+        action: "change_model_in_host_then_continue",
+        resume_token: "continue",
         turn_boundary: "end_current_turn",
-        blocked_until_explicit_choice: [
+        blocked_until_resume: [
             "product_implementation",
             "file_edits",
             "build",
             "test_execution",
         ],
-        explicit_task_specific_choice_required: true,
-        prior_explicit_task_specific_choice_satisfies: true,
-        generic_continue_satisfies: false,
-        message: "Authority Lock created. End the current turn before product implementation, file edits, builds, or tests. Ask the user to explicitly choose continue_current_model or switch_model_then_resume. Generic continue, resume, finish, or continue-goal language does not satisfy this checkpoint.",
+        model_change_owner: "host_or_user",
+        model_change_observable_by_harness: false,
+        generic_continue_satisfies: true,
+        message: "Authority Lock created. End the current turn before product implementation, file edits, builds, or tests. After handling the model change, send [continue]. Harness cannot observe or verify the model change.",
     };
 }
 function message(error) {

package/dist/commands/sync.js

@@ -5,6 +5,8 @@ export async function sync() {
     for (const skipped of report.skipped.filter((line) => line.includes("customized"))) {
         console.log(`skipped: ${skipped}`);
     }
+    for (const notice of report.notices ?? [])
+        console.log(notice);
     for (const blocked of report.blocked) {
         console.error(`blocked: ${blocked}`);
     }

package/dist/index.d.ts

@@ -2,13 +2,12 @@ export { commands } from "./commands/index.js";
 export { compileDeliveryContract, type CompileDeliveryOptionsV2, } from "./lib/long-task-delivery-compiler.js";
 export { DELIVERY_CONTRACT_FILE, parseDeliveryContract, parseDeliveryContractBundle, } from "./lib/long-task-delivery-parser.js";
 export { evaluateContractBoundary } from "./lib/long-task-boundary-check.js";
-export { publishDesignResourceHandoffBundle, type DesignResourceHandoffBundleOptions, type DesignResourceHandoffBundleResult, } from "./lib/design-resource-handoff-bundle.js";
+export { publishDesignResourceHandoffBundle } from "./lib/design-resource-handoff-bundle.js";
 export { preflightDesignResourceHandoff } from "./lib/design-resource-handoff-validation.js";
+export { symbolicDenotation } from "./lib/symbolic-denotation-public.js";
 export { classifyLongTaskRisk, validateRiskProof, } from "./lib/long-task-risk.js";
 export { verifyDeliveryContract } from "./lib/long-task-verifier-v2.js";
 export { runDeliveryFinalGate } from "./lib/long-task-final-v2.js";
 export { closeDeliveryTask, type DeliveryStatusV2, doctorDeliveryTask, readDeliveryStatus, resumeDeliveryTask, stopCheckDeliveryTask, } from "./lib/long-task-status-v2.js";
 export { readActiveLongTaskBinding, readCompiledDeliveryContract, readFinalReceipt, } from "./lib/long-task-state.js";
-export type { HarnessConfig, HarnessProfile, ManagedFile, SourceMapping, } from "./lib/types.js";
-export type { CheckExecutionResultV2, CompiledDeliveryContractV2, DeliveryAssertionV2, DeliveryCheckV2, DeliveryContractV2, DeliveryOutcomeV2, EffectiveRiskLevel, ExternalConfirmationV2, FinalReceiptV2, LongTaskFindingV2, LongTaskRiskFacts, ProofSurface, ProgressRecordV2, RequestedRiskLevel, RunnerType, SourceClaimV2, TargetedVerificationResultV2, } from "./lib/long-task-delivery-types.js";
-export type { BoundaryCheckDecisionV2, BoundaryCheckInputV2, } from "./lib/long-task-boundary-check.js";
+export type { BoundaryCheckDecisionV2, BoundaryCheckInputV2, CheckExecutionResultV2, CompiledDeliveryContractV2, DesignResourceHandoffBundleOptions, DesignResourceHandoffBundleResult, DesignResourceHandoffPreflightV1, DesignResourceHandoffPreflightV2, DesignResourceHandoffV1, DesignResourceHandoffV2, DesignResourceObservableRuleManifestV2, DesignResourceSymbolicFactRuleV2, DesignResourceSymbolicNoninterferenceArtifactV2, DesignResourceSymbolicNoninterferenceCertificateV2, DesignResourceSymbolicNoninterferenceDerivedResultV2, DesignResourceSymbolicNoninterferenceFailureWitnessV1, DesignResourceSymbolicNoninterferenceInputBindingV2, DesignResourceSymbolicNoninterferenceProofV2, DesignResourceSymbolicProofObligationV2, DesignResourceSymbolicSourceIrCertificateScopeV1, DesignResourceSymbolicSourceIrRegionV1, DesignResourceSymbolicSourceIrV1, CompiledSymbolicDenotationV1, SymbolicDenotationAxisDomain, SymbolicDenotationComplexityLimits, SymbolicDenotationPredicate, SymbolicExtensionalPointV1, SymbolicPointDenotationV1, DeliveryAssertionV2, DeliveryCheckV2, DeliveryContractV2, DeliveryOutcomeV2, EffectiveRiskLevel, ExternalConfirmationV2, FinalReceiptV2, LongTaskFindingV2, LongTaskRiskFacts, ProofSurface, ProgressRecordV2, RequestedRiskLevel, RunnerType, SourceClaimV2, TargetedVerificationResultV2, HarnessConfig, HarnessProfile, ManagedFile, SourceMapping, } from "./public-types.js";

package/dist/index.js

@@ -2,8 +2,9 @@ export { commands } from "./commands/index.js";
 export { compileDeliveryContract, } from "./lib/long-task-delivery-compiler.js";
 export { DELIVERY_CONTRACT_FILE, parseDeliveryContract, parseDeliveryContractBundle, } from "./lib/long-task-delivery-parser.js";
 export { evaluateContractBoundary } from "./lib/long-task-boundary-check.js";
-export { publishDesignResourceHandoffBundle, } from "./lib/design-resource-handoff-bundle.js";
+export { publishDesignResourceHandoffBundle } from "./lib/design-resource-handoff-bundle.js";
 export { preflightDesignResourceHandoff } from "./lib/design-resource-handoff-validation.js";
+export { symbolicDenotation } from "./lib/symbolic-denotation-public.js";
 export { classifyLongTaskRisk, validateRiskProof, } from "./lib/long-task-risk.js";
 export { verifyDeliveryContract } from "./lib/long-task-verifier-v2.js";
 export { runDeliveryFinalGate } from "./lib/long-task-final-v2.js";

package/dist/lib/compact-authoring-support.d.ts

@@ -0,0 +1,22 @@
+export declare function compactCommonFields<T extends Record<string, unknown>>(rows: T[], excluded: string[]): Record<string, unknown>;
+export declare function compactWithoutFields<T extends Record<string, unknown>>(value: T, fields: string[]): Record<string, unknown>;
+export declare function compactAuthoringTable<T extends object>(input: T[], excludedDefaults?: string[]): {
+    defaults: Record<string, unknown>;
+    columns: string[];
+    rows: unknown[][];
+};
+export declare function applyCompactAuthoringSelectors(base: Record<string, unknown>): {
+    value: Record<string, unknown>;
+    selectors: Array<{
+        key: string;
+        members: string[];
+    }>;
+};
+export declare function compactCapacityBudget(name: string, measured: number): number;
+export declare function compactDeterministicTemplates(records: Record<string, unknown>[], excludedFields: string[], keyPrefix: string): {
+    templates: Array<{
+        key: string;
+        value: Record<string, unknown>;
+    }>;
+    template_refs: string[];
+};

package/dist/lib/compact-authoring-support.js

@@ -0,0 +1,143 @@
+import { Buffer } from "node:buffer";
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+const STABLE_REF = /^[a-z0-9][a-z0-9._:-]*$/u;
+export function compactCommonFields(rows, excluded) {
+    if (!rows.length)
+        return {};
+    const result = {};
+    for (const key of Object.keys(rows[0])) {
+        if (excluded.includes(key))
+            continue;
+        const identity = canonicalValueJson(rows[0][key]);
+        if (rows.every((row) => Object.hasOwn(row, key) && canonicalValueJson(row[key]) === identity))
+            result[key] = structuredClone(rows[0][key]);
+    }
+    return result;
+}
+export function compactWithoutFields(value, fields) {
+    const excluded = new Set(fields);
+    return Object.fromEntries(Object.entries(value)
+        .filter(([key]) => !excluded.has(key))
+        .map(([key, item]) => [key, structuredClone(item)]));
+}
+export function compactAuthoringTable(input, excludedDefaults = []) {
+    const records = input;
+    const defaults = compactCommonFields(records, excludedDefaults);
+    const columns = [
+        ...new Set(records.flatMap((record) => Object.keys(record))),
+    ].filter((key) => !Object.hasOwn(defaults, key));
+    return {
+        defaults,
+        columns,
+        rows: records.map((record, rowIndex) => columns.map((column) => {
+            if (!Object.hasOwn(record, column))
+                throw new Error(`compact_authoring_sparse_cell:${rowIndex}:${column}`);
+            return structuredClone(record[column]);
+        })),
+    };
+}
+export function applyCompactAuthoringSelectors(base) {
+    const selectorCounts = countSelectorCandidates(base);
+    const selectorMap = new Map();
+    const value = replaceSharedSelectors(base, selectorCounts, selectorMap);
+    return {
+        value,
+        selectors: [...selectorMap.entries()]
+            .map(([key, members]) => ({ key, members }))
+            .sort((left, right) => left.key.localeCompare(right.key)),
+    };
+}
+function selectorCandidate(value) {
+    return Array.isArray(value) &&
+        value.length > 0 &&
+        value.every((item) => typeof item === "string" && STABLE_REF.test(item))
+        ? value
+        : null;
+}
+function countSelectorCandidates(value) {
+    const counts = new Map();
+    const visit = (item, parentKey = "") => {
+        if (parentKey === "columns" || parentKey === "selectors")
+            return;
+        if (parentKey === "rows" && Array.isArray(item)) {
+            for (const row of item)
+                visit(row, "table_row");
+            return;
+        }
+        if (parentKey === "table_row" && Array.isArray(item)) {
+            for (const cell of item)
+                visit(cell);
+            return;
+        }
+        const candidate = selectorCandidate(item);
+        if (candidate) {
+            const identity = canonicalValueJson(candidate);
+            counts.set(identity, (counts.get(identity) ?? 0) + 1);
+            return;
+        }
+        if (Array.isArray(item))
+            for (const child of item)
+                visit(child, parentKey);
+        else if (item && typeof item === "object")
+            for (const [key, child] of Object.entries(item))
+                visit(child, key);
+    };
+    visit(value);
+    return counts;
+}
+function replaceSharedSelectors(value, counts, selectors) {
+    const replace = (item, parentKey = "") => {
+        if (parentKey === "columns" || parentKey === "selectors")
+            return structuredClone(item);
+        if (parentKey === "rows" && Array.isArray(item))
+            return item.map((row) => replace(row, "table_row"));
+        if (parentKey === "table_row" && Array.isArray(item))
+            return item.map((cell) => replace(cell));
+        const candidate = selectorCandidate(item);
+        if (candidate) {
+            const identity = canonicalValueJson(candidate);
+            const count = counts.get(identity) ?? 0;
+            const selectorKey = `selector.refs.${sha256Hex(identity).slice(0, 16)}`;
+            const referenceBytes = Buffer.byteLength(canonicalValueJson({ selector_ref: selectorKey }), "utf8");
+            const listBytes = Buffer.byteLength(identity, "utf8");
+            if (count > 1 && (count - 1) * listBytes > count * referenceBytes) {
+                selectors.set(selectorKey, [...candidate]);
+                return { selector_ref: selectorKey };
+            }
+            return [...candidate];
+        }
+        if (Array.isArray(item))
+            return item.map((child) => replace(child, parentKey));
+        if (item && typeof item === "object")
+            return Object.fromEntries(Object.entries(item).map(([key, child]) => [key, replace(child, key)]));
+        return item;
+    };
+    return replace(value);
+}
+export function compactCapacityBudget(name, measured) {
+    if (name === "canonical_bytes")
+        return Math.max(1024 * 1024, roundPowerOfTwo(measured));
+    return Math.max(16, roundPowerOfTwo(measured));
+}
+export function compactDeterministicTemplates(records, excludedFields, keyPrefix) {
+    const templateByIdentity = new Map();
+    const templateRefs = records.map((record) => {
+        const value = compactWithoutFields(record, excludedFields);
+        const identity = canonicalValueJson(value);
+        const current = templateByIdentity.get(identity);
+        if (current)
+            return current.key;
+        const key = `${keyPrefix}.${sha256Hex(identity).slice(0, 20)}`;
+        templateByIdentity.set(identity, { key, value });
+        return key;
+    });
+    return {
+        templates: [...templateByIdentity.values()].sort((left, right) => left.key.localeCompare(right.key)),
+        template_refs: templateRefs,
+    };
+}
+function roundPowerOfTwo(value) {
+    if (value <= 1)
+        return 1;
+    return 2 ** Math.ceil(Math.log2(value));
+}

package/dist/lib/compact-shared-structure-authoring.d.ts

@@ -0,0 +1,5 @@
+import type { CompactSharedStructureStatistics, CompactSharedStructureTarget, CompactSharedStructureTemplate } from "./compact-shared-structure-types.js";
+export declare function applyCompactSharedStructures(targets: CompactSharedStructureTarget[]): {
+    catalog: CompactSharedStructureTemplate[];
+    statistics: CompactSharedStructureStatistics;
+};

package/dist/lib/compact-shared-structure-authoring.js

@@ -0,0 +1,9 @@
+import { createCompactSharedStructures } from "./compact-shared-structures.js";
+export function applyCompactSharedStructures(targets) {
+    const encoded = createCompactSharedStructures(targets.map((target) => ({
+        boundary: target.boundary,
+        value: target.read(),
+    })));
+    encoded.slots.forEach((slot, index) => targets[index].write(slot.value));
+    return { catalog: encoded.catalog, statistics: encoded.statistics };
+}

package/dist/lib/compact-shared-structure-types.d.ts

@@ -0,0 +1,61 @@
+export interface CompactSharedStructureSlot {
+    boundary: string;
+    value: unknown;
+}
+export interface CompactSharedStructureTarget {
+    boundary: string;
+    read: () => unknown;
+    write: (value: unknown) => void;
+}
+export interface CompactSharedStructureTemplate {
+    key: string;
+    digest: string;
+    boundary: string;
+    parameter_count: number;
+    template: unknown;
+}
+export interface CompactSharedStructureFamilyStatistic {
+    key: string;
+    boundary: string;
+    occurrences: number;
+    parameter_count: number;
+    original_bytes: number;
+    encoded_bytes: number;
+    saved_bytes: number;
+}
+export interface CompactSharedStructureStatistics {
+    slot_count: number;
+    composite_slot_count: number;
+    candidate_family_count: number;
+    emitted_family_count: number;
+    exact_family_count: number;
+    parameterized_family_count: number;
+    reference_count: number;
+    argument_count: number;
+    original_payload_bytes: number;
+    encoded_payload_bytes: number;
+    catalog_bytes: number;
+    saved_bytes: number;
+    remaining_beneficial_candidates: number;
+    families: CompactSharedStructureFamilyStatistic[];
+}
+export interface CompactSharedStructureEncoding {
+    slots: CompactSharedStructureSlot[];
+    catalog: CompactSharedStructureTemplate[];
+    statistics: CompactSharedStructureStatistics;
+}
+export interface CompactSharedStructureCandidateOccurrence {
+    slot_index: number;
+    value: unknown;
+    leaves: unknown[];
+    original_bytes: number;
+}
+export interface CompactSharedStructureCandidateFamily {
+    boundary: string;
+    occurrences: CompactSharedStructureCandidateOccurrence[];
+    parameter_positions: number[];
+    template: unknown;
+    row: CompactSharedStructureTemplate;
+    references: unknown[];
+    statistic: CompactSharedStructureFamilyStatistic;
+}

package/dist/lib/compact-shared-structure-types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/compact-shared-structure-validation.d.ts

@@ -0,0 +1,2 @@
+import type { CompactSharedStructureStatistics, CompactSharedStructureTarget } from "./compact-shared-structure-types.js";
+export declare function materializeCanonicalCompactSharedStructures(targets: CompactSharedStructureTarget[], catalogInput: unknown, label: string): CompactSharedStructureStatistics;

package/dist/lib/compact-shared-structure-validation.js

@@ -0,0 +1,159 @@
+import { createCompactSharedStructures } from "./compact-shared-structures.js";
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+const STABLE_BOUNDARY = /^[a-z0-9][a-z0-9._:-]*$/u;
+const STRUCTURE_KEY = /^structure\.[a-f0-9]{24}$/u;
+export function materializeCanonicalCompactSharedStructures(targets, catalogInput, label) {
+    const catalog = parseCatalog(catalogInput, `${label}.shared_structures`);
+    const encodedSlots = targets.map((target, index) => ({
+        boundary: validBoundary(target.boundary, `${label}.slots[${index}]`),
+        value: structuredClone(target.read()),
+    }));
+    const catalogByKey = new Map(catalog.map((item) => [item.key, item]));
+    const materializedSlots = encodedSlots.map((slot, index) => ({
+        boundary: slot.boundary,
+        value: resolveReference(slot.value, slot.boundary, catalogByKey, `${label}.slots[${index}]`),
+    }));
+    const canonical = createCompactSharedStructures(materializedSlots);
+    if (canonicalValueJson(canonical.catalog) !== canonicalValueJson(catalog) ||
+        canonicalValueJson(canonical.slots) !== canonicalValueJson(encodedSlots))
+        fail(label, "shared structure catalog is not canonical");
+    materializedSlots.forEach((slot, index) => targets[index].write(slot.value));
+    return canonical.statistics;
+}
+function parseCatalog(value, label) {
+    if (!Array.isArray(value))
+        fail(label, "must be an array");
+    const seen = new Set();
+    return value.map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            fail(itemLabel, "must be an object");
+        const row = item;
+        const fields = ["key", "digest", "boundary", "parameter_count", "template"];
+        const unknown = Object.keys(row).filter((key) => !fields.includes(key));
+        const missing = fields.filter((key) => !Object.hasOwn(row, key));
+        if (unknown.length)
+            fail(itemLabel, `unknown keys: ${unknown.join(",")}`);
+        if (missing.length)
+            fail(itemLabel, `missing keys: ${missing.join(",")}`);
+        if (typeof row.key !== "string" || !STRUCTURE_KEY.test(row.key))
+            fail(`${itemLabel}.key`, "must be a canonical structure key");
+        if (seen.has(row.key))
+            fail(itemLabel, `duplicate key: ${row.key}`);
+        seen.add(row.key);
+        if (typeof row.digest !== "string" || !/^[a-f0-9]{64}$/u.test(row.digest))
+            fail(`${itemLabel}.digest`, "must be a lowercase SHA-256");
+        const boundary = validBoundary(row.boundary, `${itemLabel}.boundary`);
+        if (!Number.isInteger(row.parameter_count) ||
+            Number(row.parameter_count) < 0)
+            fail(`${itemLabel}.parameter_count`, "must be an integer >= 0");
+        const parameterCount = Number(row.parameter_count);
+        const used = validateTemplate(row.template, parameterCount, itemLabel);
+        for (let parameter = 0; parameter < parameterCount; parameter += 1)
+            if (!used.has(parameter))
+                fail(`${itemLabel}.template`, `unused parameter: ${parameter}`);
+        const digest = sha256Hex(canonicalValueJson({
+            boundary,
+            parameter_count: parameterCount,
+            template: row.template,
+        }));
+        if (row.digest !== digest)
+            fail(`${itemLabel}.digest`, `digest mismatch: ${row.digest}:${digest}`);
+        if (row.key !== `structure.${digest.slice(0, 24)}`)
+            fail(`${itemLabel}.key`, "key does not match digest");
+        return {
+            key: row.key,
+            digest,
+            boundary,
+            parameter_count: parameterCount,
+            template: structuredClone(row.template),
+        };
+    });
+}
+function validateTemplate(value, parameterCount, label) {
+    const used = new Set();
+    const visit = (item, path) => {
+        if (Array.isArray(item)) {
+            item.forEach((child, index) => visit(child, `${path}[${index}]`));
+            return;
+        }
+        if (!item || typeof item !== "object") {
+            leafKind(item);
+            return;
+        }
+        const row = item;
+        if (Object.hasOwn(row, "structure_ref"))
+            fail(path, "templates cannot contain structure references");
+        if (Object.hasOwn(row, "parameter_index")) {
+            if (Object.keys(row).length !== 1 ||
+                !Number.isInteger(row.parameter_index) ||
+                Number(row.parameter_index) < 0 ||
+                Number(row.parameter_index) >= parameterCount)
+                fail(path, "invalid parameter placeholder");
+            used.add(Number(row.parameter_index));
+            return;
+        }
+        for (const [key, child] of Object.entries(row))
+            visit(child, `${path}.${key}`);
+    };
+    visit(value, `${label}.template`);
+    return used;
+}
+function resolveReference(value, boundary, catalog, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return structuredClone(value);
+    const row = value;
+    if (!Object.hasOwn(row, "structure_ref"))
+        return structuredClone(value);
+    if (Object.keys(row).length !== 2 ||
+        !Object.hasOwn(row, "arguments") ||
+        typeof row.structure_ref !== "string")
+        fail(label, "structure reference must contain only structure_ref/arguments");
+    const template = catalog.get(row.structure_ref);
+    if (!template)
+        fail(label, `unknown structure: ${String(row.structure_ref)}`);
+    if (template.boundary !== boundary)
+        fail(label, `structure boundary mismatch: ${template.boundary}:${boundary}`);
+    if (!Array.isArray(row.arguments))
+        fail(`${label}.arguments`, "must be an array");
+    if (row.arguments.length !== template.parameter_count)
+        fail(`${label}.arguments`, `parameter count mismatch: ${row.arguments.length}:${template.parameter_count}`);
+    row.arguments.forEach((argument, index) => {
+        if (argument && typeof argument === "object")
+            fail(`${label}.arguments[${index}]`, "arguments must be scalar");
+        leafKind(argument);
+    });
+    return instantiateTemplate(template.template, row.arguments);
+}
+function instantiateTemplate(template, arguments_) {
+    if (Array.isArray(template))
+        return template.map((item) => instantiateTemplate(item, arguments_));
+    if (!template || typeof template !== "object")
+        return structuredClone(template);
+    const row = template;
+    if (Object.keys(row).length === 1 && Object.hasOwn(row, "parameter_index"))
+        return structuredClone(arguments_[Number(row.parameter_index)]);
+    return Object.fromEntries(Object.entries(row).map(([key, value]) => [
+        key,
+        instantiateTemplate(value, arguments_),
+    ]));
+}
+function leafKind(value) {
+    if (value === null)
+        return "null";
+    if (typeof value === "string")
+        return "string";
+    if (typeof value === "boolean")
+        return "boolean";
+    if (typeof value === "number" && Number.isFinite(value))
+        return "number";
+    fail("value", `unsupported scalar: ${typeof value}`);
+}
+function validBoundary(value, label) {
+    if (typeof value !== "string" || !STABLE_BOUNDARY.test(value))
+        fail(label, "must be a stable lowercase boundary");
+    return value;
+}
+function fail(label, message) {
+    throw new Error(`compact_shared_structure_invalid:${label}:${message}`);
+}

package/dist/lib/compact-shared-structures.d.ts

@@ -0,0 +1,3 @@
+import type { CompactSharedStructureEncoding, CompactSharedStructureSlot } from "./compact-shared-structure-types.js";
+export type { CompactSharedStructureEncoding, CompactSharedStructureFamilyStatistic, CompactSharedStructureSlot, CompactSharedStructureStatistics, CompactSharedStructureTarget, CompactSharedStructureTemplate, } from "./compact-shared-structure-types.js";
+export declare function createCompactSharedStructures(slotsInput: CompactSharedStructureSlot[]): CompactSharedStructureEncoding;