@swifttui/web 0.0.13 → 0.0.15

package/src/wasi/WasiPollScheduler.test.ts

@@ -1,176 +0,0 @@
-import { expect, test } from "bun:test";
-import { Worker } from "node:worker_threads";
-import { wasi } from "@bjorn3/browser_wasi_shim";
-
-import {
-  SharedInputQueueReader,
-  type SharedInputQueueBuffers,
-  createSharedInputQueue,
-} from "./SharedInputQueue.ts";
-import {
-  WasiPollScheduler,
-  type WasiPollReadableSource,
-  readPollEventsForTesting,
-  writeClockSubscriptionForTesting,
-  writeFdReadSubscriptionForTesting,
-} from "./WasiPollScheduler.ts";
-
-test("scheduler completes a relative monotonic clock subscription", () => {
-  const memory = new WebAssembly.Memory({ initial: 1 });
-  const view = new DataView(memory.buffer);
-  writeClockSubscriptionForTesting(view, 0, {
-    userdata: 1n,
-    timeoutNanoseconds: 1_000_000n,
-  });
-
-  const scheduler = new WasiPollScheduler({
-    memory: () => memory,
-    stdin: closedSource(),
-    fallbackPoll: () => wasi.ERRNO_INVAL,
-  });
-
-  expect(scheduler.pollOneOff(0, 128, 1, 256)).toBe(wasi.ERRNO_SUCCESS);
-  expect(readPollEventsForTesting(view, 128, 1)).toEqual([
-    { userdata: 1n, errno: wasi.ERRNO_SUCCESS, eventtype: wasi.EVENTTYPE_CLOCK },
-  ]);
-  expect(view.getUint32(256, true)).toBe(1);
-});
-
-test("scheduler wakes stdin-only poll on stdin readability", async () => {
-  const memory = new WebAssembly.Memory({ initial: 1 });
-  const view = new DataView(memory.buffer);
-  const queue = createSharedInputQueue(8);
-  const reader = new SharedInputQueueReader(queue);
-  const worker = writeInputFromWorker(queue, "x", 10);
-
-  writeFdReadSubscriptionForTesting(view, 0, { userdata: 10n, fd: 0 });
-
-  const scheduler = new WasiPollScheduler({
-    memory: () => memory,
-    stdin: reader,
-    fallbackPoll: () => wasi.ERRNO_INVAL,
-  });
-
-  try {
-    expect(scheduler.pollOneOff(0, 128, 1, 256)).toBe(wasi.ERRNO_SUCCESS);
-    expect(readPollEventsForTesting(view, 128, 1)).toEqual([
-      { userdata: 10n, errno: wasi.ERRNO_SUCCESS, eventtype: wasi.EVENTTYPE_FD_READ },
-    ]);
-    expect(view.getBigUint64(128 + 16, true)).toBe(1n);
-    expect(view.getUint16(128 + 24, true)).toBe(0);
-    expect(view.getUint32(256, true)).toBe(1);
-  } finally {
-    await worker.terminate();
-  }
-});
-
-test("scheduler wakes mixed stdin and clock poll on stdin readability", async () => {
-  const memory = new WebAssembly.Memory({ initial: 1 });
-  const view = new DataView(memory.buffer);
-  const queue = createSharedInputQueue(8);
-  const reader = new SharedInputQueueReader(queue);
-  const worker = writeInputFromWorker(queue, "x", 10);
-
-  writeFdReadSubscriptionForTesting(view, 0, { userdata: 10n, fd: 0 });
-  writeClockSubscriptionForTesting(view, 48, {
-    userdata: 11n,
-    timeoutNanoseconds: 500_000_000n,
-  });
-
-  const scheduler = new WasiPollScheduler({
-    memory: () => memory,
-    stdin: reader,
-    fallbackPoll: () => wasi.ERRNO_INVAL,
-  });
-
-  try {
-    expect(scheduler.pollOneOff(0, 128, 2, 256)).toBe(wasi.ERRNO_SUCCESS);
-    expect(readPollEventsForTesting(view, 128, 1)).toEqual([
-      { userdata: 10n, errno: wasi.ERRNO_SUCCESS, eventtype: wasi.EVENTTYPE_FD_READ },
-    ]);
-    expect(view.getUint32(256, true)).toBe(1);
-  } finally {
-    await worker.terminate();
-  }
-});
-
-test("scheduler wakes mixed stdin and clock poll on timeout", () => {
-  const memory = new WebAssembly.Memory({ initial: 1 });
-  const view = new DataView(memory.buffer);
-  const queue = createSharedInputQueue(8);
-  const reader = new SharedInputQueueReader(queue);
-
-  writeFdReadSubscriptionForTesting(view, 0, { userdata: 10n, fd: 0 });
-  writeClockSubscriptionForTesting(view, 48, {
-    userdata: 11n,
-    timeoutNanoseconds: 1_000_000n,
-  });
-
-  const scheduler = new WasiPollScheduler({
-    memory: () => memory,
-    stdin: reader,
-    fallbackPoll: () => wasi.ERRNO_INVAL,
-  });
-
-  expect(scheduler.pollOneOff(0, 128, 2, 256)).toBe(wasi.ERRNO_SUCCESS);
-  expect(readPollEventsForTesting(view, 128, 1)).toEqual([
-    { userdata: 11n, errno: wasi.ERRNO_SUCCESS, eventtype: wasi.EVENTTYPE_CLOCK },
-  ]);
-  expect(view.getUint32(256, true)).toBe(1);
-});
-
-test("scheduler reports closed stdin as readable hangup", () => {
-  const memory = new WebAssembly.Memory({ initial: 1 });
-  const view = new DataView(memory.buffer);
-
-  writeFdReadSubscriptionForTesting(view, 0, { userdata: 10n, fd: 0 });
-
-  const scheduler = new WasiPollScheduler({
-    memory: () => memory,
-    stdin: closedSource(),
-    fallbackPoll: () => wasi.ERRNO_INVAL,
-  });
-
-  expect(scheduler.pollOneOff(0, 128, 1, 256)).toBe(wasi.ERRNO_SUCCESS);
-  expect(readPollEventsForTesting(view, 128, 1)).toEqual([
-    { userdata: 10n, errno: wasi.ERRNO_SUCCESS, eventtype: wasi.EVENTTYPE_FD_READ },
-  ]);
-  expect(view.getBigUint64(128 + 16, true)).toBe(0n);
-  expect(view.getUint16(128 + 24, true)).toBe(wasi.EVENTRWFLAGS_FD_READWRITE_HANGUP);
-  expect(view.getUint32(256, true)).toBe(1);
-});
-
-function closedSource(): WasiPollReadableSource {
-  return {
-    availableBytes: () => 0,
-    isClosed: () => true,
-    waitForReadable: () => "closed",
-  };
-}
-
-function writeInputFromWorker(
-  queue: SharedInputQueueBuffers,
-  text: string,
-  delayMilliseconds: number
-): Worker {
-  return new Worker(`
-    const { workerData } = require("node:worker_threads");
-    const control = new Int32Array(workerData.controlBuffer);
-    const data = new Uint8Array(workerData.dataBuffer);
-    const bytes = new TextEncoder().encode(workerData.text);
-    setTimeout(() => {
-      const writeIndex = Atomics.load(control, 1);
-      data.set(bytes, writeIndex % data.length);
-      Atomics.store(control, 1, writeIndex + bytes.length);
-      Atomics.notify(control, 1);
-    }, workerData.delayMilliseconds);
-  `, {
-    eval: true,
-    workerData: {
-      controlBuffer: queue.controlBuffer,
-      dataBuffer: queue.dataBuffer,
-      delayMilliseconds,
-      text,
-    },
-  });
-}

package/src/wasi/WasiPollScheduler.ts

@@ -1,305 +0,0 @@
-import { wasi } from "@bjorn3/browser_wasi_shim";
-
-import type { SharedInputReadiness } from "./SharedInputQueue.ts";
-
-const subscriptionByteLength = 48;
-const eventByteLength = 32;
-const maximumAtomicsWaitMilliseconds = 2_147_483_647;
-
-interface ClockSubscription {
-  readonly type: "clock";
-  readonly userdata: bigint;
-  readonly clockid: number;
-  readonly deadlineMilliseconds: number;
-}
-
-interface FdReadSubscription {
-  readonly type: "fdRead";
-  readonly userdata: bigint;
-  readonly fd: number;
-}
-
-type SupportedSubscription = ClockSubscription | FdReadSubscription;
-
-export interface WasiPollReadableSource {
-  availableBytes(): number;
-  isClosed(): boolean;
-  waitForReadable(timeoutMilliseconds?: number): SharedInputReadiness;
-}
-
-export interface WasiPollSchedulerOptions {
-  memory(): WebAssembly.Memory | undefined;
-  stdin: WasiPollReadableSource;
-  fallbackPoll(
-    inPtr: number,
-    outPtr: number,
-    nsubscriptions: number,
-    neventsPtr?: number
-  ): number;
-  nowMilliseconds?(): number;
-}
-
-export class WasiPollScheduler {
-  private readonly memory: WasiPollSchedulerOptions["memory"];
-  private readonly stdin: WasiPollReadableSource;
-  private readonly fallbackPoll: WasiPollSchedulerOptions["fallbackPoll"];
-  private readonly nowMilliseconds: () => number;
-  private readonly waitBuffer = new Int32Array(
-    new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)
-  );
-
-  constructor(options: WasiPollSchedulerOptions) {
-    this.memory = options.memory;
-    this.stdin = options.stdin;
-    this.fallbackPoll = options.fallbackPoll;
-    this.nowMilliseconds = options.nowMilliseconds ?? (() => performance.now());
-  }
-
-  pollOneOff(
-    inPtr: number,
-    outPtr: number,
-    nsubscriptions: number,
-    neventsPtr?: number
-  ): number {
-    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 === undefined) {
-      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 !== undefined) {
-          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 !== undefined) {
-        Atomics.wait(
-          this.waitBuffer,
-          0,
-          0,
-          Math.min(timeoutMilliseconds, maximumAtomicsWaitMilliseconds)
-        );
-      } else {
-        return this.fallbackPoll(inPtr, outPtr, nsubscriptions, neventsPtr);
-      }
-    }
-  }
-}
-
-function readSubscriptions(
-  view: DataView,
-  inPtr: number,
-  nsubscriptions: number,
-  nowMilliseconds: number
-): SupportedSubscription[] | undefined {
-  const subscriptions: SupportedSubscription[] = [];
-  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 undefined;
-      }
-      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 undefined;
-      }
-      subscriptions.push({
-        type: "fdRead",
-        userdata: subscription.userdata,
-        fd: subscription.clockid,
-      });
-      break;
-    default:
-      return undefined;
-    }
-  }
-  return subscriptions;
-}
-
-function isSupportedClockId(
-  clockid: number
-): boolean {
-  return clockid === wasi.CLOCKID_MONOTONIC || clockid === wasi.CLOCKID_REALTIME;
-}
-
-function shortestClockTimeoutMilliseconds(
-  subscriptions: readonly SupportedSubscription[],
-  nowMilliseconds: number
-): number | undefined {
-  let timeoutMilliseconds: number | undefined;
-  for (const subscription of subscriptions) {
-    if (subscription.type !== "clock") {
-      continue;
-    }
-    const remaining = clockRemainingMilliseconds(subscription, nowMilliseconds);
-    timeoutMilliseconds = timeoutMilliseconds === undefined
-      ? remaining
-      : Math.min(timeoutMilliseconds, remaining);
-  }
-  return timeoutMilliseconds;
-}
-
-function readySubscriptions(
-  subscriptions: readonly SupportedSubscription[],
-  stdin: WasiPollReadableSource,
-  nowMilliseconds: number
-): SupportedSubscription[] {
-  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: readonly SupportedSubscription[]
-): boolean {
-  return subscriptions.some((subscription) => subscription.type === "fdRead");
-}
-
-function clockRemainingMilliseconds(
-  subscription: ClockSubscription,
-  nowMilliseconds: number
-): number {
-  return Math.max(0, subscription.deadlineMilliseconds - nowMillisecondsForClock(
-    subscription.clockid,
-    nowMilliseconds
-  ));
-}
-
-function clockDeadlineMilliseconds(
-  subscription: wasi.Subscription,
-  nowMilliseconds: number
-): number {
-  if ((subscription.flags & wasi.SUBCLOCKFLAGS_SUBSCRIPTION_CLOCK_ABSTIME) !== 0) {
-    return Number(subscription.timeout) / 1_000_000;
-  }
-  return nowMillisecondsForClock(subscription.clockid, nowMilliseconds)
-    + Number(subscription.timeout) / 1_000_000;
-}
-
-function nowMillisecondsForClock(
-  clockid: number,
-  nowMilliseconds: number
-): number {
-  if (clockid === wasi.CLOCKID_REALTIME) {
-    return Date.now();
-  }
-  return nowMilliseconds;
-}
-
-function writeEvents(
-  view: DataView,
-  outPtr: number,
-  subscriptions: readonly SupportedSubscription[],
-  stdin: WasiPollReadableSource
-): void {
-  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);
-      }
-    }
-  });
-}
-
-export function writeClockSubscriptionForTesting(
-  view: DataView,
-  offset: number,
-  subscription: {
-    userdata: bigint;
-    timeoutNanoseconds: bigint;
-    clockid?: number;
-    flags?: number;
-  }
-): void {
-  clearRecord(view, offset, subscriptionByteLength);
-  view.setBigUint64(offset, subscription.userdata, true);
-  view.setUint8(offset + 8, wasi.EVENTTYPE_CLOCK);
-  view.setUint32(offset + 16, subscription.clockid ?? wasi.CLOCKID_MONOTONIC, true);
-  view.setBigUint64(offset + 24, subscription.timeoutNanoseconds, true);
-  view.setUint16(offset + 36, subscription.flags ?? 0, true);
-}
-
-export function writeFdReadSubscriptionForTesting(
-  view: DataView,
-  offset: number,
-  subscription: {
-    userdata: bigint;
-    fd: number;
-  }
-): void {
-  clearRecord(view, offset, subscriptionByteLength);
-  view.setBigUint64(offset, subscription.userdata, true);
-  view.setUint8(offset + 8, wasi.EVENTTYPE_FD_READ);
-  view.setUint32(offset + 16, subscription.fd, true);
-}
-
-export function readPollEventsForTesting(
-  view: DataView,
-  offset: number,
-  count: number
-): Array<{ userdata: bigint; errno: number; eventtype: number }> {
-  return Array.from({ length: count }, (_, index) => {
-    const eventOffset = offset + index * eventByteLength;
-    return {
-      userdata: view.getBigUint64(eventOffset, true),
-      errno: view.getUint16(eventOffset + 8, true),
-      eventtype: view.getUint8(eventOffset + 10),
-    };
-  });
-}
-
-function clearRecord(
-  view: DataView,
-  offset: number,
-  byteLength: number
-): void {
-  new Uint8Array(view.buffer, offset, byteLength).fill(0);
-}

package/src/wasi/WasmSceneRuntime.ts

@@ -1,205 +0,0 @@
-import {
-  WebHostSceneRuntime,
-  type WebHostSceneRuntimeOptions,
-} from "../WebHostSceneRuntime.ts";
-import {
-  encodeResizeControlMessage,
-  type BrowserWASIBridge,
-} from "./BrowserWASIBridge.ts";
-
-import {
-  SharedInputQueueWriter,
-  createSharedInputQueue,
-  type SharedInputQueueBuffers,
-} from "./SharedInputQueue.ts";
-
-const workerModuleURL = new URL("./wasm-scene-worker.js", import.meta.url);
-
-interface WorkerStartMessage {
-  type: "start";
-  wasmURL: string;
-  environment: Record<string, string>;
-  inputQueue: SharedInputQueueBuffers;
-}
-
-interface WorkerOutputMessage {
-  type: "stdout" | "stderr";
-  chunk: Uint8Array;
-}
-
-interface WorkerExitMessage {
-  type: "exit";
-  code: number;
-}
-
-interface WorkerErrorMessage {
-  type: "error";
-  message: string;
-}
-
-type WorkerMessage = WorkerOutputMessage | WorkerExitMessage | WorkerErrorMessage;
-
-export interface WasmSceneResizeEvent {
-  sceneId: string;
-  columns: number;
-  rows: number;
-  cellWidth?: number;
-  cellHeight?: number;
-}
-
-export interface WasmSceneRuntimeHandle {
-  readonly descriptor: WebHostSceneRuntime["descriptor"];
-  sendInput(chunk: Uint8Array): void;
-}
-
-export interface WasmSceneRuntimeFactoryOptions {
-  onSceneResize?(event: WasmSceneResizeEvent): void;
-  onRuntimeCreated?(runtime: WasmSceneRuntimeHandle): void;
-  workerModuleURL?: string | URL;
-}
-
-export function createWasmSceneRuntimeFactory(
-  wasmURL: URL,
-  factoryOptions: WasmSceneRuntimeFactoryOptions = {}
-): (options: WebHostSceneRuntimeOptions) => WebHostSceneRuntime {
-  return (options) => {
-    const runtime = new WasmSceneRuntime(options, wasmURL, factoryOptions);
-    factoryOptions.onRuntimeCreated?.(runtime);
-    return runtime;
-  };
-}
-
-class WasmSceneRuntime extends WebHostSceneRuntime {
-  private readonly bridge?: BrowserWASIBridge;
-  private readonly wasmURL: URL;
-  private readonly onSceneResize?: (event: WasmSceneResizeEvent) => void;
-  private readonly workerModuleURL: string | URL;
-  private readonly inputQueue?: SharedInputQueueBuffers;
-  private readonly inputWriter?: SharedInputQueueWriter;
-
-  private detachBridgeInputListener?: () => void;
-  private detachResizeListener?: () => void;
-  private worker?: Worker;
-  private didMount = false;
-
-  constructor(
-    options: WebHostSceneRuntimeOptions,
-    wasmURL: URL,
-    factoryOptions: WasmSceneRuntimeFactoryOptions
-  ) {
-    let inputQueue: SharedInputQueueBuffers | undefined;
-    let inputWriter: SharedInputQueueWriter | undefined;
-
-    try {
-      inputQueue = createSharedInputQueue();
-      inputWriter = new SharedInputQueueWriter(inputQueue);
-    } catch (error) {
-      console.error("[SwiftTUIWeb] failed to create shared stdin queue", error);
-    }
-
-    super({
-      ...options,
-      onInput: (chunk) => {
-        try {
-          inputWriter?.write(chunk);
-        } catch (error) {
-          console.error("[SwiftTUIWeb] failed to enqueue terminal input", error);
-        }
-      },
-    });
-
-    this.bridge = options.bridge;
-    this.wasmURL = wasmURL;
-    this.onSceneResize = factoryOptions.onSceneResize;
-    this.workerModuleURL = factoryOptions.workerModuleURL ?? workerModuleURL;
-    this.inputQueue = inputQueue;
-    this.inputWriter = inputWriter;
-  }
-
-  override async mount(): Promise<void> {
-    await super.mount();
-    if (this.didMount) {
-      return;
-    }
-
-    this.didMount = true;
-    this.detachBridgeInputListener = this.bridge?.stdin.subscribe((chunk) => {
-      this.inputWriter?.write(chunk);
-    });
-    this.detachResizeListener = this.bridge?.subscribeResize((columns, rows, cellWidth, cellHeight) => {
-      this.onSceneResize?.({
-        sceneId: this.descriptor.id,
-        columns,
-        rows,
-        cellWidth,
-        cellHeight,
-      });
-    });
-
-    const initialColumns = Number(this.bridge?.environment.TUIGUI_COLUMNS ?? "0") || 0;
-    const initialRows = Number(this.bridge?.environment.TUIGUI_ROWS ?? "0") || 0;
-    if (!this.bridge && initialColumns > 0 && initialRows > 0) {
-      this.onSceneResize?.({
-        sceneId: this.descriptor.id,
-        columns: initialColumns,
-        rows: initialRows,
-      });
-    }
-
-    if (!this.inputQueue || !this.inputWriter || !this.bridge) {
-      this.writeOutput(
-        "\r\nSwiftTUI WASI browser runtime requires SharedArrayBuffer-backed stdin. Serve the app with COOP/COEP headers.\r\n"
-      );
-      return;
-    }
-
-    this.worker = new Worker(this.workerModuleURL, { type: "module" });
-    this.worker.addEventListener("message", (event: MessageEvent<WorkerMessage>) => {
-      this.handleWorkerMessage(event.data);
-    });
-    this.worker.addEventListener("error", (event) => {
-      this.bridge?.stderr.write(
-        `\nSwiftTUI WASI worker failed: ${event.message || "unknown worker error"}\n`
-      );
-    });
-
-    const environment = { ...this.bridge.environment };
-
-    const message: WorkerStartMessage = {
-      type: "start",
-      wasmURL: this.wasmURL.href,
-      environment,
-      inputQueue: this.inputQueue,
-    };
-    this.worker.postMessage(message);
-  }
-
-  override dispose(): void {
-    this.detachBridgeInputListener?.();
-    this.detachResizeListener?.();
-    this.inputWriter?.close();
-    this.worker?.terminate();
-    super.dispose();
-  }
-
-  private handleWorkerMessage(
-    message: WorkerMessage
-  ): void {
-    switch (message.type) {
-    case "stdout":
-      this.bridge?.stdout.write(message.chunk);
-      break;
-    case "stderr":
-      this.bridge?.stderr.write(message.chunk);
-      break;
-    case "exit":
-      if (message.code !== 0) {
-        this.bridge?.stderr.write(`\nSwiftTUI WASI app exited with code ${message.code}.\n`);
-      }
-      break;
-    case "error":
-      this.bridge?.stderr.write(`\nFailed to start SwiftTUI WASI app: ${message.message}\n`);
-      break;
-    }
-  }
-}