@ttsc/wasm 0.13.0 → 0.14.0-dev.20260528

package/host/host.go

@@ -3,16 +3,17 @@
 // JS-side bindings for the host package.
 //
 // `Expose` installs `globalThis[apiName]` with the base ttsc endpoints
-// (version, build, check, transform) plus a `plugin(name, command, opts)`
-// dispatcher that routes into the consumer's registered plugins. The handler
-// shape mirrors typia's `ttsc-typia` wasm so JS callers can build a single
-// boot helper that works against any host-built binary.
+// (version, build, check, transform) plus `plugin({ name, command, ...opts })`,
+// routing into the consumer's registered plugins. Every async endpoint returns
+// the JS result envelope so callers can build a single boot helper that works
+// against any host-built binary.
 package host
 
 import (
   "fmt"
   "os"
   "runtime"
+  "sync"
   "sync/atomic"
   "syscall/js"
   "time"
@@ -26,6 +27,10 @@ var (
   date    = "unknown"
 )
 
+// exposed gates Expose so a duplicate call panics instead of leaking the
+// previous batch of js.Funcs + spawning a second keepalive goroutine.
+var exposed atomic.Bool
+
 // API stability: experimental until v1.0; signatures may change between
 // minor releases. Pin exact versions in production playgrounds.
 //
@@ -35,15 +40,36 @@ var (
 // The contract:
 //
 //   - globalThis[apiName].version()                        → version banner
-//   - globalThis[apiName].build({ cwd, tsconfig })         → Promise<CompileResult>
-//   - globalThis[apiName].check({ cwd, tsconfig })         → Promise<CompileResult>
-//   - globalThis[apiName].transform({ cwd, tsconfig })     → Promise<TransformResult>
-//   - globalThis[apiName].plugin({ name, command, ...opts}) → Promise<APIResult>
+//   - globalThis[apiName].build({ cwd, tsconfig })         → Promise<ITtscResult>
+//   - globalThis[apiName].check({ cwd, tsconfig })         → Promise<ITtscResult>
+//   - globalThis[apiName].transform({ cwd, tsconfig })     → Promise<ITtscResult>
+//   - globalThis[apiName].plugin({ name, command, ...opts}) → Promise<ITtscResult>
 //   - globalThis[apiName].plugins()                        → string[] of registered names
 //
+// build/check/transform encode their structured payloads as JSON in
+// ITtscResult.result. Plugin stdout/stderr are captured in the envelope streams.
+//
 // A matching readiness resolver is invoked: `globalThis[`${apiName}Ready`]`.
 // JS callers register this BEFORE go.run begins so they can await wasm boot.
 func Expose(apiName string, cfg Config) {
+  // Refuse double-Expose: the second call would leak every js.FuncOf from
+  // the first batch (Go pins js.Funcs and they're not GC'd), spin a second
+  // keepalive goroutine forever, and overwrite the ready resolver so JS
+  // may await against a different generation than the api globals.
+  //
+  // Surface the refusal as console.error + a JS-visible reject signal
+  // (`globalThis[apiName+"Failed"](err)`) and return without panicking.
+  // A panic would terminate the Go runtime before any Ready resolver
+  // could fire, and bootTtsc's `await ready` (no timeout) would hang
+  // indefinitely with no observable cause.
+  if !exposed.CompareAndSwap(false, true) {
+    msg := "host.Expose: must be called at most once per wasm instance"
+    fmt.Fprintln(os.Stderr, msg)
+    if failed := js.Global().Get(apiName + "Failed"); failed.Type() == js.TypeFunction {
+      failed.Invoke(js.Global().Get("Error").New(msg))
+    }
+    return
+  }
   plugins := map[string]Plugin{}
   pluginNames := make([]string, 0, len(cfg.Plugins))
   for _, p := range cfg.Plugins {
@@ -69,6 +95,9 @@ func Expose(apiName string, cfg Config) {
     "plugin":    js.FuncOf(jsPluginDispatch(plugins)),
     "plugins":   js.FuncOf(jsPluginsList(pluginNames)),
   }
+  for verb, fn := range fountainAPIMap() {
+    api[verb] = fn
+  }
   js.Global().Set(apiName, js.ValueOf(api))
 
   if ready := js.Global().Get(apiName + "Ready"); ready.Type() == js.TypeFunction {
@@ -294,6 +323,9 @@ func stringProp(obj js.Value, key string) string {
 // supported on the wasm target. The temp-file approach works because the
 // MemFS shim implements file open/write/read.
 func runWithCapturedIO(task func() int) APIResult {
+  captureMu.Lock()
+  defer captureMu.Unlock()
+
   prevOut, prevErr := os.Stdout, os.Stderr
   // The defer is a safety net: if an early return skips the explicit restore
   // below, os.Stdout/os.Stderr are still restored. The explicit restore that
@@ -329,9 +361,25 @@ func runWithCapturedIO(task func() int) APIResult {
     }
     return APIResult{Code: task()}
   }
+  capturing := false
+  defer func() {
+    if capturing {
+      os.Stdout = prevOut
+      os.Stderr = prevErr
+    }
+    if outFile != nil {
+      _ = outFile.Close()
+    }
+    if errFile != nil {
+      _ = errFile.Close()
+    }
+    _ = os.Remove(stdoutPath)
+    _ = os.Remove(stderrPath)
+  }()
 
   os.Stdout = outFile
   os.Stderr = errFile
+  capturing = true
 
   code := task()
 
@@ -340,15 +388,16 @@ func runWithCapturedIO(task func() int) APIResult {
   _ = outFile.Sync()
   _ = errFile.Sync()
   _ = outFile.Close()
+  outFile = nil
   _ = errFile.Close()
+  errFile = nil
 
   os.Stdout = prevOut
   os.Stderr = prevErr
+  capturing = false
 
   stdoutBytes, _ := os.ReadFile(stdoutPath)
   stderrBytes, _ := os.ReadFile(stderrPath)
-  _ = os.Remove(stdoutPath)
-  _ = os.Remove(stderrPath)
 
   return APIResult{
     Code:   code,
@@ -361,3 +410,8 @@ func runWithCapturedIO(task func() int) APIResult {
 // overlap (multiple goroutines could be in runWithCapturedIO concurrently
 // from independent JS callers).
 var captureCounter atomic.Uint64
+
+// captureMu serializes temporary replacement of package-global stdout/stderr.
+// The temp filenames are unique, but os.Stdout/os.Stderr themselves are shared
+// process state in the wasm runtime.
+var captureMu sync.Mutex

package/host/plugin.go

@@ -30,8 +30,9 @@ package host
 // streams is captured and returned to the JS caller.
 type Plugin interface {
   // Name is the npm-style plugin id (e.g. `@ttsc/banner`). The JS side
-  // passes this exact string when dispatching: `api.plugin("@ttsc/banner",
-  // "build", opts)`. Names must be unique within a Config.
+  // passes this exact string when dispatching:
+  // `api.plugin({ name: "@ttsc/banner", command: "build", ...opts })`.
+  // Names must be unique within a Config.
   Name() string
 
   // Run dispatches a subcommand. `command` is the verb the JS caller asked
@@ -39,8 +40,8 @@ type Plugin interface {
   // `args` is the rest of the argv, already prefixed with `--flag=value`
   // pairs the host built from the JS options object.
   //
-  // Return the exit code (0 for success, 2 for usage errors, 3 for runtime
-  // errors — mirrors the native CLI exit-code contract). Anything written
+  // Return the exit code (0 for success, 2 for compiler/config/usage errors, 3
+  // for runtime errors — mirrors the native CLI exit-code contract). Anything written
   // to `os.Stdout` / `os.Stderr` is captured by the host.
   //
   // API stability: experimental until v1.0; the signature is expected to
@@ -51,7 +52,7 @@ type Plugin interface {
 // Config carries the optional registrations the host applies before binding
 // `globalThis[name]`. Pass `Config{}` for a vanilla ttsc + tsgo wasm.
 type Config struct {
-  // Plugins are dispatched through `api.plugin(name, command, opts)` from
+  // Plugins are dispatched through `api.plugin({ name, command, ...opts })` from
   // JS. Their Run methods share the same `os.Stdout` / `os.Stderr` streams
   // the base build/check/transform endpoints use, so diagnostics render
   // the same way no matter which lane produced them.

package/lib/src/MemFSError.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Filesystem error with a POSIX error code and numeric `errno`.
+ *
+ * Matches the shape of `NodeJS.ErrnoException` so Go's `os` package interprets
+ * it as a proper `os.PathError` with a numeric error code. Thrown by the
+ * MemFS implementation when a callback would otherwise pass `null` for an
+ * impossible filesystem operation (missing path, type mismatch, …).
+ */
+export declare class MemFSError extends Error {
+    code: string;
+    errno: number;
+    path?: string;
+    syscall?: string;
+    constructor(code: string, syscall: string, path?: string);
+}

package/lib/src/MemFSError.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemFSError = void 0;
+/**
+ * Filesystem error with a POSIX error code and numeric `errno`.
+ *
+ * Matches the shape of `NodeJS.ErrnoException` so Go's `os` package interprets
+ * it as a proper `os.PathError` with a numeric error code. Thrown by the
+ * MemFS implementation when a callback would otherwise pass `null` for an
+ * impossible filesystem operation (missing path, type mismatch, …).
+ */
+class MemFSError extends Error {
+    code;
+    errno;
+    path;
+    syscall;
+    constructor(code, syscall, path) {
+        super(`${code}: ${syscall} ${path ?? ""}`.trim());
+        this.code = code;
+        this.errno = errnoForCode(code);
+        this.path = path;
+        this.syscall = syscall;
+    }
+}
+exports.MemFSError = MemFSError;
+/** Map a POSIX error name to its Linux numeric errno (negative by convention). */
+function errnoForCode(code) {
+    switch (code) {
+        case "ENOENT":
+            return -2;
+        case "EBADF":
+            return -9;
+        case "EEXIST":
+            return -17;
+        case "ENOTDIR":
+            return -20;
+        case "EISDIR":
+            return -21;
+        case "EINVAL":
+            return -22;
+        case "ESPIPE":
+            return -29;
+        default:
+            return -1;
+    }
+}
+//# sourceMappingURL=MemFSError.js.map

package/lib/src/MemFSError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemFSError.js","sourceRoot":"","sources":["../../src/MemFSError.ts"],"names":[],"mappings":";;;AAAA;;;;;;;GAOG;AACH,gBAAwB,SAAQ,KAAK;IAC5B,IAAI,CAAS;IACb,KAAK,CAAS;IACd,IAAI,CAAU;IACd,OAAO,CAAU;IACxB,YAAY,IAAY,EAAE,OAAe,EAAE,IAAa;QACtD,KAAK,CAAC,GAAG,IAAI,KAAK,OAAO,IAAI,IAAI,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC;QAClD,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,KAAK,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;CACF;;AAED,kFAAkF;AAClF,SAAS,YAAY,CAAC,IAAY;IAChC,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,QAAQ;YACX,OAAO,CAAC,CAAC,CAAC;QACZ,KAAK,OAAO;YACV,OAAO,CAAC,CAAC,CAAC;QACZ,KAAK,QAAQ;YACX,OAAO,CAAC,EAAE,CAAC;QACb,KAAK,SAAS;YACZ,OAAO,CAAC,EAAE,CAAC;QACb,KAAK,QAAQ;YACX,OAAO,CAAC,EAAE,CAAC;QACb,KAAK,QAAQ;YACX,OAAO,CAAC,EAAE,CAAC;QACb,KAAK,QAAQ;YACX,OAAO,CAAC,EAAE,CAAC;QACb;YACE,OAAO,CAAC,CAAC,CAAC;IACd,CAAC;AACH,CAAC"}

package/lib/src/bootTtsc.d.ts

@@ -0,0 +1,21 @@
+import type { IBootResult } from "./structures/IBootResult";
+import type { IBootTtscOptions } from "./structures/IBootTtscOptions";
+/**
+ * Boot a host-built wasm. Re-entrant only if you reuse the same `host`.
+ *
+ * Concurrent calls with the same `(apiName, wasmUrl)` pair share the same
+ * in-flight boot. Calls with the same `apiName` but different `wasmUrl`
+ * are serialized via `bootChainByApiName` so they don't race on the
+ * shared `globalThis[apiName+"Ready"]` resolver slot. On rejection the
+ * cache entries are cleared so the next call retries from scratch.
+ *
+ * **Single-Worker caveat.** Even with the chain, a second boot loaded
+ * into the SAME Worker after a first boot completes will overlay its
+ * Go runtime on top of the first — `importScripts(wasmExecUrl)` rebinds
+ * `globalThis.Go`, and the first wasm's keepalive goroutine keeps
+ * running through the new runtime's js-bridge tables. The serialization
+ * is sufficient for the typical use case (one boot per Worker over the
+ * page's lifetime) but DOES NOT make a Worker safe to host two wasm
+ * instances at once. Create a fresh Worker per concurrent wasm.
+ */
+export declare function bootTtsc(options: IBootTtscOptions): Promise<IBootResult>;

package/lib/src/bootTtsc.js

@@ -0,0 +1,180 @@
+"use strict";
+// Boots a host-built wasm and returns the JS-side handle.
+//
+// Order of operations matters: wasm_exec.js installs default no-op fs/process
+// shims if `globalThis.fs` is missing at load time, so we must install our
+// MemFS BEFORE importing wasm_exec.js.
+//
+// The boot helper is parameterized by `apiName` so any wasm built with
+// `host.Expose(...)` can be loaded the same way. The base wasm uses "ttsc";
+// downstream consumers pick their own (e.g. "ttscPlayground", "ttscTypia").
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bootTtsc = bootTtsc;
+const createMemFS_1 = require("./createMemFS");
+/**
+ * Per-(apiName, wasmUrl) single-flight cache for boots. Keying on apiName
+ * alone would let a second call with the same apiName but a different
+ * wasmUrl silently return the cached IBootResult of the first wasm — the
+ * caller would think they booted a fresh binary while the cached one
+ * stayed in place. The composite key lets HMR / cache-busting query
+ * strings get a fresh boot while still single-flighting genuine concurrent
+ * duplicate calls.
+ */
+const bootsInFlight = new Map();
+/**
+ * Per-apiName serialization chain. Two concurrent boots with the same
+ * apiName but different wasmUrls each install their own `globalThis[apiName
+ * + "Ready"]` resolver — they would race and the second would overwrite
+ * the first, stranding the first boot's await. The chain serializes them
+ * so one boot's Go-side `Ready.Invoke()` always lands on the resolver
+ * that boot installed.
+ */
+const bootChainByApiName = new Map();
+function bootKey(apiName, wasmUrl) {
+    return `${apiName}|${resolveWasmUrl(wasmUrl)}`;
+}
+/**
+ * Resolve `wasmUrl` against the current document base before keying so
+ * that `./playground.wasm`, `/compiler/playground.wasm`, and the fully
+ * qualified absolute href all collapse to the same cache entry instead
+ * of spawning duplicate boots. Falls back to the raw string when no
+ * base is available (Node-side tests, non-DOM workers).
+ */
+function resolveWasmUrl(wasmUrl) {
+    try {
+        const base = typeof location !== "undefined" ? location.href : "http://local/";
+        return new URL(wasmUrl, base).href;
+    }
+    catch {
+        return wasmUrl;
+    }
+}
+/**
+ * Boot a host-built wasm. Re-entrant only if you reuse the same `host`.
+ *
+ * Concurrent calls with the same `(apiName, wasmUrl)` pair share the same
+ * in-flight boot. Calls with the same `apiName` but different `wasmUrl`
+ * are serialized via `bootChainByApiName` so they don't race on the
+ * shared `globalThis[apiName+"Ready"]` resolver slot. On rejection the
+ * cache entries are cleared so the next call retries from scratch.
+ *
+ * **Single-Worker caveat.** Even with the chain, a second boot loaded
+ * into the SAME Worker after a first boot completes will overlay its
+ * Go runtime on top of the first — `importScripts(wasmExecUrl)` rebinds
+ * `globalThis.Go`, and the first wasm's keepalive goroutine keeps
+ * running through the new runtime's js-bridge tables. The serialization
+ * is sufficient for the typical use case (one boot per Worker over the
+ * page's lifetime) but DOES NOT make a Worker safe to host two wasm
+ * instances at once. Create a fresh Worker per concurrent wasm.
+ */
+function bootTtsc(options) {
+    const apiName = options.apiName ?? "ttsc";
+    const key = bootKey(apiName, options.wasmUrl);
+    const inflight = bootsInFlight.get(key);
+    if (inflight)
+        return inflight;
+    const prior = bootChainByApiName.get(apiName) ?? Promise.resolve();
+    const promise = prior
+        .catch(() => {
+        /* don't propagate a prior boot's rejection — let this one run */
+    })
+        .then(() => bootTtscOnce(options, apiName))
+        .catch((err) => {
+        bootsInFlight.delete(key);
+        throw err;
+    });
+    bootsInFlight.set(key, promise);
+    // Track the chain head for this apiName so the next boot waits on it.
+    // Swallow on the chain head specifically: we already throw to the
+    // immediate caller; surfacing it through the chain would reject every
+    // subsequent boot just because this one failed.
+    bootChainByApiName.set(apiName, promise.catch(() => { }));
+    return promise;
+}
+async function bootTtscOnce(options, apiName) {
+    const wasmUrl = options.wasmUrl;
+    const wasmExecUrl = options.wasmExecUrl ?? defaultWasmExecUrl(wasmUrl);
+    const host = options.host ?? (0, createMemFS_1.createMemFS)();
+    const globalAny = globalThis;
+    // Only install fs / process if they aren't already in place. A caller
+    // booting a second wasm over the same MemFS reuses the same shims.
+    if (!globalAny.fs)
+        globalAny.fs = host.fs;
+    if (!globalAny.process)
+        globalAny.process = createProcessShim();
+    // wasm_exec.js installs `globalThis.Go`. It also reads globalThis.fs at
+    // module-eval time, so this import must follow the assignment above.
+    importScripts(wasmExecUrl);
+    // Race the Ready resolver against a Failed signal so a wasm-side fault
+    // (e.g. `host.Expose` refusing a duplicate call) surfaces here instead of
+    // hanging on `await ready` forever. `go.run` is fire-and-forget so its
+    // own rejection cannot reach this promise without an explicit channel.
+    const ready = new Promise((resolve, reject) => {
+        globalAny[apiName + "Ready"] = () => {
+            delete globalAny[apiName + "Failed"];
+            resolve();
+        };
+        globalAny[apiName + "Failed"] = (err) => {
+            delete globalAny[apiName + "Ready"];
+            reject(err instanceof Error ? err : new Error(String(err)));
+        };
+    });
+    const goCtor = globalAny.Go;
+    if (typeof goCtor !== "function") {
+        throw new Error(`bootTtsc: globalThis.Go was not installed by ${wasmExecUrl} — the file may not have loaded (CSP block, wrong content type, 404), or it is not the wasm_exec.js shipped with the Go toolchain.`);
+    }
+    const go = new goCtor();
+    const response = await fetch(wasmUrl);
+    if (!response.ok) {
+        throw new Error(`bootTtsc: failed to fetch ${wasmUrl}: ${response.status}`);
+    }
+    const wasm = await WebAssembly.instantiateStreaming(response, go.importObject);
+    // go.run never resolves until the wasm exits; we don't await it.
+    void go.run(wasm.instance);
+    await ready;
+    const api = globalAny[apiName];
+    if (!api)
+        throw new Error(`bootTtsc: ${apiName} global was not set — was the wasm built with host.Expose(${JSON.stringify(apiName)}, ...)?`);
+    return { api, host };
+}
+/**
+ * Derive the `wasm_exec.js` URL from the wasm URL by replacing the filename.
+ *
+ * If `wasmUrl` has no directory component, returns `"wasm_exec.js"` (same
+ * directory as the caller's base URL).
+ */
+function defaultWasmExecUrl(wasmUrl) {
+    const slash = wasmUrl.lastIndexOf("/");
+    if (slash < 0)
+        return "wasm_exec.js";
+    return wasmUrl.slice(0, slash + 1) + "wasm_exec.js";
+}
+/**
+ * Minimal `process` shim required by `wasm_exec.js` in non-Node environments.
+ *
+ * Go's js/wasm bridge reads `process.pid`, `process.ppid`, and calls
+ * `process.cwd()`. `getuid`/`getgid` and friends return `-1` (root-less).
+ * `umask` and `getgroups` are never exercised by the compiler but are
+ * included for completeness so unexpected calls surface as clear errors.
+ */
+function createProcessShim() {
+    return {
+        getuid: () => -1,
+        getgid: () => -1,
+        geteuid: () => -1,
+        getegid: () => -1,
+        getgroups: () => {
+            throw new Error("not implemented");
+        },
+        pid: -1,
+        ppid: -1,
+        umask: () => {
+            throw new Error("not implemented");
+        },
+        cwd: () => "/",
+        chdir: () => {
+            /* no-op; the workspace lives inside the MemFS */
+        },
+    };
+}
+//# sourceMappingURL=bootTtsc.js.map

package/lib/src/bootTtsc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootTtsc.js","sourceRoot":"","sources":["../../src/bootTtsc.ts"],"names":[],"mappings":"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"}

package/lib/src/createMemFS.d.ts

@@ -0,0 +1,11 @@
+import type { IMemFSHost } from "./structures/IMemFSHost";
+/**
+ * Create an in-memory filesystem suitable for use as `globalThis.fs` inside a
+ * Go/wasm runtime.
+ *
+ * The returned host exposes the low-level `fs` object (install it on
+ * `globalThis.fs` before loading `wasm_exec.js`) and convenience helpers
+ * (`writeFile`, `readFile`, `mkdirp`, …) for seeding source files and reading
+ * compiler output without touching the real filesystem.
+ */
+export declare function createMemFS(): IMemFSHost;