@volter/tabnode 0.4.0 → 0.5.0

package/dist/fetch-transport.d.ts

@@ -0,0 +1,20 @@
+/** Host Fetch I/O uses the same process-owned liveness registry as sockets. */
+import type { Process } from './shims/process';
+export interface FetchActivity {
+    /** One pending transport operation; the returned release is idempotent. */
+    hold(): () => void;
+    /** EOF/error/cancellation ends ownership, without cancelling completed I/O. */
+    release(): void;
+}
+export interface FetchTransportContext {
+    /** Retain cancellation ownership while idle, but do not keep the run alive. */
+    begin(cancel: () => void): FetchActivity;
+}
+export type FetchTransport = (input: RequestInfo | URL, init: RequestInit | undefined, context: FetchTransportContext) => Promise<Response>;
+export declare function rememberRequestBodySource(request: Request, input: RequestInfo | URL, init?: RequestInit): void;
+/** Host transport metadata; it carries no network permission. */
+export declare function requestHasStaticBody(request: Request): boolean;
+/** Host-only seam: the adapter reports pending headers/pulls and final cleanup. */
+export declare function installFetchTransport(adapter: FetchTransport): () => void;
+/** Each process may replace its own fetch; the host adapter remains private. */
+export declare function guestFetch(process: Process, fallback: typeof globalThis.fetch): typeof globalThis.fetch;

package/dist/guest-timers.d.ts

@@ -0,0 +1,15 @@
+export declare function pendingGuestTimers(process: object): number;
+/**
+ * Clear every timer a guest still holds, as ending a Node process clears the
+ * ones its loop was waiting on. The ids were made by the host's own
+ * `setTimeout`/`setInterval` through the guest's global view, so the host's
+ * own clears end them; a `Timeout` is cleared by either in Node, and either
+ * refusing an id of the other kind is not an error here.
+ */
+export declare function stopGuestTimers(process: object): void;
+export declare function guestTimerFunctions(process: object, host: Record<string, unknown>): {
+    setTimeout(fn: (...a: unknown[]) => void, ms?: number, ...rest: unknown[]): unknown;
+    setInterval(fn: (...a: unknown[]) => void, ms?: number, ...rest: unknown[]): unknown;
+    clearTimeout(id: unknown): void;
+    clearInterval(id: unknown): void;
+};

package/dist/http-client-transport.d.ts

@@ -0,0 +1,19 @@
+export interface HttpClientExchangeRequest {
+    url: string;
+    method: string;
+    headers: Array<[string, string]>;
+    body?: ReadableStream<Uint8Array>;
+    signal: AbortSignal;
+    profile: 'server-http';
+}
+export interface HttpClientExchangeResponse {
+    status: number;
+    statusText: string;
+    headers: Array<[string, string]>;
+    body: ReadableStream<Uint8Array> | null;
+}
+export type HttpClientExchange = (request: HttpClientExchangeRequest) => Promise<HttpClientExchangeResponse>;
+/** Capture process attribution synchronously when the connection is requested. */
+export type HttpClientTransportFactory = () => HttpClientExchange;
+/** Host-only installation; guest modules receive Node's normal exports. */
+export declare function installHttpClientTransport(factory: HttpClientTransportFactory): () => void;

package/dist/index.d.ts

@@ -20,6 +20,8 @@ export { createProcess } from './shims/process';
 export type { Process, ProcessEnv } from './shims/process';
 export * as path from './shims/path';
 export { httpModule as http, httpsModule as https } from './node-lib/http-module';
+export { installHttpClientTransport } from './http-client-transport';
+export type { HttpClientExchange, HttpClientExchangeRequest, HttpClientExchangeResponse, HttpClientTransportFactory } from './http-client-transport';
 export { netModule as net } from './node-lib/net-module';
 export { eventsModule as events } from './node-lib/events-module';
 export { streamModule as stream } from './node-lib/stream-module';
@@ -44,6 +46,13 @@ import { ServerBridge } from './server-bridge';
 import { type Socket as NetSocket } from './node-lib/net-module';
 import { runPid, processByPid } from './process-tokens';
 export { runPid, processByPid };
+export { createProcessRegistryScope, installProcessRegistry, ownerProcessRegistryScope } from './process-tokens';
+export { installNodeProcessHost, nodeProcessHostInstalled } from './node-process-host';
+export type { NodeProcessLaunch, NodeProcessHost } from './node-process-host';
+export type { ProcessIdentity, ProcessRegistry, ProcessRegistryScope, InitialProcessRegistration } from './process-registry';
+export { NativeStreamScope } from './native-stream-owner';
+export { installNativeStreamTransport, nativeStreamDescriptor } from './native-stream-binding';
+export type { NativeStreamDescriptor, NativeStreamLimits, NativeStreamEvent, NativeStreamOperation, NativeStreamReply, NativeStreamTransport } from './native-stream-owner';
 export interface RunResult {
     stdout: string;
     stderr: string;
@@ -128,5 +137,7 @@ export declare function createContainer(options?: ContainerOptions): {
     on: (event: string, listener: (...args: unknown[]) => void) => void;
 };
 export default createContainer;
+export { installFetchTransport, requestHasStaticBody } from './fetch-transport';
+export type { FetchActivity, FetchTransport, FetchTransportContext } from './fetch-transport';
 export { createNodeResolver } from './node-resolution';
 export type { ResolutionFs, ExportsResolver, NodeResolverOptions, NodeResolver } from './node-resolution';