@giovannijecha/jecode 0.8.1 → 0.8.3

package/dist/context/estimate.js

@@ -2,8 +2,25 @@
 import { constants, deflateRawSync } from "node:zlib";
 const BYTES_PER_TOKEN = 3;
 const COMPRESSED_BYTES_PER_TOKEN = 5 / 6;
+const SERIALIZED_CHUNK_CODE_UNITS = 64 * 1_024;
 export function estimateSerializedTokens(value) {
-    const serialized = Buffer.from(JSON.stringify(value), "utf8");
+    let tokens = 0;
+    for (const serialized of serializedChunks(value))
+        tokens += estimateChunk(serialized);
+    return tokens;
+}
+/** Estimate the same conservative value while yielding between bounded chunks. */
+export async function estimateSerializedTokensResponsive(value, signal) {
+    let tokens = 0;
+    for (const serialized of serializedChunks(value)) {
+        throwIfAborted(signal);
+        tokens += estimateChunk(serialized);
+        await new Promise((resolve) => setImmediate(resolve));
+    }
+    throwIfAborted(signal);
+    return tokens;
+}
+function estimateChunk(serialized) {
     const compressedBytes = deflateRawSync(serialized, {
         level: constants.Z_BEST_SPEED,
     }).byteLength;
@@ -14,6 +31,20 @@ export function estimateSerializedTokens(value) {
     // floor, including when repeated input compresses unusually well.
     return Math.min(serialized.byteLength, Math.max(Math.ceil(serialized.byteLength / BYTES_PER_TOKEN), Math.ceil(compressedBytes / COMPRESSED_BYTES_PER_TOKEN), literalTokens));
 }
+function* serializedChunks(value) {
+    const serialized = JSON.stringify(value);
+    if (serialized === undefined)
+        throw new TypeError("value is not JSON-serializable");
+    for (let start = 0; start < serialized.length;) {
+        let end = Math.min(serialized.length, start + SERIALIZED_CHUNK_CODE_UNITS);
+        if (end < serialized.length &&
+            highSurrogate(serialized.charCodeAt(end - 1)) &&
+            lowSurrogate(serialized.charCodeAt(end)))
+            end--;
+        yield Buffer.from(serialized.slice(start, end), "utf8");
+        start = end;
+    }
+}
 function literalTokenFloor(serialized) {
     let compactableAscii = 0;
     let literalBytes = 0;
@@ -29,3 +60,14 @@ function literalTokenFloor(serialized) {
     }
     return literalBytes + Math.ceil(compactableAscii / BYTES_PER_TOKEN);
 }
+function highSurrogate(value) {
+    return value >= 0xd800 && value <= 0xdbff;
+}
+function lowSurrogate(value) {
+    return value >= 0xdc00 && value <= 0xdfff;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted !== true)
+        return;
+    throw signal.reason instanceof Error ? signal.reason : new Error("aborted");
+}

package/dist/context/manual.js

@@ -6,14 +6,15 @@
 import { recordAuxiliaryUsage } from "../usage.js";
 import { resolveContextPolicy } from "./capacity.js";
 import { compactContext } from "./compactor.js";
-import { estimateTokens, planCompaction } from "./policy.js";
+import { estimateTokensResponsive, planCompaction } from "./policy.js";
 const MIN_PREFIX_TOKENS = 512;
 export async function compactSession(session, options = {}) {
     const active = session.conversation.activeNode;
     if (active === undefined)
         return "unchanged";
     const context = session.conversation.contextHistory;
-    if (estimateTokens(context) < MIN_PREFIX_TOKENS)
+    const estimatedInputTokens = await estimateTokensResponsive(context, options.signal);
+    if (estimatedInputTokens < MIN_PREFIX_TOKENS)
         return "unchanged";
     if (session.conversation.nodes.some((node) => node.parentId === active.id)) {
         throw new Error("continue this branch before compacting");
@@ -29,8 +30,9 @@ export async function compactSession(session, options = {}) {
     const coveredMessages = active.context?.throughNodeId === active.id
         ? active.context.messageCount
         : 0;
-    const plan = planCompaction(context, active.messages, coveredMessages, session.usage.lastInputTokens, true, policy);
-    if (plan === undefined || estimateTokens(plan.prefix) < MIN_PREFIX_TOKENS) {
+    const plan = await planCompaction(context, active.messages, coveredMessages, session.usage.lastInputTokens, true, policy, estimatedInputTokens, options.signal);
+    if (plan === undefined ||
+        await estimateTokensResponsive(plan.prefix, options.signal) < MIN_PREFIX_TOKENS) {
         options.onStatus?.();
         return "unchanged";
     }
@@ -43,6 +45,8 @@ export async function compactSession(session, options = {}) {
         nodeId: active.id,
         coveredMessages,
         lastInputTokens: session.usage.lastInputTokens,
+        estimatedInputTokens,
+        precomputedPlan: plan,
         signal: options.signal,
         force: true,
         failLoudly: true,

package/dist/context/policy.js

@@ -1,15 +1,18 @@
 // Provider-neutral context pressure and safe compaction boundaries.
-import { estimateSerializedTokens } from "./estimate.js";
+import { estimateSerializedTokens, estimateSerializedTokensResponsive, } from "./estimate.js";
 export const DEFAULT_COMPACTION_PERCENT = 85;
 export const MIN_COMPACTION_PERCENT = 50;
 export const MAX_COMPACTION_PERCENT = 95;
 export const FALLBACK_CONTEXT_WINDOW_TOKENS = 200_000;
 export const REQUEST_ESTIMATE_HEADROOM_PERCENT = 5;
 export const MIN_REQUEST_OUTPUT_TOKENS = 256;
-export function planCompaction(context, turn, coveredMessages, lastInputTokens, force, policy) {
+export async function planCompaction(context, turn, coveredMessages, lastInputTokens, force, policy, estimatedInputTokens, signal) {
     if (!validPolicy(policy) || coveredMessages < 0 || coveredMessages > turn.length)
         return undefined;
-    const estimated = estimateTokens(context);
+    if (estimatedInputTokens !== undefined &&
+        (!Number.isSafeInteger(estimatedInputTokens) || estimatedInputTokens <= 0))
+        return undefined;
+    const estimated = estimatedInputTokens ?? await estimateTokensResponsive(context, signal);
     if (!force &&
         (estimated < policy.targetTokens || Math.max(estimated, lastInputTokens) < policy.triggerTokens))
         return undefined;
@@ -17,15 +20,16 @@ export function planCompaction(context, turn, coveredMessages, lastInputTokens,
     const contextPrefix = context.length - currentSuffix;
     if (contextPrefix < 0)
         return undefined;
-    if (!sameMessages(context.slice(contextPrefix), turn.slice(coveredMessages)))
+    if (!await sameMessages(context.slice(contextPrefix), turn.slice(coveredMessages), signal))
         return undefined;
     const targetTokens = force
         ? Math.min(policy.targetTokens, Math.max(512, Math.floor(estimated / 4)))
         : policy.targetTokens;
     const recentTokens = Math.min(policy.recentTokens, Math.max(256, Math.floor(targetTokens / 2)));
-    let boundary = recentBoundary(turn, coveredMessages, recentTokens);
+    const recent = await recentBoundary(turn, coveredMessages, recentTokens, signal);
+    let boundary = recent.boundary;
     let tail = turn.slice(boundary);
-    if (turn.length > 1 && estimateTokens(tail) > targetTokens) {
+    if (turn.length > 1 && recent.tokens > targetTokens) {
         boundary = turn.length;
         tail = [];
     }
@@ -33,8 +37,9 @@ export function planCompaction(context, turn, coveredMessages, lastInputTokens,
     if (prefixEnd <= 0 || prefixEnd > context.length)
         return undefined;
     const prefix = context.slice(0, prefixEnd);
-    if (!force && estimateTokens(prefix) < policy.minimumPrefixTokens)
+    if (!force && await estimateTokensResponsive(prefix, signal) < policy.minimumPrefixTokens) {
         return undefined;
+    }
     return {
         prefix: clone(prefix),
         tail: clone(tail),
@@ -70,6 +75,9 @@ export function policyForContextWindow(context, compactionPercent) {
 export function estimateTokens(messages) {
     return estimateSerializedTokens(messages) + messages.length * 8;
 }
+export async function estimateTokensResponsive(messages, signal) {
+    return await estimateSerializedTokensResponsive(messages, signal) + messages.length * 8;
+}
 export function isContextOverflow(error) {
     const candidate = error;
     if (candidate.status !== 400 && candidate.status !== 413)
@@ -77,16 +85,45 @@ export function isContextOverflow(error) {
     const detail = `${candidate.message}\n${candidate.body ?? ""}`;
     return /context_length_exceeded|maximum context length|context window|prompt is too long|input (?:is )?too (?:long|large)|(?:input|prompt|context).{0,80}(?:exceed|maximum|max tokens)/i.test(detail);
 }
-function recentBoundary(turn, coveredMessages, recentTokens) {
-    let boundary = minimumRecentBoundary(turn);
-    for (let candidate = boundary - 1; candidate >= coveredMessages; candidate--) {
-        if (!safeBoundary(turn, candidate))
-            continue;
-        if (estimateTokens(turn.slice(candidate)) > recentTokens)
-            break;
-        boundary = candidate;
+async function recentBoundary(turn, coveredMessages, recentTokens, signal) {
+    const minimum = Math.max(coveredMessages, minimumRecentBoundary(turn));
+    const candidates = [];
+    for (let candidate = coveredMessages; candidate <= minimum; candidate++) {
+        if (candidate === minimum || safeBoundary(turn, candidate))
+            candidates.push(candidate);
+    }
+    const cache = new Map();
+    const estimateAt = (candidate) => {
+        let estimate = cache.get(candidate);
+        if (estimate === undefined) {
+            estimate = estimateTokensResponsive(turn.slice(candidate), signal);
+            cache.set(candidate, estimate);
+        }
+        return estimate;
+    };
+    const last = candidates.length - 1;
+    const minimumTokens = await estimateAt(candidates[last]);
+    if (minimumTokens > recentTokens) {
+        return { boundary: candidates[last], tokens: minimumTokens };
     }
-    return Math.max(coveredMessages, boundary);
+    // Adding older messages raises the byte and literal floors. A lower-bound
+    // search therefore replaces the former serialization of every suffix.
+    let low = 0;
+    let high = last;
+    let selected = last;
+    while (low <= high) {
+        const middle = Math.floor((low + high) / 2);
+        const tokens = await estimateAt(candidates[middle]);
+        if (tokens <= recentTokens) {
+            selected = middle;
+            high = middle - 1;
+        }
+        else {
+            low = middle + 1;
+        }
+    }
+    const boundary = candidates[selected];
+    return { boundary, tokens: await estimateAt(boundary) };
 }
 function minimumRecentBoundary(turn) {
     const last = turn.at(-1);
@@ -127,8 +164,21 @@ function validPercent(value) {
     return Number.isSafeInteger(value) &&
         value >= MIN_COMPACTION_PERCENT && value <= MAX_COMPACTION_PERCENT;
 }
-function sameMessages(left, right) {
-    return JSON.stringify(left) === JSON.stringify(right);
+async function sameMessages(left, right, signal) {
+    if (left.length !== right.length)
+        return false;
+    for (let index = 0; index < left.length; index++) {
+        throwIfAborted(signal);
+        if (JSON.stringify(left[index]) !== JSON.stringify(right[index]))
+            return false;
+        await new Promise((resolve) => setImmediate(resolve));
+    }
+    return true;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted !== true)
+        return;
+    throw signal.reason instanceof Error ? signal.reason : new Error("aborted");
 }
 function clone(value) {
     return structuredClone(value);

package/dist/controller-request.js

@@ -1,17 +1,14 @@
 // One streamed provider request with a single safe context-overflow recovery.
-import { budgetRequest, estimateRequestInputTokens } from "./context/budget.js";
+import { budgetRequestFromInputTokens, estimateRequestInputTokensResponsive, } from "./context/budget.js";
 import { isContextOverflow } from "./context/policy.js";
 export async function requestAssistant(history, current, specs, options, events, signal) {
     let policy = await options.contextPolicy();
-    const prepared = await prepareContext(history, current, specs, options, events, policy, "budget");
-    let context = prepared === undefined ? [...current] : clone(prepared);
+    const prepared = await prepareContext(history, current, specs, options, events, policy, "budget", signal);
+    let context = prepared.projected === undefined ? [...current] : clone(prepared.projected);
+    let inputTokens = prepared.inputTokens;
     let recovered = false;
     for (;;) {
-        const budget = budgetRequest({
-            system: options.system,
-            messages: context,
-            tools: specs,
-        }, options.maxTokens, policy);
+        const budget = budgetRequestFromInputTokens(inputTokens, options.maxTokens, policy);
         try {
             const message = await options.provider.send({
                 model: options.model,
@@ -31,26 +28,37 @@ export async function requestAssistant(history, current, specs, options, events,
                 throw error;
             if (isContextOverflow(error))
                 policy = await options.contextPolicy();
-            const projected = await prepareContext(history, context, specs, options, events, policy, "overflow", error);
-            if (projected === undefined)
+            const next = await prepareContext(history, context, specs, options, events, policy, "overflow", signal, error, inputTokens);
+            if (next.projected === undefined)
                 throw error;
-            context = clone(projected);
+            context = clone(next.projected);
+            inputTokens = next.inputTokens;
             recovered = true;
         }
     }
 }
-async function prepareContext(history, context, specs, options, events, policy, reason, error) {
-    const inputTokens = estimateRequestInputTokens({
+async function prepareContext(history, context, specs, options, events, policy, reason, signal, error, knownInputTokens) {
+    const inputTokens = knownInputTokens ?? await estimateRequestInputTokensResponsive({
         system: options.system,
         messages: context,
         tools: specs,
-    });
-    return events.onContext?.(history, context, {
+    }, signal);
+    const projected = await events.onContext?.(history, context, {
         reason,
         policy,
         inputTokens,
         ...(error === undefined ? {} : { error }),
     });
+    return {
+        projected,
+        inputTokens: projected === undefined
+            ? inputTokens
+            : await estimateRequestInputTokensResponsive({
+                system: options.system,
+                messages: projected,
+                tools: specs,
+            }, signal),
+    };
 }
 function clone(messages) {
     return structuredClone([...messages]);

package/dist/controller.js

@@ -97,13 +97,29 @@ export async function runTurn(history, options, events, signal, modelHistory = h
                     events.onToolCall(call, preview);
                     prepared.push({ call, current, preview });
                 }
-                const runs = await Promise.all(prepared.map(({ call, current, preview }) => settle(call, current, calls.length, options, events, signal, preview)));
-                for (let offset = 0; offset < runs.length; offset++) {
+                const settlements = await Promise.allSettled(prepared.map(({ call, current, preview }) => settle(call, current, calls.length, options, events, signal, preview)));
+                let batchFailure;
+                for (let offset = 0; offset < settlements.length; offset++) {
                     const call = prepared[offset]?.call;
-                    const run = runs[offset];
+                    const settlement = settlements[offset];
+                    const run = settlement.status === "fulfilled"
+                        ? settlement.value
+                        : refuse(call, signal?.aborted === true
+                            ? "interrupted before completion"
+                            : "tool processing stopped before completion", signal?.aborted === true ? "interrupted" : "failed");
+                    if (settlement.status === "rejected" && batchFailure === undefined) {
+                        batchFailure = { error: settlement.reason };
+                    }
                     results.push(run.result);
-                    events.onToolResult(call, run.result, run.summary);
+                    try {
+                        events.onToolResult(call, run.result, run.summary);
+                    }
+                    catch (error) {
+                        batchFailure ??= { error };
+                    }
                 }
+                if (batchFailure !== undefined)
+                    throw batchFailure.error;
             }
         }
         catch (error) {
@@ -169,11 +185,14 @@ function assertToolCallIds(calls) {
     }
 }
 async function settle(call, current, total, options, events, signal, preview) {
+    throwIfAborted(signal);
+    if (call.inputError !== undefined) {
+        return refuse(call, call.inputError, "invalid arguments");
+    }
     const tool = findTool(options.tools, call.name);
     if (tool === undefined) {
         return refuse(call, `no such tool: ${call.name}`, "unknown tool");
     }
-    throwIfAborted(signal);
     const approved = !tool.dangerous || await events.approve(call);
     throwIfAborted(signal);
     if (!approved) {
@@ -202,6 +221,8 @@ function refuse(call, reason, summary) {
  * turn depends on it, because it exists for the user, not for the model.
  */
 async function look(call, options, signal) {
+    if (call.inputError !== undefined)
+        return undefined;
     const tool = findTool(options.tools, call.name);
     if (tool?.preview === undefined)
         return undefined;

package/dist/conversation.js

@@ -16,13 +16,17 @@ export const CONVERSATION_LIMITS = Object.freeze({
 export class ConversationTree {
     #nodes;
     #activeNodeId;
-    constructor(nodes, activeNodeId) {
-        this.#nodes = Object.freeze([...nodes]);
+    #nodeBounds;
+    #bounds;
+    constructor(nodes, activeNodeId, nodeBounds, bounds) {
+        this.#nodes = nodes;
         this.#activeNodeId = activeNodeId;
+        this.#nodeBounds = nodeBounds;
+        this.#bounds = bounds;
         Object.freeze(this);
     }
     static empty() {
-        return new ConversationTree([], 0);
+        return new ConversationTree(Object.freeze([]), 0, Object.freeze([]), emptyBounds());
     }
     static restore(nodes, activeNodeId) {
         if (nodes.length > CONVERSATION_LIMITS.nodes) {
@@ -39,11 +43,13 @@ export class ConversationTree {
             assertPersistableNode(owned);
             restored.push(owned);
         }
-        assertBounds(restored);
+        const measured = measureBounds(restored);
+        assertBounds(measured.total);
+        assertContextPaths(restored, restored.filter((node) => node.context !== undefined));
         if (!validNodeId(activeNodeId) ||
             (activeNodeId !== 0 && restored[activeNodeId - 1]?.id !== activeNodeId))
             throw new Error("conversation node does not exist");
-        return new ConversationTree(restored, activeNodeId);
+        return new ConversationTree(Object.freeze(restored), activeNodeId, Object.freeze(measured.nodes), measured.total);
     }
     /** Commit or extend the one prospective leaf turn. */
     commit(draft, settlement) {
@@ -60,7 +66,7 @@ export class ConversationTree {
         if (!validNodeId(nodeId) || (nodeId !== 0 && this.#nodes[nodeId - 1]?.id !== nodeId)) {
             throw new Error("conversation node does not exist");
         }
-        return new ConversationTree(this.#nodes, nodeId);
+        return new ConversationTree(this.#nodes, nodeId, this.#nodeBounds, this.#bounds);
     }
     node(nodeId) {
         return nodeId === 0 ? undefined : this.#nodes[nodeId - 1];
@@ -132,9 +138,11 @@ export class ConversationTree {
         });
         assertTurn(node);
         assertPersistableNode(node);
-        const nodes = [...this.#nodes, node];
-        assertBounds(nodes);
-        return new ConversationTree(nodes, node.id);
+        assertContextPath(this.#nodes, node);
+        const nodeBounds = measureNode(node);
+        const bounds = addBounds(this.#bounds, nodeBounds);
+        assertBounds(bounds);
+        return new ConversationTree(Object.freeze([...this.#nodes, node]), node.id, Object.freeze([...this.#nodeBounds, nodeBounds]), bounds);
     }
     #replace(draft, settlement) {
         const id = draft.nodeId;
@@ -154,10 +162,16 @@ export class ConversationTree {
         });
         assertTurn(node);
         assertPersistableNode(node);
+        assertContextPath(this.#nodes, node);
         const nodes = [...this.#nodes];
         nodes[id - 1] = node;
-        assertBounds(nodes);
-        return new ConversationTree(nodes, id);
+        const priorBounds = this.#nodeBounds[id - 1];
+        const nextNodeBounds = measureNode(node);
+        const nodeBounds = [...this.#nodeBounds];
+        nodeBounds[id - 1] = nextNodeBounds;
+        const bounds = replaceBounds(this.#bounds, priorBounds, nextNodeBounds);
+        assertBounds(bounds);
+        return new ConversationTree(Object.freeze(nodes), id, Object.freeze(nodeBounds), bounds);
     }
     #path() {
         const path = [];
@@ -174,13 +188,13 @@ export class ConversationTree {
     }
 }
 function ownedNode(node) {
-    return Object.freeze({
+    return deepFreeze({
         ...node,
-        identity: Object.freeze({ ...node.identity }),
-        messages: Object.freeze(clone(node.messages)),
-        blocks: Object.freeze(clone(node.blocks)),
-        ...(node.context === undefined ? {} : { context: Object.freeze({ ...node.context }) }),
-        ...(node.failure === undefined ? {} : { failure: Object.freeze({ ...node.failure }) }),
+        identity: { ...node.identity },
+        messages: clone(node.messages),
+        blocks: clone(node.blocks),
+        ...(node.context === undefined ? {} : { context: { ...node.context } }),
+        ...(node.failure === undefined ? {} : { failure: { ...node.failure } }),
     });
 }
 function settledBlocks(blocks) {
@@ -225,28 +239,64 @@ function validSettlement(value) {
     return value === "checkpointed" || value === "completed" ||
         value === "failed" || value === "interrupted";
 }
-function assertBounds(nodes) {
-    let messageCodeUnits = 0;
-    let transcriptCodeUnits = 0;
-    let contextCodeUnits = 0;
-    const contextOwners = [];
-    for (const node of nodes) {
-        messageCodeUnits += JSON.stringify(node.messages).length;
-        transcriptCodeUnits += JSON.stringify(node.blocks).length;
-        contextCodeUnits += node.context?.summary.length ?? 0;
-        if (node.context !== undefined)
-            contextOwners.push(node);
-    }
-    if (messageCodeUnits > CONVERSATION_LIMITS.messageCodeUnits) {
+function assertBounds(bounds) {
+    if (bounds.messageCodeUnits > CONVERSATION_LIMITS.messageCodeUnits) {
         throw new Error("conversation model history reached its session limit — start /new");
     }
-    if (transcriptCodeUnits > CONVERSATION_LIMITS.transcriptCodeUnits) {
+    if (bounds.transcriptCodeUnits > CONVERSATION_LIMITS.transcriptCodeUnits) {
         throw new Error("conversation transcript reached its session limit — start /new");
     }
-    if (contextCodeUnits > CONVERSATION_LIMITS.contextCodeUnits) {
+    if (bounds.contextCodeUnits > CONVERSATION_LIMITS.contextCodeUnits) {
         throw new Error("conversation context summaries reached their session limit — start /new");
     }
-    assertContextPaths(nodes, contextOwners);
+}
+function measureBounds(nodes) {
+    const measured = nodes.map(measureNode);
+    return {
+        nodes: measured,
+        total: measured.reduce(addBounds, emptyBounds()),
+    };
+}
+function measureNode(node) {
+    return Object.freeze({
+        messageCodeUnits: JSON.stringify(node.messages).length,
+        transcriptCodeUnits: JSON.stringify(node.blocks).length,
+        contextCodeUnits: node.context?.summary.length ?? 0,
+    });
+}
+function emptyBounds() {
+    return Object.freeze({ messageCodeUnits: 0, transcriptCodeUnits: 0, contextCodeUnits: 0 });
+}
+function addBounds(left, right) {
+    return Object.freeze({
+        messageCodeUnits: left.messageCodeUnits + right.messageCodeUnits,
+        transcriptCodeUnits: left.transcriptCodeUnits + right.transcriptCodeUnits,
+        contextCodeUnits: left.contextCodeUnits + right.contextCodeUnits,
+    });
+}
+function replaceBounds(total, before, after) {
+    return Object.freeze({
+        messageCodeUnits: total.messageCodeUnits - before.messageCodeUnits + after.messageCodeUnits,
+        transcriptCodeUnits: total.transcriptCodeUnits - before.transcriptCodeUnits + after.transcriptCodeUnits,
+        contextCodeUnits: total.contextCodeUnits - before.contextCodeUnits + after.contextCodeUnits,
+    });
+}
+function assertContextPath(nodes, owner) {
+    const context = owner.context;
+    if (context === undefined)
+        return;
+    const boundary = context.throughNodeId === owner.id
+        ? owner
+        : nodes[context.throughNodeId - 1];
+    if (boundary === undefined || !validContextAnchor(context, boundary.messages.length)) {
+        throw new Error("turn context checkpoint is invalid");
+    }
+    let current = owner;
+    while (current !== undefined && current.id !== boundary.id) {
+        current = nodes[current.parentId - 1];
+    }
+    if (current === undefined)
+        throw new Error("turn context checkpoint is outside its branch");
 }
 function assertContextPaths(nodes, owners) {
     if (owners.length === 0)
@@ -288,3 +338,14 @@ function validNodeId(value) {
 function clone(value) {
     return structuredClone(value);
 }
+function deepFreeze(value, seen = new WeakSet()) {
+    if (typeof value !== "object" || value === null || seen.has(value))
+        return value;
+    seen.add(value);
+    if (!ArrayBuffer.isView(value)) {
+        for (const child of Object.values(value))
+            deepFreeze(child, seen);
+        Object.freeze(value);
+    }
+    return value;
+}