as-test 1.0.16 → 1.1.1

package/lib/build/web-runner/client.d.ts

@@ -0,0 +1 @@
+export declare function buildWebRunnerClientSource(): string;

package/lib/build/web-runner/client.js

@@ -0,0 +1,167 @@
+export function buildWebRunnerClientSource() {
+    return String.raw `const runnerOrigin = location.origin;
+const workerUrl = new URL("/worker.js", runnerOrigin);
+const wsUrl = new URL("/ws", runnerOrigin);
+wsUrl.protocol = location.protocol == "https:" ? "wss:" : "ws:";
+
+const status = document.getElementById("status");
+const statusDot = document.getElementById("status-dot");
+const summary = document.getElementById("summary");
+const footerDetail = document.getElementById("footer-detail");
+const output = document.getElementById("output");
+const replyBuffer = new SharedArrayBuffer(8 + 4 * 1024 * 1024);
+const replyState = new Int32Array(replyBuffer, 0, 2);
+const replyBytes = new Uint8Array(replyBuffer, 8);
+const worker = new Worker(workerUrl, { type: "module" });
+const ws = new WebSocket(wsUrl);
+ws.binaryType = "arraybuffer";
+
+appendLine("launching browser terminal session", "dim prompt");
+appendLine("waiting for worker bootstrap", "dim");
+
+function setStatus(message, tone = "warn") {
+  status.textContent = message;
+  const tones = {
+    warn: "var(--warn)",
+    error: "var(--error)",
+    ok: "var(--success)",
+    accent: "var(--accent)",
+  };
+  statusDot.style.color = tones[tone] || tones.warn;
+  statusDot.style.background = tones[tone] || tones.warn;
+}
+
+function setSummary(message) {
+  summary.textContent = message;
+}
+
+function setFooter(message) {
+  footerDetail.textContent = message;
+}
+
+function appendLine(message, className = "") {
+  const line = document.createElement("span");
+  line.className = "line " + className;
+  line.textContent = String(message ?? "");
+  output.appendChild(line);
+  output.appendChild(document.createTextNode("\n"));
+  output.scrollTop = output.scrollHeight;
+}
+
+function pushReply(frame) {
+  if (frame.byteLength > replyBytes.byteLength) {
+    throw new Error("WIPC reply exceeded shared browser buffer");
+  }
+  if (Atomics.load(replyState, 0) != 0) {
+    throw new Error("received concurrent WIPC replies in web runner");
+  }
+  replyBytes.set(new Uint8Array(frame), 0);
+  Atomics.store(replyState, 1, frame.byteLength);
+  Atomics.store(replyState, 0, 1);
+  Atomics.notify(replyState, 0, 1);
+}
+
+worker.onmessage = (event) => {
+  const message = event.data ?? {};
+  if (message.kind == "wipc" && message.frame instanceof ArrayBuffer) {
+    ws.send(message.frame);
+    return;
+  }
+  if (message.kind == "terminal") {
+    appendLine(String(message.text ?? ""), String(message.level ?? ""));
+    return;
+  }
+  if (message.kind == "instantiated") {
+    setStatus("ready", "accent");
+    setSummary("worker instantiated the wasm module");
+    setFooter("Waiting for start signal from the host runner.");
+    appendLine("runtime instantiated", "success prompt");
+    ws.send(JSON.stringify({ kind: "instantiated" }));
+    return;
+  }
+  if (message.kind == "done") {
+    setStatus("finished", "ok");
+    setSummary("test execution completed");
+    setFooter("Browser runtime finished cleanly.");
+    appendLine("session complete", "success prompt");
+    ws.send(JSON.stringify({ kind: "done" }));
+    return;
+  }
+  if (message.kind == "error") {
+    setStatus("failed", "error");
+    setSummary("browser runtime failed");
+    setFooter("See terminal output for the failure reason.");
+    appendLine(String(message.message ?? "unknown browser runtime error"), "error");
+    ws.send(
+      JSON.stringify({
+        kind: "error",
+        message: String(message.message ?? "unknown browser runtime error"),
+      }),
+    );
+    return;
+  }
+  if (message.kind == "status") {
+    setStatus(String(message.text ?? "running"), String(message.level ?? "accent"));
+    if (message.summary) setSummary(String(message.summary));
+    if (message.footer) setFooter(String(message.footer));
+    return;
+  }
+};
+
+ws.addEventListener("open", () => {
+  setStatus("connected", "accent");
+  setSummary("transport online");
+  setFooter("Spawning browser worker.");
+  appendLine("websocket tunnel established", "accent prompt");
+  ws.send(JSON.stringify({ kind: "ready" }));
+  worker.postMessage({
+    kind: "init",
+    env: window.__AS_TEST_ENV__,
+    replyBuffer,
+  });
+});
+
+ws.addEventListener("message", (event) => {
+  if (typeof event.data == "string") {
+    let message = null;
+    try {
+      message = JSON.parse(event.data);
+    } catch {
+      return;
+    }
+    if (message?.kind == "start") {
+      setStatus("running", "accent");
+      setSummary("host runner started execution");
+      setFooter("Streaming runtime frames to the host runner.");
+      appendLine("received start signal", "accent prompt");
+      worker.postMessage({ kind: "start" });
+    }
+    return;
+  }
+  try {
+    pushReply(event.data);
+  } catch (error) {
+    const message = String(error instanceof Error ? error.message : error);
+    setStatus("bridge failure", "error");
+    setSummary("shared reply buffer failure");
+    setFooter("The browser could not deliver runtime data.");
+    appendLine(message, "error");
+    ws.send(JSON.stringify({ kind: "error", message }));
+  }
+});
+
+ws.addEventListener("close", () => {
+  setStatus("disconnected", "error");
+  setSummary("runner disconnected");
+  setFooter("The browser transport closed.");
+  appendLine("runner disconnected", "error prompt");
+});
+
+ws.addEventListener("error", () => {
+  setStatus("connection error", "error");
+  setSummary("websocket connection failed");
+  setFooter("Unable to connect to the local web runner.");
+  appendLine("websocket connection failed", "error prompt");
+});
+`;
+}

package/lib/build/web-runner/html.d.ts

@@ -0,0 +1 @@
+export declare function buildWebRunnerHtml(): string;

package/lib/build/web-runner/html.js

@@ -0,0 +1,201 @@
+export function buildWebRunnerHtml() {
+    return String.raw `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>as-test web runner</title>
+    <style>
+      :root {
+        color-scheme: dark;
+        --bg: #030712;
+        --bg2: #07101d;
+        --line: rgba(125, 211, 252, 0.14);
+        --muted: #7f92b0;
+        --text: #dde7f7;
+        --accent: #7dd3fc;
+        --accent2: #5eead4;
+        --warn: #fbbf24;
+        --error: #f87171;
+        --success: #86efac;
+      }
+      * {
+        box-sizing: border-box;
+      }
+      html,
+      body {
+        margin: 0;
+        min-height: 100vh;
+      }
+      body {
+        overflow: hidden;
+        background:
+          radial-gradient(circle at top left, rgba(125, 211, 252, 0.12), transparent 34%),
+          radial-gradient(circle at top right, rgba(94, 234, 212, 0.08), transparent 28%),
+          linear-gradient(180deg, var(--bg), var(--bg2));
+        color: var(--text);
+        font: 14px/1.6 "SFMono-Regular", Menlo, Monaco, Consolas, "Liberation Mono", monospace;
+      }
+      .shell {
+        min-height: 100vh;
+        display: grid;
+        grid-template-rows: auto 1fr auto;
+      }
+      .chrome {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        gap: 16px;
+        padding: 18px 22px 14px;
+        border-bottom: 1px solid var(--line);
+        background: linear-gradient(180deg, rgba(8, 14, 28, 0.96), rgba(8, 14, 28, 0.78));
+        backdrop-filter: blur(18px);
+      }
+      .brand {
+        display: flex;
+        align-items: center;
+        gap: 14px;
+      }
+      .lights {
+        display: flex;
+        gap: 8px;
+      }
+      .light {
+        width: 11px;
+        height: 11px;
+        border-radius: 999px;
+        box-shadow: 0 0 0 1px rgba(255, 255, 255, 0.08) inset;
+      }
+      .light.red { background: #fb7185; }
+      .light.yellow { background: #fbbf24; }
+      .light.green { background: #4ade80; }
+      .title {
+        display: grid;
+        gap: 2px;
+      }
+      .title strong {
+        font-size: 13px;
+        letter-spacing: 0.08em;
+        text-transform: uppercase;
+      }
+      .title span,
+      .footer {
+        color: var(--muted);
+      }
+      .statusbar {
+        display: flex;
+        align-items: center;
+        gap: 10px;
+      }
+      .status-dot {
+        width: 10px;
+        height: 10px;
+        border-radius: 999px;
+        background: var(--warn);
+        box-shadow: 0 0 18px currentColor;
+      }
+      .status-text {
+        font-size: 12px;
+        letter-spacing: 0.04em;
+        text-transform: uppercase;
+      }
+      .terminal {
+        position: relative;
+        overflow: hidden;
+        background:
+          linear-gradient(180deg, rgba(7, 12, 24, 0.92), rgba(3, 8, 18, 0.98)),
+          linear-gradient(90deg, rgba(125, 211, 252, 0.03), rgba(94, 234, 212, 0.03));
+      }
+      .terminal::before {
+        content: "";
+        position: absolute;
+        inset: 0;
+        background:
+          linear-gradient(rgba(125, 211, 252, 0.04), transparent 2px),
+          linear-gradient(90deg, rgba(125, 211, 252, 0.03), transparent 1px);
+        background-size: 100% 4px, 24px 100%;
+        opacity: 0.22;
+        pointer-events: none;
+      }
+      #output {
+        position: absolute;
+        inset: 0;
+        margin: 0;
+        padding: 22px 24px 28px;
+        overflow: auto;
+        white-space: pre-wrap;
+        word-break: break-word;
+        line-height: 1.65;
+        tab-size: 2;
+      }
+      .line {
+        display: block;
+      }
+      .line.dim { color: var(--muted); }
+      .line.warn { color: var(--warn); }
+      .line.error { color: var(--error); }
+      .line.success { color: var(--success); }
+      .line.accent { color: var(--accent); }
+      .prompt::before {
+        content: "› ";
+        color: var(--accent2);
+      }
+      .footer {
+        display: flex;
+        justify-content: space-between;
+        gap: 12px;
+        padding: 10px 22px 14px;
+        border-top: 1px solid var(--line);
+        font-size: 12px;
+        background: rgba(7, 12, 24, 0.86);
+      }
+      .footer strong {
+        color: var(--text);
+      }
+      @media (max-width: 720px) {
+        .chrome {
+          padding: 14px 16px 12px;
+          align-items: flex-start;
+          flex-direction: column;
+        }
+        #output {
+          padding: 16px 16px 22px;
+        }
+        .footer {
+          padding: 10px 16px 14px;
+          flex-direction: column;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <div class="shell">
+      <header class="chrome">
+        <div class="brand">
+          <div class="lights" aria-hidden="true">
+            <span class="light red"></span>
+            <span class="light yellow"></span>
+            <span class="light green"></span>
+          </div>
+          <div class="title">
+            <strong>as-test web runner</strong>
+            <span id="summary">waiting for browser runtime bootstrap</span>
+          </div>
+        </div>
+        <div class="statusbar">
+          <span id="status-dot" class="status-dot"></span>
+          <span id="status" class="status-text">connecting</span>
+        </div>
+      </header>
+      <main class="terminal">
+        <pre id="output" aria-live="polite"></pre>
+      </main>
+      <footer class="footer">
+        <span>Mode: <strong>web</strong></span>
+        <span id="footer-detail">Waiting for transport handshake.</span>
+      </footer>
+    </div>
+    <script type="module" src="/client.js"></script>
+  </body>
+</html>`;
+}

package/lib/build/web-runner/worker.d.ts

@@ -0,0 +1 @@
+export declare function buildWebRunnerWorkerSource(): string;

package/lib/build/web-runner/worker.js

@@ -0,0 +1,271 @@
+export function buildWebRunnerWorkerSource() {
+    return String.raw `let replyState = null;
+let replyBytes = null;
+const WIPC_MAGIC = [0x57, 0x49, 0x50, 0x43];
+let runtimeEnv = {};
+let instance = null;
+
+self.onmessage = async (event) => {
+  const message = event.data ?? {};
+  if (message.kind == "init") {
+    const shared = message.replyBuffer;
+    replyState = new Int32Array(shared, 0, 2);
+    replyBytes = new Uint8Array(shared, 8);
+    try {
+      self.postMessage({
+        kind: "status",
+        level: "accent",
+        text: "initializing",
+        summary: "worker resolving runtime imports",
+        footer: "Loading wasm assets in the browser worker.",
+      });
+      runtimeEnv = message.env ?? {};
+      applyRuntimeEnvironment(runtimeEnv);
+      instance = await instantiate({});
+      self.postMessage({ kind: "instantiated" });
+    } catch (error) {
+      emitError(error);
+    }
+    return;
+  }
+  if (message.kind == "start") {
+    try {
+      if (!instance) {
+        throw new Error("web runtime has not been instantiated yet");
+      }
+      instance.exports.start?.();
+      self.postMessage({ kind: "done" });
+    } catch (error) {
+      emitError(error);
+    }
+  }
+};
+
+function emitError(error) {
+  const message =
+    error && typeof error == "object" && "stack" in error
+      ? String(error.stack)
+      : String(error);
+  self.postMessage({ kind: "error", message });
+}
+
+function readReply(max) {
+  if (!replyState || !replyBytes || max <= 0) {
+    return new ArrayBuffer(0);
+  }
+  while (Atomics.load(replyState, 0) == 0) {
+    Atomics.wait(replyState, 0, 0);
+  }
+  const total = Atomics.load(replyState, 1);
+  const size = Math.min(max, total);
+  const out = new Uint8Array(size);
+  out.set(replyBytes.subarray(0, size));
+  if (size < total) {
+    replyBytes.copyWithin(0, size, total);
+    Atomics.store(replyState, 1, total - size);
+  } else {
+    Atomics.store(replyState, 1, 0);
+    Atomics.store(replyState, 0, 0);
+    Atomics.notify(replyState, 0, 1);
+  }
+  return out.buffer;
+}
+
+function applyRuntimeEnvironment(env) {
+  self.process = {
+    env,
+    stdout: {
+      write(data) {
+        const frame = data instanceof ArrayBuffer ? data : data?.buffer;
+        if (frame) {
+          mirrorFrame(frame);
+          self.postMessage({ kind: "wipc", frame }, [frame]);
+        }
+        return true;
+      },
+    },
+    stdin: {
+      read(size) {
+        return readReply(Number(size ?? 0));
+      },
+    },
+  };
+}
+
+async function instantiate(imports) {
+  const wasmUrl = String(runtimeEnv.AS_TEST_WASM_PATH ?? "");
+  const helperUrl = String(runtimeEnv.AS_TEST_HELPER_PATH ?? "");
+  const kind = String(runtimeEnv.AS_TEST_BINDINGS_KIND ?? "raw");
+  if (!wasmUrl) {
+    throw new Error("web runtime wasm path is missing");
+  }
+  if (kind === "raw") {
+    if (!helperUrl) {
+      throw new Error("web runtime helper path is missing for raw bindings");
+    }
+    const binary = await fetchWasmBinary(wasmUrl);
+    const module = new WebAssembly.Module(binary);
+    const helper = await import(helperUrl);
+    if (typeof helper.instantiate != "function") {
+      throw new Error("bindings helper missing instantiate export");
+    }
+    const instance = await captureInstantiateInstance(async () => {
+      await helper.instantiate(module, imports);
+    });
+    return decorateInstance(instance);
+  }
+  if (kind === "esm") {
+    if (!helperUrl) {
+      throw new Error("web runtime helper path is missing for esm bindings");
+    }
+    const instance = await captureInstantiateInstance(async () => {
+      await import(helperUrl);
+    });
+    return decorateInstance(instance);
+  }
+  const binary = await fetchWasmBinary(wasmUrl);
+  const module = new WebAssembly.Module(binary);
+  const result = await WebAssembly.instantiate(module, imports);
+  const instance = result instanceof WebAssembly.Instance ? result : result.instance;
+  return decorateInstance(instance);
+}
+
+async function fetchWasmBinary(wasmUrl) {
+  const response = await fetch(wasmUrl);
+  if (!response.ok) {
+    throw new Error("failed to fetch wasm artifact: " + response.status);
+  }
+  return response.arrayBuffer();
+}
+
+async function captureInstantiateInstance(run) {
+  const originalInstantiate = WebAssembly.instantiate.bind(WebAssembly);
+  let captured = null;
+  WebAssembly.instantiate = async (source, importObject) => {
+    const result = await originalInstantiate(source, importObject);
+    if (result instanceof WebAssembly.Instance) {
+      captured = result;
+    } else {
+      captured = result.instance;
+    }
+    return result;
+  };
+  try {
+    await run();
+  } finally {
+    WebAssembly.instantiate = originalInstantiate;
+  }
+  if (!captured) {
+    throw new Error("failed to capture WebAssembly.Instance in web worker");
+  }
+  return captured;
+}
+
+function decorateInstance(instance) {
+  const exports = instance.exports ?? {};
+  if (typeof exports.start == "function") {
+    return instance;
+  }
+  const startFn = exports._start;
+  if (typeof startFn != "function") {
+    return instance;
+  }
+  const exportsProxy = new Proxy(exports, {
+    get(target, prop, receiver) {
+      if (prop == "start") {
+        return () => startFn.call(target);
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+    has(target, prop) {
+      if (prop == "start") return true;
+      return Reflect.has(target, prop);
+    },
+  });
+  return new Proxy(instance, {
+    get(target, prop, receiver) {
+      if (prop == "exports") return exportsProxy;
+      return Reflect.get(target, prop, receiver);
+    },
+  });
+}
+
+function mirrorFrame(frame) {
+  if (!(frame instanceof ArrayBuffer)) return;
+  const bytes = new Uint8Array(frame);
+  if (
+    bytes.length < 9 ||
+    bytes[0] !== WIPC_MAGIC[0] ||
+    bytes[1] !== WIPC_MAGIC[1] ||
+    bytes[2] !== WIPC_MAGIC[2] ||
+    bytes[3] !== WIPC_MAGIC[3]
+  ) {
+    return;
+  }
+  const type = bytes[4];
+  const size =
+    bytes[5] |
+    (bytes[6] << 8) |
+    (bytes[7] << 16) |
+    (bytes[8] << 24);
+  const payload = bytes.subarray(9, 9 + size);
+  if (type !== 0x02) return;
+  let raw = "";
+  try {
+    raw = new TextDecoder().decode(payload);
+  } catch {
+    return;
+  }
+  if (!raw.length) return;
+  let message = null;
+  try {
+    message = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  renderControl(message);
+}
+
+function renderControl(message) {
+  if (!message || typeof message !== "object") return;
+  const kind = String(message.kind ?? "");
+  if (kind === "event:file-start") {
+    self.postMessage({ kind: "terminal", level: "accent prompt", text: "running " + String(message.file ?? "spec") });
+    return;
+  }
+  if (kind === "event:file-end") {
+    const verdict = String(message.verdict ?? "done").toUpperCase();
+    const time = String(message.time ?? "");
+    self.postMessage({
+      kind: "terminal",
+      level: verdict === "PASS" ? "success" : "error",
+      text: verdict + " " + String(message.file ?? "") + (time ? " " + time : ""),
+    });
+    return;
+  }
+  if (kind === "event:suite-start") {
+    const depth = Number(message.depth ?? 0);
+    const indent = "  ".repeat(Math.max(0, depth));
+    self.postMessage({ kind: "terminal", level: "dim", text: indent + String(message.description ?? "") });
+    return;
+  }
+  if (kind === "event:log") {
+    self.postMessage({ kind: "terminal", level: "", text: String(message.text ?? "") });
+    return;
+  }
+  if (kind === "event:warn") {
+    self.postMessage({ kind: "terminal", level: "warn", text: String(message.message ?? "warning") });
+    return;
+  }
+  if (kind === "event:assert-fail") {
+    const parts = [
+      "assertion failed",
+      String(message.message ?? ""),
+      "left: " + String(message.left ?? ""),
+      "right: " + String(message.right ?? ""),
+    ].filter(Boolean);
+    self.postMessage({ kind: "terminal", level: "error", text: parts.join(" | ") });
+  }
+}
+`;
+}