@swifttui/web 0.0.14 → 0.0.15

package/dist/src/wasi/BrowserWASIBridge.d.ts

@@ -0,0 +1,33 @@
+import { WebHostTerminalStyle } from "../WebHostTerminalStyle.js";
+import { WebHostOutputSink, encodeRenderStyleControlMessage, encodeResizeControlMessage } from "../WebHostSurfaceTransport.js";
+import { StdIOPipe } from "./StdIOPipe.js";
+
+//#region src/wasi/BrowserWASIBridge.d.ts
+interface BrowserWASIBridgeOptions {
+  sceneId: string;
+  columns: number;
+  rows: number;
+  environment?: Record<string, string>;
+  renderStyle?: WebHostTerminalStyle;
+}
+type BrowserWASIOutputSink = WebHostOutputSink;
+declare class BrowserWASIBridge {
+  readonly stdin: StdIOPipe;
+  readonly stdout: StdIOPipe;
+  readonly stderr: StdIOPipe;
+  readonly environment: Record<string, string>;
+  private detachStdout?;
+  private detachStderr?;
+  private readonly resizeListeners;
+  private latestResize;
+  constructor(options: BrowserWASIBridgeOptions);
+  bindOutput(sink: BrowserWASIOutputSink): void;
+  resize(columns: number, rows: number, cellWidth?: number, cellHeight?: number): void;
+  updateRenderStyle(style: WebHostTerminalStyle): void;
+  sendInput(chunk: Uint8Array): void;
+  subscribeResize(listener: (columns: number, rows: number, cellWidth?: number, cellHeight?: number) => void): () => void;
+  dispose(): void;
+}
+//#endregion
+export { BrowserWASIBridge, BrowserWASIBridgeOptions, BrowserWASIOutputSink };
+//# sourceMappingURL=BrowserWASIBridge.d.ts.map

package/dist/src/wasi/BrowserWASIBridge.js

@@ -0,0 +1,97 @@
+import { StdIOPipe } from "./StdIOPipe.js";
+import { encodeWebHostTerminalRenderStyleBase64 } from "../WebHostTerminalStyle.js";
+import { WebHostOutputDecoder, encodeRenderStyleControlMessage, encodeResizeControlMessage } from "../WebHostSurfaceTransport.js";
+//#region src/wasi/BrowserWASIBridge.ts
+var BrowserWASIBridge = class {
+	stdin = new StdIOPipe();
+	stdout = new StdIOPipe();
+	stderr = new StdIOPipe();
+	environment;
+	detachStdout;
+	detachStderr;
+	resizeListeners = /* @__PURE__ */ new Set();
+	latestResize;
+	constructor(options) {
+		this.environment = {
+			TUIGUI_MODE: "browser",
+			TUIGUI_TRANSPORT: "surface",
+			TUIGUI_SURFACE_DELTA: "1",
+			TUIGUI_SCENE: options.sceneId,
+			TUIGUI_COLUMNS: String(Math.max(1, options.columns)),
+			TUIGUI_ROWS: String(Math.max(1, options.rows)),
+			...options.environment,
+			...options.renderStyle ? { TUIGUI_RENDER_STYLE: encodeWebHostTerminalRenderStyleBase64(options.renderStyle) } : {}
+		};
+		this.latestResize = {
+			columns: Math.max(1, options.columns),
+			rows: Math.max(1, options.rows)
+		};
+	}
+	bindOutput(sink) {
+		this.detachStdout?.();
+		this.detachStderr?.();
+		const decoder = new WebHostOutputDecoder();
+		this.detachStdout = this.stdout.subscribe((chunk) => {
+			for (const record of decoder.feed(chunk)) switch (record.type) {
+				case "surface":
+					sink.presentSurface(record.frame);
+					break;
+				case "clipboard":
+					sink.writeClipboard?.(record.text);
+					break;
+				case "runtimeIssue":
+					sink.notifyRuntimeIssue?.(record.issue);
+					break;
+				case "frameDiagnostic":
+					sink.recordFrameDiagnostic?.(record.diagnostic);
+					break;
+				case "text":
+					sink.writeOutput?.(record.text);
+					break;
+			}
+		});
+		this.detachStderr = this.stderr.subscribe((chunk) => {
+			sink.writeError?.(new TextDecoder().decode(chunk));
+		});
+	}
+	resize(columns, rows, cellWidth, cellHeight) {
+		const normalizedColumns = Math.max(1, columns);
+		const normalizedRows = Math.max(1, rows);
+		this.environment.TUIGUI_COLUMNS = String(normalizedColumns);
+		this.environment.TUIGUI_ROWS = String(normalizedRows);
+		this.latestResize = {
+			columns: normalizedColumns,
+			rows: normalizedRows,
+			cellWidth,
+			cellHeight
+		};
+		this.stdin.write(encodeResizeControlMessage(columns, rows, cellWidth, cellHeight));
+		for (const listener of this.resizeListeners) listener(normalizedColumns, normalizedRows, cellWidth, cellHeight);
+	}
+	updateRenderStyle(style) {
+		this.environment.TUIGUI_RENDER_STYLE = encodeWebHostTerminalRenderStyleBase64(style);
+		this.stdin.write(encodeRenderStyleControlMessage(style));
+	}
+	sendInput(chunk) {
+		this.stdin.write(chunk);
+	}
+	subscribeResize(listener) {
+		this.resizeListeners.add(listener);
+		listener(this.latestResize.columns, this.latestResize.rows, this.latestResize.cellWidth, this.latestResize.cellHeight);
+		return () => {
+			this.resizeListeners.delete(listener);
+		};
+	}
+	dispose() {
+		this.detachStdout?.();
+		this.detachStderr?.();
+		this.resizeListeners.clear();
+		this.stdin.close();
+		this.stdout.close();
+		this.stderr.close();
+	}
+};
+//#endregion
+export { BrowserWASIBridge };
+
+//# sourceMappingURL=BrowserWASIBridge.js.map

package/dist/src/wasi/BrowserWASIBridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BrowserWASIBridge.js","names":[],"sources":["../../../src/wasi/BrowserWASIBridge.ts"],"sourcesContent":["import { StdIOPipe } from \"./StdIOPipe.ts\";\nimport {\n  encodeWebHostTerminalRenderStyleBase64,\n  type WebHostTerminalStyle,\n} from \"../WebHostTerminalStyle.ts\";\nimport {\n  WebHostOutputDecoder,\n  encodeRenderStyleControlMessage,\n  encodeResizeControlMessage,\n  type WebHostOutputSink,\n} from \"../WebHostSurfaceTransport.ts\";\n\nexport interface BrowserWASIBridgeOptions {\n  sceneId: string;\n  columns: number;\n  rows: number;\n  environment?: Record<string, string>;\n  renderStyle?: WebHostTerminalStyle;\n}\n\nexport type BrowserWASIOutputSink = WebHostOutputSink;\n\nexport class BrowserWASIBridge {\n  readonly stdin = new StdIOPipe();\n  readonly stdout = new StdIOPipe();\n  readonly stderr = new StdIOPipe();\n  readonly environment: Record<string, string>;\n\n  private detachStdout?: () => void;\n  private detachStderr?: () => void;\n  private readonly resizeListeners = new Set<(\n    columns: number,\n    rows: number,\n    cellWidth?: number,\n    cellHeight?: number\n  ) => void>();\n  private latestResize: {\n    columns: number;\n    rows: number;\n    cellWidth?: number;\n    cellHeight?: number;\n  };\n\n  constructor(options: BrowserWASIBridgeOptions) {\n    this.environment = {\n      TUIGUI_MODE: \"browser\",\n      TUIGUI_TRANSPORT: \"surface\",\n      TUIGUI_SURFACE_DELTA: \"1\",\n      TUIGUI_SCENE: options.sceneId,\n      TUIGUI_COLUMNS: String(Math.max(1, options.columns)),\n      TUIGUI_ROWS: String(Math.max(1, options.rows)),\n      ...options.environment,\n      ...(options.renderStyle\n        ? {\n            TUIGUI_RENDER_STYLE: encodeWebHostTerminalRenderStyleBase64(\n              options.renderStyle\n            ),\n          }\n        : {}),\n    };\n    this.latestResize = {\n      columns: Math.max(1, options.columns),\n      rows: Math.max(1, options.rows),\n    };\n  }\n\n  bindOutput(\n    sink: BrowserWASIOutputSink\n  ): void {\n    this.detachStdout?.();\n    this.detachStderr?.();\n    const decoder = new WebHostOutputDecoder();\n    this.detachStdout = this.stdout.subscribe((chunk) => {\n      for (const record of decoder.feed(chunk)) {\n        switch (record.type) {\n        case \"surface\":\n          sink.presentSurface(record.frame);\n          break;\n        case \"clipboard\":\n          void sink.writeClipboard?.(record.text);\n          break;\n        case \"runtimeIssue\":\n          sink.notifyRuntimeIssue?.(record.issue);\n          break;\n        case \"frameDiagnostic\":\n          sink.recordFrameDiagnostic?.(record.diagnostic);\n          break;\n        case \"text\":\n          sink.writeOutput?.(record.text);\n          break;\n        }\n      }\n    });\n    this.detachStderr = this.stderr.subscribe((chunk) => {\n      sink.writeError?.(new TextDecoder().decode(chunk));\n    });\n  }\n\n  resize(\n    columns: number,\n    rows: number,\n    cellWidth?: number,\n    cellHeight?: number\n  ): void {\n    const normalizedColumns = Math.max(1, columns);\n    const normalizedRows = Math.max(1, rows);\n    this.environment.TUIGUI_COLUMNS = String(normalizedColumns);\n    this.environment.TUIGUI_ROWS = String(normalizedRows);\n    this.latestResize = {\n      columns: normalizedColumns,\n      rows: normalizedRows,\n      cellWidth,\n      cellHeight,\n    };\n    this.stdin.write(encodeResizeControlMessage(columns, rows, cellWidth, cellHeight));\n    for (const listener of this.resizeListeners) {\n      listener(normalizedColumns, normalizedRows, cellWidth, cellHeight);\n    }\n  }\n\n  updateRenderStyle(\n    style: WebHostTerminalStyle\n  ): void {\n    this.environment.TUIGUI_RENDER_STYLE = encodeWebHostTerminalRenderStyleBase64(style);\n    this.stdin.write(encodeRenderStyleControlMessage(style));\n  }\n\n  sendInput(\n    chunk: Uint8Array\n  ): void {\n    this.stdin.write(chunk);\n  }\n\n  subscribeResize(\n    listener: (\n      columns: number,\n      rows: number,\n      cellWidth?: number,\n      cellHeight?: number\n    ) => void\n  ): () => void {\n    this.resizeListeners.add(listener);\n    listener(\n      this.latestResize.columns,\n      this.latestResize.rows,\n      this.latestResize.cellWidth,\n      this.latestResize.cellHeight\n    );\n    return () => {\n      this.resizeListeners.delete(listener);\n    };\n  }\n\n  dispose(): void {\n    this.detachStdout?.();\n    this.detachStderr?.();\n    this.resizeListeners.clear();\n    this.stdin.close();\n    this.stdout.close();\n    this.stderr.close();\n  }\n}\n\nexport {\n  encodeRenderStyleControlMessage,\n  encodeResizeControlMessage,\n};\n"],"mappings":";;;;AAsBA,IAAa,oBAAb,MAA+B;CAC7B,QAAiB,IAAI,UAAU;CAC/B,SAAkB,IAAI,UAAU;CAChC,SAAkB,IAAI,UAAU;CAChC;CAEA;CACA;CACA,kCAAmC,IAAI,IAK5B;CACX;CAOA,YAAY,SAAmC;EAC7C,KAAK,cAAc;GACjB,aAAa;GACb,kBAAkB;GAClB,sBAAsB;GACtB,cAAc,QAAQ;GACtB,gBAAgB,OAAO,KAAK,IAAI,GAAG,QAAQ,OAAO,CAAC;GACnD,aAAa,OAAO,KAAK,IAAI,GAAG,QAAQ,IAAI,CAAC;GAC7C,GAAG,QAAQ;GACX,GAAI,QAAQ,cACR,EACE,qBAAqB,uCACnB,QAAQ,WACV,EACF,IACA,CAAC;EACP;EACA,KAAK,eAAe;GAClB,SAAS,KAAK,IAAI,GAAG,QAAQ,OAAO;GACpC,MAAM,KAAK,IAAI,GAAG,QAAQ,IAAI;EAChC;CACF;CAEA,WACE,MACM;EACN,KAAK,eAAe;EACpB,KAAK,eAAe;EACpB,MAAM,UAAU,IAAI,qBAAqB;EACzC,KAAK,eAAe,KAAK,OAAO,WAAW,UAAU;GACnD,KAAK,MAAM,UAAU,QAAQ,KAAK,KAAK,GACrC,QAAQ,OAAO,MAAf;IACA,KAAK;KACH,KAAK,eAAe,OAAO,KAAK;KAChC;IACF,KAAK;KACH,KAAU,iBAAiB,OAAO,IAAI;KACtC;IACF,KAAK;KACH,KAAK,qBAAqB,OAAO,KAAK;KACtC;IACF,KAAK;KACH,KAAK,wBAAwB,OAAO,UAAU;KAC9C;IACF,KAAK;KACH,KAAK,cAAc,OAAO,IAAI;KAC9B;GACF;EAEJ,CAAC;EACD,KAAK,eAAe,KAAK,OAAO,WAAW,UAAU;GACnD,KAAK,aAAa,IAAI,YAAY,CAAC,CAAC,OAAO,KAAK,CAAC;EACnD,CAAC;CACH;CAEA,OACE,SACA,MACA,WACA,YACM;EACN,MAAM,oBAAoB,KAAK,IAAI,GAAG,OAAO;EAC7C,MAAM,iBAAiB,KAAK,IAAI,GAAG,IAAI;EACvC,KAAK,YAAY,iBAAiB,OAAO,iBAAiB;EAC1D,KAAK,YAAY,cAAc,OAAO,cAAc;EACpD,KAAK,eAAe;GAClB,SAAS;GACT,MAAM;GACN;GACA;EACF;EACA,KAAK,MAAM,MAAM,2BAA2B,SAAS,MAAM,WAAW,UAAU,CAAC;EACjF,KAAK,MAAM,YAAY,KAAK,iBAC1B,SAAS,mBAAmB,gBAAgB,WAAW,UAAU;CAErE;CAEA,kBACE,OACM;EACN,KAAK,YAAY,sBAAsB,uCAAuC,KAAK;EACnF,KAAK,MAAM,MAAM,gCAAgC,KAAK,CAAC;CACzD;CAEA,UACE,OACM;EACN,KAAK,MAAM,MAAM,KAAK;CACxB;CAEA,gBACE,UAMY;EACZ,KAAK,gBAAgB,IAAI,QAAQ;EACjC,SACE,KAAK,aAAa,SAClB,KAAK,aAAa,MAClB,KAAK,aAAa,WAClB,KAAK,aAAa,UACpB;EACA,aAAa;GACX,KAAK,gBAAgB,OAAO,QAAQ;EACtC;CACF;CAEA,UAAgB;EACd,KAAK,eAAe;EACpB,KAAK,eAAe;EACpB,KAAK,gBAAgB,MAAM;EAC3B,KAAK,MAAM,MAAM;EACjB,KAAK,OAAO,MAAM;EAClB,KAAK,OAAO,MAAM;CACpB;AACF"}

package/dist/src/wasi/SharedInputQueue.d.ts

@@ -0,0 +1,31 @@
+//#region src/wasi/SharedInputQueue.d.ts
+declare const sharedInputQueueDefaultCapacity: number;
+interface SharedInputQueueBuffers {
+  readonly controlBuffer: SharedArrayBuffer;
+  readonly dataBuffer: SharedArrayBuffer;
+}
+type SharedInputReadiness = "readable" | "closed" | "timedOut";
+interface SharedInputQueueState {
+  readonly control: Int32Array;
+  readonly data: Uint8Array;
+}
+declare function createSharedInputQueue(capacity?: number): SharedInputQueueBuffers;
+declare function hydrateSharedInputQueue(buffers: SharedInputQueueBuffers): SharedInputQueueState;
+declare class SharedInputQueueWriter {
+  private readonly queue;
+  constructor(buffers: SharedInputQueueBuffers);
+  write(chunk: Uint8Array | string): void;
+  close(): void;
+}
+declare class SharedInputQueueReader {
+  private readonly queue;
+  constructor(buffers: SharedInputQueueBuffers);
+  read(maxBytes: number): Uint8Array | undefined;
+  readAvailable(maxBytes: number): Uint8Array | undefined;
+  availableBytes(): number;
+  waitForReadable(timeoutMilliseconds?: number): SharedInputReadiness;
+  isClosed(): boolean;
+}
+//#endregion
+export { SharedInputQueueBuffers, SharedInputQueueReader, SharedInputQueueWriter, SharedInputReadiness, createSharedInputQueue, hydrateSharedInputQueue, sharedInputQueueDefaultCapacity };
+//# sourceMappingURL=SharedInputQueue.d.ts.map

package/dist/src/wasi/SharedInputQueue.js

@@ -0,0 +1,102 @@
+//#region src/wasi/SharedInputQueue.ts
+const controlSlots = 3;
+const sharedInputQueueDefaultCapacity = 64 * 1024;
+function createSharedInputQueue(capacity = sharedInputQueueDefaultCapacity) {
+	if (typeof SharedArrayBuffer === "undefined") throw new Error("SharedArrayBuffer is unavailable. Serve the app with COOP/COEP headers so browser WASI stdin can stay live.");
+	if (!Number.isInteger(capacity) || capacity <= 0) throw new Error(`Shared input queue capacity must be a positive integer, received ${capacity}.`);
+	return {
+		controlBuffer: new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * controlSlots),
+		dataBuffer: new SharedArrayBuffer(capacity)
+	};
+}
+function hydrateSharedInputQueue(buffers) {
+	return {
+		control: new Int32Array(buffers.controlBuffer),
+		data: new Uint8Array(buffers.dataBuffer)
+	};
+}
+var SharedInputQueueWriter = class {
+	queue;
+	constructor(buffers) {
+		this.queue = hydrateSharedInputQueue(buffers);
+	}
+	write(chunk) {
+		if (Atomics.load(this.queue.control, 2) !== 0) return;
+		const bytes = normalizeChunk(chunk);
+		if (bytes.length == 0) return;
+		const readIndex = Atomics.load(this.queue.control, 0);
+		const writeIndex = Atomics.load(this.queue.control, 1);
+		const usedCapacity = writeIndex - readIndex;
+		const availableCapacity = this.queue.data.length - usedCapacity;
+		if (bytes.length > availableCapacity) throw new Error(`Shared input queue overflow: cannot enqueue ${bytes.length} byte(s) into ${availableCapacity} byte(s) of free space.`);
+		writeToRingBuffer(this.queue.data, bytes, writeIndex);
+		Atomics.store(this.queue.control, 1, writeIndex + bytes.length);
+		Atomics.notify(this.queue.control, 1);
+	}
+	close() {
+		Atomics.store(this.queue.control, 2, 1);
+		Atomics.notify(this.queue.control, 1);
+	}
+};
+var SharedInputQueueReader = class {
+	queue;
+	constructor(buffers) {
+		this.queue = hydrateSharedInputQueue(buffers);
+	}
+	read(maxBytes) {
+		while (true) {
+			const next = this.readAvailable(maxBytes);
+			if (next) return next;
+			if (this.isClosed()) return;
+			const writeIndex = Atomics.load(this.queue.control, 1);
+			Atomics.wait(this.queue.control, 1, writeIndex);
+		}
+	}
+	readAvailable(maxBytes) {
+		if (!Number.isInteger(maxBytes) || maxBytes <= 0) return new Uint8Array();
+		const readIndex = Atomics.load(this.queue.control, 0);
+		const availableBytes = Atomics.load(this.queue.control, 1) - readIndex;
+		if (availableBytes <= 0) return;
+		const byteCount = Math.min(maxBytes, availableBytes);
+		const chunk = readFromRingBuffer(this.queue.data, readIndex, byteCount);
+		Atomics.store(this.queue.control, 0, readIndex + byteCount);
+		return chunk;
+	}
+	availableBytes() {
+		const readIndex = Atomics.load(this.queue.control, 0);
+		const writeIndex = Atomics.load(this.queue.control, 1);
+		return Math.max(0, writeIndex - readIndex);
+	}
+	waitForReadable(timeoutMilliseconds) {
+		while (true) {
+			if (this.availableBytes() > 0) return "readable";
+			if (this.isClosed()) return "closed";
+			const writeIndex = Atomics.load(this.queue.control, 1);
+			if (Atomics.wait(this.queue.control, 1, writeIndex, timeoutMilliseconds) === "timed-out") return "timedOut";
+		}
+	}
+	isClosed() {
+		return Atomics.load(this.queue.control, 2) !== 0;
+	}
+};
+function normalizeChunk(chunk) {
+	return typeof chunk == "string" ? new TextEncoder().encode(chunk) : new Uint8Array(chunk);
+}
+function writeToRingBuffer(buffer, chunk, startIndex) {
+	const offset = startIndex % buffer.length;
+	const firstSegmentLength = Math.min(chunk.length, buffer.length - offset);
+	buffer.set(chunk.subarray(0, firstSegmentLength), offset);
+	if (firstSegmentLength < chunk.length) buffer.set(chunk.subarray(firstSegmentLength), 0);
+}
+function readFromRingBuffer(buffer, startIndex, byteCount) {
+	const chunk = new Uint8Array(byteCount);
+	const offset = startIndex % buffer.length;
+	const firstSegmentLength = Math.min(byteCount, buffer.length - offset);
+	chunk.set(buffer.subarray(offset, offset + firstSegmentLength), 0);
+	if (firstSegmentLength < byteCount) chunk.set(buffer.subarray(0, byteCount - firstSegmentLength), firstSegmentLength);
+	return chunk;
+}
+//#endregion
+export { SharedInputQueueReader, SharedInputQueueWriter, createSharedInputQueue, hydrateSharedInputQueue, sharedInputQueueDefaultCapacity };
+
+//# sourceMappingURL=SharedInputQueue.js.map

package/dist/src/wasi/SharedInputQueue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SharedInputQueue.js","names":[],"sources":["../../../src/wasi/SharedInputQueue.ts"],"sourcesContent":["const controlSlots = 3;\n\nconst enum ControlSlot {\n  readIndex = 0,\n  writeIndex = 1,\n  closed = 2,\n}\n\nexport const sharedInputQueueDefaultCapacity = 64 * 1024;\n\nexport interface SharedInputQueueBuffers {\n  readonly controlBuffer: SharedArrayBuffer;\n  readonly dataBuffer: SharedArrayBuffer;\n}\n\nexport type SharedInputReadiness = \"readable\" | \"closed\" | \"timedOut\";\n\ninterface SharedInputQueueState {\n  readonly control: Int32Array;\n  readonly data: Uint8Array;\n}\n\nexport function createSharedInputQueue(\n  capacity: number = sharedInputQueueDefaultCapacity\n): SharedInputQueueBuffers {\n  if (typeof SharedArrayBuffer === \"undefined\") {\n    throw new Error(\n      \"SharedArrayBuffer is unavailable. Serve the app with COOP/COEP headers so browser WASI stdin can stay live.\"\n    );\n  }\n\n  if (!Number.isInteger(capacity) || capacity <= 0) {\n    throw new Error(`Shared input queue capacity must be a positive integer, received ${capacity}.`);\n  }\n\n  return {\n    controlBuffer: new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * controlSlots),\n    dataBuffer: new SharedArrayBuffer(capacity),\n  };\n}\n\nexport function hydrateSharedInputQueue(\n  buffers: SharedInputQueueBuffers\n): SharedInputQueueState {\n  return {\n    control: new Int32Array(buffers.controlBuffer),\n    data: new Uint8Array(buffers.dataBuffer),\n  };\n}\n\nexport class SharedInputQueueWriter {\n  private readonly queue: SharedInputQueueState;\n\n  constructor(buffers: SharedInputQueueBuffers) {\n    this.queue = hydrateSharedInputQueue(buffers);\n  }\n\n  write(chunk: Uint8Array | string): void {\n    if (Atomics.load(this.queue.control, ControlSlot.closed) !== 0) {\n      return;\n    }\n\n    const bytes = normalizeChunk(chunk);\n    if (bytes.length == 0) {\n      return;\n    }\n\n    const readIndex = Atomics.load(this.queue.control, ControlSlot.readIndex);\n    const writeIndex = Atomics.load(this.queue.control, ControlSlot.writeIndex);\n    const usedCapacity = writeIndex - readIndex;\n    const availableCapacity = this.queue.data.length - usedCapacity;\n\n    if (bytes.length > availableCapacity) {\n      throw new Error(\n        `Shared input queue overflow: cannot enqueue ${bytes.length} byte(s) into ${availableCapacity} byte(s) of free space.`\n      );\n    }\n\n    writeToRingBuffer(this.queue.data, bytes, writeIndex);\n    Atomics.store(this.queue.control, ControlSlot.writeIndex, writeIndex + bytes.length);\n    Atomics.notify(this.queue.control, ControlSlot.writeIndex);\n  }\n\n  close(): void {\n    Atomics.store(this.queue.control, ControlSlot.closed, 1);\n    Atomics.notify(this.queue.control, ControlSlot.writeIndex);\n  }\n}\n\nexport class SharedInputQueueReader {\n  private readonly queue: SharedInputQueueState;\n\n  constructor(buffers: SharedInputQueueBuffers) {\n    this.queue = hydrateSharedInputQueue(buffers);\n  }\n\n  read(maxBytes: number): Uint8Array | undefined {\n    while (true) {\n      const next = this.readAvailable(maxBytes);\n      if (next) {\n        return next;\n      }\n\n      if (this.isClosed()) {\n        return undefined;\n      }\n\n      const writeIndex = Atomics.load(this.queue.control, ControlSlot.writeIndex);\n      Atomics.wait(this.queue.control, ControlSlot.writeIndex, writeIndex);\n    }\n  }\n\n  readAvailable(maxBytes: number): Uint8Array | undefined {\n    if (!Number.isInteger(maxBytes) || maxBytes <= 0) {\n      return new Uint8Array();\n    }\n\n    const readIndex = Atomics.load(this.queue.control, ControlSlot.readIndex);\n    const writeIndex = Atomics.load(this.queue.control, ControlSlot.writeIndex);\n    const availableBytes = writeIndex - readIndex;\n\n    if (availableBytes <= 0) {\n      return undefined;\n    }\n\n    const byteCount = Math.min(maxBytes, availableBytes);\n    const chunk = readFromRingBuffer(this.queue.data, readIndex, byteCount);\n    Atomics.store(this.queue.control, ControlSlot.readIndex, readIndex + byteCount);\n    return chunk;\n  }\n\n  availableBytes(): number {\n    const readIndex = Atomics.load(this.queue.control, ControlSlot.readIndex);\n    const writeIndex = Atomics.load(this.queue.control, ControlSlot.writeIndex);\n    return Math.max(0, writeIndex - readIndex);\n  }\n\n  waitForReadable(\n    timeoutMilliseconds?: number\n  ): SharedInputReadiness {\n    while (true) {\n      if (this.availableBytes() > 0) {\n        return \"readable\";\n      }\n      if (this.isClosed()) {\n        return \"closed\";\n      }\n\n      const writeIndex = Atomics.load(this.queue.control, ControlSlot.writeIndex);\n      const result = Atomics.wait(\n        this.queue.control,\n        ControlSlot.writeIndex,\n        writeIndex,\n        timeoutMilliseconds\n      );\n      if (result === \"timed-out\") {\n        return \"timedOut\";\n      }\n    }\n  }\n\n  isClosed(): boolean {\n    return Atomics.load(this.queue.control, ControlSlot.closed) !== 0;\n  }\n}\n\nfunction normalizeChunk(\n  chunk: Uint8Array | string\n): Uint8Array {\n  return typeof chunk == \"string\" ? new TextEncoder().encode(chunk) : new Uint8Array(chunk);\n}\n\nfunction writeToRingBuffer(\n  buffer: Uint8Array,\n  chunk: Uint8Array,\n  startIndex: number\n): void {\n  const offset = startIndex % buffer.length;\n  const firstSegmentLength = Math.min(chunk.length, buffer.length - offset);\n  buffer.set(chunk.subarray(0, firstSegmentLength), offset);\n  if (firstSegmentLength < chunk.length) {\n    buffer.set(chunk.subarray(firstSegmentLength), 0);\n  }\n}\n\nfunction readFromRingBuffer(\n  buffer: Uint8Array,\n  startIndex: number,\n  byteCount: number\n): Uint8Array {\n  const chunk = new Uint8Array(byteCount);\n  const offset = startIndex % buffer.length;\n  const firstSegmentLength = Math.min(byteCount, buffer.length - offset);\n  chunk.set(buffer.subarray(offset, offset + firstSegmentLength), 0);\n  if (firstSegmentLength < byteCount) {\n    chunk.set(buffer.subarray(0, byteCount - firstSegmentLength), firstSegmentLength);\n  }\n  return chunk;\n}\n"],"mappings":"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"}

package/dist/src/wasi/StdIOPipe.d.ts

@@ -0,0 +1,15 @@
+//#region src/wasi/StdIOPipe.d.ts
+declare class StdIOPipe implements AsyncIterable<Uint8Array> {
+  private readonly chunks;
+  private readonly waiters;
+  private readonly listeners;
+  private closed;
+  write(chunk: Uint8Array | string): void;
+  close(): void;
+  read(): Promise<Uint8Array | undefined>;
+  subscribe(listener: (chunk: Uint8Array) => void): () => void;
+  [Symbol.asyncIterator](): AsyncIterator<Uint8Array>;
+}
+//#endregion
+export { StdIOPipe };
+//# sourceMappingURL=StdIOPipe.d.ts.map

package/dist/src/wasi/StdIOPipe.js

@@ -0,0 +1,56 @@
+//#region src/wasi/StdIOPipe.ts
+var StdIOPipe = class {
+	chunks = [];
+	waiters = [];
+	listeners = /* @__PURE__ */ new Set();
+	closed = false;
+	write(chunk) {
+		if (this.closed) return;
+		const bytes = typeof chunk === "string" ? new TextEncoder().encode(chunk) : new Uint8Array(chunk);
+		const waiter = this.waiters.shift();
+		if (waiter) {
+			waiter({
+				done: false,
+				value: bytes
+			});
+			return;
+		}
+		this.chunks.push(bytes);
+		for (const listener of this.listeners) listener(bytes);
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		while (this.waiters.length > 0) this.waiters.shift()?.({
+			done: true,
+			value: void 0
+		});
+	}
+	async read() {
+		const next = this.chunks.shift();
+		if (next) return next;
+		if (this.closed) return;
+		return await new Promise((resolve) => {
+			this.waiters.push((result) => {
+				resolve(result.done ? void 0 : result.value);
+			});
+		});
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	async *[Symbol.asyncIterator]() {
+		while (true) {
+			const next = await this.read();
+			if (!next) return;
+			yield next;
+		}
+	}
+};
+//#endregion
+export { StdIOPipe };
+
+//# sourceMappingURL=StdIOPipe.js.map

package/dist/src/wasi/StdIOPipe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StdIOPipe.js","names":[],"sources":["../../../src/wasi/StdIOPipe.ts"],"sourcesContent":["export class StdIOPipe implements AsyncIterable<Uint8Array> {\n  private readonly chunks: Uint8Array[] = [];\n  private readonly waiters: Array<(value: IteratorResult<Uint8Array>) => void> = [];\n  private readonly listeners = new Set<(chunk: Uint8Array) => void>();\n  private closed = false;\n\n  write(chunk: Uint8Array | string): void {\n    if (this.closed) {\n      return;\n    }\n\n    const bytes = typeof chunk === \"string\" ? new TextEncoder().encode(chunk) : new Uint8Array(chunk);\n    const waiter = this.waiters.shift();\n    if (waiter) {\n      waiter({ done: false, value: bytes });\n      return;\n    }\n\n    this.chunks.push(bytes);\n    for (const listener of this.listeners) {\n      listener(bytes);\n    }\n  }\n\n  close(): void {\n    if (this.closed) {\n      return;\n    }\n\n    this.closed = true;\n    while (this.waiters.length > 0) {\n      const waiter = this.waiters.shift();\n      waiter?.({ done: true, value: undefined as never });\n    }\n  }\n\n  async read(): Promise<Uint8Array | undefined> {\n    const next = this.chunks.shift();\n    if (next) {\n      return next;\n    }\n\n    if (this.closed) {\n      return undefined;\n    }\n\n    return await new Promise<Uint8Array | undefined>((resolve) => {\n      this.waiters.push((result) => {\n        resolve(result.done ? undefined : result.value);\n      });\n    });\n  }\n\n  subscribe(\n    listener: (chunk: Uint8Array) => void\n  ): () => void {\n    this.listeners.add(listener);\n    return () => {\n      this.listeners.delete(listener);\n    };\n  }\n\n  async *[Symbol.asyncIterator](): AsyncIterator<Uint8Array> {\n    while (true) {\n      const next = await this.read();\n      if (!next) {\n        return;\n      }\n      yield next;\n    }\n  }\n}\n"],"mappings":";AAAA,IAAa,YAAb,MAA4D;CAC1D,SAAwC,CAAC;CACzC,UAA+E,CAAC;CAChF,4BAA6B,IAAI,IAAiC;CAClE,SAAiB;CAEjB,MAAM,OAAkC;EACtC,IAAI,KAAK,QACP;EAGF,MAAM,QAAQ,OAAO,UAAU,WAAW,IAAI,YAAY,CAAC,CAAC,OAAO,KAAK,IAAI,IAAI,WAAW,KAAK;EAChG,MAAM,SAAS,KAAK,QAAQ,MAAM;EAClC,IAAI,QAAQ;GACV,OAAO;IAAE,MAAM;IAAO,OAAO;GAAM,CAAC;GACpC;EACF;EAEA,KAAK,OAAO,KAAK,KAAK;EACtB,KAAK,MAAM,YAAY,KAAK,WAC1B,SAAS,KAAK;CAElB;CAEA,QAAc;EACZ,IAAI,KAAK,QACP;EAGF,KAAK,SAAS;EACd,OAAO,KAAK,QAAQ,SAAS,GAE3B,KADoB,QAAQ,MACvB,CAAC,GAAG;GAAE,MAAM;GAAM,OAAO,KAAA;EAAmB,CAAC;CAEtD;CAEA,MAAM,OAAwC;EAC5C,MAAM,OAAO,KAAK,OAAO,MAAM;EAC/B,IAAI,MACF,OAAO;EAGT,IAAI,KAAK,QACP;EAGF,OAAO,MAAM,IAAI,SAAiC,YAAY;GAC5D,KAAK,QAAQ,MAAM,WAAW;IAC5B,QAAQ,OAAO,OAAO,KAAA,IAAY,OAAO,KAAK;GAChD,CAAC;EACH,CAAC;CACH;CAEA,UACE,UACY;EACZ,KAAK,UAAU,IAAI,QAAQ;EAC3B,aAAa;GACX,KAAK,UAAU,OAAO,QAAQ;EAChC;CACF;CAEA,QAAQ,OAAO,iBAA4C;EACzD,OAAO,MAAM;GACX,MAAM,OAAO,MAAM,KAAK,KAAK;GAC7B,IAAI,CAAC,MACH;GAEF,MAAM;EACR;CACF;AACF"}

package/dist/src/wasi/WasiPollScheduler.js

@@ -0,0 +1,114 @@
+import { wasi } from "@bjorn3/browser_wasi_shim";
+//#region src/wasi/WasiPollScheduler.ts
+const subscriptionByteLength = 48;
+const eventByteLength = 32;
+const maximumAtomicsWaitMilliseconds = 2147483647;
+var WasiPollScheduler = class {
+	memory;
+	stdin;
+	fallbackPoll;
+	nowMilliseconds;
+	waitBuffer = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+	constructor(options) {
+		this.memory = options.memory;
+		this.stdin = options.stdin;
+		this.fallbackPoll = options.fallbackPoll;
+		this.nowMilliseconds = options.nowMilliseconds ?? (() => performance.now());
+	}
+	pollOneOff(inPtr, outPtr, nsubscriptions, neventsPtr) {
+		const memory = this.memory();
+		if (!memory || nsubscriptions <= 0) return this.fallbackPoll(inPtr, outPtr, nsubscriptions, neventsPtr);
+		const view = new DataView(memory.buffer);
+		const subscriptions = readSubscriptions(view, inPtr, nsubscriptions, this.nowMilliseconds());
+		if (subscriptions === void 0) return this.fallbackPoll(inPtr, outPtr, nsubscriptions, neventsPtr);
+		while (true) {
+			const ready = readySubscriptions(subscriptions, this.stdin, this.nowMilliseconds());
+			if (ready.length > 0) {
+				writeEvents(view, outPtr, ready, this.stdin);
+				if (neventsPtr !== void 0) view.setUint32(neventsPtr, ready.length, true);
+				return wasi.ERRNO_SUCCESS;
+			}
+			const timeoutMilliseconds = shortestClockTimeoutMilliseconds(subscriptions, this.nowMilliseconds());
+			if (hasFdReadSubscription(subscriptions)) this.stdin.waitForReadable(timeoutMilliseconds);
+			else if (timeoutMilliseconds !== void 0) Atomics.wait(this.waitBuffer, 0, 0, Math.min(timeoutMilliseconds, maximumAtomicsWaitMilliseconds));
+			else return this.fallbackPoll(inPtr, outPtr, nsubscriptions, neventsPtr);
+		}
+	}
+};
+function readSubscriptions(view, inPtr, nsubscriptions, nowMilliseconds) {
+	const subscriptions = [];
+	for (let index = 0; index < nsubscriptions; index += 1) {
+		const subscription = wasi.Subscription.read_bytes(view, inPtr + index * subscriptionByteLength);
+		switch (subscription.eventtype) {
+			case wasi.EVENTTYPE_CLOCK:
+				if (!isSupportedClockId(subscription.clockid)) return;
+				subscriptions.push({
+					type: "clock",
+					userdata: subscription.userdata,
+					clockid: subscription.clockid,
+					deadlineMilliseconds: clockDeadlineMilliseconds(subscription, nowMilliseconds)
+				});
+				break;
+			case wasi.EVENTTYPE_FD_READ:
+				if (subscription.clockid !== wasi.FD_STDIN) return;
+				subscriptions.push({
+					type: "fdRead",
+					userdata: subscription.userdata,
+					fd: subscription.clockid
+				});
+				break;
+			default: return;
+		}
+	}
+	return subscriptions;
+}
+function isSupportedClockId(clockid) {
+	return clockid === wasi.CLOCKID_MONOTONIC || clockid === wasi.CLOCKID_REALTIME;
+}
+function shortestClockTimeoutMilliseconds(subscriptions, nowMilliseconds) {
+	let timeoutMilliseconds;
+	for (const subscription of subscriptions) {
+		if (subscription.type !== "clock") continue;
+		const remaining = clockRemainingMilliseconds(subscription, nowMilliseconds);
+		timeoutMilliseconds = timeoutMilliseconds === void 0 ? remaining : Math.min(timeoutMilliseconds, remaining);
+	}
+	return timeoutMilliseconds;
+}
+function readySubscriptions(subscriptions, stdin, nowMilliseconds) {
+	return subscriptions.filter((subscription) => {
+		switch (subscription.type) {
+			case "clock": return clockRemainingMilliseconds(subscription, nowMilliseconds) <= 0;
+			case "fdRead": return stdin.availableBytes() > 0 || stdin.isClosed();
+		}
+	});
+}
+function hasFdReadSubscription(subscriptions) {
+	return subscriptions.some((subscription) => subscription.type === "fdRead");
+}
+function clockRemainingMilliseconds(subscription, nowMilliseconds) {
+	return Math.max(0, subscription.deadlineMilliseconds - nowMillisecondsForClock(subscription.clockid, nowMilliseconds));
+}
+function clockDeadlineMilliseconds(subscription, nowMilliseconds) {
+	if ((subscription.flags & wasi.SUBCLOCKFLAGS_SUBSCRIPTION_CLOCK_ABSTIME) !== 0) return Number(subscription.timeout) / 1e6;
+	return nowMillisecondsForClock(subscription.clockid, nowMilliseconds) + Number(subscription.timeout) / 1e6;
+}
+function nowMillisecondsForClock(clockid, nowMilliseconds) {
+	if (clockid === wasi.CLOCKID_REALTIME) return Date.now();
+	return nowMilliseconds;
+}
+function writeEvents(view, outPtr, subscriptions, stdin) {
+	subscriptions.forEach((subscription, index) => {
+		const eventtype = subscription.type === "clock" ? wasi.EVENTTYPE_CLOCK : wasi.EVENTTYPE_FD_READ;
+		const offset = outPtr + index * eventByteLength;
+		new wasi.Event(subscription.userdata, wasi.ERRNO_SUCCESS, eventtype).write_bytes(view, offset);
+		if (subscription.type === "fdRead") {
+			const availableBytes = Math.max(0, stdin.availableBytes());
+			view.setBigUint64(offset + 16, BigInt(availableBytes), true);
+			if (availableBytes === 0 && stdin.isClosed()) view.setUint16(offset + 24, wasi.EVENTRWFLAGS_FD_READWRITE_HANGUP, true);
+		}
+	});
+}
+//#endregion
+export { WasiPollScheduler };
+
+//# sourceMappingURL=WasiPollScheduler.js.map

package/dist/src/wasi/WasiPollScheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WasiPollScheduler.js","names":[],"sources":["../../../src/wasi/WasiPollScheduler.ts"],"sourcesContent":["import { wasi } from \"@bjorn3/browser_wasi_shim\";\n\nimport type { SharedInputReadiness } from \"./SharedInputQueue.ts\";\n\nconst subscriptionByteLength = 48;\nconst eventByteLength = 32;\nconst maximumAtomicsWaitMilliseconds = 2_147_483_647;\n\ninterface ClockSubscription {\n  readonly type: \"clock\";\n  readonly userdata: bigint;\n  readonly clockid: number;\n  readonly deadlineMilliseconds: number;\n}\n\ninterface FdReadSubscription {\n  readonly type: \"fdRead\";\n  readonly userdata: bigint;\n  readonly fd: number;\n}\n\ntype SupportedSubscription = ClockSubscription | FdReadSubscription;\n\nexport interface WasiPollReadableSource {\n  availableBytes(): number;\n  isClosed(): boolean;\n  waitForReadable(timeoutMilliseconds?: number): SharedInputReadiness;\n}\n\nexport interface WasiPollSchedulerOptions {\n  memory(): WebAssembly.Memory | undefined;\n  stdin: WasiPollReadableSource;\n  fallbackPoll(\n    inPtr: number,\n    outPtr: number,\n    nsubscriptions: number,\n    neventsPtr?: number\n  ): number;\n  nowMilliseconds?(): number;\n}\n\nexport class WasiPollScheduler {\n  private readonly memory: WasiPollSchedulerOptions[\"memory\"];\n  private readonly stdin: WasiPollReadableSource;\n  private readonly fallbackPoll: WasiPollSchedulerOptions[\"fallbackPoll\"];\n  private readonly nowMilliseconds: () => number;\n  private readonly waitBuffer = new Int32Array(\n    new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)\n  );\n\n  constructor(options: WasiPollSchedulerOptions) {\n    this.memory = options.memory;\n    this.stdin = options.stdin;\n    this.fallbackPoll = options.fallbackPoll;\n    this.nowMilliseconds = options.nowMilliseconds ?? (() => performance.now());\n  }\n\n  pollOneOff(\n    inPtr: number,\n    outPtr: number,\n    nsubscriptions: number,\n    neventsPtr?: number\n  ): number {\n    const memory = this.memory();\n    if (!memory || nsubscriptions <= 0) {\n      return this.fallbackPoll(inPtr, outPtr, nsubscriptions, neventsPtr);\n    }\n\n    const view = new DataView(memory.buffer);\n    const subscriptions = readSubscriptions(\n      view,\n      inPtr,\n      nsubscriptions,\n      this.nowMilliseconds()\n    );\n    if (subscriptions === undefined) {\n      return this.fallbackPoll(inPtr, outPtr, nsubscriptions, neventsPtr);\n    }\n\n    while (true) {\n      const ready = readySubscriptions(subscriptions, this.stdin, this.nowMilliseconds());\n      if (ready.length > 0) {\n        writeEvents(view, outPtr, ready, this.stdin);\n        if (neventsPtr !== undefined) {\n          view.setUint32(neventsPtr, ready.length, true);\n        }\n        return wasi.ERRNO_SUCCESS;\n      }\n\n      const timeoutMilliseconds = shortestClockTimeoutMilliseconds(\n        subscriptions,\n        this.nowMilliseconds()\n      );\n      if (hasFdReadSubscription(subscriptions)) {\n        this.stdin.waitForReadable(timeoutMilliseconds);\n      } else if (timeoutMilliseconds !== undefined) {\n        Atomics.wait(\n          this.waitBuffer,\n          0,\n          0,\n          Math.min(timeoutMilliseconds, maximumAtomicsWaitMilliseconds)\n        );\n      } else {\n        return this.fallbackPoll(inPtr, outPtr, nsubscriptions, neventsPtr);\n      }\n    }\n  }\n}\n\nfunction readSubscriptions(\n  view: DataView,\n  inPtr: number,\n  nsubscriptions: number,\n  nowMilliseconds: number\n): SupportedSubscription[] | undefined {\n  const subscriptions: SupportedSubscription[] = [];\n  for (let index = 0; index < nsubscriptions; index += 1) {\n    const subscription = wasi.Subscription.read_bytes(\n      view,\n      inPtr + index * subscriptionByteLength\n    );\n    switch (subscription.eventtype) {\n    case wasi.EVENTTYPE_CLOCK:\n      if (!isSupportedClockId(subscription.clockid)) {\n        return undefined;\n      }\n      subscriptions.push({\n        type: \"clock\",\n        userdata: subscription.userdata,\n        clockid: subscription.clockid,\n        deadlineMilliseconds: clockDeadlineMilliseconds(subscription, nowMilliseconds),\n      });\n      break;\n    case wasi.EVENTTYPE_FD_READ:\n      if (subscription.clockid !== wasi.FD_STDIN) {\n        return undefined;\n      }\n      subscriptions.push({\n        type: \"fdRead\",\n        userdata: subscription.userdata,\n        fd: subscription.clockid,\n      });\n      break;\n    default:\n      return undefined;\n    }\n  }\n  return subscriptions;\n}\n\nfunction isSupportedClockId(\n  clockid: number\n): boolean {\n  return clockid === wasi.CLOCKID_MONOTONIC || clockid === wasi.CLOCKID_REALTIME;\n}\n\nfunction shortestClockTimeoutMilliseconds(\n  subscriptions: readonly SupportedSubscription[],\n  nowMilliseconds: number\n): number | undefined {\n  let timeoutMilliseconds: number | undefined;\n  for (const subscription of subscriptions) {\n    if (subscription.type !== \"clock\") {\n      continue;\n    }\n    const remaining = clockRemainingMilliseconds(subscription, nowMilliseconds);\n    timeoutMilliseconds = timeoutMilliseconds === undefined\n      ? remaining\n      : Math.min(timeoutMilliseconds, remaining);\n  }\n  return timeoutMilliseconds;\n}\n\nfunction readySubscriptions(\n  subscriptions: readonly SupportedSubscription[],\n  stdin: WasiPollReadableSource,\n  nowMilliseconds: number\n): SupportedSubscription[] {\n  return subscriptions.filter((subscription) => {\n    switch (subscription.type) {\n    case \"clock\":\n      return clockRemainingMilliseconds(subscription, nowMilliseconds) <= 0;\n    case \"fdRead\":\n      return stdin.availableBytes() > 0 || stdin.isClosed();\n    }\n  });\n}\n\nfunction hasFdReadSubscription(\n  subscriptions: readonly SupportedSubscription[]\n): boolean {\n  return subscriptions.some((subscription) => subscription.type === \"fdRead\");\n}\n\nfunction clockRemainingMilliseconds(\n  subscription: ClockSubscription,\n  nowMilliseconds: number\n): number {\n  return Math.max(0, subscription.deadlineMilliseconds - nowMillisecondsForClock(\n    subscription.clockid,\n    nowMilliseconds\n  ));\n}\n\nfunction clockDeadlineMilliseconds(\n  subscription: wasi.Subscription,\n  nowMilliseconds: number\n): number {\n  if ((subscription.flags & wasi.SUBCLOCKFLAGS_SUBSCRIPTION_CLOCK_ABSTIME) !== 0) {\n    return Number(subscription.timeout) / 1_000_000;\n  }\n  return nowMillisecondsForClock(subscription.clockid, nowMilliseconds)\n    + Number(subscription.timeout) / 1_000_000;\n}\n\nfunction nowMillisecondsForClock(\n  clockid: number,\n  nowMilliseconds: number\n): number {\n  if (clockid === wasi.CLOCKID_REALTIME) {\n    return Date.now();\n  }\n  return nowMilliseconds;\n}\n\nfunction writeEvents(\n  view: DataView,\n  outPtr: number,\n  subscriptions: readonly SupportedSubscription[],\n  stdin: WasiPollReadableSource\n): void {\n  subscriptions.forEach((subscription, index) => {\n    const eventtype = subscription.type === \"clock\"\n      ? wasi.EVENTTYPE_CLOCK\n      : wasi.EVENTTYPE_FD_READ;\n    const offset = outPtr + index * eventByteLength;\n    new wasi.Event(\n      subscription.userdata,\n      wasi.ERRNO_SUCCESS,\n      eventtype\n    ).write_bytes(view, offset);\n    if (subscription.type === \"fdRead\") {\n      const availableBytes = Math.max(0, stdin.availableBytes());\n      view.setBigUint64(offset + 16, BigInt(availableBytes), true);\n      if (availableBytes === 0 && stdin.isClosed()) {\n        view.setUint16(offset + 24, wasi.EVENTRWFLAGS_FD_READWRITE_HANGUP, true);\n      }\n    }\n  });\n}\n\nexport function writeClockSubscriptionForTesting(\n  view: DataView,\n  offset: number,\n  subscription: {\n    userdata: bigint;\n    timeoutNanoseconds: bigint;\n    clockid?: number;\n    flags?: number;\n  }\n): void {\n  clearRecord(view, offset, subscriptionByteLength);\n  view.setBigUint64(offset, subscription.userdata, true);\n  view.setUint8(offset + 8, wasi.EVENTTYPE_CLOCK);\n  view.setUint32(offset + 16, subscription.clockid ?? wasi.CLOCKID_MONOTONIC, true);\n  view.setBigUint64(offset + 24, subscription.timeoutNanoseconds, true);\n  view.setUint16(offset + 36, subscription.flags ?? 0, true);\n}\n\nexport function writeFdReadSubscriptionForTesting(\n  view: DataView,\n  offset: number,\n  subscription: {\n    userdata: bigint;\n    fd: number;\n  }\n): void {\n  clearRecord(view, offset, subscriptionByteLength);\n  view.setBigUint64(offset, subscription.userdata, true);\n  view.setUint8(offset + 8, wasi.EVENTTYPE_FD_READ);\n  view.setUint32(offset + 16, subscription.fd, true);\n}\n\nexport function readPollEventsForTesting(\n  view: DataView,\n  offset: number,\n  count: number\n): Array<{ userdata: bigint; errno: number; eventtype: number }> {\n  return Array.from({ length: count }, (_, index) => {\n    const eventOffset = offset + index * eventByteLength;\n    return {\n      userdata: view.getBigUint64(eventOffset, true),\n      errno: view.getUint16(eventOffset + 8, true),\n      eventtype: view.getUint8(eventOffset + 10),\n    };\n  });\n}\n\nfunction clearRecord(\n  view: DataView,\n  offset: number,\n  byteLength: number\n): void {\n  new Uint8Array(view.buffer, offset, byteLength).fill(0);\n}\n"],"mappings":";;AAIA,MAAM,yBAAyB;AAC/B,MAAM,kBAAkB;AACxB,MAAM,iCAAiC;AAmCvC,IAAa,oBAAb,MAA+B;CAC7B;CACA;CACA;CACA;CACA,aAA8B,IAAI,WAChC,IAAI,kBAAkB,WAAW,iBAAiB,CACpD;CAEA,YAAY,SAAmC;EAC7C,KAAK,SAAS,QAAQ;EACtB,KAAK,QAAQ,QAAQ;EACrB,KAAK,eAAe,QAAQ;EAC5B,KAAK,kBAAkB,QAAQ,0BAA0B,YAAY,IAAI;CAC3E;CAEA,WACE,OACA,QACA,gBACA,YACQ;EACR,MAAM,SAAS,KAAK,OAAO;EAC3B,IAAI,CAAC,UAAU,kBAAkB,GAC/B,OAAO,KAAK,aAAa,OAAO,QAAQ,gBAAgB,UAAU;EAGpE,MAAM,OAAO,IAAI,SAAS,OAAO,MAAM;EACvC,MAAM,gBAAgB,kBACpB,MACA,OACA,gBACA,KAAK,gBAAgB,CACvB;EACA,IAAI,kBAAkB,KAAA,GACpB,OAAO,KAAK,aAAa,OAAO,QAAQ,gBAAgB,UAAU;EAGpE,OAAO,MAAM;GACX,MAAM,QAAQ,mBAAmB,eAAe,KAAK,OAAO,KAAK,gBAAgB,CAAC;GAClF,IAAI,MAAM,SAAS,GAAG;IACpB,YAAY,MAAM,QAAQ,OAAO,KAAK,KAAK;IAC3C,IAAI,eAAe,KAAA,GACjB,KAAK,UAAU,YAAY,MAAM,QAAQ,IAAI;IAE/C,OAAO,KAAK;GACd;GAEA,MAAM,sBAAsB,iCAC1B,eACA,KAAK,gBAAgB,CACvB;GACA,IAAI,sBAAsB,aAAa,GACrC,KAAK,MAAM,gBAAgB,mBAAmB;QACzC,IAAI,wBAAwB,KAAA,GACjC,QAAQ,KACN,KAAK,YACL,GACA,GACA,KAAK,IAAI,qBAAqB,8BAA8B,CAC9D;QAEA,OAAO,KAAK,aAAa,OAAO,QAAQ,gBAAgB,UAAU;EAEtE;CACF;AACF;AAEA,SAAS,kBACP,MACA,OACA,gBACA,iBACqC;CACrC,MAAM,gBAAyC,CAAC;CAChD,KAAK,IAAI,QAAQ,GAAG,QAAQ,gBAAgB,SAAS,GAAG;EACtD,MAAM,eAAe,KAAK,aAAa,WACrC,MACA,QAAQ,QAAQ,sBAClB;EACA,QAAQ,aAAa,WAArB;GACA,KAAK,KAAK;IACR,IAAI,CAAC,mBAAmB,aAAa,OAAO,GAC1C;IAEF,cAAc,KAAK;KACjB,MAAM;KACN,UAAU,aAAa;KACvB,SAAS,aAAa;KACtB,sBAAsB,0BAA0B,cAAc,eAAe;IAC/E,CAAC;IACD;GACF,KAAK,KAAK;IACR,IAAI,aAAa,YAAY,KAAK,UAChC;IAEF,cAAc,KAAK;KACjB,MAAM;KACN,UAAU,aAAa;KACvB,IAAI,aAAa;IACnB,CAAC;IACD;GACF,SACE;EACF;CACF;CACA,OAAO;AACT;AAEA,SAAS,mBACP,SACS;CACT,OAAO,YAAY,KAAK,qBAAqB,YAAY,KAAK;AAChE;AAEA,SAAS,iCACP,eACA,iBACoB;CACpB,IAAI;CACJ,KAAK,MAAM,gBAAgB,eAAe;EACxC,IAAI,aAAa,SAAS,SACxB;EAEF,MAAM,YAAY,2BAA2B,cAAc,eAAe;EAC1E,sBAAsB,wBAAwB,KAAA,IAC1C,YACA,KAAK,IAAI,qBAAqB,SAAS;CAC7C;CACA,OAAO;AACT;AAEA,SAAS,mBACP,eACA,OACA,iBACyB;CACzB,OAAO,cAAc,QAAQ,iBAAiB;EAC5C,QAAQ,aAAa,MAArB;GACA,KAAK,SACH,OAAO,2BAA2B,cAAc,eAAe,KAAK;GACtE,KAAK,UACH,OAAO,MAAM,eAAe,IAAI,KAAK,MAAM,SAAS;EACtD;CACF,CAAC;AACH;AAEA,SAAS,sBACP,eACS;CACT,OAAO,cAAc,MAAM,iBAAiB,aAAa,SAAS,QAAQ;AAC5E;AAEA,SAAS,2BACP,cACA,iBACQ;CACR,OAAO,KAAK,IAAI,GAAG,aAAa,uBAAuB,wBACrD,aAAa,SACb,eACF,CAAC;AACH;AAEA,SAAS,0BACP,cACA,iBACQ;CACR,KAAK,aAAa,QAAQ,KAAK,8CAA8C,GAC3E,OAAO,OAAO,aAAa,OAAO,IAAI;CAExC,OAAO,wBAAwB,aAAa,SAAS,eAAe,IAChE,OAAO,aAAa,OAAO,IAAI;AACrC;AAEA,SAAS,wBACP,SACA,iBACQ;CACR,IAAI,YAAY,KAAK,kBACnB,OAAO,KAAK,IAAI;CAElB,OAAO;AACT;AAEA,SAAS,YACP,MACA,QACA,eACA,OACM;CACN,cAAc,SAAS,cAAc,UAAU;EAC7C,MAAM,YAAY,aAAa,SAAS,UACpC,KAAK,kBACL,KAAK;EACT,MAAM,SAAS,SAAS,QAAQ;EAChC,IAAI,KAAK,MACP,aAAa,UACb,KAAK,eACL,SACF,CAAC,CAAC,YAAY,MAAM,MAAM;EAC1B,IAAI,aAAa,SAAS,UAAU;GAClC,MAAM,iBAAiB,KAAK,IAAI,GAAG,MAAM,eAAe,CAAC;GACzD,KAAK,aAAa,SAAS,IAAI,OAAO,cAAc,GAAG,IAAI;GAC3D,IAAI,mBAAmB,KAAK,MAAM,SAAS,GACzC,KAAK,UAAU,SAAS,IAAI,KAAK,kCAAkC,IAAI;EAE3E;CACF,CAAC;AACH"}

package/dist/src/wasi/WasmSceneRuntime.d.ts

@@ -0,0 +1,23 @@
+import { WebHostSceneRuntime, WebHostSceneRuntimeOptions } from "../WebHostSceneRuntime.js";
+
+//#region src/wasi/WasmSceneRuntime.d.ts
+interface WasmSceneResizeEvent {
+  sceneId: string;
+  columns: number;
+  rows: number;
+  cellWidth?: number;
+  cellHeight?: number;
+}
+interface WasmSceneRuntimeHandle {
+  readonly descriptor: WebHostSceneRuntime["descriptor"];
+  sendInput(chunk: Uint8Array): void;
+}
+interface WasmSceneRuntimeFactoryOptions {
+  onSceneResize?(event: WasmSceneResizeEvent): void;
+  onRuntimeCreated?(runtime: WasmSceneRuntimeHandle): void;
+  workerModuleURL?: string | URL;
+}
+declare function createWasmSceneRuntimeFactory(wasmURL: URL, factoryOptions?: WasmSceneRuntimeFactoryOptions): (options: WebHostSceneRuntimeOptions) => WebHostSceneRuntime;
+//#endregion
+export { WasmSceneResizeEvent, WasmSceneRuntimeFactoryOptions, WasmSceneRuntimeHandle, createWasmSceneRuntimeFactory };
+//# sourceMappingURL=WasmSceneRuntime.d.ts.map