project-tiny-context-harness 0.8.11 → 0.8.13

package/dist/commands/design-resource-recovery.d.ts

@@ -0,0 +1 @@
+export declare function designResourceRecoveryCommand(args: string[]): Promise<void>;

package/dist/commands/design-resource-recovery.js

@@ -0,0 +1,152 @@
+import { parseDesignResourceRecoveryCreateInput } from "../lib/design-resource-recovery-codec.js";
+import { readRecoveryRepositoryFile } from "../lib/design-resource-recovery-files.js";
+import { applyDesignResourceRecoveryWriteback, createDesignResourceRecoveryCheckpoint, inspectDesignResourceRecovery, previewDesignResourceRecoveryWriteback, reconcileDesignResourceRecovery, removeDesignResourceRecoveryCheckpoint, updateDesignResourceRecoveryCheckpoint, } from "../lib/design-resource-recovery.js";
+import { canonicalJson } from "../lib/strict-codec.js";
+export async function designResourceRecoveryCommand(args) {
+    const [action, sessionId, ...rest] = args;
+    if (!action || !sessionId)
+        throw new Error("usage: ty-context design-resource recovery <create|update|inspect|preview|apply|reconcile|remove> <session> [options]");
+    const options = recoveryOptions(rest);
+    let result;
+    if (action === "create")
+        result = await create(process.cwd(), sessionId, options);
+    else if (action === "update")
+        result = await update(process.cwd(), sessionId, options);
+    else if (action === "inspect") {
+        assertNoValueOptions(options, action);
+        result = await inspectDesignResourceRecovery(process.cwd(), sessionId);
+    }
+    else if (action === "preview") {
+        assertNoValueOptions(options, action);
+        result = await previewDesignResourceRecoveryWriteback(process.cwd(), sessionId);
+    }
+    else if (action === "apply")
+        result = await apply(process.cwd(), sessionId, options);
+    else if (action === "reconcile")
+        result = await reconcile(process.cwd(), sessionId, options);
+    else if (action === "remove")
+        result = await remove(process.cwd(), sessionId, options);
+    else
+        throw new Error(`Unknown design-resource recovery action: ${action}`);
+    if (options.json)
+        process.stdout.write(canonicalJson(result));
+    else
+        printRecoveryResult(action, result);
+    if ((action === "apply" || action === "reconcile") &&
+        result.status === "blocked")
+        process.exitCode = 2;
+    if (action === "remove" &&
+        result.status === "partial")
+        process.exitCode = 2;
+}
+async function create(repository, sessionId, options) {
+    if (!options.input || options.audit || options.expectedSha256)
+        usage("create <session> --input <state.json>");
+    const input = await readCreateInput(repository, options.input);
+    if (input.session_id !== sessionId)
+        throw new Error("design_resource_recovery_invalid:create_session_identity_mismatch");
+    return createDesignResourceRecoveryCheckpoint(repository, input);
+}
+async function apply(repository, sessionId, options) {
+    if (!options.audit || options.input || options.expectedSha256)
+        usage("apply <session> --audit <audit.json>");
+    return applyDesignResourceRecoveryWriteback(repository, sessionId, options.audit);
+}
+async function reconcile(repository, sessionId, options) {
+    if (!options.audit || options.input || options.expectedSha256)
+        usage("reconcile <session> --audit <audit.json>");
+    return reconcileDesignResourceRecovery(repository, sessionId, options.audit);
+}
+async function update(repository, sessionId, options) {
+    if (!options.input || !options.expectedSha256 || options.audit)
+        usage("update <session> --input <state.json> --expected-sha256 <sha256>");
+    const input = await readCreateInput(repository, options.input);
+    if (input.session_id !== sessionId)
+        throw new Error("design_resource_recovery_invalid:update_session_identity_mismatch");
+    return updateDesignResourceRecoveryCheckpoint(repository, input, options.expectedSha256);
+}
+async function remove(repository, sessionId, options) {
+    if (!options.expectedSha256 || options.input || options.audit)
+        usage("remove <session> --expected-sha256 <sha256>");
+    return removeDesignResourceRecoveryCheckpoint(repository, sessionId, options.expectedSha256);
+}
+function recoveryOptions(args) {
+    const result = { json: false };
+    for (let index = 0; index < args.length; index += 1) {
+        const item = args[index];
+        if (item === "--json") {
+            result.json = true;
+            continue;
+        }
+        const value = args[index + 1];
+        if (!value || value.startsWith("--"))
+            throw new Error(`${item} requires a value`);
+        if (item === "--input")
+            result.input = value;
+        else if (item === "--audit")
+            result.audit = value;
+        else if (item === "--expected-sha256")
+            result.expectedSha256 = value;
+        else
+            throw new Error(`Unknown design-resource recovery option: ${item}`);
+        index += 1;
+    }
+    return result;
+}
+function assertNoValueOptions(options, action) {
+    if (options.input || options.audit || options.expectedSha256)
+        usage(`${action} <session>`);
+}
+function usage(value) {
+    throw new Error(`usage: ty-context design-resource recovery ${value} [--json]`);
+}
+async function readCreateInput(repository, locator) {
+    const inputSnapshot = await readRecoveryRepositoryFile(repository, locator, "design_resource_recovery_create_input");
+    return parseDesignResourceRecoveryCreateInput(inputSnapshot.bytes.toString("utf8"));
+}
+function printRecoveryResult(action, result) {
+    const row = result;
+    if (action === "create" || action === "update") {
+        console.log(`DRA recovery checkpoint: ${row.status}`);
+        console.log(`Path: ${row.checkpoint_path}`);
+        console.log(`SHA-256: ${row.checkpoint_raw_byte_digest}`);
+        return;
+    }
+    if (action === "inspect" || action === "preview") {
+        printInspection(row);
+        if (action === "preview")
+            printPatch(row);
+        return;
+    }
+    if (action === "apply") {
+        console.log(`DRA writeback: ${row.status}`);
+        console.log(`Write transaction: ${row.write_transaction}`);
+        console.log(`Reconciliation: ${JSON.stringify(row.reconciliation)}`);
+        return;
+    }
+    if (action === "reconcile") {
+        console.log(`DRA reconciliation: ${row.status}`);
+        console.log(`Write transaction: ${row.write_transaction}`);
+        console.log(`Reconciliation: ${JSON.stringify(row.reconciliation)}`);
+        return;
+    }
+    console.log(`DRA recovery cleanup: ${row.status}`);
+    console.log(`Path: ${row.path}`);
+    if (row.status === "partial")
+        console.log(`Retained: ${JSON.stringify(row.retained_entries)}`);
+}
+function printInspection(row) {
+    const replay = row.replay;
+    console.log(`Base: ${replay.base.locator}@${replay.base.raw_byte_digest}`);
+    console.log(`Delta: ${replay.ordered_active_accepted_deltas.length} accepted / ${replay.rejected_deltas.length} rejected / ${replay.unresolved_deltas.length} unresolved`);
+    console.log(`Explicitly unchanged: ${replay.explicitly_unchanged_keys.join(", ") || "none"}`);
+    console.log(`Writeback: ${JSON.stringify(row.writeback)}`);
+}
+function printPatch(row) {
+    const patch = row.patch;
+    for (const operation of patch.patch.operations) {
+        console.log(`Patch ${operation.operation_id} [${operation.target_key}]:`);
+        console.log(`- ${operation.before_text}`);
+        console.log(`+ ${operation.after_text}`);
+    }
+}

package/dist/commands/design-resource.js

@@ -1,5 +1,6 @@
 import { publishDesignResourceHandoffBundle } from "../lib/design-resource-handoff-bundle.js";
 import { preflightDesignResourceHandoff } from "../lib/design-resource-handoff-validation.js";
+import { designResourceRecoveryCommand } from "./design-resource-recovery.js";
 import { normalizeRepositoryCwd, normalizeRepositoryFile, } from "../lib/long-task-paths.js";
 import { canonicalJson } from "../lib/strict-codec.js";
 export async function designResource(args) {
@@ -12,6 +13,10 @@ export async function designResource(args) {
         await bundle(rest);
         return;
     }
+    if (subcommand === "recovery") {
+        await designResourceRecoveryCommand(rest);
+        return;
+    }
     if (subcommand !== "preflight")
         throw new Error(`Unknown design-resource subcommand: ${subcommand}`);
     const json = rest.includes("--json");
@@ -27,8 +32,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 = [];
@@ -88,5 +100,19 @@ function help() {
          --max-handoff-bytes <bytes> [--json]
                        Validate manifest-backed one-target handoffs and
                        atomically publish the complete target set; the
-                       output parent directory must already exist`);
+                       output parent directory must already exist
+  recovery create <session> --input <state.json> [--json]
+                       Create one explicit ignored task-local checkpoint
+  recovery update <session> --input <state.json> --expected-sha256 <sha256> [--json]
+                       CAS-replace one existing task-local checkpoint
+  recovery inspect <session> [--json]
+                       Revalidate Base and derive replay/CAS state
+  recovery preview <session> [--json]
+                       Show the frozen exact writeback patch without writing
+  recovery apply <session> --audit <audit.json> [--json]
+                       CAS-apply and reread only after fresh balanced audit
+  recovery reconcile <session> --audit <audit.json> [--json]
+                       Read-only reconciliation for a no-writeback checkpoint
+  recovery remove <session> --expected-sha256 <sha256> [--json]
+                       Remove only the digest-matched helper-owned checkpoint`);
 }

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]
@@ -55,7 +55,7 @@ export function help() {
                        Enforce touched handwritten source file modularity
   validate-harness     Run validate-context and validate-code-modularity
   design-resource <subcommand>
-                       Validate a selected design-resource implementation handoff
+                       Validate handoffs or operate explicit DRA recovery
   long-task <subcommand>
                        Manage one Canonical Delivery Contract in the current workspace
   delivery-set <subcommand>

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,12 +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 } 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,7 +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 { 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;