@ttsc/wasm 0.18.4 → 0.19.1

package/src/MemFSError.ts

@@ -27,6 +27,8 @@ function errnoForCode(code: string): number {
       return -2;
     case "EBADF":
       return -9;
+    case "EBUSY":
+      return -16;
     case "EEXIST":
       return -17;
     case "ENOTDIR":
@@ -37,6 +39,8 @@ function errnoForCode(code: string): number {
       return -22;
     case "ESPIPE":
       return -29;
+    case "ENOTEMPTY":
+      return -39;
     default:
       return -1;
   }

package/src/bootTtsc.ts

@@ -109,56 +109,124 @@ async function bootTtscOnce(
 
   const host = options.host ?? createMemFS();
   const globalAny = globalThis as Record<string, unknown>;
-  // 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<void>((resolve, reject) => {
-    globalAny[apiName + "Ready"] = () => {
-      delete globalAny[apiName + "Failed"];
-      resolve();
-    };
-    globalAny[apiName + "Failed"] = (err: unknown) => {
-      delete globalAny[apiName + "Ready"];
-      reject(err instanceof Error ? err : new Error(String(err)));
-    };
-  });
-
-  const goCtor = (globalAny as { Go?: new () => IGoInstance }).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.`,
-    );
+  // Install fs / process only if they aren't already in place, and remember
+  // whether THIS attempt installed them. The Go runtime this boot starts reads
+  // `globalThis.fs` when it runs, so the returned `host` must be the exact host
+  // backing those globals. A caller booting a second wasm over the same MemFS
+  // (or reusing one host across retries) reuses the same shims. When an earlier
+  // failed attempt already installed a different host's shims, those are torn
+  // down on failure below so this attempt can install its own.
+  const installedFs = !globalAny.fs;
+  const installedProcess = !globalAny.process;
+  let processShim: unknown;
+  if (installedFs) globalAny.fs = host.fs;
+  if (installedProcess) {
+    processShim = createProcessShim();
+    globalAny.process = processShim;
   }
-  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 as Record<string, ITtscApi | undefined>)[apiName];
-  if (!api)
-    throw new Error(
-      `bootTtsc: ${apiName} global was not set — was the wasm built with host.Expose(${JSON.stringify(apiName)}, ...)?`,
+  // Any failure after global installation must leave the globals as this
+  // attempt found them, so a retry installs its own host's fs (and the returned
+  // host keeps matching the runtime's filesystem). Only remove what we
+  // installed and only while it is still ours — never stomp a foreign fs or one
+  // a concurrently-booted runtime already claimed.
+  const restoreGlobals = (): void => {
+    if (installedFs && globalAny.fs === host.fs) delete globalAny.fs;
+    if (installedProcess && globalAny.process === processShim)
+      delete globalAny.process;
+  };
+
+  try {
+    // 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.
+    let readyCb!: () => void;
+    let failedCb!: (err: unknown) => void;
+    const ready = new Promise<void>((resolve, reject) => {
+      readyCb = () => {
+        delete globalAny[apiName + "Failed"];
+        resolve();
+      };
+      failedCb = (err: unknown) => {
+        delete globalAny[apiName + "Ready"];
+        reject(err instanceof Error ? err : new Error(String(err)));
+      };
+      globalAny[apiName + "Ready"] = readyCb;
+      globalAny[apiName + "Failed"] = failedCb;
+    });
+
+    const goCtor = (globalAny as { Go?: new () => IGoInstance }).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,
+    );
+
+    // A normal host keeps `go.run` pending forever after signaling Ready, so a
+    // settlement (fulfil OR reject) BEFORE Ready means the Go runtime exited or
+    // panicked before it could register — e.g. an early `host.Expose` panic
+    // that never reached the Failed bridge. Race that early exit against
+    // readiness so the boot rejects with an actionable cause instead of hanging.
+    // The standard Go runner discards the exit code, so an unknown early exit
+    // can only synthesize a generic message; known host validation failures
+    // reject through Failed above and keep their original cause.
+    const runPromise = Promise.resolve(go.run(wasm.instance));
+    const earlyExit = runPromise.then(
+      () => {
+        throw new Error(
+          `bootTtsc: the ${apiName} wasm runtime exited before signaling readiness (the host may have panicked; check the wasm stderr).`,
+        );
+      },
+      (err: unknown) => {
+        throw new Error(
+          `bootTtsc: the ${apiName} wasm runtime failed before signaling readiness: ${
+            err instanceof Error ? err.message : String(err)
+          }`,
+        );
+      },
     );
-  return { api, host };
+    // When Ready wins, the long-running runtime's eventual `go.run` settlement
+    // must not surface as an unhandled rejection. Attach a terminal handler to
+    // the losing branch.
+    earlyExit.catch(() => {});
+
+    try {
+      await Promise.race([ready, earlyExit]);
+    } finally {
+      // Drop this attempt's readiness bridge so a later boot for the same
+      // apiName installs a clean pair and no stale resolver survives.
+      if (globalAny[apiName + "Ready"] === readyCb)
+        delete globalAny[apiName + "Ready"];
+      if (globalAny[apiName + "Failed"] === failedCb)
+        delete globalAny[apiName + "Failed"];
+    }
+
+    const api = (globalAny as Record<string, ITtscApi | undefined>)[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 };
+  } catch (err) {
+    restoreGlobals();
+    throw err;
+  }
 }
 
 /**

package/src/createMemFS.ts

@@ -160,6 +160,59 @@ export function createMemFS(): IMemFSHost {
     }
   }
 
+  /** Absolute parent directory of a normalized path (`/` for a top-level path). */
+  function parentDir(norm: string): string {
+    const idx = norm.lastIndexOf("/");
+    return idx <= 0 ? "/" : norm.slice(0, idx);
+  }
+
+  /** True when `dir` has at least one descendant node in the tree. */
+  function hasChildren(dir: string): boolean {
+    const prefix = dir === "/" ? "/" : dir + "/";
+    for (const key of nodes.keys()) {
+      if (key !== dir && key.startsWith(prefix)) return true;
+    }
+    return false;
+  }
+
+  /**
+   * Grow or shrink a file's byte buffer to exactly `length`, zero-filling any
+   * extension. Callers validate `length >= 0` first.
+   */
+  function resizeFileData(data: Uint8Array, length: number): Uint8Array {
+    const next = new Uint8Array(length);
+    next.set(data.subarray(0, Math.min(length, data.byteLength)));
+    return next;
+  }
+
+  /**
+   * Move the entire subtree rooted at `src` to `dest`, overwriting any existing
+   * `dest` node. Every descendant key is re-parented so no old-prefix node is
+   * left orphaned, and open descriptors that referenced a moved path follow to
+   * the new location (a rename must not strand an fd's inode).
+   */
+  function moveSubtree(src: string, dest: string): void {
+    const srcPrefix = src + "/";
+    const moves: Array<[string, INode]> = [];
+    for (const [key, node] of nodes) {
+      if (key === src) moves.push([dest, node]);
+      else if (key.startsWith(srcPrefix))
+        moves.push([dest + "/" + key.slice(srcPrefix.length), node]);
+    }
+    // Delete the whole source subtree first so a nested overwrite cannot leave
+    // a stale descendant behind, then reinsert at the destination prefix. Any
+    // pre-existing `dest` node is replaced by the reinsert.
+    for (const key of [...nodes.keys()]) {
+      if (key === src || key.startsWith(srcPrefix)) nodes.delete(key);
+    }
+    for (const [key, node] of moves) nodes.set(key, node);
+    for (const entry of fdTable.values()) {
+      if (entry.path === src) entry.path = dest;
+      else if (entry.path.startsWith(srcPrefix))
+        entry.path = dest + "/" + entry.path.slice(srcPrefix.length);
+    }
+  }
+
   function mkdirp(p: string): void {
     const segments = normalize(p).split("/").filter(Boolean);
     let cursor = "";
@@ -281,10 +334,8 @@ export function createMemFS(): IMemFSHost {
           console.error("[wasm]", line);
         return buf.length;
       }
-      // Open-file fds (>= 100): append to the underlying file. This is the
-      // path the wasm host's runWithCapturedIO uses to capture plugin
-      // stdout/stderr via /tmp/* temp files (os.Pipe is not implemented on
-      // js/wasm so we mirror its semantics via files).
+      // Open-file fds (>= 100): append to the underlying file. Browser-hosted
+      // tools use this path for ordinary virtual files and explicit outputs.
       const entry = fdTable.get(fd);
       if (entry) {
         const node = nodes.get(entry.path);
@@ -508,10 +559,19 @@ export function createMemFS(): IMemFSHost {
 
     unlink(p, callback) {
       const norm = normalize(p);
-      if (!nodes.has(norm)) {
+      const node = nodes.get(norm);
+      if (!node) {
         callback(new MemFSError("ENOENT", "unlink", norm));
         return;
       }
+      // POSIX unlink refuses directories (EISDIR/EPERM). Go's os.Remove tries
+      // unlink first and only falls back to rmdir when it fails, so a false
+      // success here would delete just the directory node and orphan every
+      // descendant. Reject so the rmdir path (which validates emptiness) runs.
+      if (node.kind === "dir") {
+        callback(new MemFSError("EISDIR", "unlink", norm));
+        return;
+      }
       nodes.delete(norm);
       callback(null);
     },
@@ -523,14 +583,73 @@ export function createMemFS(): IMemFSHost {
         callback(new MemFSError("ENOENT", "rename", src));
         return;
       }
+      if (src === "/") {
+        callback(new MemFSError("EBUSY", "rename", src));
+        return;
+      }
       const dest = normalize(to);
-      nodes.delete(src);
-      nodes.set(dest, node);
+      // Renaming a path onto itself is a defined no-op success.
+      if (src === dest) {
+        callback(null);
+        return;
+      }
+      // A directory cannot be moved inside itself or its own descendants.
+      if (node.kind === "dir" && dest.startsWith(src + "/")) {
+        callback(new MemFSError("EINVAL", "rename", src));
+        return;
+      }
+      // The destination's parent must already exist as a directory.
+      const parent = nodes.get(parentDir(dest));
+      if (!parent) {
+        callback(new MemFSError("ENOENT", "rename", dest));
+        return;
+      }
+      if (parent.kind !== "dir") {
+        callback(new MemFSError("ENOTDIR", "rename", dest));
+        return;
+      }
+      // Reconcile against an existing destination before mutating anything so a
+      // rejected rename leaves the tree untouched (no partial state).
+      const destNode = nodes.get(dest);
+      if (destNode) {
+        if (node.kind === "file") {
+          if (destNode.kind === "dir") {
+            callback(new MemFSError("EISDIR", "rename", dest));
+            return;
+          }
+        } else if (destNode.kind !== "dir") {
+          callback(new MemFSError("ENOTDIR", "rename", dest));
+          return;
+        } else if (hasChildren(dest)) {
+          callback(new MemFSError("ENOTEMPTY", "rename", dest));
+          return;
+        }
+      }
+      moveSubtree(src, dest);
       callback(null);
     },
 
     rmdir(p, callback) {
-      this.unlink(p, callback);
+      const norm = normalize(p);
+      const node = nodes.get(norm);
+      if (!node) {
+        callback(new MemFSError("ENOENT", "rmdir", norm));
+        return;
+      }
+      if (node.kind !== "dir") {
+        callback(new MemFSError("ENOTDIR", "rmdir", norm));
+        return;
+      }
+      if (norm === "/") {
+        callback(new MemFSError("EBUSY", "rmdir", norm));
+        return;
+      }
+      if (hasChildren(norm)) {
+        callback(new MemFSError("ENOTEMPTY", "rmdir", norm));
+        return;
+      }
+      nodes.delete(norm);
+      callback(null);
     },
 
     chmod(_p, _mode, callback) {
@@ -560,10 +679,51 @@ export function createMemFS(): IMemFSHost {
     readlink(_p, callback) {
       callback(new MemFSError("EINVAL", "readlink"), "");
     },
-    truncate(_p, _length, callback) {
+    truncate(p, length, callback) {
+      const norm = normalize(p);
+      const node = nodes.get(norm);
+      if (!node) {
+        callback(new MemFSError("ENOENT", "truncate", norm));
+        return;
+      }
+      if (node.kind !== "file") {
+        callback(new MemFSError("EISDIR", "truncate", norm));
+        return;
+      }
+      if (!Number.isInteger(length) || length < 0) {
+        callback(new MemFSError("EINVAL", "truncate", norm));
+        return;
+      }
+      node.data = resizeFileData(node.data, length);
+      node.mtimeMs = Date.now();
       callback(null);
     },
-    ftruncate(_fd, _length, callback) {
+    ftruncate(fd, length, callback) {
+      // Pipe ends and the reserved stdout/stderr fds have no truncatable file.
+      if (pipes.has(fd)) {
+        callback(new MemFSError("EINVAL", "ftruncate"));
+        return;
+      }
+      const entry = fdTable.get(fd);
+      if (!entry) {
+        callback(new MemFSError("EBADF", "ftruncate"));
+        return;
+      }
+      if (entry.isStdout || entry.isStderr) {
+        callback(new MemFSError("EINVAL", "ftruncate"));
+        return;
+      }
+      const node = nodes.get(entry.path);
+      if (!node || node.kind !== "file") {
+        callback(new MemFSError("EINVAL", "ftruncate", entry.path));
+        return;
+      }
+      if (!Number.isInteger(length) || length < 0) {
+        callback(new MemFSError("EINVAL", "ftruncate", entry.path));
+        return;
+      }
+      node.data = resizeFileData(node.data, length);
+      node.mtimeMs = Date.now();
       callback(null);
     },
     pipe2(_flags, callback) {

package/shim-vendor/shim/checker/signature_api_completeness.go

@@ -1,58 +0,0 @@
-package checker
-
-// Compile-time guard: the signature-introspection surface that typia's
-// plain.classify from/new construction-strategy detection depends on must
-// compose end-to-end through the shim.
-//
-// 0.15.5 exposed a CONSUMER of a *Signature (Checker_getMinArgumentCount)
-// without the PRODUCER that yields one (Checker_getSignaturesOfType): a
-// *Signature was nameable (the `Signature` alias) but unobtainable. The closure
-// auditor checks that every escaping type can be NAMED, not that it can be
-// PRODUCED, so it did not catch the gap and the feature stayed blocked.
-//
-// This lives in a NORMAL (non-_test) file on purpose. The shim/checker package
-// is a nested Go module that no CI job runs `go test` against, so a _test.go
-// guard would never be compiled and would silently stop guarding. As ordinary
-// package code it is type-checked by every build that links the shim (typia's
-// native plugin, ttsc's lint engine), so dropping or renaming any leg below
-// turns those builds red. It never runs (assigned to blank, never called).
-var _ = func(c *Checker, instanceType *Type) {
-  // class instance type -> class symbol -> constructor (static) type, which
-  // carries both the construct signatures and the static `from` member.
-  classSymbol := Type_getTypeNameSymbol(instanceType)
-  ctorType := Checker_getTypeOfSymbol(c, classSymbol)
-
-  // `new C(seed)` strategy: construct signatures -> arity (min args +
-  // parameter count, together disambiguating `()` from `(x?)`) -> return type
-  // -> the seed parameter's type. The seed is Signature_parameters[0]'s type,
-  // EXCEPT a rest-ONLY parameter `(...xs: S[])` — when
-  // `hasRestParameter && parameterCount == 1` — whose seed is the rest ELEMENT
-  // (getRestTypeOfSignature). A leading-required + rest-tail `(s, ...r)` still
-  // has hasRestParameter true but its seed is the first parameter S.
-  for _, sig := range Checker_getSignaturesOfType(c, ctorType, SignatureKindConstruct) {
-    _ = Checker_getMinArgumentCount(c, sig)
-    _ = Signature_parameterCount(sig)
-    _ = Checker_getReturnTypeOfSignature(c, sig)
-    if Signature_hasRestParameter(sig) {
-      _ = Checker_getRestTypeOfSignature(c, sig)
-    }
-    for _, p := range Signature_parameters(sig) {
-      _ = Checker_getTypeOfSymbol(c, p)
-    }
-  }
-
-  // `C.from(seed)` strategy: static `from` member -> its call signatures, read
-  // identically (arity, return type, seed parameter / rest element type).
-  fromType := Checker_getTypeOfPropertyOfType(c, ctorType, "from")
-  for _, sig := range Checker_getSignaturesOfType(c, fromType, SignatureKindCall) {
-    _ = Checker_getMinArgumentCount(c, sig)
-    _ = Signature_parameterCount(sig)
-    _ = Checker_getReturnTypeOfSignature(c, sig)
-    if Signature_hasRestParameter(sig) {
-      _ = Checker_getRestTypeOfSignature(c, sig)
-    }
-    for _, p := range Signature_parameters(sig) {
-      _ = Checker_getTypeOfSymbol(c, p)
-    }
-  }
-}