@happyvertical/smrt-app-shell 0.0.0-stage → 0.60.16

package/dist/engine/index.d.ts

@@ -0,0 +1,6 @@
+export { type Command, type CommandType, type ExecuteOptions, isRiskyCommand, isRiskyTool, type Plan, RISKY_COMMANDS, type Template, } from './commands.ts';
+export { type AppDefinition, builtInFields, coerceValue, convertValue, type DescribedModel, describeApp, EMPTY_APP, FIELD_NAME_PATTERN, FIELD_TYPES, type FieldDef, type FieldType, FORMAT, isValidFieldName, isValidModelName, type MethodDef, type MethodParamDef, type Migration, type ModelDef, RECIPES, type Recipe, type RecipeModel, refuseChanges, type Step, snake, suggestFieldName, tableFor, USER_PKG, validate, } from './definition.ts';
+export { AppError, ApprovalRequiredError, EngineError, type EngineErrorCode, WorkerCrashedError, } from './errors.ts';
+export { AppHost, type ChangeResult, type CleanUpResult, type ExecuteResult, type HostOptions, type MethodResult, type RestResult, type ToolResult, type VersionSummary, } from './host.ts';
+export { checkSyntax, type MethodInput, type MethodOutput, runMethod, SANDBOX_LIMITS, SandboxError, type SandboxLimits, validateWrites, type WritableModel, type Write, } from './sandbox.ts';
+export { MemoryVersionStore, type VersionMigration, type VersionRecord, type VersionStore, } from './store.ts';

package/dist/engine/index.js

@@ -0,0 +1,7 @@
+// The app-shell engine: runs a person's own smrt app from a definition.
+export { isRiskyCommand, isRiskyTool, RISKY_COMMANDS, } from "./commands.js";
+export { builtInFields, coerceValue, convertValue, describeApp, EMPTY_APP, FIELD_NAME_PATTERN, FIELD_TYPES, FORMAT, isValidFieldName, isValidModelName, RECIPES, refuseChanges, snake, suggestFieldName, tableFor, USER_PKG, validate, } from "./definition.js";
+export { AppError, ApprovalRequiredError, EngineError, WorkerCrashedError, } from "./errors.js";
+export { AppHost, } from "./host.js";
+export { checkSyntax, runMethod, SANDBOX_LIMITS, SandboxError, validateWrites, } from "./sandbox.js";
+export { MemoryVersionStore, } from "./store.js";

package/dist/engine/sandbox.d.ts

@@ -0,0 +1,60 @@
+import { type FieldDef } from './definition.ts';
+import { EngineError } from './errors.ts';
+export interface MethodInput {
+    record: Record<string, unknown> | null;
+    params: Record<string, unknown>;
+    data: Record<string, Record<string, unknown>[]>;
+}
+export interface Write {
+    op: 'create' | 'update' | 'delete';
+    model: string;
+    id?: string;
+    data?: Record<string, unknown>;
+}
+export interface MethodOutput {
+    result: unknown;
+    writes: Write[];
+}
+export interface SandboxLimits {
+    timeoutMs: number;
+    memoryBytes: number;
+    stackBytes: number;
+    maxWrites: number;
+    /** Largest JSON the method may return, result and writes together. */
+    maxOutputBytes: number;
+    /** Largest JSON of data a method may be handed. */
+    maxInputBytes: number;
+}
+export declare const SANDBOX_LIMITS: SandboxLimits;
+/** A method failed or broke a limit. */
+export declare class SandboxError extends EngineError {
+    constructor(message: string);
+}
+/**
+ * The WebAssembly heap every method runs in, capped at 128 MB (64 KiB pages).
+ *
+ * `setMemoryLimit` does not bound large single allocations here: a loop of
+ * `'x'.repeat(1e6)` ran to the 2 GB WebAssembly maximum (2,141 allocations,
+ * 3.3 s locally, 17 s or more on a CI runner) whatever limit was set, and the
+ * interrupt handler is polled only every ~10,000 operations, so the deadline
+ * did not fire in that loop either. A hard cap on the heap itself stops every
+ * allocation pattern in a fraction of a second; the runtime limit still
+ * covers many small allocations.
+ */
+export declare const SANDBOX_HEAP_PAGES: {
+    readonly initial: 256;
+    readonly maximum: 2048;
+};
+/** Compile-check only: does the method body parse? Returns the problem, or null. */
+export declare function checkSyntax(code: string): Promise<string | null>;
+export declare function runMethod(code: string, input: MethodInput, limits?: Partial<SandboxLimits>): Promise<MethodOutput>;
+export interface WritableModel {
+    /** Fields a write may set: visible fields, built-in ones included. */
+    fields: Record<string, FieldDef>;
+}
+/**
+ * Check the writes a method proposed before anything is applied: bounded in
+ * number, known operations, known models, known fields, values of the right
+ * type. Returns clean copies; throws on the first problem.
+ */
+export declare function validateWrites(writes: unknown, models: Record<string, WritableModel>, maxWrites?: number): Write[];

package/dist/engine/sandbox.js

@@ -0,0 +1,260 @@
+// Code methods run in QuickJS (WebAssembly): no filesystem, network, timers or
+// Node APIs. A method is a pure function over a copy of the data. It returns
+// { result, writes } and the engine decides whether to apply the writes.
+//
+// Everything crossing the boundary is JSON text: the input goes in as one
+// string parsed inside the VM, the output comes out as one string parsed
+// here. No host object, function or handle is ever visible to method code.
+import { newQuickJSWASMModuleFromVariant, newVariant, RELEASE_SYNC, shouldInterruptAfterDeadline, } from 'quickjs-emscripten';
+import { coerceValue } from "./definition.js";
+import { EngineError } from "./errors.js";
+export const SANDBOX_LIMITS = {
+    timeoutMs: 500,
+    memoryBytes: 64 * 1024 * 1024,
+    // Small on purpose: past what the host's own stack can hold, V8 throws
+    // out of WebAssembly and QuickJS cannot recover (see AGENTS.md).
+    stackBytes: 128 * 1024,
+    maxWrites: 1000,
+    maxOutputBytes: 1024 * 1024,
+    maxInputBytes: 8 * 1024 * 1024,
+};
+/** A method failed or broke a limit. */
+export class SandboxError extends EngineError {
+    constructor(message) {
+        super(message, 'refused');
+        this.name = 'SandboxError';
+    }
+}
+/**
+ * The WebAssembly heap every method runs in, capped at 128 MB (64 KiB pages).
+ *
+ * `setMemoryLimit` does not bound large single allocations here: a loop of
+ * `'x'.repeat(1e6)` ran to the 2 GB WebAssembly maximum (2,141 allocations,
+ * 3.3 s locally, 17 s or more on a CI runner) whatever limit was set, and the
+ * interrupt handler is polled only every ~10,000 operations, so the deadline
+ * did not fire in that loop either. A hard cap on the heap itself stops every
+ * allocation pattern in a fraction of a second; the runtime limit still
+ * covers many small allocations.
+ */
+export const SANDBOX_HEAP_PAGES = { initial: 256, maximum: 2048 };
+let qjs;
+const quickjs = () => {
+    qjs ??= newQuickJSWASMModuleFromVariant(newVariant(RELEASE_SYNC, {
+        wasmMemory: new WebAssembly.Memory({ ...SANDBOX_HEAP_PAGES }),
+    }));
+    return qjs;
+};
+/**
+ * The host (not the method) threw while the VM was running, e.g. V8 ran out of
+ * stack inside WebAssembly. That module instance is no longer trustworthy:
+ * drop it so the next method gets a fresh one.
+ */
+const poison = () => {
+    qjs = undefined;
+};
+/** Disposing after a host-level failure can abort; that is the same poison. */
+function disposeAll(vm, runtime) {
+    try {
+        vm.dispose();
+        runtime.dispose();
+    }
+    catch {
+        poison();
+    }
+}
+const describeThrown = (e) => typeof e === 'object' && e
+    ? `${e.name ?? 'Error'}: ${e.message ?? ''}`
+    : String(e);
+/** The body is compiled as a function body on its own, so it cannot close the wrapper. */
+const COMPILE = `new Function('record', 'params', 'data', 'app', "'use strict';\\n" + globalThis.__code)`;
+/**
+ * Does `code` parse as a function body, and nothing more? V8 parses the body
+ * on its own (it never runs), so a body such as `}); evil(); (function(){`
+ * cannot close the wrapper: QuickJS's own Function constructor would accept it.
+ */
+function parsesAsBody(code) {
+    try {
+        // Constructed, never called: parse only.
+        new Function('record', 'params', 'data', 'app', `'use strict';\n${code}`);
+        return null;
+    }
+    catch (e) {
+        return describeThrown(e);
+    }
+}
+/** Compile-check only: does the method body parse? Returns the problem, or null. */
+export async function checkSyntax(code) {
+    const structural = parsesAsBody(code);
+    if (structural)
+        return structural;
+    const runtime = (await quickjs()).newRuntime();
+    runtime.setMemoryLimit(SANDBOX_LIMITS.memoryBytes);
+    runtime.setMaxStackSize(SANDBOX_LIMITS.stackBytes);
+    runtime.setInterruptHandler(shouldInterruptAfterDeadline(Date.now() + SANDBOX_LIMITS.timeoutMs));
+    const vm = runtime.newContext();
+    try {
+        const src = vm.newString(code);
+        vm.setProp(vm.global, '__code', src);
+        src.dispose();
+        const r = vm.evalCode(COMPILE);
+        if (r.error) {
+            const e = vm.dump(r.error);
+            r.error.dispose();
+            return describeThrown(e);
+        }
+        r.value.dispose();
+        return null;
+    }
+    finally {
+        disposeAll(vm, runtime);
+    }
+}
+export async function runMethod(code, input, limits = {}) {
+    const lim = { ...SANDBOX_LIMITS, ...limits };
+    const structural = parsesAsBody(code);
+    if (structural)
+        throw new SandboxError(`method does not parse: ${structural}`);
+    const json = JSON.stringify(input);
+    if (json.length > lim.maxInputBytes)
+        throw new SandboxError('there is too much data for a method to read');
+    const deadline = Date.now() + lim.timeoutMs;
+    const runtime = (await quickjs()).newRuntime();
+    runtime.setMemoryLimit(lim.memoryBytes);
+    runtime.setMaxStackSize(lim.stackBytes);
+    runtime.setInterruptHandler(shouldInterruptAfterDeadline(deadline));
+    const vm = runtime.newContext();
+    try {
+        for (const [k, v] of [
+            ['__input', json],
+            ['__code', code],
+        ]) {
+            const h = vm.newString(v);
+            vm.setProp(vm.global, k, h);
+            h.dispose();
+        }
+        const src = `'use strict'; (function () {
+      const parse = JSON.parse;
+      const stringify = JSON.stringify;
+      const raw = globalThis.__input;
+      const body = globalThis.__code;
+      delete globalThis.__input;
+      delete globalThis.__code;
+      const input = parse(raw);
+      const writes = [];
+      // Iterative, so a hostile structure cannot overflow the stack here.
+      const tooDeep = (root) => {
+        const todo = [[root, 0]];
+        let seen = 0;
+        while (todo.length) {
+          const [v, d] = todo.pop();
+          if (v === null || typeof v !== 'object') continue;
+          if (d > 64 || ++seen > 200000) return true;
+          for (const k of Object.keys(v)) todo.push([v[k], d + 1]);
+        }
+        return false;
+      };
+      const push = (w) => {
+        if (writes.length >= ${lim.maxWrites}) throw new Error('a method may propose at most ${lim.maxWrites} writes');
+        if (tooDeep(w)) throw new Error('a write is nested too deeply');
+        writes.push(parse(stringify(w)));
+      };
+      const app = Object.freeze({
+        create: (model, data) => { push({ op: 'create', model, data }); },
+        update: (model, id, data) => { push({ op: 'update', model, id, data }); },
+        delete: (model, id) => { push({ op: 'delete', model, id }); },
+      });
+      const run = new Function('record', 'params', 'data', 'app', "'use strict';\\n" + body);
+      const result = run(input.record, input.params, input.data, app);
+      if (result && typeof result.then === 'function')
+        throw new Error('a method must return a value, not a promise');
+      if (tooDeep(result)) throw new Error('the result is nested too deeply');
+      const out = stringify({ result: result === undefined ? null : result, writes });
+      if (typeof out !== 'string' || out.length > ${lim.maxOutputBytes})
+        throw new Error('the method returned too much');
+      return out;
+    })()`;
+        const r = vm.evalCode(src, 'method.js');
+        if (r.error) {
+            const e = vm.dump(r.error);
+            r.error.dispose();
+            const timedOut = Date.now() >= deadline;
+            throw new SandboxError(timedOut
+                ? `method ran too long (limit ${lim.timeoutMs} ms)`
+                : `method failed: ${describeThrown(e)}`);
+        }
+        const text = vm.getString(r.value);
+        r.value.dispose();
+        let out;
+        try {
+            out = JSON.parse(text);
+        }
+        catch {
+            throw new SandboxError('method returned something that is not JSON');
+        }
+        const o = out;
+        if (!o || typeof o !== 'object' || !Array.isArray(o.writes))
+            throw new SandboxError('method returned an unexpected shape');
+        return { result: o.result ?? null, writes: o.writes };
+    }
+    catch (e) {
+        if (e instanceof SandboxError)
+            throw e;
+        poison();
+        throw new SandboxError(`method crashed the sandbox: ${e.message}`);
+    }
+    finally {
+        disposeAll(vm, runtime);
+    }
+}
+const isPlain = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+/**
+ * Check the writes a method proposed before anything is applied: bounded in
+ * number, known operations, known models, known fields, values of the right
+ * type. Returns clean copies; throws on the first problem.
+ */
+export function validateWrites(writes, models, maxWrites = SANDBOX_LIMITS.maxWrites) {
+    if (!Array.isArray(writes))
+        throw new SandboxError('writes must be a list');
+    if (writes.length > maxWrites)
+        throw new SandboxError(`too many writes (limit ${maxWrites})`);
+    const out = [];
+    writes.forEach((w, i) => {
+        const at = `write ${i + 1}`;
+        if (!isPlain(w))
+            throw new SandboxError(`${at}: not an object`);
+        for (const k of Object.keys(w))
+            if (!['op', 'model', 'id', 'data'].includes(k))
+                throw new SandboxError(`${at}: unknown key '${k}'`);
+        if (w.op !== 'create' && w.op !== 'update' && w.op !== 'delete')
+            throw new SandboxError(`${at}: unknown operation '${String(w.op)}'`);
+        if (typeof w.model !== 'string' || !Object.hasOwn(models, w.model))
+            throw new SandboxError(`${at}: no model '${String(w.model)}'`);
+        const clean = { op: w.op, model: w.model };
+        if (w.op !== 'create') {
+            if (typeof w.id !== 'string' || !w.id)
+                throw new SandboxError(`${at}: ${w.op} needs a record id`);
+            clean.id = w.id;
+        }
+        if (w.op === 'delete') {
+            if (w.data !== undefined)
+                throw new SandboxError(`${at}: delete takes no data`);
+        }
+        else {
+            if (!isPlain(w.data))
+                throw new SandboxError(`${at}: ${w.op} needs data`);
+            const fields = models[w.model].fields;
+            const data = {};
+            for (const [k, v] of Object.entries(w.data)) {
+                if (!Object.hasOwn(fields, k))
+                    throw new SandboxError(`${at}: ${w.model} has no field '${k}'`);
+                const c = coerceValue(fields[k], v);
+                if (!c.ok)
+                    throw new SandboxError(`${at}: ${w.model}.${k} ${c.error}`);
+                data[k] = v;
+            }
+            clean.data = data;
+        }
+        out.push(clean);
+    });
+    return out;
+}

package/dist/engine/snapshots.d.ts

@@ -0,0 +1,7 @@
+/** How many `method-*` snapshots stay (each applied method write takes one). */
+export declare const METHOD_SNAPSHOTS_KEPT = 20;
+export type SnapshotKind = 'method' | 'migrate' | 'schema';
+/** Keep the newest `keep` `method-*` snapshots; delete the rest. */
+export declare function pruneMethodSnapshots(dir: string, keep?: number): number;
+/** Delete `migrate-*` and `schema-*` snapshots taken before `beforeMs`. */
+export declare function pruneMigrationSnapshots(dir: string, beforeMs: number): number;

package/dist/engine/snapshots.js

@@ -0,0 +1,54 @@
+// Retention for `<dataDir>/snapshots`. Only plain files whose names match the
+// engine's own pattern are ever touched: never a directory, a symlink, or a
+// file someone else put there.
+import { readdirSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+/** How many `method-*` snapshots stay (each applied method write takes one). */
+export const METHOD_SNAPSHOTS_KEPT = 20;
+/** `<epoch ms>-<counter>-<kind...>.db`, as `AppRuntime.snapshot` names them. */
+const NAME = /^(\d{1,16})-(\d{1,9})-(method-|migrate-|schema)[A-Za-z0-9._-]*\.db$/;
+function ours(dir) {
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const e of entries) {
+        if (!e.isFile())
+            continue; // symlinks and directories are left alone
+        const m = NAME.exec(e.name);
+        if (!m)
+            continue;
+        out.push({
+            name: e.name,
+            at: Number(m[1]),
+            n: Number(m[2]),
+            kind: m[3].replace(/-$/, ''),
+        });
+    }
+    return out.sort((a, b) => a.at - b.at || a.n - b.n);
+}
+function remove(dir, files) {
+    let removed = 0;
+    for (const f of files)
+        try {
+            unlinkSync(join(dir, f.name));
+            removed++;
+        }
+        catch {
+            // already gone or not ours to remove: retention is best effort
+        }
+    return removed;
+}
+/** Keep the newest `keep` `method-*` snapshots; delete the rest. */
+export function pruneMethodSnapshots(dir, keep = METHOD_SNAPSHOTS_KEPT) {
+    const method = ours(dir).filter((f) => f.kind === 'method');
+    return remove(dir, method.slice(0, Math.max(0, method.length - keep)));
+}
+/** Delete `migrate-*` and `schema-*` snapshots taken before `beforeMs`. */
+export function pruneMigrationSnapshots(dir, beforeMs) {
+    return remove(dir, ours(dir).filter((f) => f.kind !== 'method' && f.at < beforeMs));
+}

package/dist/engine/store.d.ts

@@ -0,0 +1,39 @@
+import type { AppDefinition, Step } from './definition.ts';
+export interface VersionMigration {
+    steps: Step[];
+    /** Archived data was cleaned up: this change can no longer be undone. */
+    purged?: boolean;
+}
+export interface VersionRecord {
+    version: number;
+    parent: number | null;
+    author: string;
+    summary: string;
+    definition: AppDefinition;
+    migration: VersionMigration | null;
+    createdAt: string;
+}
+export interface VersionStore {
+    /** The current version, or null for a store that has never held one. */
+    current(): Promise<number | null>;
+    setCurrent(version: number): Promise<void>;
+    get(version: number): Promise<VersionRecord | null>;
+    /** Every version, oldest first. */
+    list(): Promise<VersionRecord[]>;
+    append(record: VersionRecord): Promise<void>;
+    /** Mark a version's migration `purged`. Never delete the record. */
+    markPurged(version: number): Promise<void>;
+    /** Highest version number held, or -1 when empty. */
+    maxVersion(): Promise<number>;
+}
+export declare class MemoryVersionStore implements VersionStore {
+    private cur;
+    private records;
+    current(): Promise<number | null>;
+    setCurrent(version: number): Promise<void>;
+    get(version: number): Promise<VersionRecord | null>;
+    list(): Promise<VersionRecord[]>;
+    append(record: VersionRecord): Promise<void>;
+    markPurged(version: number): Promise<void>;
+    maxVersion(): Promise<number>;
+}

package/dist/engine/store.js

@@ -0,0 +1,32 @@
+export class MemoryVersionStore {
+    cur = null;
+    records = new Map();
+    async current() {
+        return this.cur;
+    }
+    async setCurrent(version) {
+        this.cur = version;
+    }
+    async get(version) {
+        const r = this.records.get(version);
+        return r ? structuredClone(r) : null;
+    }
+    async list() {
+        return [...this.records.values()]
+            .sort((a, b) => a.version - b.version)
+            .map((r) => structuredClone(r));
+    }
+    async append(record) {
+        if (this.records.has(record.version))
+            throw new Error(`version ${record.version} already exists`);
+        this.records.set(record.version, structuredClone(record));
+    }
+    async markPurged(version) {
+        const r = this.records.get(version);
+        if (r?.migration)
+            r.migration = { ...r.migration, purged: true };
+    }
+    async maxVersion() {
+        return this.records.size ? Math.max(...this.records.keys()) : -1;
+    }
+}

package/dist/engine/worker-handle.d.ts

@@ -0,0 +1,29 @@
+import type { AppDefinition, Migration } from './definition.ts';
+import type { BootInfo, WorkerOp } from './worker-protocol.ts';
+/** The app answered with an error (as opposed to the thread dying). */
+export declare class AppCallError extends Error {
+    readonly user: boolean;
+    constructor(message: string, user: boolean);
+}
+/** The app's heap is bounded; a runaway app cannot starve the host. */
+export declare const WORKER_HEAP_MB = 512;
+export declare class AppWorker {
+    readonly version: number;
+    private worker;
+    private next;
+    private dead;
+    private pending;
+    readonly ready: Promise<BootInfo>;
+    constructor(workerUrl: URL | string, init: {
+        dataDir: string;
+        def: AppDefinition;
+        version: number;
+        migration?: Migration;
+    });
+    get alive(): boolean;
+    private settle;
+    call<T = unknown>(op: WorkerOp, ...args: unknown[]): Promise<T>;
+    /** Let in-flight calls finish (up to `ms`), then stop the thread. */
+    retire(ms?: number): Promise<void>;
+    terminate(): Promise<number>;
+}

package/dist/engine/worker-handle.js

@@ -0,0 +1,89 @@
+// The host's handle on one app runtime thread.
+import { Worker } from 'node:worker_threads';
+import { EngineError, WorkerCrashedError } from "./errors.js";
+/** The app answered with an error (as opposed to the thread dying). */
+export class AppCallError extends Error {
+    user;
+    constructor(message, user) {
+        super(message);
+        this.name = 'AppCallError';
+        this.user = user;
+    }
+}
+/** The app's heap is bounded; a runaway app cannot starve the host. */
+export const WORKER_HEAP_MB = 512;
+export class AppWorker {
+    version;
+    worker;
+    next = 1;
+    dead = null;
+    pending = new Map();
+    ready;
+    constructor(workerUrl, init) {
+        this.version = init.version;
+        this.worker = new Worker(workerUrl, {
+            workerData: { appWorker: true, ...init },
+            resourceLimits: { maxOldGenerationSizeMb: WORKER_HEAP_MB },
+        });
+        const die = (e) => {
+            this.dead ??= e;
+            for (const p of this.pending.values())
+                p.reject(this.dead);
+            this.pending.clear();
+        };
+        this.ready = new Promise((resolve, reject) => {
+            this.worker.once('message', (m) => {
+                if (m.ready)
+                    resolve(m);
+                else
+                    reject(new EngineError(m.error ?? 'the app did not start', 'migration_failed'));
+                this.worker.on('message', (r) => this.settle(r));
+            });
+            this.worker.once('error', (e) => {
+                die(new WorkerCrashedError(`the app stopped: ${e.message}`));
+                reject(e);
+            });
+            this.worker.once('exit', () => {
+                die(new WorkerCrashedError());
+                reject(new WorkerCrashedError('the app stopped before it was ready'));
+            });
+        });
+        // A rejected `ready` nobody awaited (a worker that died later) is not an error.
+        this.ready.catch(() => { });
+    }
+    get alive() {
+        return !this.dead;
+    }
+    settle(r) {
+        const p = this.pending.get(r.id);
+        if (!p)
+            return;
+        this.pending.delete(r.id);
+        if (r.ok)
+            p.resolve(r.value);
+        else
+            p.reject(new AppCallError(r.error, r.user));
+    }
+    call(op, ...args) {
+        if (this.dead)
+            return Promise.reject(this.dead);
+        const id = this.next++;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, {
+                resolve: resolve,
+                reject,
+            });
+            this.worker.postMessage({ id, op, args });
+        });
+    }
+    /** Let in-flight calls finish (up to `ms`), then stop the thread. */
+    async retire(ms = 2000) {
+        const until = Date.now() + ms;
+        while (this.pending.size && !this.dead && Date.now() < until)
+            await new Promise((r) => setTimeout(r, 20));
+        await this.worker.terminate();
+    }
+    terminate() {
+        return this.worker.terminate();
+    }
+}

package/dist/engine/worker-protocol.d.ts

@@ -0,0 +1,22 @@
+export declare const WORKER_OPS: readonly ["list", "get", "create", "update", "remove", "runMethod", "tools", "callTool", "rest", "snapshot", "previewConversion", "countValues", "countRows", "countArchives", "countOverwrites", "pruneSnapshots", "purgeArchives", "importRecords"];
+export type WorkerOp = (typeof WORKER_OPS)[number];
+export type WorkerCall = {
+    id: number;
+    op: string;
+    args: unknown[];
+};
+export type WorkerReply = {
+    id: number;
+    ok: true;
+    value: unknown;
+} | {
+    id: number;
+    ok: false;
+    error: string;
+    user: boolean;
+};
+export interface BootInfo {
+    statements: string[];
+    snapshot: string | null;
+    bootMs: number;
+}

package/dist/engine/worker-protocol.js

@@ -0,0 +1,20 @@
+export const WORKER_OPS = [
+    'list',
+    'get',
+    'create',
+    'update',
+    'remove',
+    'runMethod',
+    'tools',
+    'callTool',
+    'rest',
+    'snapshot',
+    'previewConversion',
+    'countValues',
+    'countRows',
+    'countArchives',
+    'countOverwrites',
+    'pruneSnapshots',
+    'purgeArchives',
+    'importRecords',
+];