@ttsc/playground 0.22.0 → 0.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/playground",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "Reusable React + Web Worker scaffolding for in-browser ttsc playgrounds built on @ttsc/wasm.",
   "main": "lib/src/index.js",
   "types": "lib/src/index.d.ts",
@@ -39,7 +39,7 @@
     "react": "^18.0.0",
     "react-dom": "^18.0.0",
     "tgrid": "^1.0.3",
-    "@ttsc/wasm": "^0.22.0"
+    "@ttsc/wasm": "^0.23.0"
   },
   "devDependencies": {
     "@monaco-editor/react": "^4.6.0",
@@ -52,7 +52,7 @@
     "rimraf": "^6.1.2",
     "tgrid": "^1.0.3",
     "typescript": "^7.0.2",
-    "@ttsc/wasm": "^0.22.0"
+    "@ttsc/wasm": "^0.23.0"
   },
   "keywords": [
     "ttsc",

package/src/compiler/internal/createWorkerCompilerService.ts

@@ -6,11 +6,12 @@
 // service — including plugin success/failure interpretation — can be exercised
 // against a fake `IBootResult` without building or booting WASM. The public
 // wrapper supplies the real `bootTtsc` / `parseResult`.
-import type {
-  IBootResult,
-  IBootTtscOptions,
-  ITtscCompileResult,
-  ITtscResult,
+import {
+  BootTtscWorkerTerminationError,
+  type IBootResult,
+  type IBootTtscOptions,
+  type ITtscCompileResult,
+  type ITtscResult,
 } from "@ttsc/wasm";
 
 import type { ICompilerService } from "../../structures/ICompilerService";
@@ -84,26 +85,51 @@ export function createWorkerCompilerService(
     compilerOptions: extraCompilerOptions,
   });
 
-  // Cache the boot promise across calls. If the boot rejects we clear the
-  // cache so the next call retries — otherwise every later compile/bundle/
-  // lint would replay the same rejection forever (page reload required).
-  // Mirrors the createCompilerClient (UI-side) pattern.
-  let boot: Promise<IBootResult> | null = null;
-  function getBoot(): Promise<IBootResult> {
-    if (boot) return boot;
-    boot = (async () => {
-      const result = await deps.bootTtsc({
+  // Cache the runtime separately from the optional source-pack mount. A mount
+  // runs after Go is ready, so retrying a failed mount must reuse that runtime
+  // instead of calling bootTtsc again in the same Worker.
+  //
+  // Pre-runtime failures clear the runtime cache so the next call can retry. A
+  // post-go.run failure stays cached because the old runtime cannot be stopped
+  // and must never receive a replacement Ready bridge in the same Worker. The
+  // UI retry resets the compiler client, which terminates this Worker and
+  // creates a safe replacement.
+  let runtimeBoot: Promise<IBootResult> | null = null;
+  function getRuntimeBoot(): Promise<IBootResult> {
+    if (runtimeBoot) return runtimeBoot;
+    let attempt!: Promise<IBootResult>;
+    attempt = (async () =>
+      deps.bootTtsc({
         wasmUrl: options.wasmUrl,
         wasmExecUrl: options.wasmExecUrl,
         apiName: options.apiName,
-      });
+      }))().catch((err) => {
+      if (
+        !(err instanceof BootTtscWorkerTerminationError) &&
+        runtimeBoot === attempt
+      ) {
+        runtimeBoot = null;
+      }
+      throw err;
+    });
+    runtimeBoot = attempt;
+    return attempt;
+  }
+
+  let boot: Promise<IBootResult> | null = null;
+  function getBoot(): Promise<IBootResult> {
+    if (boot) return boot;
+    let attempt!: Promise<IBootResult>;
+    attempt = (async () => {
+      const result = await getRuntimeBoot();
       if (typiaPlugin?.mount) await typiaPlugin.mount(result.host, workDir);
       return result;
     })().catch((err) => {
-      boot = null;
+      if (boot === attempt) boot = null;
       throw err;
     });
-    return boot;
+    boot = attempt;
+    return attempt;
   }
 
   // Serialize every MemFS-mutating call. tgrid queues incoming messages, but

package/src/compiler/loadTypiaSourcePack.ts

@@ -1,37 +1,179 @@
 import type { IInstallTypiaSourcePackOptions } from "../structures/IInstallTypiaSourcePackOptions";
 
-const packCache = new Map<string, Promise<Record<string, string>>>();
+interface SourcePackEntry {
+  controller: AbortController;
+  promise: Promise<Record<string, string>>;
+}
+
+interface SourcePackCancellationReason {
+  kind: "abort" | "timeout";
+  reason?: unknown;
+  timeoutMs?: number;
+}
+
+interface SourcePackCancellation {
+  promise: Promise<never>;
+  dispose: () => void;
+}
+
+export const DEFAULT_SOURCE_PACK_TIMEOUT_MS = 30_000;
+
+const packCache = new Map<string, SourcePackEntry>();
 
 /**
- * Fetch the typia source pack JSON. Cached per URL across calls. On rejection
- * the cache entry is cleared so the next call retries — otherwise a transient
- * fetch failure during the first boot would wedge every later boot through
- * `getBoot`'s typiaPlugin.mount path.
+ * Fetch the typia source pack JSON once per URL.
+ *
+ * Concurrent callers share one load. A caller abort or deadline cancels that
+ * shared attempt; rejection removes it from the cache so the next call retries
+ * from scratch. The deadline covers both the response and its JSON body.
  */
 export function loadTypiaSourcePack(
   options: IInstallTypiaSourcePackOptions,
 ): Promise<Record<string, string>> {
+  const timeoutMs = resolveSourcePackTimeout(options.timeoutMs);
   const cached = packCache.get(options.url);
-  if (cached) return cached;
+  if (cached) {
+    attachSourcePackCancellation(cached, options.signal, timeoutMs);
+    return cached.promise;
+  }
+
   const fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
   if (!fetchImpl) {
     throw new Error(
       "loadTypiaSourcePack: no fetch implementation available in this environment.",
     );
   }
+
   const url = options.url;
+  const controller = new AbortController();
+  let phase = `fetching ${url}`;
+  const cancellation = createSourcePackCancellation(
+    controller.signal,
+    () => phase,
+  );
+  let entry!: SourcePackEntry;
   const promise = (async () => {
-    const response = await fetchImpl(url);
+    const response = await raceSourcePackCancellation(
+      fetchImpl(url, { signal: controller.signal }),
+      cancellation.promise,
+      controller.signal,
+      () => phase,
+    );
     if (!response.ok) {
       throw new Error(
         `loadTypiaSourcePack: failed to fetch ${url}: ${response.status}`,
       );
     }
-    return (await response.json()) as Record<string, string>;
-  })().catch((err) => {
-    packCache.delete(url);
-    throw err;
-  });
-  packCache.set(url, promise);
+
+    phase = `reading JSON from ${url}`;
+    return (await raceSourcePackCancellation(
+      response.json(),
+      cancellation.promise,
+      controller.signal,
+      () => phase,
+    )) as Record<string, string>;
+  })()
+    .catch((error) => {
+      if (packCache.get(url) === entry) packCache.delete(url);
+      throw error;
+    })
+    .finally(cancellation.dispose);
+
+  entry = { controller, promise };
+  packCache.set(url, entry);
+  attachSourcePackCancellation(entry, options.signal, timeoutMs);
   return promise;
 }
+
+function resolveSourcePackTimeout(timeoutMs: number | undefined): number {
+  const value = timeoutMs ?? DEFAULT_SOURCE_PACK_TIMEOUT_MS;
+  if (!Number.isSafeInteger(value) || value <= 0 || value > 2_147_483_647) {
+    throw new RangeError(
+      "loadTypiaSourcePack: timeoutMs must be a positive integer no greater than 2147483647.",
+    );
+  }
+  return value;
+}
+
+function attachSourcePackCancellation(
+  entry: SourcePackEntry,
+  callerSignal: AbortSignal | undefined,
+  timeoutMs: number,
+): void {
+  const abortFromCaller = (): void => {
+    if (!entry.controller.signal.aborted) {
+      entry.controller.abort({
+        kind: "abort",
+        reason: callerSignal?.reason,
+      } satisfies SourcePackCancellationReason);
+    }
+  };
+  if (callerSignal?.aborted) abortFromCaller();
+  else callerSignal?.addEventListener("abort", abortFromCaller, { once: true });
+
+  const timer = setTimeout(() => {
+    if (!entry.controller.signal.aborted) {
+      entry.controller.abort({
+        kind: "timeout",
+        timeoutMs,
+      } satisfies SourcePackCancellationReason);
+    }
+  }, timeoutMs);
+  const cleanup = (): void => {
+    clearTimeout(timer);
+    callerSignal?.removeEventListener("abort", abortFromCaller);
+  };
+  void entry.promise.then(cleanup, cleanup);
+}
+
+function createSourcePackCancellation(
+  signal: AbortSignal,
+  getPhase: () => string,
+): SourcePackCancellation {
+  let rejectCancellation!: (error: Error) => void;
+  const promise = new Promise<never>((_resolve, reject) => {
+    rejectCancellation = reject;
+  });
+  const onAbort = (): void => {
+    rejectCancellation(sourcePackCancellationError(signal, getPhase()));
+  };
+  signal.addEventListener("abort", onAbort, { once: true });
+  if (signal.aborted) onAbort();
+  return {
+    promise,
+    dispose: () => signal.removeEventListener("abort", onAbort),
+  };
+}
+
+async function raceSourcePackCancellation<T>(
+  work: Promise<T>,
+  cancellation: Promise<never>,
+  signal: AbortSignal,
+  getPhase: () => string,
+): Promise<T> {
+  try {
+    return await Promise.race([work, cancellation]);
+  } catch (error) {
+    if (signal.aborted) {
+      throw sourcePackCancellationError(signal, getPhase());
+    }
+    throw error;
+  }
+}
+
+function sourcePackCancellationError(
+  signal: AbortSignal,
+  phase: string,
+): Error {
+  const reason = signal.reason as SourcePackCancellationReason | undefined;
+  if (reason?.kind === "timeout") {
+    return new Error(
+      `loadTypiaSourcePack: timed out after ${reason.timeoutMs}ms while ${phase}.`,
+    );
+  }
+
+  const error = new Error(`loadTypiaSourcePack: aborted while ${phase}.`);
+  const cause = reason?.kind === "abort" ? reason.reason : signal.reason;
+  if (cause !== undefined) (error as Error & { cause?: unknown }).cause = cause;
+  return error;
+}

package/src/compiler/normalizeError.ts

@@ -1,7 +1,20 @@
 /** Best-effort error normalization for tgrid transport. */
 export function normalizeError(error: unknown): unknown {
-  if (error instanceof Error)
-    return { name: error.name, message: error.message, stack: error.stack };
+  if (error instanceof Error) {
+    const normalized: {
+      code?: string;
+      message: string;
+      name: string;
+      stack?: string;
+    } = {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+    };
+    const code = (error as Error & { code?: unknown }).code;
+    if (typeof code === "string") normalized.code = code;
+    return normalized;
+  }
   if (
     error &&
     typeof error === "object" &&

package/src/index.ts

@@ -24,7 +24,10 @@ export { DEFAULT_WORK_DIR } from "./compiler/DEFAULT_WORK_DIR";
 export { installDependenciesIntoMemFS } from "./compiler/installDependenciesIntoMemFS";
 export { installTypiaSourcePack } from "./compiler/installTypiaSourcePack";
 export { lineColumnOf } from "./compiler/lineColumnOf";
-export { loadTypiaSourcePack } from "./compiler/loadTypiaSourcePack";
+export {
+  DEFAULT_SOURCE_PACK_TIMEOUT_MS,
+  loadTypiaSourcePack,
+} from "./compiler/loadTypiaSourcePack";
 export { mapDiagnostic } from "./compiler/mapDiagnostic";
 export { normalizeError } from "./compiler/normalizeError";
 export { normalizeNodeModulePath } from "./compiler/normalizeNodeModulePath";
@@ -38,7 +41,10 @@ export { packageNameFromSpecifier } from "./npm/packageNameFromSpecifier";
 
 // ── typia runtime sandbox (CJS-flavoured require over a pack JSON) ────────
 export { createSandboxRequire } from "./sandbox/createSandboxRequire";
-export { loadTypiaRuntimePack } from "./sandbox/loadTypiaRuntimePack";
+export {
+  DEFAULT_RUNTIME_PACK_TIMEOUT_MS,
+  loadTypiaRuntimePack,
+} from "./sandbox/loadTypiaRuntimePack";
 
 // ── React UI surface ──────────────────────────────────────────────────────
 export { ConsoleViewer } from "./react/ConsoleViewer";