@hachej/boring-agent 0.4.27 → 0.4.29

package/README.md

@@ -460,7 +460,7 @@ const delegates = [
 ];
 ```
 
-**Schedule.** `@hachej/boring-agent/schedule` exports `createScheduleExtension({ now?, onDeadline?, maxDelaySeconds? })`, one native extension with `schedule({ instruction, delaySeconds | at, operationId? })`, `list_schedules()` and `cancel_schedule({ id })`, plus the delivery task `ScheduledDelivery`. A schedule is a native Pi task owned by the conversation as background work: it sleeps on the Harness clock (`runtime.sleep`) and then submits the instruction to its conversation as a follow-up input (entry kind `boring.schedule.delivery`, request id = schedule id, so a replayed delivery never submits twice). Pi's scheduler runs it and a restart resumes it; there is no second scheduler. Pending schedules live in the conversation document `ConversationSchedules`, so a conversation lists and cancels only its own; a cancelled schedule's task wakes and ends without delivering. `schedule` is idempotent on `operationId` (default: the tool task, so a replayed call returns the schedule it made). Hosts schedule outside a tool with `addSchedule(tx, conversationId, { operationId, instruction, runAt })`, `cancelSchedule(tx, conversationId, id)` and `listSchedules(harness, conversationId, context)`. Pass the Harness's own clock as `now`. A host with one wake-up timer (a Durable Object alarm) computes the earliest deadline from `harness.inspect()` with `scheduledDeadline(task)` and moves the timer earlier from `onDeadline`; its alarm handler only reopens or resumes the Harness, and Pi delivers what is due.
+**Schedule.** `@hachej/boring-agent/schedule` exports `createScheduleExtension({ now?, onDeadline?, maxDelaySeconds? })`, one native extension with `schedule({ instruction, delaySeconds | at, operationId? })`, `list_schedules()` and `cancel_schedule({ id })`, plus the delivery task `ScheduledDelivery`. A schedule is a native Pi task owned by the conversation as background work: it waits on the Harness clock (`runtime.setTimer`; Pi 1.4 removed `runtime.sleep`) and then submits the instruction to its conversation as a follow-up input (entry kind `boring.schedule.delivery`, request id = schedule id, so a replayed delivery never submits twice). Pi's scheduler runs it and a restart resumes it; there is no second scheduler. Pending schedules live in the conversation document `ConversationSchedules`, so a conversation lists and cancels only its own; a cancelled schedule's task wakes and ends without delivering. `schedule` is idempotent on `operationId` (default: the tool task, so a replayed call returns the schedule it made). Hosts schedule outside a tool with `addSchedule(tx, conversationId, { operationId, instruction, runAt })`, `cancelSchedule(tx, conversationId, id)` and `listSchedules(harness, conversationId, context)`. Pass the Harness's own clock as `now`. A host with one wake-up timer (a Durable Object alarm) computes the earliest deadline from `harness.inspect()` with `scheduledDeadline(task)` and moves the timer earlier from `onDeadline`; its alarm handler only reopens or resumes the Harness, and Pi delivers what is due.
 
 **Storage conformance.** Boring ships no Pi `Storage` implementation. `test/packages/pi-storage-conformance.test.mjs` runs Pi's own suite (`createStorageConformance`, what `registerStorageConformance` registers with Vitest) on every storage the repository configures: `openPiStorage` (shared/pi-storage.mjs) on the local-disk and network-file-system presets, Pi's `SqliteStorage` over `openBrowserSqlite`, and Pi's `openDurableObjectSqliteStorage` on a SQLite-backed Durable Object in workerd through miniflare (the version the pinned wrangler resolves).
 
@@ -551,3 +551,7 @@ Reply placeholders such as `{note.title}` accept actual strings, finite numbers
 Hosts must explicitly configure existing conversations when adopting this virtual model; deployment alone does not change their persisted selection. Keep the action's tool and result contract compatible while native work is pending. Changing definitions during an outstanding action is not a version-pinning guarantee.
 
 Evidence: `node --test test/packages/agent-actions.test.mjs` runs the public package through a native Harness, SQLite reopen, native tool gates and scripted models. `npm run test:definitions-consumer -- --actions` repeats these tests and checks strict installed declarations. Real-model speed and decision accuracy remain consumer evals, not claims of these scripted tests.
+
+### Deferred action context
+
+`withActionModels(models, { resolve, prepareFullContext })` optionally prepares context only before a full-model fallback. The asynchronous callback receives the native model context and request options, including cancellation. Successful extraction and automatic replies never invoke it. A preparation failure fails the generation without sending unprepared context. Hosts must install required guards before routing and preserve their native request/task ownership when deferring memory; this callback does not create background work or persist anything.

package/dist/actions.d.ts

@@ -26,6 +26,8 @@ export interface StructuredAction {
 export interface ActionModelsOptions {
     /** Resolve trusted configuration; this never registers tools or grants permissions. */
     readonly resolve: (id: string) => StructuredAction | undefined;
+    /** Prepare memory only when a real full-model request is needed; errors fail closed. */
+    readonly prepareFullContext?: (context: Parameters<Models['streamSimple']>[1], options: Parameters<Models['streamSimple']>[2]) => Promise<Parameters<Models['streamSimple']>[1]>;
     readonly now?: () => number;
 }
 /** Substitute actual scalar results only. Missing values cannot become invented confirmations. */

package/dist/actions.js

@@ -72,8 +72,12 @@ export function withActionModels(models, options) {
             const action = resolve(model.id);
             const original = required(action.model);
             const out = createAssistantMessageEventStream();
-            const full = async () => { for await (const event of models.streamSimple(original, context, requestOptions))
-                out.push(event); };
+            const full = async () => {
+                const prepared = options.prepareFullContext ? await options.prepareFullContext(context, requestOptions) : context;
+                requestOptions?.signal?.throwIfAborted();
+                for await (const event of models.streamSimple(original, prepared, requestOptions))
+                    out.push(event);
+            };
             const emit = (message) => {
                 if (message.stopReason === 'error' || message.stopReason === 'aborted')
                     out.push({ type: 'error', reason: message.stopReason, error: message });

package/dist/ask-user.js

@@ -6,7 +6,7 @@ export const ASK_USER_TOOL = 'ask_user';
 export const ASK_USER_MAX_ANSWER = 2000;
 /** One member per assistant entry and tool call, in the asking conversation. */
 const documents = defineDocFamily({
-    kind: 'boring.ask-user.question', version: 1, scope: 'conversation', history: 'latest', fork: 'initial', family: true,
+    kind: 'boring.ask-user.question', checkpointWhen: () => false, version: 1, scope: 'conversation', history: 'latest', fork: 'initial', family: true,
     initial: () => ({ question: null }),
 });
 /** Bind an answer to the exact assistant entry that asked it. */

package/dist/browser-task.js

@@ -11,7 +11,7 @@ import { AmbiguousCall, UnknownCall, callBinding, callBindingId, ownBindingKey,
 export const BROWSER_TASK_MAX_ANSWER = 16_384;
 /** One member per assistant entry and tool call, in the calling conversation. */
 const documents = defineDocFamily({
-    kind: 'boring.browser-task', version: 1, scope: 'conversation', history: 'latest', fork: 'initial', family: true,
+    kind: 'boring.browser-task', checkpointWhen: () => false, version: 1, scope: 'conversation', history: 'latest', fork: 'initial', family: true,
     initial: () => ({ task: null }),
 });
 /** The answer ID of a browser task call: the same `[assistantEntryId, callId]` binding as `askUserQuestionId`. */

package/dist/conversations.js

@@ -3,7 +3,7 @@ import { RequestGuardError, hasJsonContentType, readJsonBody } from '@hachej/bor
 import { MENTION_FILE_PREFIX } from './mentions.js';
 /** The native document. `fork: 'initial'`: a fork made by `fork()` gets its own metadata in the creating commit; any other fork starts unmanaged. */
 export const conversationMetadata = defineDoc({
-    kind: 'boring.conversation.metadata', version: 1, scope: 'conversation', history: 'latest', fork: 'initial',
+    kind: 'boring.conversation.metadata', checkpointWhen: () => false, version: 1, scope: 'conversation', history: 'latest', fork: 'initial',
     initial: () => ({ owner: '', title: null, createdAt: 0, updatedAt: 0, lastMessage: null, archived: false, deletedAt: null }),
 });
 const managed = (meta, owner) => meta !== undefined && meta.owner !== '' && meta.deletedAt === null && (owner === undefined || meta.owner === owner);

package/dist/file-guard.js

@@ -4,7 +4,7 @@ import { createEditTool, createReadTool, createWriteTool } from '@earendil-works
 import { asWorkspaceResolver, decorate, workspaceFor } from './workspaces.js';
 /** Conversation document: workspace and path (relative to the workspace root; see `baselineKey`) to the revision this conversation last read or wrote. */
 export const lastReadRevisions = defineDoc({
-    kind: 'boring.files.last-read', version: 1, scope: 'conversation', history: 'latest', fork: 'initial',
+    kind: 'boring.files.last-read', checkpointWhen: () => false, version: 1, scope: 'conversation', history: 'latest', fork: 'initial',
     initial: () => ({ revisions: {} }),
 });
 /** The baseline key of `path` in `workspace` (its `id`, or its provider id): `<workspace>:<path>`. */

package/dist/memory/optchat.js

@@ -15,26 +15,26 @@ export { DEFAULTS as OPTCHAT_DEFAULTS, PLACEHOLDER as OPTCHAT_PLACEHOLDER, compa
 export { OptChatLog, OptChatTree, advanceFold, emptyFold, leavesOf, renderView, zoomText, dateText } from './optchat-core.js';
 /** Summaries of one conversation, in shards of 64 nodes per level (`<level>.<shard>`). A fork starts with the current ones; fingerprints reject any that no longer match. */
 export const OptChatNodes = defineDocFamily({
-    kind: 'boring.memory.optchat.nodes', version: 1, family: true, scope: 'conversation', history: 'latest', fork: 'current', initial: () => ({ nodes: {} }),
+    kind: 'boring.memory.optchat.nodes', checkpointWhen: () => false, version: 1, family: true, scope: 'conversation', history: 'latest', fork: 'current', initial: () => ({ nodes: {} }),
 });
 /** Seed memories, stored once per conversation and inherited by forks. They precede the Pi transcript in the memory only. */
 export const OptChatNotes = defineDoc({
-    kind: 'boring.memory.optchat.notes', version: 1, scope: 'conversation', history: 'latest', fork: 'current',
+    kind: 'boring.memory.optchat.notes', checkpointWhen: () => false, version: 1, scope: 'conversation', history: 'latest', fork: 'current',
     initial: () => ({ seeded: false, notes: [] }),
 });
 /** Memory-only tombstones. Values are leaf counts, never the forgotten content. Pi's transcript is unchanged. */
 export const OptChatEdits = defineDoc({
-    kind: 'boring.memory.optchat.edits', version: 1, scope: 'conversation', history: 'latest', fork: 'current',
+    kind: 'boring.memory.optchat.edits', checkpointWhen: () => false, version: 1, scope: 'conversation', history: 'latest', fork: 'current',
     initial: () => ({ revision: 0, forgotten: {} }),
 });
 /** Only the emitted tiling and fingerprints are retained, never another copy of message or summary text. */
 const OptChatFold = defineDocFamily({
-    kind: 'boring.memory.optchat.fold', version: 1, family: true, scope: 'conversation', history: 'latest', fork: 'current',
+    kind: 'boring.memory.optchat.fold', checkpointWhen: () => false, version: 1, family: true, scope: 'conversation', history: 'latest', fork: 'current',
     initial: () => ({ configuration: '', revision: -1, fingerprints: [], fold: null }),
 });
 /** Compactor bookkeeping of one conversation: calls, spend and the last failure of each node, including its retry streak. */
 export const OptChatState = defineDoc({
-    kind: 'boring.memory.optchat.state', version: 1, scope: 'conversation', history: 'latest', fork: 'initial',
+    kind: 'boring.memory.optchat.state', checkpointWhen: () => false, version: 1, scope: 'conversation', history: 'latest', fork: 'initial',
     initial: () => ({ calls: 0, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 }, failures: {} }),
 });
 const SHARD = 64;

package/dist/native-version.d.ts

@@ -3,7 +3,7 @@
  * native shapes produced them. New records take the current release; records written under an earlier reviewed release stay
  * readable, because the native conversation and tool shapes they refer to did not change between them.
  */
-export declare const NATIVE_VERSION = "pi-durable@1.2.0";
+export declare const NATIVE_VERSION = "pi-durable@1.4.0";
 export type NativeVersion = 'pi-durable@1.0.1' | 'pi-durable@1.1.0' | typeof NATIVE_VERSION;
 export declare const isNativeVersion: (value: unknown) => value is NativeVersion;
 //# sourceMappingURL=native-version.d.ts.map

package/dist/native-version.js

@@ -3,5 +3,5 @@
  * native shapes produced them. New records take the current release; records written under an earlier reviewed release stay
  * readable, because the native conversation and tool shapes they refer to did not change between them.
  */
-export const NATIVE_VERSION = 'pi-durable@1.2.0';
+export const NATIVE_VERSION = 'pi-durable@1.4.0';
 export const isNativeVersion = (value) => value === NATIVE_VERSION || value === 'pi-durable@1.1.0' || value === 'pi-durable@1.0.1';

package/dist/questions.js

@@ -1,4 +1,5 @@
 import { ReadAfterWrite, defineDocFamily, defineExtension, defineTask } from '@earendil-works/pi-durable';
+import { waitUntil } from './wait-until.js';
 function sameRef(left, right) {
     return left.runtimeId === right.runtimeId && left.conversationId === right.conversationId
         && left.taskId === right.taskId && left.questionId === right.questionId && left.scopeId === right.scopeId
@@ -11,7 +12,7 @@ export function createQuestions(options) {
         throw new TypeError('A stable runtime identity is required');
     const now = options.now ?? Date.now;
     const documents = defineDocFamily({
-        kind: 'boring.questions.record', version: 1, scope: 'session', family: true,
+        kind: 'boring.questions.record', checkpointWhen: () => false, version: 1, scope: 'session', family: true,
         initial: () => ({ question: null }),
     });
     const key = (ref) => JSON.stringify([runtimeId, ref.scopeId, ref.questionId]);
@@ -40,11 +41,17 @@ export function createQuestions(options) {
                             watch.start(async (value) => { if (value?.question?.state.kind !== 'pending')
                                 resolve(); });
                         });
-                        await Promise.race([
-                            changed,
-                            runtime.sleep(Date.parse(watch.value.question.ref.expiresAt), context),
-                            watch.closed.then(() => { throw new Error('Question observation closed'); }),
-                        ]);
+                        const expiry = waitUntil(runtime, Date.parse(watch.value.question.ref.expiresAt), context);
+                        try {
+                            await Promise.race([
+                                changed,
+                                expiry.done,
+                                watch.closed.then(() => { throw new Error('Question observation closed'); }),
+                            ]);
+                        }
+                        finally {
+                            expiry.disarm();
+                        }
                     }
                     await runtime.commit(async (tx) => {
                         const doc = await tx.doc(documents, running.input.key, null);

package/dist/room.js

@@ -118,8 +118,8 @@ export function wakeFor(entry, room) {
     return room.people.length === 1 && room.people[0] === author && room.agents.includes('agent:pm') ? [wake('agent:pm')] : [];
 }
 /** Conversation names to native ids, and each card's first entry (an action's target). */
-const RoomIndex = defineDoc({ kind: 'boring.room.index', version: 1, scope: 'session', initial: () => ({ conversations: {}, cards: {} }) });
-const RoomWakes = defineDoc({ kind: 'boring.room.wakes', version: 1, scope: 'session', initial: () => ({ open: [] }) });
+const RoomIndex = defineDoc({ kind: 'boring.room.index', checkpointWhen: () => false, version: 1, scope: 'session', initial: () => ({ conversations: {}, cards: {} }) });
+const RoomWakes = defineDoc({ kind: 'boring.room.wakes', checkpointWhen: () => false, version: 1, scope: 'session', initial: () => ({ open: [] }) });
 const REFUSED = Object.freeze({ refused: 'no-open-wake' });
 const copyWake = (wake) => ({ ...wake });
 /** The room over one Harness that never runs a model. Membership, roles and rates are the host's, before it calls. */
@@ -264,7 +264,7 @@ const framesOf = (entries) => entries.flatMap(entry => (entry.model ?? []).flatM
         return [];
     return message.content.flatMap((part) => part.type === 'text' && part.text ? [{ type: 'text', text: part.text }] : part.type === 'toolCall' ? [{ type: 'step', label: part.name, status: 'running' }] : []);
 }));
-const Turns = defineDoc({ kind: 'boring.room.turns', version: 1, scope: 'conversation', history: 'latest', fork: 'initial', initial: () => ({ owed: [] }) });
+const Turns = defineDoc({ kind: 'boring.room.turns', checkpointWhen: () => false, version: 1, scope: 'conversation', history: 'latest', fork: 'initial', initial: () => ({ owed: [] }) });
 /** The agent's side of a room, over its own conversation in its own home. Delivery to the port is at least once. */
 export function createRoomTurn(options) {
     const { conversation, port } = options;

package/dist/run-result.js

@@ -9,7 +9,7 @@ const INTERRUPTED = new Set(['aborted', 'reset', 'stale']);
  * Defined without `history` and `fork`, exactly as the homes that ran this protocol before persisted it: pi-durable refuses a token
  * whose semantics differ from the stored record, so adding them here would break every existing run store.
  */
-export const ResultBudget = defineDoc({ kind: 'boring.result-budget', version: 1, scope: 'conversation', initial: () => ({ misses: 0 }) });
+export const ResultBudget = defineDoc({ kind: 'boring.result-budget', checkpointWhen: () => false, version: 1, scope: 'conversation', initial: () => ({ misses: 0 }) });
 /** Parse `result:` of a card. `legacy` is the card's `tool.json`, whose input is the default schema. Throws a plain Error naming the agent. */
 export function resultConfig(value, legacy, name) {
     if (value !== undefined && (!value || typeof value !== 'object' || Array.isArray(value)))

package/dist/schedule.d.ts

@@ -33,7 +33,7 @@ export declare const ConversationSchedules: import("@earendil-works/pi-durable")
     next: number;
 }>;
 /**
- * The native durable task behind one schedule: it sleeps on the Harness clock (`runtime.sleep`), then delivers the instruction to
+ * The native durable task behind one schedule: it waits on the Harness clock (`runtime.setTimer`), then delivers the instruction to
  * its conversation as a follow-up input whose request id is the schedule id, so a replayed delivery never submits twice. Owned by
  * the conversation as background work: a person stopping the current turn does not cancel it. No second scheduler: Pi's own
  * scheduler runs it, and a restart resumes it.

package/dist/schedule.js

@@ -1,6 +1,7 @@
 import { defineDoc, defineExtension, defineTask, defineTool } from '@earendil-works/pi-durable';
 import { Type } from '@earendil-works/pi-ai';
 import { withAbortSignal } from '@earendil-works/chord/context';
+import { waitUntil } from './wait-until.js';
 export const SCHEDULE_TOOL = 'schedule';
 export const LIST_SCHEDULES_TOOL = 'list_schedules';
 export const CANCEL_SCHEDULE_TOOL = 'cancel_schedule';
@@ -11,7 +12,7 @@ const MAX_INSTRUCTION = 4000;
 const TIMEZONE_SUFFIX = /(?:Z|[+-]\d{2}:\d{2})$/i;
 /** Pending schedules of one conversation. Forks start empty: a schedule belongs to the conversation that made it. */
 export const ConversationSchedules = defineDoc({
-    kind: 'boring.schedules', version: 1, scope: 'conversation', history: 'latest', fork: 'initial', initial: () => ({ items: [], next: 1 }),
+    kind: 'boring.schedules', checkpointWhen: () => false, version: 1, scope: 'conversation', history: 'latest', fork: 'initial', initial: () => ({ items: [], next: 1 }),
 });
 const remove = (items, id) => { const index = items.findIndex(item => item.id === id); if (index !== -1)
     items.splice(index, 1); };
@@ -27,7 +28,13 @@ async function sleepUnlessCancelled(runtime, input, context) {
             return true;
         watch.start(async (value) => { if (cancelledIn(value))
             cancel.abort(); });
-        await runtime.sleep(input.runAt, withAbortSignal(cancel.signal, context));
+        const wait = waitUntil(runtime, input.runAt, withAbortSignal(cancel.signal, context));
+        try {
+            await wait.done;
+        }
+        finally {
+            wait.disarm();
+        }
         return false;
     }
     catch (error) {
@@ -40,7 +47,7 @@ async function sleepUnlessCancelled(runtime, input, context) {
     }
 }
 /**
- * The native durable task behind one schedule: it sleeps on the Harness clock (`runtime.sleep`), then delivers the instruction to
+ * The native durable task behind one schedule: it waits on the Harness clock (`runtime.setTimer`), then delivers the instruction to
  * its conversation as a follow-up input whose request id is the schedule id, so a replayed delivery never submits twice. Owned by
  * the conversation as background work: a person stopping the current turn does not cancel it. No second scheduler: Pi's own
  * scheduler runs it, and a restart resumes it.

package/dist/view-open.js

@@ -12,7 +12,7 @@ export const VIEW_OPEN_TIMEOUT_MS = 15_000;
 export const PRESENT_TOOL = 'present';
 /** One member per assistant entry and tool call, in the calling conversation. */
 const documents = defineDocFamily({
-    kind: 'boring.view-open', version: 1, scope: 'conversation', history: 'latest', fork: 'initial', family: true,
+    kind: 'boring.view-open', checkpointWhen: () => false, version: 1, scope: 'conversation', history: 'latest', fork: 'initial', family: true,
     initial: () => ({ view: null }),
 });
 const MAX_REASON = 200;

package/dist/wait-until.d.ts

@@ -0,0 +1,12 @@
+import type { TaskRuntime } from '@earendil-works/pi-durable';
+import type { Context } from '@earendil-works/chord';
+/**
+ * Wait inside the running phase until the Harness clock reaches `at`, on the Harness's own timer (`TaskRuntime.setTimer`, the
+ * 1.4 replacement for the removed `TaskRuntime.sleep`). It rejects when `context` is cancelled first. `disarm` frees the timer
+ * when something else ends the wait. It is not durable: a restart reruns the phase, which reads its absolute deadline again.
+ */
+export declare function waitUntil(runtime: Pick<TaskRuntime<never, never, never, never>, 'now' | 'setTimer'>, at: number, context: Context): {
+    readonly done: Promise<void>;
+    readonly disarm: () => void;
+};
+//# sourceMappingURL=wait-until.d.ts.map

package/dist/wait-until.js

@@ -0,0 +1,20 @@
+/**
+ * Wait inside the running phase until the Harness clock reaches `at`, on the Harness's own timer (`TaskRuntime.setTimer`, the
+ * 1.4 replacement for the removed `TaskRuntime.sleep`). It rejects when `context` is cancelled first. `disarm` frees the timer
+ * when something else ends the wait. It is not durable: a restart reruns the phase, which reads its absolute deadline again.
+ */
+export function waitUntil(runtime, at, context) {
+    let disarm = () => { };
+    const done = new Promise((resolve, reject) => {
+        const signal = context.abortSignal;
+        if (signal?.aborted) {
+            reject(signal.reason ?? new Error('Wait cancelled'));
+            return;
+        }
+        const onAbort = () => { disarm(); reject(signal.reason ?? new Error('Wait cancelled')); };
+        const disarmTimer = runtime.setTimer(() => { signal?.removeEventListener('abort', onAbort); resolve(); }, Math.max(0, at - runtime.now()));
+        signal?.addEventListener('abort', onAbort, { once: true });
+        disarm = () => { signal?.removeEventListener('abort', onAbort); disarmTimer(); };
+    });
+    return { done, disarm: () => disarm() };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hachej/boring-agent",
-  "version": "0.4.27",
+  "version": "0.4.29",
   "license": "MIT",
   "private": false,
   "type": "module",
@@ -177,11 +177,11 @@
     "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz"
   },
   "peerDependencies": {
-    "@earendil-works/pi-durable": "~1.2.0",
-    "@earendil-works/pi-ai": "~1.2.0",
-    "@earendil-works/chord": "~1.2.0",
-    "@hachej/boring-files": "^0.4.27",
-    "@hachej/boring-ui-kit": "^0.4.27",
+    "@earendil-works/pi-durable": "~1.4.0",
+    "@earendil-works/pi-ai": "~1.4.0",
+    "@earendil-works/chord": "~1.4.0",
+    "@hachej/boring-files": "^0.4.29",
+    "@hachej/boring-ui-kit": "^0.4.29",
     "typebox": "1.3.27",
     "xlsx": "^0.20.3"
   },