@animalabs/agent-framework 0.23.3 → 0.24.1

package/dist/src/clock-rows.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Clock rows: a time marker an agent's window takes when an interval
+ * boundary has passed since the last one it holds.
+ *
+ * The model is a tick event at every boundary of the agent's local wall
+ * clock (every 10 minutes, say, from local midnight). The ticks aren't
+ * written as they fire. One is written when the window next takes something
+ * (an incoming event, a tool round's results, the start of a turn), and only
+ * the latest of the ticks that fired meanwhile: nothing was written between
+ * them, and a clock wakes no one, so the window reads exactly as it would
+ * had every tick been written and the earlier ones coalesced away.
+ *
+ * A clock never lies about order. One that lands where its tick would have
+ * been (the row before it is no newer than the boundary) reads the
+ * boundary's time, which is in the past by the time it is written. One that
+ * can't (the boundary passed while the agent was mid-reply or a tool ran:
+ * a tool's results must follow its call directly, so nothing can be written
+ * between them) reads the time it is written instead.
+ *
+ * Everything the next clock needs is read back from the window: the last
+ * clock row's time, wherever it is, and the newest row's. A window that
+ * holds no clock row takes one the next time it would take a clock (an
+ * incoming event, a turn's start, a tool boundary), so a window that has
+ * just had a clock turned on, or a fork seeded with copies of its
+ * template's rows (which carry none of their metadata), reads the time
+ * then. A restart, a rollback or a second resident sharing the window
+ * leaves nothing stale to reconcile.
+ */
+import type { ContentBlock } from '@animalabs/membrane';
+/** `AgentConfig.clock`: when the agent's window takes clock rows. */
+export interface ClockConfig {
+    /** Minutes between boundaries. Give this or `intervalSeconds`. */
+    intervalMinutes?: number;
+    /** Seconds between boundaries, for clocks finer than a minute. */
+    intervalSeconds?: number;
+    /**
+     * How a clock reads: `'minutes'` (`10:50`) or `'seconds'` (`10:50:30`).
+     * Defaults to minutes for an interval of whole minutes, else seconds.
+     */
+    precision?: 'minutes' | 'seconds';
+}
+export interface ResolvedClockConfig {
+    intervalSeconds: number;
+    precision: 'minutes' | 'seconds';
+}
+/** `metadata.kind` of a clock row. */
+export declare const CLOCK_ROW_KIND = "clock";
+/** `metadata.clock` of a clock row. */
+export interface ClockStamp {
+    /** The instant the row reads, epoch ms. */
+    at: number;
+    /** Whether that instant is the boundary itself (else, when it was written). */
+    onBoundary: boolean;
+    /** The IANA zone it reads in. */
+    zone: string;
+}
+/**
+ * Validate `AgentConfig.clock`. Undefined when the agent has no clock; throws
+ * on a setting that can't be read as one, naming the agent.
+ */
+export declare function resolveClockConfig(agentName: string, config: ClockConfig | undefined): ResolvedClockConfig | undefined;
+/**
+ * The latest boundary at or before `now`: an instant at which the zone's
+ * wall clock read a whole multiple of the interval since local midnight. A
+ * boundary whose wall time a DST change skips doesn't occur; one it repeats
+ * occurs twice.
+ *
+ * While the zone's offset stays the same, its wall clock runs with real
+ * time, so the latest boundary is `now` less how far the wall clock has run
+ * past its last multiple of the interval. Where that instant has another
+ * offset, the offset changed in between and no boundary falls between the
+ * change and `now`: the walk goes on from just before the change. The change
+ * is found by searching between the two instants, whatever their offsets
+ * are. The same offset at both is taken to mean no change between them: in
+ * the tz data, no zone changes its offset twice within a day, the longest
+ * interval, from 2024 through 2040. Throws if the walk passes 24 changes,
+ * which no real zone reaches, rather than return an instant that isn't a
+ * boundary.
+ */
+export declare function latestBoundary(now: number, intervalSeconds: number, zone: string): number;
+/**
+ * A clock row's text: `Clock: 10:50 Europe/Berlin (UTC+02:00)`, with the
+ * weekday and date ahead of the time when `withDate`
+ * (`Clock: Thursday 2026-10-22, 00:00 Europe/Berlin (UTC+02:00)`).
+ */
+export declare function formatClockText(at: number, zone: string, precision: 'minutes' | 'seconds', withDate: boolean): string;
+/** A clock row to store. */
+export interface PlannedClock {
+    content: ContentBlock[];
+    stamp: ClockStamp;
+}
+/**
+ * The clock row the window takes next, or null when no boundary has passed
+ * since the last clock it holds. The framework asks before an incoming
+ * event, at a turn's start and at a tool boundary (storeDueClock).
+ *
+ * - `newestRowAt`: the newest row's time, which the clock goes after.
+ * - `lastClockAt`: the time the window's last clock row reads, when it holds
+ *   one. Without one, no boundary counts as told: the window takes a clock
+ *   now, and it carries the date.
+ */
+export declare function planClock(args: {
+    now: number;
+    newestRowAt: number | undefined;
+    lastClockAt: number | undefined;
+    config: ResolvedClockConfig;
+    zone: string;
+}): PlannedClock | null;
+/** The clock stamp a stored row's metadata carries, if it is a clock row. */
+export declare function clockStampOf(metadata: unknown): ClockStamp | undefined;
+/** Whether a row can have a clock written before it: not the agent's own
+ *  (an assistant turn), no tool blocks (a tool's results follow its call
+ *  directly), and not itself a clock. */
+export declare function takesClockBefore(participant: string, content: readonly ContentBlock[], metadata: unknown, agentName: string): boolean;
+//# sourceMappingURL=clock-rows.d.ts.map

package/dist/src/clock-rows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock-rows.d.ts","sourceRoot":"","sources":["../../src/clock-rows.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGxD,qEAAqE;AACrE,MAAM,WAAW,WAAW;IAC1B,kEAAkE;IAClE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,kEAAkE;IAClE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,SAAS,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;CACnC;AAED,MAAM,WAAW,mBAAmB;IAClC,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,SAAS,GAAG,SAAS,CAAC;CAClC;AAED,sCAAsC;AACtC,eAAO,MAAM,cAAc,UAAU,CAAC;AAEtC,uCAAuC;AACvC,MAAM,WAAW,UAAU;IACzB,2CAA2C;IAC3C,EAAE,EAAE,MAAM,CAAC;IACX,+EAA+E;IAC/E,UAAU,EAAE,OAAO,CAAC;IACpB,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAC;CACd;AAID;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,SAAS,GAAG,mBAAmB,GAAG,SAAS,CA4BtH;AAsDD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAczF;AAkCD;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,SAAS,GAAG,SAAS,EAChC,QAAQ,EAAE,OAAO,GAChB,MAAM,CAaR;AAED,4BAA4B;AAC5B,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,KAAK,EAAE,UAAU,CAAC;CACnB;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,MAAM,EAAE,mBAAmB,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,YAAY,GAAG,IAAI,CAgBtB;AAED,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,QAAQ,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAItE;AAED;;yCAEyC;AACzC,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,QAAQ,EAAE,OAAO,EACjB,SAAS,EAAE,MAAM,GAChB,OAAO,CAIT"}

package/dist/src/clock-rows.js

@@ -0,0 +1,222 @@
+/**
+ * Clock rows: a time marker an agent's window takes when an interval
+ * boundary has passed since the last one it holds.
+ *
+ * The model is a tick event at every boundary of the agent's local wall
+ * clock (every 10 minutes, say, from local midnight). The ticks aren't
+ * written as they fire. One is written when the window next takes something
+ * (an incoming event, a tool round's results, the start of a turn), and only
+ * the latest of the ticks that fired meanwhile: nothing was written between
+ * them, and a clock wakes no one, so the window reads exactly as it would
+ * had every tick been written and the earlier ones coalesced away.
+ *
+ * A clock never lies about order. One that lands where its tick would have
+ * been (the row before it is no newer than the boundary) reads the
+ * boundary's time, which is in the past by the time it is written. One that
+ * can't (the boundary passed while the agent was mid-reply or a tool ran:
+ * a tool's results must follow its call directly, so nothing can be written
+ * between them) reads the time it is written instead.
+ *
+ * Everything the next clock needs is read back from the window: the last
+ * clock row's time, wherever it is, and the newest row's. A window that
+ * holds no clock row takes one the next time it would take a clock (an
+ * incoming event, a turn's start, a tool boundary), so a window that has
+ * just had a clock turned on, or a fork seeded with copies of its
+ * template's rows (which carry none of their metadata), reads the time
+ * then. A restart, a rollback or a second resident sharing the window
+ * leaves nothing stale to reconcile.
+ */
+import { resolveTimeZone } from './timezone.js';
+/** `metadata.kind` of a clock row. */
+export const CLOCK_ROW_KIND = 'clock';
+const DAY_SECONDS = 86_400;
+/**
+ * Validate `AgentConfig.clock`. Undefined when the agent has no clock; throws
+ * on a setting that can't be read as one, naming the agent.
+ */
+export function resolveClockConfig(agentName, config) {
+    if (config === undefined)
+        return undefined;
+    const at = `Agent "${agentName}" clock`;
+    if (config === null || typeof config !== 'object' || Array.isArray(config)) {
+        throw new Error(`${at} must be an object such as { intervalMinutes: 10 }, or left out for no clock rows of its own`);
+    }
+    const { intervalMinutes, intervalSeconds, precision } = config;
+    if ((intervalMinutes === undefined) === (intervalSeconds === undefined)) {
+        throw new Error(`${at} takes exactly one of intervalMinutes and intervalSeconds`);
+    }
+    const given = intervalMinutes !== undefined ? intervalMinutes : intervalSeconds;
+    if (typeof given !== 'number' || !Number.isInteger(given) || given <= 0) {
+        throw new Error(`${at}.${intervalMinutes !== undefined ? 'intervalMinutes' : 'intervalSeconds'} must be a positive whole number`);
+    }
+    const seconds = intervalMinutes !== undefined ? given * 60 : given;
+    if (seconds > DAY_SECONDS) {
+        throw new Error(`${at} interval is at most a day (1440 minutes); boundaries count from local midnight`);
+    }
+    if (precision !== undefined && precision !== 'minutes' && precision !== 'seconds') {
+        throw new Error(`${at}.precision must be 'minutes' or 'seconds'`);
+    }
+    const resolved = precision ?? (seconds % 60 === 0 ? 'minutes' : 'seconds');
+    if (resolved === 'minutes' && seconds % 60 !== 0) {
+        throw new Error(`${at}: an interval of ${seconds} seconds isn't whole minutes, so its clocks need precision 'seconds'`);
+    }
+    return { intervalSeconds: seconds, precision: resolved };
+}
+const formatters = new Map();
+function formatterFor(zone) {
+    let formatter = formatters.get(zone);
+    if (!formatter) {
+        formatter = new Intl.DateTimeFormat('en-CA', {
+            timeZone: zone,
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            hourCycle: 'h23',
+        });
+        formatters.set(zone, formatter);
+    }
+    return formatter;
+}
+function wallFields(at, zone) {
+    const parts = formatterFor(zone).formatToParts(new Date(at));
+    const get = (type) => Number(parts.find((part) => part.type === type)?.value ?? NaN);
+    const fields = {
+        year: get('year'),
+        month: get('month'),
+        day: get('day'),
+        hour: get('hour'),
+        minute: get('minute'),
+        second: get('second'),
+    };
+    const shownAsUtc = Date.UTC(fields.year, fields.month - 1, fields.day, fields.hour, fields.minute, fields.second);
+    const offsetMinutes = Math.round((shownAsUtc - Math.floor(at / 1000) * 1000) / 60_000);
+    return { ...fields, offsetMinutes };
+}
+/**
+ * The latest boundary at or before `now`: an instant at which the zone's
+ * wall clock read a whole multiple of the interval since local midnight. A
+ * boundary whose wall time a DST change skips doesn't occur; one it repeats
+ * occurs twice.
+ *
+ * While the zone's offset stays the same, its wall clock runs with real
+ * time, so the latest boundary is `now` less how far the wall clock has run
+ * past its last multiple of the interval. Where that instant has another
+ * offset, the offset changed in between and no boundary falls between the
+ * change and `now`: the walk goes on from just before the change. The change
+ * is found by searching between the two instants, whatever their offsets
+ * are. The same offset at both is taken to mean no change between them: in
+ * the tz data, no zone changes its offset twice within a day, the longest
+ * interval, from 2024 through 2040. Throws if the walk passes 24 changes,
+ * which no real zone reaches, rather than return an instant that isn't a
+ * boundary.
+ */
+export function latestBoundary(now, intervalSeconds, zone) {
+    let at = now;
+    // A pass that doesn't return steps back past an offset change, and a day
+    // of a real zone holds at most two of them; running out of passes is a
+    // defect, and it throws rather than return an instant that isn't a boundary.
+    for (let pass = 0; pass < 24; pass++) {
+        const f = wallFields(at, zone);
+        const secondOfDay = f.hour * 3600 + f.minute * 60 + f.second;
+        const subSecond = at - Math.floor(at / 1000) * 1000;
+        const candidate = at - (secondOfDay % intervalSeconds) * 1000 - subSecond;
+        if (wallFields(candidate, zone).offsetMinutes === f.offsetMinutes)
+            return candidate;
+        at = offsetTakenAt(candidate, at, f.offsetMinutes, zone) - 1;
+    }
+    throw new Error(`no clock boundary found within 24 offset changes of ${new Date(now).toISOString()} in ${zone}`);
+}
+/**
+ * The instant in (`from`, `to`] at which the zone took `offset`, given that
+ * `to` reads at that offset and `from` doesn't, to the millisecond.
+ */
+function offsetTakenAt(from, to, offset, zone) {
+    let before = from;
+    let after = to;
+    while (after - before > 1) {
+        const mid = Math.floor((before + after) / 2);
+        if (wallFields(mid, zone).offsetMinutes === offset)
+            after = mid;
+        else
+            before = mid;
+    }
+    return after;
+}
+// ---------------------------------------------------------------------------
+// What a clock reads
+// ---------------------------------------------------------------------------
+const WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+const pad = (n) => String(n).padStart(2, '0');
+function localDate(at, zone) {
+    const f = wallFields(at, zone);
+    return `${f.year}-${pad(f.month)}-${pad(f.day)}`;
+}
+function isUtcZone(zone) {
+    return /^(Etc\/)?(UTC|UCT|Zulu|Universal|GMT|Greenwich)$/.test(zone) || zone === 'Etc/GMT0' || zone === 'GMT0';
+}
+/**
+ * A clock row's text: `Clock: 10:50 Europe/Berlin (UTC+02:00)`, with the
+ * weekday and date ahead of the time when `withDate`
+ * (`Clock: Thursday 2026-10-22, 00:00 Europe/Berlin (UTC+02:00)`).
+ */
+export function formatClockText(at, zone, precision, withDate) {
+    const f = wallFields(at, zone);
+    const time = precision === 'seconds'
+        ? `${pad(f.hour)}:${pad(f.minute)}:${pad(f.second)}`
+        : `${pad(f.hour)}:${pad(f.minute)}`;
+    const weekday = WEEKDAYS[new Date(Date.UTC(f.year, f.month - 1, f.day)).getUTCDay()];
+    const date = withDate ? `${weekday} ${f.year}-${pad(f.month)}-${pad(f.day)}, ` : '';
+    const sign = f.offsetMinutes < 0 ? '-' : '+';
+    const offset = Math.abs(f.offsetMinutes);
+    const where = isUtcZone(zone) && f.offsetMinutes === 0
+        ? 'UTC'
+        : `${zone} (UTC${sign}${pad(Math.floor(offset / 60))}:${pad(offset % 60)})`;
+    return `Clock: ${date}${time} ${where}`;
+}
+/**
+ * The clock row the window takes next, or null when no boundary has passed
+ * since the last clock it holds. The framework asks before an incoming
+ * event, at a turn's start and at a tool boundary (storeDueClock).
+ *
+ * - `newestRowAt`: the newest row's time, which the clock goes after.
+ * - `lastClockAt`: the time the window's last clock row reads, when it holds
+ *   one. Without one, no boundary counts as told: the window takes a clock
+ *   now, and it carries the date.
+ */
+export function planClock(args) {
+    const { now, newestRowAt, lastClockAt, config } = args;
+    const zone = resolveTimeZone(args.zone);
+    const boundary = latestBoundary(now, config.intervalSeconds, zone);
+    const told = lastClockAt !== undefined ? latestBoundary(lastClockAt, config.intervalSeconds, zone) : -Infinity;
+    if (boundary <= told)
+        return null;
+    // The boundary's own time only where its tick would have been: no row
+    // after the boundary comes before the clock. Otherwise the time it is
+    // written, and never earlier than the row it follows.
+    const onBoundary = newestRowAt === undefined || newestRowAt <= boundary;
+    const at = onBoundary ? boundary : Math.max(now, newestRowAt);
+    const withDate = lastClockAt === undefined || localDate(lastClockAt, zone) !== localDate(at, zone);
+    return {
+        content: [{ type: 'text', text: formatClockText(at, zone, config.precision, withDate) }],
+        stamp: { at, onBoundary, zone },
+    };
+}
+/** The clock stamp a stored row's metadata carries, if it is a clock row. */
+export function clockStampOf(metadata) {
+    const m = metadata;
+    if (m?.kind !== CLOCK_ROW_KIND || typeof m.clock?.at !== 'number')
+        return undefined;
+    return m.clock;
+}
+/** Whether a row can have a clock written before it: not the agent's own
+ *  (an assistant turn), no tool blocks (a tool's results follow its call
+ *  directly), and not itself a clock. */
+export function takesClockBefore(participant, content, metadata, agentName) {
+    return participant !== agentName
+        && !content.some((b) => b.type === 'tool_use' || b.type === 'tool_result')
+        && clockStampOf(metadata) === undefined;
+}
+//# sourceMappingURL=clock-rows.js.map

package/dist/src/clock-rows.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock-rows.js","sourceRoot":"","sources":["../../src/clock-rows.ts"],"names":[],"mappings":"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"}

package/dist/src/code-execution/engine.d.ts

@@ -0,0 +1,177 @@
+/** What the child sets once, before any script code runs. */
+export interface EngineLimits {
+    /**
+     * The linear memory's maximum, the guest's budget: a whole number of 64 KiB pages, from
+     * `MIN_MEMORY_BYTES` to `MAX_MEMORY_BYTES`. The engine's own stack and data take its first ~1.1 MiB, and
+     * QuickJS's allocation limit sits a margin below the rest, so that a script reaching it gets a
+     * catchable out-of-memory error rather than a failed allocation inside the engine.
+     */
+    memoryMaxBytes: number;
+    /** QuickJS's stack limit, at most `MAX_STACK_BYTES`; `DEFAULT_STACK_BYTES` when left out. */
+    maxStackBytes?: number;
+}
+/**
+ * The four imports, as slots the child fills. Each is called synchronously from inside the
+ * engine, so none may await, and none may call back into the engine: a call into it from a slot
+ * throws an `EngineError`. A slot that throws ends the run: the call in progress throws that
+ * error, wrapped as an `EngineError`, and no slot is called again but `supervise()`.
+ */
+export interface EngineSlots {
+    /**
+     * The guest called `__host(name, argsJson)`, which returned a pending promise to the guest.
+     * `callId` names that promise for `settle`. Ids are the engine's, 1, 2, 3 and on.
+     */
+    hostCall(callId: number, name: string, argsJson: string): void;
+    /**
+     * Called while the guest runs, every few thousand of its operations. Return true to stop it for
+     * good: the engine doesn't ask again, the call in progress answers `interrupted`, and so does
+     * every call after, with two exceptions. A stop in the jobs that reading the script's ending
+     * queued, after the ending was read whole, lets that call answer the ending, and the calls after
+     * it answer `interrupted`. And a run answered `failed` stays so, a stop while its exception is
+     * read included; a throw as the run starts is the script's own ending, answered `rejected`, which
+     * a stop while it's read turns into `interrupted`, as for any rejection.
+     */
+    interrupt(): boolean;
+    /**
+     * Called at every interrupt check, before `interrupt()` is asked, and after it has said stop or a
+     * slot has failed, when it's asked no more: the child's watch over its own process, such as its
+     * parent going, which no stop or failure ends, since a script can keep a stop from landing. It
+     * returns nothing: a stop it calls for comes through `interrupt()`. One that throws ends the run
+     * as any slot's failure, and is still called at the checks after.
+     */
+    supervise(): void;
+    /** The guest called `__output(stream, text)`: stream 1 is out, 2 is err. */
+    output(stream: 1 | 2, text: string): void;
+}
+/** How a call into the guest left it. */
+export type RunState = 
+/** The queue is empty and the script hasn't settled: it awaits a call, or a promise nothing settles. */
+{
+    kind: 'pending';
+}
+/**
+ * The script settled. `json` is JSON.stringify of its value, undefined when that gives none. It's
+ * taken once: every later answer of this state carries the same text.
+ */
+ | {
+    kind: 'fulfilled';
+    json: string | undefined;
+}
+/**
+ * The prelude or the script threw, or its value couldn't be stringified (a BigInt, a cycle).
+ * The fields are what was thrown: an Error's name, message and stack. A thrown value with no
+ * message of its own has name `''`, and as its message an object's JSON, or else its string
+ * form; a Symbol, which has none here, leaves the message `''`.
+ */
+ | {
+    kind: 'rejected';
+    name: string;
+    message: string;
+    stack?: string;
+}
+/**
+ * Once the script was running, an exception escaped its promises and ended the run, even after
+ * its own ending: a callback it gave `queueMicrotask` or a `FinalizationRegistry` threw, or a job
+ * failed in the engine itself; or the engine couldn't settle a call. The fields are the
+ * exception's, read as the engine reads a `rejected` one (an Error's name, message and stack; a
+ * value with no message of its own, its JSON or string form), less any part a stop cut off while
+ * it was read: a stop ends the read, and nothing after it is read. Every later call answers
+ * the same, a stop after it included, and no later result reaches the script.
+ */
+ | {
+    kind: 'failed';
+    name: string;
+    message: string;
+    stack?: string;
+}
+/** `interrupt()` returned true while it ran. */
+ | {
+    kind: 'interrupted';
+};
+/**
+ * What `settle` answers: the run's state; `unfit` when the guest couldn't take the result, for
+ * want of memory to copy it in or of memory or stack to parse it, and the call took the child's
+ * own error instead; and `dropped` when neither was handed over, because the run had been stopped
+ * or had failed before this settle (`interrupted` or `failed`), or the call of the promise's
+ * resolve or reject function was stopped or failed before it ran. Without `dropped`, that function
+ * ran with the result or the child's error, and the script's own code runs with it: a `then`
+ * getter it put on Object.prototype, which can reject the promise instead, and its continuations.
+ * A stop or failure in that code, or in the jobs after, leaves it handed over. The two are never
+ * both set.
+ */
+export type SettleState = RunState & {
+    unfit?: true;
+    dropped?: true;
+};
+export interface Engine {
+    /**
+     * Evaluates the prelude as a global script, then the script as global code with top-level
+     * await, then runs pending jobs until none is left, the guest is interrupted or the run fails.
+     * The script's value is that of its last expression statement. Called once.
+     */
+    start(prelude: string, script: string, filename: string): RunState;
+    /**
+     * Settles call `callId`, then runs pending jobs as `start` does. With `ok`, the call's promise
+     * resolves to the parsed JSON; otherwise it rejects with it, and the prelude makes an Error of
+     * it. A result the guest can't take, for want of memory to copy it in or of memory or stack to
+     * parse it, nested deeper than `MAX_RESULT_DEPTH`, or not JSON, rejects it with `unfitJson`
+     * parsed, the child's own error (`ResultTooLarge`), and the answer has `unfit: true`: the call
+     * took effect, and an error at its await would read as a failed call. Allowed after `fulfilled`,
+     * for calls still in flight when a script returned. Throws for an id that isn't pending.
+     *
+     * Once a call has answered the script's ending, later calls answer it again, unless something
+     * came after it: a stop answers `interrupted`, a slot's failure throws, and an exception that
+     * escapes the script's promises answers `failed`. One that escapes the jobs reading the ending
+     * queued is answered by the call that read it, in the ending's place.
+     */
+    settle(callId: number, ok: boolean, json: string | Uint8Array, unfitJson: string): SettleState;
+    /** Frees the engine's runtime, unless the module trapped, which leaves it as it is. Nothing may be called after it. */
+    dispose(): void;
+}
+/** The engine failed, rather than the script: a slot threw, the engine crashed, or it was misused. */
+export declare class EngineError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare const MIN_MEMORY_BYTES: number;
+/**
+ * 2 GiB, so that every address in linear memory fits the signed 32-bit numbers the module's
+ * pointers arrive as, and no conversion is needed where the host reads them.
+ */
+export declare const MAX_MEMORY_BYTES: number;
+/**
+ * The most QuickJS's stack limit may be, and its default. QuickJS measures its stack in the
+ * module's linear memory, but each level of a script's recursion through calls also takes the
+ * host's own stack, two to three times as much in the 31 ways to recurse that were measured, and
+ * under Node that stack is about 984 KiB. Recursing through a getter, a proxy trap or a built-in
+ * that calls back (map, toString, for...of), the host's stack ran out first, crashing the engine,
+ * once QuickJS's limit passed about 320 KiB. At this limit, QuickJS's catchable RangeError comes
+ * first in each of the 31, with about two fifths of the host's stack to spare. Bun's stack is
+ * larger, and the same limit holds there, so recursion through calls ends the same way on either.
+ *
+ * Recursion in C that the check barely sees isn't held to it, and under Node crashes the run, the
+ * host's stack running out: a script's text nesting function expressions 300 deep or brackets 700
+ * deep (the parser), a chain of 3,000 iterator helpers, and the script's own data nested about
+ * 5,000 deep in JSON.stringify (4,000 with V8's optimizing tier alone), as a call's arguments
+ * are, or about 8,000 deep in JSON.parse (5,000; see MAX_RESULT_DEPTH). Under Bun, whose stack
+ * is larger, QuickJS's check ends JSON's recursion first, with a RangeError the script can catch,
+ * from about 15,000 deep, though a parse nested 22,000 deep still runs Bun's stack out. Each
+ * iterator helper's next calls the one before directly, past QuickJS's checks, so under Bun a
+ * chain of 30,000 runs the module's own 1 MiB stack out instead, and the module traps: the stack
+ * sits first in its memory, so an overflow wraps below address 0 to past the memory's end.
+ */
+export declare const MAX_STACK_BYTES: number;
+export declare const DEFAULT_STACK_BYTES: number;
+/**
+ * The deepest nesting of arrays and objects a result may have. QuickJS's stack check measures the
+ * module's own stack, which the C recursion of JSON's parse and stringify barely uses, so under
+ * Node a parse nested about 8,000 deep (5,000 with V8's optimizing tier alone) overflows the
+ * host's stack first, and the engine crashes (under Bun, QuickJS's check comes first). A deeper
+ * result is unfit, since the call took effect. A script's own data isn't held to this, and nested
+ * thousands deep, it can crash its own run (see MAX_STACK_BYTES).
+ */
+export declare const MAX_RESULT_DEPTH = 2000;
+/** Instantiates the committed module with these limits and slots. One instance per child. */
+export declare function loadEngine(limits: EngineLimits, slots: EngineSlots): Promise<Engine>;
+//# sourceMappingURL=engine.d.ts.map

package/dist/src/code-execution/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../src/code-execution/engine.ts"],"names":[],"mappings":"AAcA,6DAA6D;AAC7D,MAAM,WAAW,YAAY;IAC3B;;;;;OAKG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB,6FAA6F;IAC7F,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/D;;;;;;;;OAQG;IACH,SAAS,IAAI,OAAO,CAAC;IACrB;;;;;;OAMG;IACH,SAAS,IAAI,IAAI,CAAC;IAClB,4EAA4E;IAC5E,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3C;AAED,yCAAyC;AACzC,MAAM,MAAM,QAAQ;AAClB,wGAAwG;AACtG;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE;AACrB;;;GAGG;GACD;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE;AACjD;;;;;GAKG;GACD;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE;AACrE;;;;;;;;GAQG;GACD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE;AACnE,gDAAgD;GAC9C;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC;AAE5B;;;;;;;;;;GAUG;AACH,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG;IAAE,KAAK,CAAC,EAAE,IAAI,CAAC;IAAC,OAAO,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AAEtE,MAAM,WAAW,MAAM;IACrB;;;;OAIG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAC;IACnE;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE,SAAS,EAAE,MAAM,GAAG,WAAW,CAAC;IAC/F,uHAAuH;IACvH,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,sGAAsG;AACtG,qBAAa,WAAY,SAAQ,KAAK;IACpC,YAAY,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,EAGzD;CACF;AAKD,eAAO,MAAM,gBAAgB,QAAkB,CAAC;AAChD;;;GAGG;AACH,eAAO,MAAM,gBAAgB,QAAqB,CAAC;AACnD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,eAAe,QAAa,CAAC;AAC1C,eAAO,MAAM,mBAAmB,QAAkB,CAAC;AACnD;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,OAAO,CAAC;AA2ErC,6FAA6F;AAC7F,wBAAsB,UAAU,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAqV1F"}