@playcraft/cli 0.1.40-beta → 0.1.42

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

@@ -1,365 +0,0 @@
-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

@@ -1,162 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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);
-    } });
-  `)}`;
-}