@ttsc/playground 0.14.0-dev.20250530.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jeongho Nam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,191 @@
+# @ttsc/playground
+
+> **API stability: experimental until v1.0.** Public signatures (the `createWorkerCompiler` options, `ICompilerService` contract, React component props) may change between minor releases. Pin exact versions in production playgrounds.
+
+Reusable Web Worker + React scaffolding for in-browser [`ttsc`](https://ttsc.dev) playgrounds. Built on top of [`@ttsc/wasm`](https://github.com/samchon/ttsc/tree/master/packages/wasm).
+
+The package handles the parts every browser playground needs, worker boot, MemFS layout, race-guarded compile / lint / bundle calls, on-the-fly npm dependency installer, typia source-pack mounting, console-capturing execute sandbox, and ships a Tailwind-styled React shell that wires them all up. Sites supply the wasm URL, a default script, and (optionally) examples, brand slot, and an execute callback.
+
+The ttsc website (`ttsc.dev`) and the typia website (`typia.io`) are the two reference consumers.
+
+## Install
+
+```bash
+npm install @ttsc/playground @ttsc/wasm \
+  @monaco-editor/react monaco-editor react react-dom tgrid tailwindcss
+```
+
+`@monaco-editor/react`, `monaco-editor`, `react`, `react-dom`, `tgrid`, and `@ttsc/wasm` are **peer dependencies**. `lz-string` is bundled.
+
+The React components use Tailwind 4 utility classes. See [Tailwind setup](#tailwind-setup) below.
+
+## What you get
+
+| Layer | Exports |
+| --- | --- |
+| **Worker core** | `createWorkerCompiler`, `buildTsconfigJSON`, `installDependenciesIntoMemFS`, `mapDiagnostic`, `pickEmittedJS`, `DEFAULT_*` constants |
+| **Typia integration** | `createTypiaSourcePackMount`, `installTypiaSourcePack`, `loadTypiaSourcePack` |
+| **Npm installer** | `installPlaygroundDependencies`, `collectExternalPackageNames`, `packageNameFromSpecifier`, `BUILT_IN_PLAYGROUND_PACKAGES` |
+| **Execute sandbox** | `createSandboxRequire`, `loadTypiaRuntimePack` |
+| **React UI** | `PlaygroundShell`, `SourceEditor`, `ResultViewer`, `ConsoleViewer`, `OptionsPanel`, `DiagnosticsPanel`, `DependencyProgressModal`, `ExamplePicker`, `LintPane`, `createCompilerClient`, `DEFAULT_OPTION_TOGGLES` |
+| **Types** | Everything under `./src/structures/` |
+
+## Architecture
+
+```
+┌─ Browser tab ───────────────────────────────────────────┐
+│                                                         │
+│  <PlaygroundShell>            ─── tgrid RPC ───┐        │
+│      ↳ SourceEditor (Monaco)                   │        │
+│      ↳ ResultViewer                            ▼        │
+│      ↳ ConsoleViewer                  ┌────────────────┐│
+│      ↳ DiagnosticsPanel               │  Web Worker    ││
+│      ↳ DependencyProgressModal        │                ││
+│      ↳ ExamplePicker                  │  createWorker  ││
+│      ↳ OptionsPanel                   │   Compiler()   ││
+│      ↳ LintPane                       │       ↓        ││
+│                                       │  @ttsc/wasm    ││
+│  (UI installs runtime npm deps        │   bootTtsc()   ││
+│   into the same worker MemFS via      │       ↓        ││
+│   service.installDependencies())      │  MemFS         ││
+│                                       │   └─ /work/…   ││
+│                                       │  ttsc.wasm     ││
+│                                       └────────────────┘│
+└─────────────────────────────────────────────────────────┘
+```
+
+## Worker entry (site-side)
+
+The worker entry is two lines. Wire the wasm URL the site ships and the `apiName` you used in `host.Expose` when you built the wasm.
+
+```ts
+// site/src/compiler/index.ts (rspack target: "webworker")
+import { createWorkerCompiler } from "@ttsc/playground";
+import { WorkerServer } from "tgrid";
+
+const service = createWorkerCompiler({
+  wasmUrl: "/compiler/playground.wasm",
+  wasmExecUrl: "/compiler/wasm_exec.js",
+  apiName: "ttscPlayground",
+});
+
+await new WorkerServer().open(service);
+```
+
+Bundle this file with rspack/webpack/vite as a webworker target and serve the output (e.g. at `/compiler/index.js`).
+
+## UI shell (site-side)
+
+```tsx
+// site/src/components/playground/PlaygroundShell.tsx
+"use client";
+import { PlaygroundShell } from "@ttsc/playground";
+import { PLAYGROUND_DEFAULT_SCRIPT, PLAYGROUND_EXAMPLES } from "../...";
+
+export default function SitePlayground() {
+  return (
+    <PlaygroundShell
+      workerUrl="/compiler/index.js"
+      defaultScript={PLAYGROUND_DEFAULT_SCRIPT}
+      examples={PLAYGROUND_EXAMPLES}
+      brand={<a href="/">my-site</a>}
+      executeBundle={async (code, sandbox) => {
+        // run the compiled JS however you like; route console.* into sandbox.console
+        new Function("console", code)(sandbox.console);
+      }}
+    />
+  );
+}
+```
+
+## Typia integration (optional)
+
+When the wasm bundles the typia transform plugin, mount typia's source tree into the MemFS so `import typia from "typia"` resolves:
+
+```ts
+import {
+  createTypiaSourcePackMount,
+  createWorkerCompiler,
+} from "@ttsc/playground";
+
+const service = createWorkerCompiler({
+  wasmUrl: "/compiler/playground.wasm",
+  apiName: "ttscPlayground",
+  typiaPlugin: {
+    name: "typia",
+    transformModule: "typia/lib/transform",
+    mount: createTypiaSourcePackMount({
+      url: "/compiler/typia-pack.json",
+    }),
+  },
+});
+```
+
+The typia pack itself is built by the site (typically with a `pack-typia-sources.cjs`-style script that bundles `typia/`, `@typia/utils`, and `@typia/interface` into a flat JSON map). See the ttsc website's [`build/pack-typia-sources.cjs`](https://github.com/samchon/ttsc/blob/master/website/build/pack-typia-sources.cjs) for the reference implementation.
+
+## Runtime npm dependency installer
+
+When the user types `import {v4} from "uuid"`, the shell auto-fetches `uuid` (and its transitive deps) from the npm registry, unpacks the tgz in the browser, and mounts the files into the wasm MemFS, no proxy server needed.
+
+```ts
+import {
+  collectExternalPackageNames,
+  installPlaygroundDependencies,
+} from "@ttsc/playground";
+
+const names = collectExternalPackageNames(userSource);
+const installed = await installPlaygroundDependencies(names, {
+  onProgress: (p) => console.log(p.phase, p.packageName),
+});
+// mount installed.compilerFiles into the wasm MemFS via service.installDependencies
+```
+
+`PlaygroundShell` wires this automatically on every keystroke, debounced 900 ms, with an abort signal on source change.
+
+## Tailwind setup
+
+The bundled React components use Tailwind 4 utility classes. The host site must load Tailwind for them to render correctly.
+
+`postcss.config.mjs`:
+
+```js
+const config = { plugins: { "@tailwindcss/postcss": {} } };
+export default config;
+```
+
+`src/app/global.css`:
+
+```css
+@import "tailwindcss";
+
+/* Tell Tailwind 4 to scan @ttsc/playground's compiled output for utility
+   classes. Tailwind 4's @source takes a literal glob relative to this
+   CSS file — adjust the leading `../` segments to match how deep the
+   CSS file lives. Tailwind 4 follows the pnpm symlink at
+   node_modules/@ttsc/playground transparently. */
+@source "../../node_modules/@ttsc/playground/lib/**/*.js";
+```
+
+Then `import "./global.css"` from the root layout.
+
+**`@ttsc/playground` must be a direct dependency** of the consuming package. Tailwind only scans paths the consumer points at. A transitively-installed copy (where @ttsc/playground is a dep of another package) lives under a different node_modules layout and the glob above won't find it without explicit re-targeting.
+
+## Booting a custom wasm
+
+`createWorkerCompiler` is plugin-agnostic. To register a custom plugin set:
+
+1. Write a Go `main_wasm.go` that calls `host.Expose("myApi", host.Config{ Plugins: [...] })`. See [`@ttsc/wasm`](https://github.com/samchon/ttsc/tree/master/packages/wasm) for the host helper and the plugin contract.
+2. Build the wasm with `GOOS=js GOARCH=wasm go build`.
+3. Ship the wasm at any URL and pass it to `createWorkerCompiler({wasmUrl, apiName})`.
+
+If the wasm registers plugins other than typia / `@ttsc/lint`, pass `typiaPlugin: false` / `lintPlugin: false` to skip those default dispatchers and use your own toggles via `optionToggles` + a custom worker wrapper.
+
+## Conventions
+
+- **One type per file.** Public interfaces / types each live under `src/structures/` in a file named after the type. The barrel `structures/index.ts` re-exports everything.
+- **One public function per file.** Internal helpers may be grouped in `compiler/internal/` or `npm/internal/`.
+- **No sub-path exports.** Every public symbol is importable from the package root. Add a sub-path later only when a real consumer needs to avoid pulling React into a Node-only context.
+
+## Documents
+
+See the [`@ttsc/playground` guide](https://ttsc.dev/docs/playground) for the site-walkthrough version of this README.

package/lib/src/compiler/DEFAULT_ENTRY_FILE.d.ts

@@ -0,0 +1,2 @@
+/** Default entry source file inside the work dir. */
+export declare const DEFAULT_ENTRY_FILE = "src/playground.ts";

package/lib/src/compiler/DEFAULT_ENTRY_FILE.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ENTRY_FILE = void 0;
+/** Default entry source file inside the work dir. */
+exports.DEFAULT_ENTRY_FILE = "src/playground.ts";
+//# sourceMappingURL=DEFAULT_ENTRY_FILE.js.map

package/lib/src/compiler/DEFAULT_ENTRY_FILE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DEFAULT_ENTRY_FILE.js","sourceRoot":"","sources":["../../../src/compiler/DEFAULT_ENTRY_FILE.ts"],"names":[],"mappings":";;;AAAA,qDAAqD;AACxC,QAAA,kBAAkB,GAAG,mBAAmB,CAAC"}

package/lib/src/compiler/DEFAULT_LINT_PLUGIN_NAME.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Default plugin id for the `@ttsc/lint` check verb. Override via the
+ * `lintPlugin.name` option of {@link createWorkerCompiler}.
+ */
+export declare const DEFAULT_LINT_PLUGIN_NAME = "@ttsc/lint";

package/lib/src/compiler/DEFAULT_LINT_PLUGIN_NAME.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_LINT_PLUGIN_NAME = void 0;
+/**
+ * Default plugin id for the `@ttsc/lint` check verb. Override via the
+ * `lintPlugin.name` option of {@link createWorkerCompiler}.
+ */
+exports.DEFAULT_LINT_PLUGIN_NAME = "@ttsc/lint";
+//# sourceMappingURL=DEFAULT_LINT_PLUGIN_NAME.js.map

package/lib/src/compiler/DEFAULT_LINT_PLUGIN_NAME.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DEFAULT_LINT_PLUGIN_NAME.js","sourceRoot":"","sources":["../../../src/compiler/DEFAULT_LINT_PLUGIN_NAME.ts"],"names":[],"mappings":";;;AAAA;;;GAGG;AACU,QAAA,wBAAwB,GAAG,YAAY,CAAC"}

package/lib/src/compiler/DEFAULT_PLAYGROUND_COMPILER_OPTIONS.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The compiler options every playground tsconfig opts into by default. Sites
+ * pass these straight to `buildTsconfigJSON`; consumer code that needs a tweak
+ * spreads the constant and overrides individual fields.
+ *
+ * `target` and `module` are TypeScript's numeric enum values (99 = ESNext, 199
+ * = NodeNext, …). They are spelled numerically here because the wasm doesn't
+ * run the TS configuration parser through a string→enum step before Go reads
+ * the JSON; passing the canonical numbers avoids version-drift.
+ */
+export declare const DEFAULT_PLAYGROUND_COMPILER_OPTIONS: {
+    readonly target: 99;
+    readonly esModuleInterop: true;
+    readonly forceConsistentCasingInFileNames: true;
+    readonly moduleResolution: 100;
+    readonly strict: true;
+    readonly skipLibCheck: true;
+    readonly experimentalDecorators: true;
+};

package/lib/src/compiler/DEFAULT_PLAYGROUND_COMPILER_OPTIONS.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PLAYGROUND_COMPILER_OPTIONS = void 0;
+/**
+ * The compiler options every playground tsconfig opts into by default. Sites
+ * pass these straight to `buildTsconfigJSON`; consumer code that needs a tweak
+ * spreads the constant and overrides individual fields.
+ *
+ * `target` and `module` are TypeScript's numeric enum values (99 = ESNext, 199
+ * = NodeNext, …). They are spelled numerically here because the wasm doesn't
+ * run the TS configuration parser through a string→enum step before Go reads
+ * the JSON; passing the canonical numbers avoids version-drift.
+ */
+exports.DEFAULT_PLAYGROUND_COMPILER_OPTIONS = {
+    target: 99,
+    esModuleInterop: true,
+    forceConsistentCasingInFileNames: true,
+    moduleResolution: 100,
+    strict: true,
+    skipLibCheck: true,
+    experimentalDecorators: true,
+};
+//# sourceMappingURL=DEFAULT_PLAYGROUND_COMPILER_OPTIONS.js.map

package/lib/src/compiler/DEFAULT_PLAYGROUND_COMPILER_OPTIONS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DEFAULT_PLAYGROUND_COMPILER_OPTIONS.js","sourceRoot":"","sources":["../../../src/compiler/DEFAULT_PLAYGROUND_COMPILER_OPTIONS.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;GASG;AACU,QAAA,mCAAmC,GAAG;IACjD,MAAM,EAAE,EAAE;IACV,eAAe,EAAE,IAAI;IACrB,gCAAgC,EAAE,IAAI;IACtC,gBAAgB,EAAE,GAAG;IACrB,MAAM,EAAE,IAAI;IACZ,YAAY,EAAE,IAAI;IAClB,sBAAsB,EAAE,IAAI;CACpB,CAAC"}

package/lib/src/compiler/DEFAULT_TSCONFIG_PATH.d.ts

@@ -0,0 +1,2 @@
+/** Default tsconfig path inside the work dir. */
+export declare const DEFAULT_TSCONFIG_PATH = "tsconfig.json";

package/lib/src/compiler/DEFAULT_TSCONFIG_PATH.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TSCONFIG_PATH = void 0;
+/** Default tsconfig path inside the work dir. */
+exports.DEFAULT_TSCONFIG_PATH = "tsconfig.json";
+//# sourceMappingURL=DEFAULT_TSCONFIG_PATH.js.map

package/lib/src/compiler/DEFAULT_TSCONFIG_PATH.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DEFAULT_TSCONFIG_PATH.js","sourceRoot":"","sources":["../../../src/compiler/DEFAULT_TSCONFIG_PATH.ts"],"names":[],"mappings":";;;AAAA,iDAAiD;AACpC,QAAA,qBAAqB,GAAG,eAAe,CAAC"}

package/lib/src/compiler/DEFAULT_TYPIA_PLUGIN_NAME.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Default plugin id for the typia transformer. Sites that wire a renamed typia
+ * plugin override via the `typiaPlugin.name` option of
+ * {@link createWorkerCompiler}.
+ */
+export declare const DEFAULT_TYPIA_PLUGIN_NAME = "typia";

package/lib/src/compiler/DEFAULT_TYPIA_PLUGIN_NAME.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TYPIA_PLUGIN_NAME = void 0;
+/**
+ * Default plugin id for the typia transformer. Sites that wire a renamed typia
+ * plugin override via the `typiaPlugin.name` option of
+ * {@link createWorkerCompiler}.
+ */
+exports.DEFAULT_TYPIA_PLUGIN_NAME = "typia";
+//# sourceMappingURL=DEFAULT_TYPIA_PLUGIN_NAME.js.map

package/lib/src/compiler/DEFAULT_TYPIA_PLUGIN_NAME.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DEFAULT_TYPIA_PLUGIN_NAME.js","sourceRoot":"","sources":["../../../src/compiler/DEFAULT_TYPIA_PLUGIN_NAME.ts"],"names":[],"mappings":";;;AAAA;;;;GAIG;AACU,QAAA,yBAAyB,GAAG,OAAO,CAAC"}

package/lib/src/compiler/DEFAULT_WORK_DIR.d.ts

@@ -0,0 +1,2 @@
+/** Default in-MemFS project root mounted by {@link createWorkerCompiler}. */
+export declare const DEFAULT_WORK_DIR = "/work";

package/lib/src/compiler/DEFAULT_WORK_DIR.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_WORK_DIR = void 0;
+/** Default in-MemFS project root mounted by {@link createWorkerCompiler}. */
+exports.DEFAULT_WORK_DIR = "/work";
+//# sourceMappingURL=DEFAULT_WORK_DIR.js.map

package/lib/src/compiler/DEFAULT_WORK_DIR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DEFAULT_WORK_DIR.js","sourceRoot":"","sources":["../../../src/compiler/DEFAULT_WORK_DIR.ts"],"names":[],"mappings":";;;AAAA,6EAA6E;AAChE,QAAA,gBAAgB,GAAG,OAAO,CAAC"}

package/lib/src/compiler/buildTsconfigJSON.d.ts

@@ -0,0 +1,9 @@
+import type { IBuildTsconfigOptions } from "../structures/IBuildTsconfigOptions";
+/**
+ * Serialize a tsconfig JSON document the wasm-side compiler can consume.
+ *
+ * `buildTsconfigJSON` is deliberately conservative — it returns a string the
+ * caller writes to MemFS as-is, so there's no schema validation here. Bad
+ * compiler options surface as wasm-side errors on the next build call.
+ */
+export declare function buildTsconfigJSON(options: IBuildTsconfigOptions): string;

package/lib/src/compiler/buildTsconfigJSON.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTsconfigJSON = buildTsconfigJSON;
+const DEFAULT_PLAYGROUND_COMPILER_OPTIONS_1 = require("./DEFAULT_PLAYGROUND_COMPILER_OPTIONS");
+/**
+ * Serialize a tsconfig JSON document the wasm-side compiler can consume.
+ *
+ * `buildTsconfigJSON` is deliberately conservative — it returns a string the
+ * caller writes to MemFS as-is, so there's no schema validation here. Bad
+ * compiler options surface as wasm-side errors on the next build call.
+ */
+function buildTsconfigJSON(options) {
+    return JSON.stringify({
+        compilerOptions: {
+            ...DEFAULT_PLAYGROUND_COMPILER_OPTIONS_1.DEFAULT_PLAYGROUND_COMPILER_OPTIONS,
+            module: options.module,
+            outDir: options.outDir ?? "dist",
+            rootDir: options.rootDir ?? "src",
+            ...(options.compilerOptions ?? {}),
+        },
+        include: options.include ?? ["src"],
+    });
+}
+//# sourceMappingURL=buildTsconfigJSON.js.map

package/lib/src/compiler/buildTsconfigJSON.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildTsconfigJSON.js","sourceRoot":"","sources":["../../../src/compiler/buildTsconfigJSON.ts"],"names":[],"mappings":";;;AACA,+FAA4F;AAE5F;;;;;;GAMG;AACH,2BAAkC,OAA8B;IAC9D,OAAO,IAAI,CAAC,SAAS,CAAC;QACpB,eAAe,EAAE;YACf,GAAG,yEAAmC;YACtC,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,MAAM,EAAE,OAAO,CAAC,MAAM,IAAI,MAAM;YAChC,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,KAAK;YACjC,GAAG,CAAC,OAAO,CAAC,eAAe,IAAI,EAAE,CAAC;SACnC;QACD,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC;KACpC,CAAC,CAAC;AACL,CAAC"}

package/lib/src/compiler/createTypiaSourcePackMount.d.ts

@@ -0,0 +1,11 @@
+import type { IMemFSHost } from "@ttsc/wasm";
+import type { IInstallTypiaSourcePackOptions } from "../structures/IInstallTypiaSourcePackOptions";
+/**
+ * Build a `mount` callback for the `typiaPlugin` config of
+ * {@link createWorkerCompiler}.
+ *
+ * The returned function fetches the pack once (cached per URL by
+ * {@link loadTypiaSourcePack}) and writes every entry to the MemFS the first
+ * time it is invoked on a given host.
+ */
+export declare function createTypiaSourcePackMount(options: IInstallTypiaSourcePackOptions): (host: IMemFSHost, workDir?: string) => Promise<void>;

package/lib/src/compiler/createTypiaSourcePackMount.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTypiaSourcePackMount = createTypiaSourcePackMount;
+const installTypiaSourcePack_1 = require("./installTypiaSourcePack");
+/**
+ * Build a `mount` callback for the `typiaPlugin` config of
+ * {@link createWorkerCompiler}.
+ *
+ * The returned function fetches the pack once (cached per URL by
+ * {@link loadTypiaSourcePack}) and writes every entry to the MemFS the first
+ * time it is invoked on a given host.
+ */
+function createTypiaSourcePackMount(options) {
+    return async (host, workDir) => {
+        // Honor the caller's workDir when the site did not pin mountRoot
+        // explicitly. Otherwise a `createWorkerCompiler({workDir: '/foo'})`
+        // would still mount typia under `/work/node_modules/` and tsgo would
+        // never resolve `typia` from the project root.
+        //
+        // `workDir` is intentionally optional so callers built against the
+        // previous single-arg signature (`mount(host)`) keep working — when
+        // both mountRoot and workDir are absent, installTypiaSourcePack falls
+        // back to its own default (`/work/node_modules`).
+        const mountRoot = options.mountRoot ??
+            (workDir ? `${workDir.replace(/\/+$/, "")}/node_modules` : undefined);
+        await (0, installTypiaSourcePack_1.installTypiaSourcePack)(host, { ...options, mountRoot });
+    };
+}
+//# sourceMappingURL=createTypiaSourcePackMount.js.map

package/lib/src/compiler/createTypiaSourcePackMount.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTypiaSourcePackMount.js","sourceRoot":"","sources":["../../../src/compiler/createTypiaSourcePackMount.ts"],"names":[],"mappings":";;;AAGA,qEAAkE;AAElE;;;;;;;GAOG;AACH,oCACE,OAAuC;IAEvC,OAAO,KAAK,EAAE,IAAgB,EAAE,OAAgB,EAAE,EAAE;QAClD,iEAAiE;QACjE,oEAAoE;QACpE,qEAAqE;QACrE,+CAA+C;QAC/C,EAAE;QACF,mEAAmE;QACnE,oEAAoE;QACpE,sEAAsE;QACtE,kDAAkD;QAClD,MAAM,SAAS,GACb,OAAO,CAAC,SAAS;YACjB,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,eAAe,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QACxE,MAAM,IAAA,+CAAsB,EAAC,IAAI,EAAE,EAAE,GAAG,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC;IAChE,CAAC,CAAC;AACJ,CAAC"}

package/lib/src/compiler/createWorkerCompiler.d.ts

@@ -0,0 +1,25 @@
+import type { ICompilerService } from "../structures/ICompilerService";
+import type { ICreateWorkerCompilerOptions } from "../structures/ICreateWorkerCompilerOptions";
+/**
+ * Build an `ICompilerService` ready to register with tgrid's `WorkerServer`.
+ *
+ * Usage in the worker entry:
+ *
+ * ```ts
+ * import { createWorkerCompiler } from "@ttsc/playground";
+ * import { WorkerServer } from "tgrid";
+ *
+ * const service = createWorkerCompiler({
+ *   wasmUrl: "/compiler/playground.wasm",
+ *   apiName: "ttscPlayground",
+ *   typiaPlugin: { mount: installTypiaPack },
+ * });
+ *
+ * const main = async () => {
+ *   const worker = new WorkerServer();
+ *   await worker.open(service);
+ * };
+ * void main();
+ * ```
+ */
+export declare function createWorkerCompiler(options: ICreateWorkerCompilerOptions): ICompilerService;