@playcraft/cli 0.1.41-prod → 0.1.43-beta

package/dist/workspace-runtime/persistence/journal.js

@@ -0,0 +1,365 @@
+import { copyFile, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { workspaceRegistrationSchema, operationRecordSchema, pendingSourceEventSchema, replayPinResultSchema, retainedRangeHasGap, sourceAckSchema, sourceEventKey, sourceEventReceiptSchema, terminalRecordSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { SqliteWorkerClient } from './sqlite-client.js';
+export const RUNTIME_STATE_FILE = 'runtime-state.sqlite';
+export const LEGACY_JOURNAL_FILE = 'journal.json';
+export const LEGACY_JOURNAL_SENTINEL = 'PLAYCRAFT_RUNTIME_STATE_SQLITE\n';
+export class RuntimeJournal {
+    filePath;
+    legacyPath;
+    client;
+    listeners = new Set();
+    maintenance;
+    engineInfo;
+    epochs = [];
+    readToken = '';
+    inboxPending = 0;
+    locks = new Map();
+    snapshot = emptySnapshot();
+    constructor(stateDir) {
+        this.filePath = join(stateDir, RUNTIME_STATE_FILE);
+        this.legacyPath = join(stateDir, LEGACY_JOURNAL_FILE);
+    }
+    async exclusive(key, action) {
+        const previous = this.locks.get(key) ?? Promise.resolve();
+        let release;
+        const current = new Promise((resolve) => {
+            release = resolve;
+        });
+        this.locks.set(key, current);
+        await previous;
+        try {
+            return await action();
+        }
+        finally {
+            release();
+            if (this.locks.get(key) === current)
+                this.locks.delete(key);
+        }
+    }
+    async load() {
+        await mkdir(dirname(this.filePath), { recursive: true, mode: 0o700 });
+        const legacy = await readLegacy(this.legacyPath, this.filePath);
+        const started = await SqliteWorkerClient.open(this.filePath, legacy?.value ?? null);
+        this.client = started.client;
+        this.apply(started.opened);
+        if (legacy?.readable)
+            await writeFile(this.legacyPath, LEGACY_JOURNAL_SENTINEL, { mode: 0o600 });
+        this.maintenance = setInterval(() => {
+            void this.client?.request('maintain').catch(() => undefined);
+        }, 30_000);
+        this.maintenance.unref?.();
+    }
+    async close() {
+        if (this.maintenance)
+            clearInterval(this.maintenance);
+        await this.client?.close();
+        this.client = undefined;
+    }
+    engine() {
+        if (!this.engineInfo)
+            throw new Error('sqlite_engine_unavailable');
+        return this.engineInfo;
+    }
+    sourceReadToken() {
+        return this.readToken;
+    }
+    pendingInbox() {
+        return this.inboxPending;
+    }
+    epochsSnapshot() {
+        return this.epochs.map((epoch) => ({ ...epoch }));
+    }
+    onSourceEvent(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    getWorkspace(workspaceId) {
+        return this.snapshot.workspaces[workspaceId];
+    }
+    async putWorkspace(binding) {
+        const parsed = workspaceRegistrationSchema.parse(binding);
+        await this.run('upsertRecord', { bucket: 'workspaces', key: parsed.workspaceId, body: parsed });
+    }
+    async forgetWorkspaces() {
+        await this.run('forgetWorkspaces', {});
+    }
+    findSessionCreation(sessionId) {
+        return Object.values(this.snapshot.operations).find((item) => item.kind === 'session.create' && item.sessionId === sessionId);
+    }
+    findTerminalCreation(terminalId) {
+        return Object.values(this.snapshot.operations).find((item) => item.kind === 'terminal.create' && item.terminalId === terminalId);
+    }
+    getOperation(scopeKey) {
+        return this.snapshot.operations[scopeKey];
+    }
+    getOperationById(operationId) {
+        return Object.values(this.snapshot.operations).find((operation) => operation.operationId === operationId);
+    }
+    listOperations() {
+        return Object.entries(this.snapshot.operations).map(([scopeKey, operation]) => ({ scopeKey, operation }));
+    }
+    getReceipt(key) {
+        return this.snapshot.receipts[key];
+    }
+    getSession(sessionId) {
+        return this.snapshot.sessions[sessionId];
+    }
+    listSessions() {
+        return Object.values(this.snapshot.sessions);
+    }
+    getTerminal(terminalId) {
+        return this.snapshot.terminals[terminalId];
+    }
+    listTerminals(workspaceId) {
+        return Object.values(this.snapshot.terminals).filter((item) => !workspaceId || item.workspaceId === workspaceId);
+    }
+    listManagedWrites(workspaceId) {
+        return Object.values(this.snapshot.managedWrites).filter((item) => !workspaceId || item.workspaceId === workspaceId);
+    }
+    getManagedWrite(writeId) {
+        return this.snapshot.managedWrites[writeId];
+    }
+    async putManagedWrite(record) {
+        await this.run('upsertRecord', { bucket: 'managed_writes', key: record.writeId, body: record });
+    }
+    getWorkspaceDependencies(workspaceId) {
+        return this.snapshot.workspaceDependencies[workspaceId];
+    }
+    listWorkspaceDependencies() {
+        return Object.values(this.snapshot.workspaceDependencies);
+    }
+    async putWorkspaceDependencies(record) {
+        await this.run('upsertRecord', {
+            bucket: 'workspace_dependencies',
+            key: record.workspaceId,
+            body: record,
+        });
+    }
+    fileRevisions(workspaceId) {
+        return { ...(workspaceId ? this.snapshot.workspaceFileRevisions[workspaceId] ?? {} : this.snapshot.fileRevisions) };
+    }
+    fileRevision(path, workspaceId) {
+        return this.fileRevisions(workspaceId)[path]?.revision ?? 0;
+    }
+    destroyed() {
+        return this.snapshot.destroyed;
+    }
+    lastSourceSequence() {
+        return this.snapshot.lastSourceSequence;
+    }
+    acceptedLeaseFence() {
+        return this.snapshot.acceptedLeaseFence;
+    }
+    storedRuntimeEpoch() {
+        return this.snapshot.runtimeEpoch;
+    }
+    executionGroup() {
+        return { ...this.snapshot.executionGroup };
+    }
+    stoppedRuntimeEpochs() {
+        return [...(this.snapshot.stoppedRuntimeEpochs ?? [])];
+    }
+    getApproval(sessionId, approvalId) {
+        return this.snapshot.approvals[`${sessionId}:${approvalId}`];
+    }
+    listApprovals() {
+        return Object.values(this.snapshot.approvals);
+    }
+    async putApproval(approval) {
+        await this.run('upsertRecord', { bucket: 'approvals', key: `${approval.sessionId}:${approval.approvalId}`, body: approval });
+    }
+    async noteExecutionGroup(group) {
+        await this.run('noteExecutionGroup', { group });
+    }
+    async writeExecutionEpoch(input) {
+        await this.run('writeExecutionEpoch', input);
+    }
+    async setExecutionStopConfirmed(stopConfirmed) {
+        await this.run('setStopConfirmed', { stopConfirmed });
+    }
+    async bindRuntime(input) {
+        await this.run('bindRuntime', input);
+    }
+    listEvents(afterSequence = 0) {
+        return Object.values(this.snapshot.events)
+            .filter((event) => event.source.sourceSequence > afterSequence)
+            .sort((left, right) => left.source.sourceSequence - right.source.sourceSequence || left.source.runtimeEpoch - right.source.runtimeEpoch);
+    }
+    readSourcePage(input) {
+        const epoch = this.epochs.find((item) => item.runtime_id === input.runtimeId && item.generation === input.generation && item.runtime_epoch === input.runtimeEpoch);
+        const retainedFrom = epoch?.retained_from ?? 1;
+        const highWater = epoch?.local_durable_through ?? 0;
+        const coveredThrough = input.after;
+        if (retainedRangeHasGap(retainedFrom, coveredThrough)) {
+            return { ok: false, code: 'source_gap', retainedFrom, highWater, coveredThrough, ...identity(input) };
+        }
+        const matched = Object.values(this.snapshot.events)
+            .filter((event) => event.source.runtimeId === input.runtimeId &&
+            event.source.generation === input.generation &&
+            event.source.runtimeEpoch === input.runtimeEpoch &&
+            event.source.sourceSequence > input.after)
+            .sort((left, right) => left.source.sourceSequence - right.source.sourceSequence);
+        const first = matched[0];
+        if (first && first.source.sourceSequence > input.after + 1) {
+            return { ok: false, code: 'source_gap', retainedFrom, highWater, coveredThrough, ...identity(input) };
+        }
+        const events = matched.slice(0, input.limit ?? 100);
+        const nextAfter = events.at(-1)?.source.sourceSequence ?? input.after;
+        return { ok: true, events, retainedFrom, highWater, nextAfter, ...identity(input) };
+    }
+    async allocateSourceEvent(input) {
+        const result = await this.run('allocateEvent', input);
+        const event = result.committedEvents?.[0];
+        if (!event)
+            throw new Error('source_event_missing');
+        return event;
+    }
+    async commitSourceIdentity(event) {
+        await this.run('commitIdentity', { event: pendingSourceEventSchema.parse(event) });
+    }
+    async ingestNative(input) {
+        const result = await this.run('ingest', input);
+        return result.committedEvents ?? [];
+    }
+    async bindTurn(input) {
+        const result = await this.run('bindTurn', input);
+        return result.committedEvents ?? [];
+    }
+    async acknowledgeSource(ack) {
+        await this.run('ack', sourceAckSchema.parse(ack));
+    }
+    async createReplayPin(input) {
+        const result = await this.run('createPin', { identity: input, ttlMs: input.ttlMs });
+        return replayPinResultSchema.parse(result.pin);
+    }
+    async deleteReplayPin(pinId) {
+        await this.run('deletePin', { pinId });
+    }
+    async reclaimSourceEvents(minRetainMs = 0) {
+        await this.run('reclaim', { minRetainMs });
+    }
+    async putOperation(scopeKey, operation) {
+        const parsed = operationRecordSchema.parse(operation);
+        await this.run('putOperation', { scopeKey, operation: parsed });
+        return this.snapshot.operations[scopeKey] ?? parsed;
+    }
+    async putSession(binding) {
+        await this.run('upsertRecord', { bucket: 'sessions', key: binding.sessionId, body: binding });
+    }
+    async putTerminal(record) {
+        const parsed = terminalRecordSchema.parse(record);
+        await this.run('upsertRecord', { bucket: 'terminals', key: parsed.terminalId, body: parsed });
+        return parsed;
+    }
+    async putFileRevision(path, record, workspaceId) {
+        if (workspaceId) {
+            await this.run('upsertRecord', { bucket: `workspace_files:${workspaceId}`, key: path, body: record });
+            return;
+        }
+        await this.run('upsertRecord', { bucket: 'file_revisions', key: path, body: record });
+    }
+    async markDestroyed() {
+        await this.run('setDestroyed', {});
+    }
+    async replaceSessions(sessions) {
+        await this.run('replaceBucket', {
+            bucket: 'sessions',
+            entries: sessions.map((session) => ({ key: session.sessionId, body: session })),
+        });
+    }
+    async setAcceptedLeaseFence(value) {
+        await this.run('setAcceptedFence', { value });
+    }
+    async putReceipt(receipt, sourceSequence) {
+        const parsed = sourceEventReceiptSchema.parse(receipt);
+        await this.run('upsertRecord', { bucket: 'receipts', key: sourceEventKey(parsed.source), body: parsed });
+        void sourceSequence;
+    }
+    async appendEvent(event) {
+        const parsed = pendingSourceEventSchema.parse(event);
+        await this.commitSourceIdentity(parsed);
+        return this.snapshot.events[sourceEventKey(parsed.source)] ?? parsed;
+    }
+    async run(type, payload) {
+        if (!this.client)
+            throw new Error('sqlite_not_open');
+        const result = await this.client.request(type, payload);
+        this.apply(result);
+        for (const event of result.committedEvents ?? []) {
+            for (const listener of this.listeners)
+                listener(event);
+        }
+        return result;
+    }
+    apply(dump) {
+        const group = dump.snapshot.executionGroup;
+        const events = dump.snapshot.events ?? this.snapshot.events;
+        // Keep history in place: copying it on every streamed delta grows quadratically.
+        for (const event of dump.committedEvents ?? [])
+            events[sourceEventKey(event.source)] = event;
+        for (const event of dump.eventChanges ?? [])
+            events[sourceEventKey(event.source)] = event;
+        this.snapshot = {
+            ...emptySnapshot(),
+            ...dump.snapshot,
+            events,
+            executionGroup: {
+                stopConfirmed: group?.stopConfirmed === true,
+                replaced: group?.replaced === true,
+                pid: group?.pid,
+                startedAt: group?.startedAt,
+                previousPid: group?.previousPid,
+            },
+        };
+        this.epochs = dump.epochs ?? [];
+        this.readToken = dump.sourceReadToken ?? this.readToken;
+        this.inboxPending = dump.pendingInbox ?? 0;
+        if (dump.engine)
+            this.engineInfo = dump.engine;
+    }
+}
+async function readLegacy(legacyPath, sqlitePath) {
+    if (!existsSync(legacyPath))
+        return null;
+    const text = await readFile(legacyPath, 'utf8');
+    if (text.startsWith(LEGACY_JOURNAL_SENTINEL.trim())) {
+        if (!existsSync(sqlitePath))
+            throw new Error('runtime_state_missing');
+        return null;
+    }
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        throw new Error('legacy_journal_unreadable');
+    }
+    if (!existsSync(`${legacyPath}.bak`))
+        await copyFile(legacyPath, `${legacyPath}.bak`);
+    return { value, readable: true };
+}
+function identity(input) {
+    return { runtimeId: input.runtimeId, generation: input.generation, runtimeEpoch: input.runtimeEpoch };
+}
+function emptySnapshot() {
+    return {
+        workspaces: {},
+        workspaceFileRevisions: {},
+        operations: {},
+        receipts: {},
+        events: {},
+        sessions: {},
+        terminals: {},
+        fileRevisions: {},
+        approvals: {},
+        managedWrites: {},
+        workspaceDependencies: {},
+        executionGroup: { stopConfirmed: false, replaced: false },
+        lastSourceSequence: 0,
+        acceptedLeaseFence: 0,
+        destroyed: false,
+    };
+}

package/dist/workspace-runtime/persistence/native-subagents.js

@@ -0,0 +1,162 @@
+import { operationRecordSchema } from '@playcraft/common/cloud-workspace/runtime';
+/** Native ancestry is durable platform metadata, never inferred from an arbitrary turn identifier. */
+export function nativeEventOwner(database, threadId, turnId) {
+    if (!threadId)
+        return undefined;
+    const direct = sessionsForThread(database, threadId);
+    if (direct.length) {
+        if (direct.length !== 1)
+            return undefined;
+        const session = direct[0];
+        const operation = readOperation(database, 'turn_id', turnId ?? text(session.activeTurnId), threadId);
+        if (turnId && !ownsOperation(session, threadId, operation))
+            return undefined;
+        return { session, operation: ownsOperation(session, threadId, operation) ? operation : undefined };
+    }
+    const link = readRecord(database, 'native_subagent_threads', threadId);
+    if (!link || link.operationConfirmed === false)
+        return undefined;
+    const roots = sessionsForThread(database, link.rootThreadId);
+    if (roots.length !== 1)
+        return undefined;
+    const session = roots[0];
+    if (session.sessionId !== link.sessionId || session.workspaceId !== link.workspaceId)
+        return undefined;
+    const turnKey = turnId ? JSON.stringify([threadId, turnId]) : undefined;
+    const pinned = turnKey ? readRecord(database, 'native_subagent_turns', turnKey) : undefined;
+    const pending = turnKey && !pinned ? readRecord(database, 'native_subagent_pending_followups', threadId) : undefined;
+    if (pending) {
+        const followup = readOperation(database, 'scope_key', text(pending.operationScopeKey));
+        if (followup?.operation.status === 'accepted' && followup.operation.nativeTurnId === session.activeTurnId)
+            return undefined;
+        database.prepare('DELETE FROM records WHERE bucket = ? AND record_key = ?').run('native_subagent_pending_followups', threadId);
+    }
+    const scopeKey = text(pinned?.operationScopeKey) ?? link.operationScopeKey;
+    const operation = scopeKey
+        ? readOperation(database, 'scope_key', scopeKey)
+        : readOperation(database, 'turn_id', text(session.activeTurnId), link.rootThreadId);
+    if (!ownsOperation(session, link.rootThreadId, operation))
+        return undefined;
+    if (turnKey && !pinned)
+        writeRecord(database, 'native_subagent_turns', turnKey, { operationScopeKey: operation.scopeKey });
+    const { sessionId: _, workspaceId: __, operationScopeKey: ___, operationConfirmed: ____, ...subAgent } = link;
+    return { session, operation, subAgent };
+}
+/** Only native thread ancestry or a spawn from an already owned thread can introduce a child. */
+export function learnNativeSubagents(database, method, params, threadId, turnId) {
+    const payload = record(params);
+    if (method === 'thread/started') {
+        const thread = record(payload.thread);
+        const spawn = record(record(record(thread.source).subAgent).thread_spawn);
+        const childId = text(thread.id);
+        const parentId = text(thread.parentThreadId) ?? text(spawn.parent_thread_id);
+        if (!childId || !parentId || (text(thread.parentThreadId) && text(spawn.parent_thread_id) && thread.parentThreadId !== spawn.parent_thread_id))
+            return [];
+        const owner = nativeEventOwner(database, parentId);
+        if (!owner)
+            return [];
+        const changed = remember(database, childId, parentId, owner, {
+            agentNickname: text(thread.agentNickname) ?? text(spawn.agent_nickname),
+            agentRole: text(thread.agentRole) ?? text(spawn.agent_role),
+            agentPath: text(spawn.agent_path),
+        }, false);
+        return changed ? [childId] : [];
+    }
+    if (method !== 'item/started' && method !== 'item/completed')
+        return [];
+    const item = record(payload.item);
+    if (item.type !== 'collabAgentToolCall' || item.senderThreadId !== threadId)
+        return [];
+    const owner = nativeEventOwner(database, threadId, turnId);
+    if (!owner || !owner.operation)
+        return [];
+    const receivers = Array.isArray(item.receiverThreadIds) ? item.receiverThreadIds.filter((id) => typeof id === 'string' && id.length > 0) : [];
+    const changed = [];
+    for (const childId of receivers) {
+        if (item.tool === 'spawnAgent') {
+            if (remember(database, childId, threadId, owner, {}))
+                changed.push(childId);
+        }
+        else if (['sendInput', 'resumeAgent', 'sendMessage', 'followupTask'].includes(String(item.tool))) {
+            const existing = readRecord(database, 'native_subagent_threads', childId);
+            if (!existing || existing.sessionId !== owner.session.sessionId || existing.rootThreadId !== (owner.subAgent?.rootThreadId ?? threadId))
+                continue;
+            if (method === 'item/started' && item.status === 'inProgress' && existing.operationScopeKey !== owner.operation.scopeKey) {
+                writeRecord(database, 'native_subagent_pending_followups', childId, { itemId: item.id, operationScopeKey: owner.operation.scopeKey });
+                continue;
+            }
+            if (method !== 'item/completed')
+                continue;
+            const pending = readRecord(database, 'native_subagent_pending_followups', childId);
+            if (pending?.itemId === item.id)
+                database.prepare('DELETE FROM records WHERE bucket = ? AND record_key = ?').run('native_subagent_pending_followups', childId);
+            if (item.status === 'completed' && existing.operationScopeKey !== owner.operation.scopeKey)
+                writeRecord(database, 'native_subagent_threads', childId, { ...existing, operationScopeKey: owner.operation.scopeKey });
+            if (pending?.itemId === item.id || item.status === 'completed')
+                changed.push(childId);
+        }
+    }
+    return changed;
+}
+export function nativeSubagentThreads(database, rootThreadId) {
+    const rows = database.prepare("SELECT record_key FROM records WHERE bucket = 'native_subagent_threads' AND json_extract(body_json, '$.rootThreadId') = ?")
+        .all(rootThreadId);
+    return rows.map(row => row.record_key);
+}
+export function clearPendingNativeFollowups(database) {
+    const rows = database.prepare("SELECT record_key FROM records WHERE bucket = 'native_subagent_pending_followups'")
+        .all();
+    database.prepare("DELETE FROM records WHERE bucket = 'native_subagent_pending_followups'").run();
+    return rows.map(row => row.record_key);
+}
+function remember(database, childId, parentId, owner, metadata, confirmed = true) {
+    if (childId === parentId || sessionsForThread(database, childId).length)
+        return false;
+    const rootThreadId = owner.subAgent?.rootThreadId ?? text(owner.session.threadId);
+    if (childId === rootThreadId)
+        return false;
+    const previous = readRecord(database, 'native_subagent_threads', childId);
+    if (previous && (previous.parentThreadId !== parentId || previous.rootThreadId !== rootThreadId || previous.sessionId !== owner.session.sessionId))
+        return false;
+    const defined = Object.fromEntries(Object.entries(metadata).filter(([, value]) => value !== undefined));
+    // Thread ancestry contains no parent turn. Wait for its spawn item before archiving events
+    // against an operation: a parent agent may still be running an older, pinned turn.
+    const wasConfirmed = previous && previous.operationConfirmed !== false;
+    const next = { ...previous, ...defined, threadId: childId, parentThreadId: parentId, rootThreadId,
+        sessionId: String(owner.session.sessionId), workspaceId: text(owner.session.workspaceId),
+        operationConfirmed: Boolean(wasConfirmed || confirmed),
+        operationScopeKey: wasConfirmed ? previous.operationScopeKey : confirmed ? owner.operation?.scopeKey : undefined };
+    if (JSON.stringify(previous) === JSON.stringify(next))
+        return false;
+    writeRecord(database, 'native_subagent_threads', childId, next);
+    return true;
+}
+function ownsOperation(session, rootThreadId, found) {
+    return Boolean(found && ['session.turn', 'session.review', 'session.compact'].includes(found.operation.kind) && found.operation.sessionId === session.sessionId &&
+        (found.operation.workspaceId === undefined || found.operation.workspaceId === session.workspaceId) && found.operation.nativeThreadId === rootThreadId);
+}
+function readOperation(database, column, value, threadId) {
+    if (!value)
+        return undefined;
+    const row = database.prepare(`SELECT scope_key, operation_json FROM operation_intents WHERE ${column} = ?${threadId ? ' AND thread_id = ?' : ''}${column === 'turn_id' ? " AND json_extract(operation_json, '$.kind') IN ('session.turn', 'session.review', 'session.compact')" : ''}`)
+        .get(...(threadId ? [value, threadId] : [value]));
+    if (!row)
+        return undefined;
+    const parsed = operationRecordSchema.safeParse(JSON.parse(row.operation_json));
+    return parsed.success ? { scopeKey: row.scope_key, operation: parsed.data } : undefined;
+}
+function sessionsForThread(database, threadId) {
+    const rows = database.prepare("SELECT body_json FROM records WHERE bucket = 'sessions' AND json_extract(body_json, '$.threadId') = ?")
+        .all(threadId);
+    return rows.map(row => record(JSON.parse(row.body_json)));
+}
+function readRecord(database, bucket, key) {
+    const row = database.prepare('SELECT body_json FROM records WHERE bucket = ? AND record_key = ?').get(bucket, key);
+    return row ? record(JSON.parse(row.body_json)) : undefined;
+}
+function writeRecord(database, bucket, key, value) {
+    database.prepare('INSERT INTO records (bucket, record_key, body_json) VALUES (?, ?, ?) ON CONFLICT(bucket, record_key) DO UPDATE SET body_json = excluded.body_json')
+        .run(bucket, key, JSON.stringify(value));
+}
+function text(value) { return typeof value === 'string' && value.length > 0 ? value : undefined; }
+function record(value) { return value && typeof value === 'object' && !Array.isArray(value) ? value : {}; }

package/dist/workspace-runtime/persistence/sqlite-client.js

@@ -0,0 +1,77 @@
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { Worker } from 'node:worker_threads';
+export class SqliteWorkerClient {
+    nextId = 1;
+    pending = new Map();
+    chain = Promise.resolve();
+    worker;
+    constructor(worker) {
+        this.worker = worker;
+        worker.on('message', (message) => {
+            const waiter = this.pending.get(message.id);
+            if (!waiter)
+                return;
+            this.pending.delete(message.id);
+            if (message.ok)
+                waiter.resolve(message.result);
+            else
+                waiter.reject(new Error(message.error || 'sqlite_worker_failed'));
+        });
+        worker.on('error', (error) => {
+            for (const waiter of this.pending.values())
+                waiter.reject(error);
+            this.pending.clear();
+        });
+    }
+    static async open(filePath, legacy) {
+        const url = workerUrl();
+        const execArgv = url.pathname.endsWith('.ts') ? ['--import', sourceResolver()] : [];
+        const client = new SqliteWorkerClient(new Worker(url, { execArgv, env: { ...process.env, NODE_OPTIONS: '' } }));
+        try {
+            const opened = await client.request('open', { filePath, legacy });
+            return { client, opened };
+        }
+        catch (error) {
+            await client.close().catch(() => undefined);
+            throw error;
+        }
+    }
+    request(type, payload) {
+        const run = this.chain.then(() => this.send(type, payload));
+        this.chain = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    async close() {
+        await this.request('close', {}).catch(() => undefined);
+        await this.worker.terminate();
+    }
+    send(type, payload) {
+        const id = this.nextId;
+        this.nextId += 1;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve: (value) => resolve(value), reject });
+            this.worker.postMessage({ id, type, payload });
+        });
+    }
+}
+function workerUrl() {
+    const compiled = new URL('./sqlite-worker.js', import.meta.url);
+    if (existsSync(fileURLToPath(compiled)))
+        return compiled;
+    return new URL('./sqlite-worker.ts', import.meta.url);
+}
+/** Source tests use Node's type stripping, with relative emitted imports resolved to their sources. */
+function sourceResolver() {
+    return `data:text/javascript,${encodeURIComponent(`
+    import { registerHooks } from 'node:module';
+    import { existsSync } from 'node:fs';
+    registerHooks({ resolve(specifier, context, next) {
+      if (context.parentURL?.endsWith('.ts') && specifier.startsWith('./') && specifier.endsWith('.js')) {
+        const source = new URL(specifier.slice(0, -3) + '.ts', context.parentURL);
+        if (existsSync(source)) return next(source.href, context);
+      }
+      return next(specifier, context);
+    } });
+  `)}`;
+}