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

package/dist/engine/app-runtime.js

@@ -0,0 +1,545 @@
+// The user app's runtime. Runs inside its own worker thread, so it has its own
+// smrt registry: built fresh from one definition, thrown away on the next.
+//
+// Migrations here are SQLite-shaped (RENAME/DROP COLUMN, VACUUM INTO,
+// pragma_table_info). Postgres is future work.
+import { mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { ObjectRegistry, planRuntimeModelDDL, registerRuntimeModel, } from '@happyvertical/smrt-core';
+import { MCPGenerator } from '@happyvertical/smrt-core/generators/mcp';
+import { APIGenerator } from '@happyvertical/smrt-core/generators/rest';
+import { getDatabase } from '@happyvertical/sql';
+import { builtInFields, classNameFor, coerceValue, convertValue, describeApp, RECIPES, recipeModelFor, restRouteAllowed, routeFor, snake, sqlType, storageFamily, tableFor, toolNamesFor, toRuntimeModel, USER_PKG, visible, } from "./definition.js";
+import { AppError } from "./errors.js";
+import { runMethod, SANDBOX_LIMITS, validateWrites, } from "./sandbox.js";
+import { pruneMethodSnapshots, pruneMigrationSnapshots } from "./snapshots.js";
+const q = (s) => `"${s.replace(/"/g, '""')}"`;
+const OWNER = { id: 'owner', roles: ['admin'] };
+const PROFILE_TYPES = '@happyvertical/smrt-profiles:ProfileType';
+export class AppRuntime {
+    def;
+    version;
+    db;
+    dataDir;
+    snapshots = 0;
+    constructor(dataDir, def, version) {
+        this.dataDir = dataDir;
+        this.def = def;
+        this.version = version;
+    }
+    /**
+     * Open app.db, register the definition, and bring the tables up to it: the
+     * migration's steps (if any) and then the additive changes, all in one
+     * transaction. A failure leaves app.db exactly as it was.
+     */
+    async boot(migration) {
+        mkdirSync(join(this.dataDir, 'snapshots'), { recursive: true });
+        this.db = await getDatabase({
+            type: 'sqlite',
+            url: join(this.dataDir, 'app.db'),
+        });
+        await this.register();
+        const steps = migration?.steps ?? [];
+        if (!steps.length)
+            await this.checkColumns(this.db);
+        // With steps the tables change first; planning happens inside the transaction.
+        const needed = steps.length > 0 || (await this.plan(this.db, false)).length > 0;
+        const statements = [];
+        let snapshot = null;
+        if (needed) {
+            snapshot = await this.snapshot(steps.length
+                ? `migrate-v${migration?.version}-${migration?.direction}`
+                : 'schema');
+            await this.db.transaction(async (tx) => {
+                await tx.query(`CREATE TABLE IF NOT EXISTS _archive (id INTEGER PRIMARY KEY AUTOINCREMENT, version INTEGER NOT NULL, tbl TEXT NOT NULL, col TEXT NOT NULL, record_id TEXT NOT NULL, value TEXT, created_at TEXT NOT NULL)`);
+                const ordered = migration?.direction === 'down' ? [...steps].reverse() : steps;
+                for (const step of ordered)
+                    statements.push(...(await this.runStep(tx, step, migration)));
+                await this.checkColumns(tx);
+                statements.push(...(await this.plan(tx, true)));
+            });
+        }
+        await this.db.query(`CREATE TABLE IF NOT EXISTS _app_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)`);
+        for (const [k, v] of [
+            ['version', String(this.version)],
+            ['definition', JSON.stringify(this.def)],
+        ])
+            await this.db
+                .execute `INSERT INTO _app_meta (key, value) VALUES (${k}, ${v}) ON CONFLICT(key) DO UPDATE SET value = excluded.value`;
+        return { statements, snapshot };
+    }
+    // ---------- registry and tables ----------
+    /** Register the definition's models in this (fresh) registry. */
+    async register() {
+        if (this.def.recipes.length)
+            await import('@happyvertical/smrt-profiles');
+        for (const [model, md] of Object.entries(this.def.models)) {
+            const rt = this;
+            const methods = {};
+            for (const name of Object.keys(md.methods ?? {}))
+                methods[name] = function (params) {
+                    return rt.runMethod(model, name, this.id ?? null, params ?? {});
+                };
+            registerRuntimeModel(toRuntimeModel(model, md), {
+                methods: methods,
+            });
+            // The app uses only its subclass: close the shipped parent's generated
+            // surfaces so its tools do not duplicate the subclass's.
+            const parent = recipeModelFor(model, md)?.parent;
+            if (parent)
+                ObjectRegistry.registerOverride(parent, { api: false, mcp: false });
+        }
+    }
+    qualified(model) {
+        return `${USER_PKG}:${classNameFor(model, this.def.models[model])}`;
+    }
+    /**
+     * Statements that bring tables up to the registered models, reading
+     * through `h`. With `run`, each model's statements execute before the next
+     * is planned (the subclass of a shipped model plans against its parent's
+     * table). Shipped tables come first.
+     */
+    async plan(h, run) {
+        const qualifieds = [
+            ...this.def.recipes.flatMap((r) => RECIPES[r]?.tables ?? []),
+            ...Object.keys(this.def.models).map((m) => this.qualified(m)),
+        ];
+        // A subclass plans after the shipped parent it extends.
+        const out = [];
+        for (const qn of qualifieds) {
+            const statements = await planRuntimeModelDDL(qn, 'sqlite', (t) => this.existingColumns(h, t));
+            if (run)
+                for (const s of statements)
+                    await h.query(s);
+            out.push(...statements);
+            if (!run && statements.length)
+                break; // enough to know there is work
+        }
+        return out;
+    }
+    async existingColumns(h, table) {
+        const rows = (await h.query(`SELECT name FROM pragma_table_info(?)`, [table])).rows;
+        return rows.length ? rows.map((r) => String(r.name)) : null;
+    }
+    /** A column that exists with another storage family than its field wants: refuse. */
+    async checkColumns(h) {
+        for (const [model, md] of Object.entries(this.def.models)) {
+            const table = tableFor(model, md);
+            const have = await this.columnTypes(h, table);
+            if (!have.size)
+                continue;
+            for (const [f, fd] of Object.entries(visible(md.fields))) {
+                const col = have.get(snake(f));
+                if (col && storageFamily(col) !== storageFamily(sqlType(fd.type)))
+                    throw new AppError(`${table}.${snake(f)} already holds ${col} data; remove that field or change its type instead`);
+            }
+        }
+    }
+    async columnTypes(h, t) {
+        const rows = (await h.query(`SELECT name, type FROM pragma_table_info(?)`, [t])).rows;
+        return new Map(rows.map((r) => [String(r.name), String(r.type)]));
+    }
+    async tableExists(h, t) {
+        return ((await h.query(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`, [t])).rows.length > 0);
+    }
+    // ---------- migration steps ----------
+    /** Run one step up or down inside the boot transaction; returns what it did. */
+    async runStep(tx, step, m) {
+        const done = [];
+        const exec = async (sql, params = []) => {
+            await tx.query(sql, params);
+            done.push(sql);
+        };
+        const now = new Date().toISOString();
+        const up = m.direction === 'up';
+        switch (step.op) {
+            case 'renameColumn':
+                await exec(`ALTER TABLE ${q(step.table)} RENAME COLUMN ${q(up ? step.from : step.to)} TO ${q(up ? step.to : step.from)}`);
+                break;
+            case 'archiveTable':
+                await exec(`ALTER TABLE ${q(up ? step.table : step.archivedAs)} RENAME TO ${q(up ? step.archivedAs : step.table)}`);
+                break;
+            case 'dropColumn':
+                if (up) {
+                    if (!(await this.columnTypes(tx, step.table)).has(step.column))
+                        break;
+                    await exec(`INSERT INTO _archive (version, tbl, col, record_id, value, created_at) SELECT ?, ?, ?, ${q(step.key)}, ${q(step.column)}, ? FROM ${q(step.table)} WHERE ${q(step.column)} IS NOT NULL AND ${q(step.column)} <> ''`, [m.version, step.table, step.column, now]);
+                    await exec(`ALTER TABLE ${q(step.table)} DROP COLUMN ${q(step.column)}`);
+                }
+                else {
+                    await exec(`ALTER TABLE ${q(step.table)} ADD COLUMN ${q(step.column)} ${sqlType(step.type)}`);
+                    await exec(`UPDATE ${q(step.table)} SET ${q(step.column)} = (SELECT value FROM _archive a WHERE a.version = ? AND a.tbl = ? AND a.col = ? AND a.record_id = ${q(step.table)}.${q(step.key)})`, [m.version, step.table, step.column]);
+                    await exec(`DELETE FROM _archive WHERE version = ? AND tbl = ? AND col = ?`, [m.version, step.table, step.column]);
+                }
+                break;
+            case 'convertColumn': {
+                const target = up ? step.to : step.from;
+                const tmp = `${step.column}__new`;
+                const rows = (await tx.query(`SELECT ${q(step.key)} AS k, ${q(step.column)} AS v FROM ${q(step.table)}`)).rows;
+                const archived = new Map();
+                if (up) {
+                    await exec(`INSERT INTO _archive (version, tbl, col, record_id, value, created_at) SELECT ?, ?, ?, ${q(step.key)}, ${q(step.column)}, ? FROM ${q(step.table)} WHERE ${q(step.column)} IS NOT NULL`, [m.version, step.table, step.column, now]);
+                }
+                else {
+                    for (const r of (await tx.query(`SELECT record_id, value FROM _archive WHERE version = ? AND tbl = ? AND col = ?`, [m.version, step.table, step.column])).rows)
+                        archived.set(String(r.record_id), r.value);
+                }
+                await exec(`ALTER TABLE ${q(step.table)} ADD COLUMN ${q(tmp)} ${sqlType(target.type)}`);
+                for (const r of rows) {
+                    // Going back, a row's original value wins; rows made since are converted back.
+                    const value = !up && archived.has(String(r.k))
+                        ? archived.get(String(r.k))
+                        : convertValue(r.v, target).value;
+                    await tx.query(`UPDATE ${q(step.table)} SET ${q(tmp)} = ? WHERE ${q(step.key)} = ?`, [value, r.k]);
+                }
+                done.push(`-- converted ${rows.length} values to ${target.type}`);
+                await exec(`ALTER TABLE ${q(step.table)} DROP COLUMN ${q(step.column)}`);
+                await exec(`ALTER TABLE ${q(step.table)} RENAME COLUMN ${q(tmp)} TO ${q(step.column)}`);
+                if (!up)
+                    await exec(`DELETE FROM _archive WHERE version = ? AND tbl = ? AND col = ?`, [m.version, step.table, step.column]);
+                break;
+            }
+        }
+        return done;
+    }
+    // ---------- previews and archives ----------
+    /** What a type change would do to existing values, without changing anything. */
+    async previewConversion(table, key, column, to) {
+        const rows = (await this.db.query(`SELECT ${q(key)} AS k, ${q(column)} AS v FROM ${q(table)}`)).rows;
+        const failing = rows.filter((r) => r.v !== null && !convertValue(r.v, to).ok);
+        const withValue = rows.filter((r) => r.v !== null).length;
+        return {
+            rows: rows.length,
+            withValue,
+            convertible: withValue - failing.length,
+            failing: failing.slice(0, 10).map((r) => ({ id: r.k, value: r.v })),
+            failingCount: failing.length,
+        };
+    }
+    /** How many non-empty values a column holds (for a removal preview). */
+    async countValues(table, column) {
+        if (!(await this.columnTypes(this.db, table)).has(column))
+            return 0;
+        const r = await this.db.query(`SELECT COUNT(*) AS n FROM ${q(table)} WHERE ${q(column)} IS NOT NULL AND ${q(column)} <> ''`);
+        return Number(r.rows[0].n);
+    }
+    async countRows(table) {
+        if (!(await this.tableExists(this.db, table)))
+            return 0;
+        const r = await this.db.query(`SELECT COUNT(*) AS n FROM ${q(table)}`);
+        return Number(r.rows[0].n);
+    }
+    /** How many archived values and tables the given versions hold. */
+    async countArchives(versions, tables) {
+        let values = 0;
+        if (await this.tableExists(this.db, '_archive'))
+            for (const v of versions)
+                values += Number((await this.db.query(`SELECT COUNT(*) AS n FROM _archive WHERE version = ?`, [v])).rows[0].n);
+        return { values, tables: tables.length };
+    }
+    /**
+     * How many rows undoing `version`'s `convertColumn` steps would overwrite:
+     * rows whose current value is not what converting the archived original
+     * gives (they were edited, or created over the original, since).
+     */
+    async countOverwrites(version, steps) {
+        const out = [];
+        for (const step of steps) {
+            if (step.op !== 'convertColumn')
+                continue;
+            let replaced = 0;
+            if ((await this.tableExists(this.db, '_archive')) &&
+                (await this.columnTypes(this.db, step.table)).has(step.column)) {
+                const archived = (await this.db.query(`SELECT record_id, value FROM _archive WHERE version = ? AND tbl = ? AND col = ?`, [version, step.table, step.column])).rows;
+                const current = new Map((await this.db.query(`SELECT ${q(step.key)} AS k, ${q(step.column)} AS v FROM ${q(step.table)}`)).rows.map((r) => [String(r.k), r.v]));
+                for (const a of archived) {
+                    const id = String(a.record_id);
+                    if (!current.has(id))
+                        continue; // deleted since: nothing to overwrite
+                    const was = convertValue(a.value, step.to).value;
+                    const now = current.get(id);
+                    if ((was ?? null) !== (now ?? null) && String(was) !== String(now))
+                        replaced++;
+                }
+            }
+            out.push({ table: step.table, column: step.column, replaced });
+        }
+        return out;
+    }
+    /** Delete archived values and tables for the given versions. */
+    async purgeArchives(versions, tables) {
+        if (!versions.length && !tables.length)
+            return { values: 0, tables: 0 };
+        let values = 0;
+        await this.db.transaction(async (tx) => {
+            if (await this.tableExists(tx, '_archive'))
+                for (const v of versions)
+                    values +=
+                        (await tx.query(`DELETE FROM _archive WHERE version = ?`, [v]))
+                            .rowCount ?? 0;
+            for (const t of tables)
+                if (await this.tableExists(tx, t))
+                    await tx.query(`DROP TABLE ${q(t)}`);
+        });
+        return { values, tables: tables.length };
+    }
+    /** A consistent copy of app.db in snapshots/, made with VACUUM INTO. */
+    async snapshot(kind) {
+        const safe = kind.replace(/[^A-Za-z0-9._-]/g, '_').slice(0, 60);
+        const file = join(this.dataDir, 'snapshots', `${Date.now()}-${this.snapshots++}-${safe}.db`);
+        await this.db.query(`VACUUM INTO '${file.replace(/'/g, "''")}'`);
+        // Applied method writes can come in a stream: keep only the newest few.
+        if (safe.startsWith('method-'))
+            pruneMethodSnapshots(join(this.dataDir, 'snapshots'));
+        return file;
+    }
+    /** Delete migrate/schema snapshots taken before `beforeMs` (clean up). */
+    pruneSnapshots(beforeMs) {
+        return pruneMigrationSnapshots(join(this.dataDir, 'snapshots'), Number(beforeMs));
+    }
+    // ---------- SMRT's generated surfaces ----------
+    mcp() {
+        return new MCPGenerator({ name: 'app', version: String(this.version) }, {
+            db: this.db,
+            user: OWNER,
+        });
+    }
+    toolNames() {
+        return new Set(Object.entries(this.def.models).flatMap(([m, md]) => toolNamesFor(m, md)));
+    }
+    /** The app's own generated MCP tools: chore_list, chore_complete, ... */
+    async tools() {
+        const mine = this.toolNames();
+        return (await this.mcp().generateTools()).filter((t) => mine.has(t.name));
+    }
+    async callTool(name, args) {
+        if (!this.toolNames().has(name))
+            throw new AppError(`unknown tool ${name}`);
+        const r = await this.mcp().handleToolCall({
+            method: 'tools/call',
+            params: { name, arguments: args },
+        });
+        return {
+            content: r.content,
+            isError: !!r.isError,
+            structuredContent: r.structuredContent,
+        };
+    }
+    /** SMRT's generated REST routes. */
+    async rest(req) {
+        if (!restRouteAllowed(this.def, req.url))
+            return {
+                status: 404,
+                contentType: 'application/json',
+                body: JSON.stringify({ error: 'Not found' }),
+            };
+        const api = new APIGenerator({
+            basePath: '/api',
+            authMiddleware: () => async (r) => r,
+        }, { db: this.db });
+        for (const [m, md] of Object.entries(this.def.models))
+            api.registerCollection(routeFor(m, md), (await ObjectRegistry.getCollection(this.qualified(m), {
+                db: this.db,
+            })));
+        const url = req.url.startsWith('/')
+            ? `http://app.local${req.url}`
+            : req.url;
+        const hasBody = req.body !== undefined && req.method !== 'GET' && req.method !== 'HEAD';
+        const r = await api.generateHandler()(new Request(url, {
+            method: req.method,
+            headers: { 'content-type': 'application/json' },
+            body: hasBody ? req.body : undefined,
+        }));
+        return {
+            status: r.status,
+            contentType: r.headers.get('content-type') ?? 'application/json',
+            body: await r.text(),
+        };
+    }
+    // ---------- records ----------
+    describe() {
+        return describeApp(this.def, this.version);
+    }
+    modelDef(model) {
+        if (!Object.hasOwn(this.def.models, model))
+            throw new AppError(`no model ${model}`);
+        return this.def.models[model];
+    }
+    /** Fields a record of `model` carries: built-in ones and visible own ones. */
+    fieldsOf(model) {
+        const md = this.modelDef(model);
+        return { ...builtInFields(model, md), ...visible(md.fields) };
+    }
+    async collection(model) {
+        this.modelDef(model);
+        return ObjectRegistry.getCollection(this.qualified(model), { db: this.db });
+    }
+    plain(model, obj) {
+        const out = {
+            id: obj.id,
+            createdAt: toIso(obj.created_at ?? obj.createdAt),
+        };
+        for (const f of Object.keys(this.fieldsOf(model))) {
+            const v = obj[f];
+            out[f] = v instanceof Date ? v.toISOString() : (v ?? null);
+        }
+        return out;
+    }
+    async list(model, limit = 200) {
+        const rows = await (await this.collection(model)).list({
+            limit,
+            orderBy: 'created_at DESC',
+        });
+        return rows.map((r) => this.plain(model, r));
+    }
+    async get(model, id) {
+        const obj = await (await this.collection(model)).get(id);
+        if (!obj)
+            throw new AppError(`no ${model} ${id}`);
+        return this.plain(model, obj);
+    }
+    /** Check and convert `data` for a write. `refs: false` skips target lookups (imports). */
+    async coerce(model, data, creating, refs = true) {
+        const fields = this.fieldsOf(model);
+        const out = {};
+        for (const [k, v] of Object.entries(data)) {
+            if (!Object.hasOwn(fields, k))
+                throw new AppError(`${model} has no field '${k}' (fields: ${Object.keys(fields).join(', ')})`);
+            const fd = fields[k];
+            const c = coerceValue(fd, v);
+            if (!c.ok)
+                throw new AppError(`${model}.${k} ${c.error}`);
+            if (refs && fd.type === 'reference' && c.value !== null) {
+                const target = fd.ref;
+                if (!(await (await this.collection(target)).get(String(c.value))))
+                    throw new AppError(`${model}.${k}: no ${target} with id ${c.value}`);
+            }
+            out[k] = c.value;
+        }
+        if (creating)
+            for (const [k, fd] of Object.entries(fields))
+                if (fd.required &&
+                    (data[k] === undefined || data[k] === null || data[k] === ''))
+                    throw new AppError(`${model}.${k} is required`);
+        return out;
+    }
+    async create(model, data, opts = {}) {
+        const base = await this.coerce(model, data, true, opts.refs !== false);
+        if (recipeModelFor(model, this.def.models[model]))
+            base.typeId = await this.personType();
+        if (opts.id)
+            base.id = opts.id;
+        const obj = await (await this.collection(model)).create(base);
+        return this.get(model, String(obj.id));
+    }
+    async update(model, id, data) {
+        const base = await this.coerce(model, data, false);
+        const obj = await (await this.collection(model)).get(id);
+        if (!obj)
+            throw new AppError(`no ${model} ${id}`);
+        for (const [k, v] of Object.entries(base))
+            obj[k] = v;
+        await obj.save();
+        return this.get(model, id);
+    }
+    async remove(model, id) {
+        const obj = await (await this.collection(model)).get(id);
+        if (!obj)
+            throw new AppError(`no ${model} ${id}`);
+        await obj.delete();
+        return { deleted: id };
+    }
+    /** Create records of a template with their ids (references stay valid). */
+    async importRecords(records) {
+        let n = 0;
+        for (const [model, rows] of Object.entries(records)) {
+            this.modelDef(model);
+            for (const row of rows) {
+                const { id, createdAt: _c, ...data } = row;
+                await this.create(model, data, {
+                    id: typeof id === 'string' ? id : undefined,
+                    refs: false,
+                });
+                n++;
+            }
+        }
+        return { records: n };
+    }
+    /** Find or create the real `person` ProfileType (the type of every app Profile). */
+    async personType() {
+        const types = await ObjectRegistry.getCollection(PROFILE_TYPES, {
+            db: this.db,
+        });
+        const found = (await types.list({ where: { slug: 'person' }, limit: 1 }))[0];
+        if (found)
+            return String(found.id);
+        return String((await types.create({ name: 'Person', slug: 'person' })).id);
+    }
+    // ---------- methods ----------
+    async runMethod(model, method, id, params = {}) {
+        const md = this.modelDef(model).methods?.[method];
+        if (!md)
+            throw new AppError(`no method ${model}.${method}()`);
+        for (const [p, pd] of Object.entries(md.params ?? {}))
+            if (pd.required && params[p] == null)
+                throw new AppError(`param ${p} is required`);
+        const data = {};
+        for (const m of Object.keys(this.def.models))
+            data[m] = await this.list(m, 1000);
+        const record = id ? await this.get(model, id) : null;
+        let out;
+        try {
+            out = await runMethod(md.code, { record, params, data });
+        }
+        catch (e) {
+            throw new AppError(e.message);
+        }
+        let writes;
+        try {
+            writes = validateWrites(out.writes, Object.fromEntries(Object.keys(this.def.models).map((m) => [
+                m,
+                { fields: this.fieldsOf(m) },
+            ])), SANDBOX_LIMITS.maxWrites);
+            await this.checkWrites(writes);
+        }
+        catch (e) {
+            throw new AppError(`method ${model}.${method}() proposed bad writes, none applied: ${e.message}`);
+        }
+        if (!writes.length)
+            return { result: out.result, writes: [], applied: 0, snapshot: null };
+        // Snapshot first: anything the writes do can be taken back from it.
+        const snapshot = await this.snapshot(`method-${model}.${method}`);
+        let applied = 0;
+        try {
+            for (const w of writes) {
+                if (w.op === 'create')
+                    await this.create(w.model, w.data ?? {});
+                else if (w.op === 'update')
+                    await this.update(w.model, String(w.id), w.data ?? {});
+                else
+                    await this.remove(w.model, String(w.id));
+                applied++;
+            }
+        }
+        catch (e) {
+            throw new AppError(`method ${model}.${method}() failed after ${applied} of ${writes.length} writes (snapshot: ${snapshot}): ${e.message}`);
+        }
+        return { result: out.result, writes, applied, snapshot };
+    }
+    /** Reads only: records exist, required fields are present, references resolve. */
+    async checkWrites(writes) {
+        for (const w of writes) {
+            if (w.op === 'create')
+                await this.coerce(w.model, w.data ?? {}, true);
+            else {
+                if (!(await (await this.collection(w.model)).get(String(w.id))))
+                    throw new AppError(`no ${w.model} ${w.id}`);
+                if (w.op === 'update')
+                    await this.coerce(w.model, w.data ?? {}, false);
+            }
+        }
+    }
+}
+function toIso(v) {
+    return v instanceof Date ? v.toISOString() : (v ?? null);
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/engine/app-worker.js

@@ -0,0 +1,62 @@
+// The worker entry: runs one AppRuntime in its own thread. The host's handle
+// on it is in worker-handle.ts. Messages are plain JSON-safe values.
+import { isMainThread, parentPort, workerData } from 'node:worker_threads';
+import { WORKER_OPS } from "./worker-protocol.js";
+/**
+ * `@happyvertical/sql` starts an HMAC key generation on the libuv pool when it
+ * loads (a Postgres cache key). Node aborts the whole process if a worker is
+ * terminated while that job is still pending, so the worker reports ready (or
+ * failed) only after it has settled. Everything the host does to a worker
+ * (retire, terminate) happens after that message.
+ */
+const settleStartupJobs = async () => {
+    const pending = globalThis
+        .__haveSqlPostgresCacheHmacKey;
+    if (pending && typeof pending.then === 'function')
+        await pending.catch(() => { });
+};
+if (!isMainThread && workerData?.appWorker) {
+    const { AppRuntime } = await import("./app-runtime.js");
+    const { AppError } = await import("./errors.js");
+    const { dataDir, def, version, migration } = workerData;
+    const rt = new AppRuntime(dataDir, def, version);
+    const port = parentPort;
+    let ok = false;
+    try {
+        const t0 = performance.now();
+        const booted = await rt.boot(migration);
+        ok = true;
+        await settleStartupJobs();
+        port.postMessage({
+            ready: true,
+            ...booted,
+            bootMs: Math.round(performance.now() - t0),
+        });
+    }
+    catch (e) {
+        await settleStartupJobs();
+        port.postMessage({ ready: false, error: e.message });
+    }
+    if (ok)
+        port.on('message', async ({ id, op, args }) => {
+            let reply;
+            try {
+                if (!WORKER_OPS.includes(op))
+                    throw new Error(`bad op ${op}`);
+                reply = {
+                    id,
+                    ok: true,
+                    value: await rt[op](...args),
+                };
+            }
+            catch (e) {
+                reply = {
+                    id,
+                    ok: false,
+                    error: e.message,
+                    user: e instanceof AppError,
+                };
+            }
+            port.postMessage(reply);
+        });
+}