@oliphaunt/wasix-ts 0.1.0

package/lib/node-worker-options.js

@@ -0,0 +1,65 @@
+/**
+ * Keep runtime configuration flags while removing invocation modes which
+ * replace a file-backed Worker program.
+ */
+export function nodeWorkerExecArgv(execArgv = process.execArgv) {
+    const filtered = [];
+    for (let index = 0; index < execArgv.length; index += 1) {
+        const argument = execArgv[index];
+        if (argument === undefined)
+            break;
+        if (EXEC_MODE_WITH_VALUE.has(argument) || TEST_MODE_WITH_VALUE.has(argument)) {
+            index += 1;
+            continue;
+        }
+        if (EXEC_MODE_FLAGS.has(argument) ||
+            argument.startsWith('--input-type=') ||
+            argument.startsWith('--run=') ||
+            argument.startsWith('--watch-kill-signal=') ||
+            argument.startsWith('--watch-path=') ||
+            argument.startsWith('--experimental-test-isolation=') ||
+            argument === '--test' ||
+            argument.startsWith('--test-')) {
+            continue;
+        }
+        filtered.push(argument);
+    }
+    return filtered;
+}
+const EXEC_MODE_WITH_VALUE = new Set([
+    '--input-type',
+    '--eval',
+    '-e',
+    '--print',
+    '-p',
+    '--run',
+    '--watch-kill-signal',
+    '--watch-path',
+]);
+const EXEC_MODE_FLAGS = new Set([
+    '--check',
+    '-c',
+    '--interactive',
+    '-i',
+    '--watch',
+    '--watch-preserve-output',
+]);
+const TEST_MODE_WITH_VALUE = new Set([
+    '--experimental-test-isolation',
+    '--test-concurrency',
+    '--test-coverage-branches',
+    '--test-coverage-exclude',
+    '--test-coverage-functions',
+    '--test-coverage-include',
+    '--test-coverage-lines',
+    '--test-global-setup',
+    '--test-isolation',
+    '--test-name-pattern',
+    '--test-random-seed',
+    '--test-reporter',
+    '--test-reporter-destination',
+    '--test-rerun-failures',
+    '--test-shard',
+    '--test-skip-pattern',
+    '--test-timeout',
+]);

package/lib/node-worker-port.d.ts

@@ -0,0 +1,4 @@
+import type { Worker } from 'node:worker_threads';
+import type { WasixWorkerPort } from './worker-rpc.js';
+/** @internal Adapt Node-compatible Worker events to the shared RPC transport. */
+export declare function nodeWorkerPort(worker: Worker, runtimeName?: string): WasixWorkerPort;

package/lib/node-worker-port.js

@@ -0,0 +1,116 @@
+/** @internal Adapt Node-compatible Worker events to the shared RPC transport. */
+export function nodeWorkerPort(worker, runtimeName = 'Node') {
+    let terminationRequested = false;
+    let selfExitExpected = false;
+    let selfExitResponseObserved = false;
+    let exited = false;
+    let messageListener;
+    let fatalListener;
+    let fatalError;
+    let fatalDelivered = false;
+    let exitFailure;
+    let resolveExit;
+    let rejectExit;
+    const exit = new Promise((resolve, reject) => {
+        resolveExit = resolve;
+        rejectExit = reject;
+    });
+    // An unexpected Worker may never have an orderly waiter. Keep its rejected
+    // exit promise observed while preserving it for expectSelfExit().
+    void exit.catch(() => undefined);
+    const fatal = (error) => {
+        if (terminationRequested || fatalError !== undefined)
+            return;
+        fatalError = error;
+        deliverFatal();
+    };
+    const deliverFatal = () => {
+        if (fatalDelivered || fatalError === undefined || fatalListener === undefined)
+            return;
+        fatalDelivered = true;
+        fatalListener(fatalError);
+    };
+    const failExpectedExit = (error) => {
+        if (exitFailure !== undefined || exited)
+            return;
+        exitFailure = error;
+        rejectExit(error);
+    };
+    worker.on('message', (message) => {
+        if (selfExitExpected)
+            selfExitResponseObserved = true;
+        messageListener?.(message);
+    });
+    worker.on('messageerror', (error) => {
+        const failure = error instanceof Error
+            ? error
+            : new Error(`Oliphaunt WASIX ${runtimeName} Worker returned an unreadable message`);
+        if (selfExitExpected) {
+            failExpectedExit(failure);
+            if (!selfExitResponseObserved)
+                fatal(failure);
+        }
+        else
+            fatal(failure);
+    });
+    worker.on('error', (error) => {
+        if (selfExitExpected) {
+            failExpectedExit(error);
+            if (!selfExitResponseObserved)
+                fatal(error);
+        }
+        else
+            fatal(error);
+    });
+    worker.on('exit', (code) => {
+        exited = true;
+        if (selfExitExpected) {
+            if (exitFailure !== undefined)
+                return;
+            if (code === 0 && selfExitResponseObserved)
+                resolveExit();
+            else {
+                const error = new Error(code === 0
+                    ? `Oliphaunt WASIX ${runtimeName} Worker self-exited before its shutdown reply`
+                    : `Oliphaunt WASIX ${runtimeName} Worker self-exited with code ${code}`);
+                rejectExit(error);
+                if (!selfExitResponseObserved)
+                    fatal(error);
+            }
+            return;
+        }
+        if (terminationRequested) {
+            resolveExit();
+            return;
+        }
+        fatal(new Error(`Oliphaunt WASIX ${runtimeName} Worker exited unexpectedly with code ${code}`));
+    });
+    return {
+        supportsSharedMemory: true,
+        postMessage(message, transfer) {
+            if (exited)
+                throw new Error(`Oliphaunt WASIX ${runtimeName} Worker is closed`);
+            worker.postMessage(message, transfer);
+        },
+        expectSelfExit() {
+            selfExitExpected = true;
+            return exit;
+        },
+        async terminate() {
+            terminationRequested = true;
+            // An observed exit is the Node-compatible Worker's completed teardown
+            // contract. Bun 1.3 does not settle terminate() after that event, so
+            // reserve forced termination for startup/fatal cleanup before exit.
+            if (exited)
+                return;
+            await worker.terminate();
+        },
+        onMessage(listener) {
+            messageListener = listener;
+        },
+        onFatal(listener) {
+            fatalListener = listener;
+            deliverFatal();
+        },
+    };
+}

package/lib/node-worker.d.ts

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

package/lib/node-worker.js

@@ -0,0 +1,38 @@
+import { parentPort } from 'node:worker_threads';
+import { hostRuntimeName } from './host-runtime.js';
+import { openNodeDirectSession } from './node-direct.js';
+import { restoreNativeWasixStorageDirect } from './native-session.js';
+import { createWorkerSessionDispatcher } from './worker-dispatch.js';
+if (parentPort === null) {
+    throw new Error(`@oliphaunt/wasix-ts ${hostRuntimeName()} host must run inside a Worker`);
+}
+const port = parentPort;
+const runtimeName = hostRuntimeName();
+const dispatch = createWorkerSessionDispatcher(openNodeDirectSession, respond, restoreNativeWasixStorageDirect, {
+    onQuiescentClose() {
+        // Run after the close reply and dispatcher frame have unwound. Release
+        // the parent port so the Worker exits naturally. Bun 1.3 hangs if its
+        // process exit follows MessagePort teardown, so use its Worker-local
+        // exit before touching the port. Deno omits close().
+        queueMicrotask(() => {
+            // Bun's process.exit exits only this Worker, not its parent process.
+            // Native close and the close reply have both completed before this
+            // quiescent callback runs.
+            if (runtimeName === 'Bun')
+                process.exit(0);
+            port.off('message', onMessage);
+            port.close?.();
+            port.unref();
+            // Some Worker hosts also expose the standard self-close hook; Node
+            // simply omits it.
+            globalThis.close?.();
+        });
+    },
+});
+function onMessage(request) {
+    void dispatch(request);
+}
+port.on('message', onMessage);
+function respond(response, transfer = []) {
+    port.postMessage(response, [...transfer]);
+}

package/lib/pgwire-connection.d.ts

@@ -0,0 +1,60 @@
+import { type WasixByteChannel } from './byte-channel.js';
+export type WasixProtocolConnection = Readonly<{
+    frontend: WasixByteChannel;
+    backend: WasixByteChannel;
+}>;
+export type WasixProtocolExecutor = Readonly<{
+    startupResponse: Uint8Array;
+    startupIdentity?: Readonly<{
+        username: string;
+        database: string;
+    }>;
+    execDuplex(input: Uint8Array, onRead: (maximumBytes: number) => Uint8Array, onWrite: (chunk: Uint8Array) => void): void;
+    publishIdle(): Promise<void>;
+    rollback(): Promise<void>;
+}>;
+export type SynchronousPgDumpExecutor = Readonly<{
+    startupResponse: Uint8Array;
+    startupIdentity: Readonly<{
+        username: string;
+        database: string;
+    }>;
+    exec(input: Uint8Array, onChunk: (chunk: Uint8Array) => void): void;
+}>;
+/** @internal Connect same-realm pg_dump to the already stepped PostgreSQL backend. */
+export declare class SynchronousPgDumpConnection {
+    #private;
+    constructor(executor: SynchronousPgDumpExecutor);
+    get protocolStarted(): boolean;
+    write(input: Uint8Array): void;
+    read(maximumBytes: number): Uint8Array;
+    finish(): void;
+}
+/** @internal Serve one complete frontend connection over bounded byte channels. */
+export declare function serveWasixProtocolConnection(connection: WasixProtocolConnection, executor: WasixProtocolExecutor): Promise<void>;
+type FrontendKind = 'ssl' | 'cancel' | 'terminate' | 'startup' | 'protocol';
+export declare function classifyFrontendFrame(frame: Uint8Array): FrontendKind;
+/** @internal Parse the identity selected by a PostgreSQL v3 startup packet. */
+export declare function parseStartupIdentity(frame: Uint8Array): Readonly<{
+    username: string;
+    database: string;
+}>;
+export declare class FrontendFrameReader {
+    #private;
+    append(input: Uint8Array): void;
+    shift(): Uint8Array | undefined;
+    /** Stream one frontend frame at a time to COPY's synchronous pull transport. */
+    readFrameChunk(maximumBytes: number, read: () => Uint8Array): Uint8Array;
+    finishPull(): void;
+    finish(): void;
+}
+/** @internal Hold only ReadyForQuery while streaming every preceding backend message. */
+export declare class BackendResponseGate {
+    #private;
+    push(input: Uint8Array, write: (chunk: Uint8Array) => void): void;
+    finish(): Readonly<{
+        status: number;
+        frame: Uint8Array;
+    }> | undefined;
+}
+export {};