project-tiny-context-harness 0.8.17 → 0.12.0

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

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

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

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

@@ -1,61 +0,0 @@
-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-validation.d.ts

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

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

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

package/dist/lib/compact-shared-structures.js

@@ -1,204 +0,0 @@
-import { Buffer } from "node:buffer";
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-const STABLE_BOUNDARY = /^[a-z0-9][a-z0-9._:-]*$/u;
-const MINIMUM_NET_SAVING_BYTES = 32;
-export function createCompactSharedStructures(slotsInput) {
-    const slots = slotsInput.map((slot, index) => ({
-        boundary: validBoundary(slot.boundary, `slots[${index}].boundary`),
-        value: structuredClone(slot.value),
-    }));
-    const grouped = new Map();
-    for (const [slotIndex, slot] of slots.entries()) {
-        if (!isCandidateComposite(slot.value))
-            continue;
-        const descriptor = describeStructure(slot.value);
-        const identity = `${slot.boundary}\0${canonicalValueJson(descriptor.shape)}`;
-        const occurrences = grouped.get(identity) ?? [];
-        occurrences.push({
-            slot_index: slotIndex,
-            value: slot.value,
-            leaves: descriptor.leaves,
-            original_bytes: byteLength(slot.value),
-        });
-        grouped.set(identity, occurrences);
-    }
-    const candidateClusters = [...grouped.values()]
-        .filter((occurrences) => occurrences.length > 1)
-        .flatMap(partitionStableCandidateFamilies)
-        .filter((group) => group.occurrences.length > 1);
-    const candidates = candidateClusters
-        .map(({ occurrences, parameter_positions }) => buildCandidate(slots, occurrences, parameter_positions))
-        .filter((candidate) => candidate !== null)
-        .sort((left, right) => left.row.key.localeCompare(right.row.key));
-    const bySlot = new Map();
-    for (const candidate of candidates)
-        for (const occurrence of candidate.occurrences)
-            bySlot.set(occurrence.slot_index, candidate);
-    for (const [slotIndex, candidate] of bySlot) {
-        const occurrenceIndex = candidate.occurrences.findIndex((item) => item.slot_index === slotIndex);
-        slots[slotIndex].value = structuredClone(candidate.references[occurrenceIndex]);
-    }
-    const catalog = candidates.map((candidate) => candidate.row);
-    const originalPayloadBytes = slotsInput.reduce((sum, slot) => sum + byteLength(slot.value), 0);
-    const encodedPayloadBytes = slots.reduce((sum, slot) => sum + byteLength(slot.value), 0);
-    const catalogBytes = byteLength(catalog);
-    const familyStatistics = candidates
-        .map((candidate) => candidate.statistic)
-        .sort((left, right) => right.saved_bytes - left.saved_bytes ||
-        left.key.localeCompare(right.key));
-    return {
-        slots,
-        catalog,
-        statistics: {
-            slot_count: slots.length,
-            composite_slot_count: slotsInput.filter((slot) => isCandidateComposite(slot.value)).length,
-            candidate_family_count: candidateClusters.length,
-            emitted_family_count: catalog.length,
-            exact_family_count: catalog.filter((item) => item.parameter_count === 0)
-                .length,
-            parameterized_family_count: catalog.filter((item) => item.parameter_count > 0).length,
-            reference_count: candidates.reduce((sum, candidate) => sum + candidate.occurrences.length, 0),
-            argument_count: candidates.reduce((sum, candidate) => sum + candidate.occurrences.length * candidate.row.parameter_count, 0),
-            original_payload_bytes: originalPayloadBytes,
-            encoded_payload_bytes: encodedPayloadBytes,
-            catalog_bytes: catalogBytes,
-            saved_bytes: originalPayloadBytes - encodedPayloadBytes - catalogBytes,
-            remaining_beneficial_candidates: 0,
-            families: familyStatistics,
-        },
-    };
-}
-function buildCandidate(slots, occurrences, parameterPositions) {
-    const boundary = slots[occurrences[0].slot_index].boundary;
-    const parameterByPosition = new Map(parameterPositions.map((position, index) => [position, index]));
-    const template = buildTemplate(occurrences[0].value, parameterByPosition);
-    const parameterCount = parameterPositions.length;
-    const digest = sha256Hex(canonicalValueJson({ boundary, parameter_count: parameterCount, template }));
-    const key = `structure.${digest.slice(0, 24)}`;
-    const row = {
-        key,
-        digest,
-        boundary,
-        parameter_count: parameterCount,
-        template,
-    };
-    const references = occurrences.map((occurrence) => ({
-        structure_ref: key,
-        arguments: parameterPositions.map((position) => structuredClone(occurrence.leaves[position])),
-    }));
-    const originalBytes = occurrences.reduce((sum, occurrence) => sum + occurrence.original_bytes, 0);
-    const encodedBytes = byteLength(row) +
-        references.reduce((sum, reference) => sum + byteLength(reference), 0);
-    const savedBytes = originalBytes - encodedBytes;
-    if (savedBytes < MINIMUM_NET_SAVING_BYTES)
-        return null;
-    return {
-        boundary,
-        occurrences,
-        parameter_positions: parameterPositions,
-        template,
-        row,
-        references,
-        statistic: {
-            key,
-            boundary,
-            occurrences: occurrences.length,
-            parameter_count: parameterCount,
-            original_bytes: originalBytes,
-            encoded_bytes: encodedBytes,
-            saved_bytes: savedBytes,
-        },
-    };
-}
-function partitionStableCandidateFamilies(occurrences) {
-    const leafCount = occurrences[0].leaves.length;
-    const parameterPositions = [];
-    const constantPositions = [];
-    for (let index = 0; index < leafCount; index += 1) {
-        const distinct = new Set(occurrences.map((occurrence) => canonicalValueJson(occurrence.leaves[index]))).size;
-        if (distinct >= 3 && distinct / occurrences.length >= 0.2)
-            parameterPositions.push(index);
-        else
-            constantPositions.push(index);
-    }
-    const clusters = new Map();
-    for (const occurrence of occurrences) {
-        const identity = canonicalValueJson(constantPositions.map((position) => occurrence.leaves[position]));
-        const cluster = clusters.get(identity) ?? [];
-        cluster.push(occurrence);
-        clusters.set(identity, cluster);
-    }
-    return [...clusters.values()].map((cluster) => ({
-        occurrences: cluster,
-        parameter_positions: parameterPositions,
-    }));
-}
-function describeStructure(value) {
-    const leaves = [];
-    const visit = (item) => {
-        if (Array.isArray(item))
-            return ["array", item.map(visit)];
-        if (item && typeof item === "object")
-            return [
-                "object",
-                Object.keys(item)
-                    .sort()
-                    .map((key) => [key, visit(item[key])]),
-            ];
-        leaves.push(item);
-        return ["leaf", leafKind(item)];
-    };
-    return { shape: visit(value), leaves };
-}
-function buildTemplate(value, parameterByPosition) {
-    let leafIndex = 0;
-    const visit = (item) => {
-        if (Array.isArray(item))
-            return item.map(visit);
-        if (item && typeof item === "object")
-            return Object.fromEntries(Object.keys(item)
-                .sort()
-                .map((key) => [key, visit(item[key])]));
-        const parameterIndex = parameterByPosition.get(leafIndex);
-        leafIndex += 1;
-        return parameterIndex === undefined
-            ? structuredClone(item)
-            : { parameter_index: parameterIndex };
-    };
-    return visit(value);
-}
-function isCandidateComposite(value) {
-    if (!value || typeof value !== "object")
-        return false;
-    if (!Array.isArray(value)) {
-        const row = value;
-        if (Object.keys(row).length === 1 &&
-            (Object.hasOwn(row, "selector_ref") ||
-                Object.hasOwn(row, "structure_ref") ||
-                Object.hasOwn(row, "parameter_index")))
-            return false;
-    }
-    return true;
-}
-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 byteLength(value) {
-    return Buffer.byteLength(canonicalValueJson(value), "utf8");
-}
-function fail(label, message) {
-    throw new Error(`compact_shared_structure_invalid:${label}:${message}`);
-}

package/dist/lib/context-graph-snapshot.d.ts

@@ -1,18 +0,0 @@
-export interface ContextGraphSnapshot {
-    mode: "referenced" | "full";
-    topology_sha256: string;
-    files: string[];
-    sha256: Record<string, string>;
-    controlling_files: string[];
-    supporting_files: string[];
-}
-export interface CampaignContextBaseline {
-    graph_sha256: string;
-    files: Record<string, string>;
-    baseline_sha256: string;
-}
-export declare function captureContextGraphSnapshot(repositoryRoot: string, contextRefs: Iterable<string>, mode?: "referenced" | "full"): Promise<ContextGraphSnapshot>;
-export declare function captureCampaignContextBaseline(repositoryRoot: string, contextRefs: Iterable<string>): Promise<CampaignContextBaseline>;
-export declare function assertCampaignContextBaselineFresh(repositoryRoot: string, expected: CampaignContextBaseline, contextRefs: Iterable<string>): Promise<void>;
-export declare function currentContextTopologySha256(repositoryRoot: string): Promise<string>;
-export declare function listContextFiles(repositoryRoot: string): Promise<string[]>;