ttsc 0.16.3 → 0.16.6

package/lib/TtscService.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TtscService = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const startResidentTransform_1 = require("./compiler/internal/startResidentTransform");
+/**
+ * Resident, incremental transform service for the `ttsc` TypeScript-Go
+ * pipeline.
+ *
+ * Where {@link TtscCompiler.transform} spawns a fresh process and recompiles the
+ * whole project on every call, `TtscService` keeps one long-lived host warm: it
+ * compiles the project once and then answers per-file transform requests from
+ * that warm program. A single service instance transforms many files (a watch
+ * server, an editor session, a codegen tool) while paying the project compile
+ * once instead of once per file. Sharing one host across separate worker
+ * processes (a Metro worker pool) is tracked in samchon/ttsc#255.
+ *
+ * The shape mirrors a legacy TypeScript `LanguageService`: construct it against
+ * a project context, ask it to transform individual files, and dispose it when
+ * done. Construction is synchronous (it launches the host); the host compiles
+ * in the background, so the first {@link transformFile} resolves once that
+ * compile lands.
+ *
+ * Resident mode runs through the linked-plugin shared host, so the project must
+ * declare at least one transform-stage plugin; the constructor throws
+ * otherwise. It does not run check-stage plugins (unlike
+ * {@link TtscCompiler.transform}); only the program's own type-checking gates an
+ * {@link updateFile}.
+ */
+class TtscService {
+    resident;
+    projectRoot;
+    /**
+     * Create a service bound to the given project context and launch its resident
+     * host. The context is the same shape {@link TtscCompiler} accepts; it is not
+     * replaceable per call.
+     */
+    constructor(context = {}) {
+        const started = (0, startResidentTransform_1.startResidentTransform)({
+            ...context,
+            env: context.env ? { ...context.env } : undefined,
+            plugins: Array.isArray(context.plugins)
+                ? [...context.plugins]
+                : context.plugins,
+        });
+        this.resident = started.process;
+        this.projectRoot = started.projectRoot;
+    }
+    /**
+     * Return the transformed TypeScript source for one file, or `undefined` when
+     * the resident program does not contain it (for example a file excluded from
+     * the tsconfig). A relative `fileName` is resolved against the project root.
+     *
+     * Rejects when the resident host failed to compile the project; the rejection
+     * carries the host's diagnostics so callers can surface a real build error.
+     */
+    async transformFile(fileName) {
+        const reply = await this.resident.request({
+            file: this.absolutePath(fileName),
+        });
+        return reply.found === true && typeof reply.typescript === "string"
+            ? reply.typescript
+            : undefined;
+    }
+    /**
+     * Apply new in-memory content for one file and re-transform the project, so a
+     * subsequent {@link transformFile} reflects the edit without restarting the
+     * host. Returns whether the re-transform succeeded; `false` means the edit
+     * did not compile and the previous transform is still in effect. A relative
+     * `fileName` is resolved against the project root.
+     */
+    async updateFile(fileName, content) {
+        const reply = await this.resident.request({
+            content,
+            update: this.absolutePath(fileName),
+        });
+        return reply.updated === true;
+    }
+    /** Terminate the resident host and reject any in-flight requests. */
+    dispose() {
+        this.resident.dispose();
+    }
+    absolutePath(fileName) {
+        return node_path_1.default.isAbsolute(fileName)
+            ? fileName
+            : node_path_1.default.resolve(this.projectRoot, fileName);
+    }
+}
+exports.TtscService = TtscService;
+//# sourceMappingURL=TtscService.js.map

package/lib/TtscService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TtscService.js","sourceRoot":"","sources":["../src/TtscService.ts"],"names":[],"mappings":";;;;;;AAAA,0DAA6B;AAG7B,uFAAoF;AAGpF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IACmB,QAAQ,CAA2B;IACnC,WAAW,CAAS;IAErC;;;;OAIG;IACH,YAAmB,OAAO,GAAyB,EAAE;QACnD,MAAM,OAAO,GAAG,IAAA,+CAAsB,EAAC;YACrC,GAAG,OAAO;YACV,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,SAAS;YACjD,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC;gBACrC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;gBACtB,CAAC,CAAC,OAAO,CAAC,OAAO;SACpB,CAAC,CAAC;QACH,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;QAChC,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IACzC,CAAC;IAED;;;;;;;OAOG;IACI,KAAK,CAAC,aAAa,CAAC,QAAgB;QACzC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;YACxC,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC;SAClC,CAAC,CAAC;QACH,OAAO,KAAK,CAAC,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,CAAC,UAAU,KAAK,QAAQ;YACjE,CAAC,CAAC,KAAK,CAAC,UAAU;YAClB,CAAC,CAAC,SAAS,CAAC;IAChB,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,UAAU,CAAC,QAAgB,EAAE,OAAe;QACvD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;YACxC,OAAO;YACP,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC;SACpC,CAAC,CAAC;QACH,OAAO,KAAK,CAAC,OAAO,KAAK,IAAI,CAAC;IAChC,CAAC;IAED,qEAAqE;IAC9D,OAAO;QACZ,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;IAC1B,CAAC;IAEO,YAAY,CAAC,QAAgB;QACnC,OAAO,mBAAI,CAAC,UAAU,CAAC,QAAQ,CAAC;YAC9B,CAAC,CAAC,QAAQ;YACV,CAAC,CAAC,mBAAI,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;IAC/C,CAAC;CACF"}

package/lib/compiler/internal/residentTransformProcess.d.ts

@@ -0,0 +1,47 @@
+/** Options for spawning the resident transform host. */
+export interface ResidentTransformProcessOptions {
+    args: readonly string[];
+    binary: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * Async client for the long-lived `utility-host serve` process.
+ *
+ * The host transforms the whole project once at startup, caches every file's
+ * transformed TypeScript, then answers newline-delimited requests. This class
+ * speaks that protocol: each {@link request} writes one JSON line and the host
+ * replies with one line, matched FIFO. A transform request (`{"file":...}`) is
+ * answered with `{"typescript":...,"found":...}`, and an update request
+ * (`{"update":...,"content":...}`) with `{"updated":...}`.
+ *
+ * One resident process answers every request from one service instead of
+ * spawning a fresh `transform` subprocess per call, so a single process pays
+ * the project compile once (samchon/ttsc#255).
+ */
+export declare class ResidentTransformProcess {
+    private readonly child;
+    private readonly reader;
+    private readonly pending;
+    private stderr;
+    private failure;
+    constructor(options: ResidentTransformProcessOptions);
+    /**
+     * Send one request to the host and resolve with its parsed JSON reply. The
+     * host answers in FIFO order, so the caller interprets the reply shape by the
+     * payload it sent (a transform reply vs an update reply). Rejects when the
+     * host has already failed or exited, or if writing the request fails.
+     */
+    request(payload: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /**
+     * Terminate the resident process and reject any in-flight requests. Safe to
+     * call more than once.
+     */
+    dispose(): void;
+    private onLine;
+    private onReaderClose;
+    private fail;
+    private rejectAll;
+    private removePending;
+    private exitError;
+}

package/lib/compiler/internal/residentTransformProcess.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResidentTransformProcess = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_readline_1 = require("node:readline");
+/** Cap on retained stderr so a long-lived host cannot grow it without bound. */
+const STDERR_TAIL_LIMIT = 64 * 1024;
+/**
+ * Async client for the long-lived `utility-host serve` process.
+ *
+ * The host transforms the whole project once at startup, caches every file's
+ * transformed TypeScript, then answers newline-delimited requests. This class
+ * speaks that protocol: each {@link request} writes one JSON line and the host
+ * replies with one line, matched FIFO. A transform request (`{"file":...}`) is
+ * answered with `{"typescript":...,"found":...}`, and an update request
+ * (`{"update":...,"content":...}`) with `{"updated":...}`.
+ *
+ * One resident process answers every request from one service instead of
+ * spawning a fresh `transform` subprocess per call, so a single process pays
+ * the project compile once (samchon/ttsc#255).
+ */
+class ResidentTransformProcess {
+    child;
+    reader;
+    pending = [];
+    stderr = "";
+    failure;
+    constructor(options) {
+        // Default stdio is "pipe" for stdin/stdout/stderr, which is exactly what the
+        // line protocol needs; spelling it out as a string[] would not narrow to
+        // StdioOptions, so it is left implicit.
+        this.child = (0, node_child_process_1.spawn)(options.binary, [...options.args], {
+            cwd: options.cwd,
+            env: options.env,
+            windowsHide: true,
+        });
+        const stdout = this.child.stdout;
+        const stdin = this.child.stdin;
+        if (stdout === null || stdin === null) {
+            this.child.kill();
+            throw new Error("ttsc: resident transform host has no stdio pipes");
+        }
+        this.reader = (0, node_readline_1.createInterface)({ input: stdout });
+        this.reader.on("line", (line) => this.onLine(line));
+        // Drive completion off stdout's end, not the process "exit" event: every
+        // buffered "line" is delivered before "close", so a reply that arrived just
+        // before the host exited still resolves its request instead of racing the
+        // exit-time rejection.
+        this.reader.on("close", () => this.onReaderClose());
+        this.child.stderr?.on("data", (chunk) => {
+            const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+            // Keep only the tail: stderr is consulted for the crash message, and a
+            // long resident session can write diagnostics on every failed update.
+            this.stderr = (this.stderr + text).slice(-STDERR_TAIL_LIMIT);
+        });
+        this.child.on("error", (error) => this.fail(error));
+        // A dead host's pipes emit "error" (EPIPE on POSIX, often ECONNRESET on
+        // Windows). Without these listeners Node turns a pipe error into an uncaught
+        // exception that crashes the whole consumer process; route them through
+        // fail() (stderr is non-critical) so a pipe death fails in-flight requests
+        // instead, and also closes the window where stdin.destroyed has not flipped.
+        stdin.on("error", (error) => this.fail(error));
+        stdout.on("error", (error) => this.fail(error));
+        this.child.stderr?.on("error", () => { });
+    }
+    /**
+     * Send one request to the host and resolve with its parsed JSON reply. The
+     * host answers in FIFO order, so the caller interprets the reply shape by the
+     * payload it sent (a transform reply vs an update reply). Rejects when the
+     * host has already failed or exited, or if writing the request fails.
+     */
+    request(payload) {
+        if (this.failure !== undefined) {
+            return Promise.reject(this.failure);
+        }
+        const stdin = this.child.stdin;
+        if (stdin === null || stdin.destroyed) {
+            return Promise.reject(new Error("ttsc: resident transform host stdin is closed"));
+        }
+        return new Promise((resolve, reject) => {
+            const pending = { reject, resolve };
+            this.pending.push(pending);
+            stdin.write(`${JSON.stringify(payload)}\n`, (error) => {
+                if (error) {
+                    this.removePending(pending);
+                    reject(error);
+                }
+            });
+        });
+    }
+    /**
+     * Terminate the resident process and reject any in-flight requests. Safe to
+     * call more than once.
+     */
+    dispose() {
+        if (this.failure === undefined) {
+            // If the host already died, reject with its real exit error (stderr +
+            // exit code) rather than a bland "disposed" message.
+            this.failure =
+                this.child.exitCode !== null || this.child.signalCode !== null
+                    ? this.exitError()
+                    : new Error("ttsc: resident transform host disposed");
+        }
+        const stdin = this.child.stdin;
+        if (stdin !== null && !stdin.destroyed) {
+            stdin.end();
+        }
+        this.reader.close();
+        this.rejectAll(this.failure);
+        if (this.child.exitCode === null && this.child.signalCode === null) {
+            this.child.kill();
+        }
+    }
+    onLine(line) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0) {
+            return;
+        }
+        const request = this.pending.shift();
+        if (request === undefined) {
+            // The host must emit exactly one reply per request, so an unmatched line
+            // is a protocol violation that would desync every later reply into the
+            // wrong request. Fail fast rather than silently returning wrong output.
+            // A line arriving after teardown (failure already set) is benign.
+            if (this.failure === undefined) {
+                this.fail(new Error("ttsc: resident transform host sent an unsolicited reply"));
+            }
+            return;
+        }
+        request.resolve(parseReply(trimmed));
+    }
+    onReaderClose() {
+        if (this.pending.length === 0) {
+            return;
+        }
+        this.rejectAll(this.failure ?? this.exitError());
+    }
+    fail(error) {
+        this.failure ??= error;
+        this.rejectAll(this.failure);
+    }
+    rejectAll(error) {
+        while (this.pending.length !== 0) {
+            this.pending.shift().reject(error);
+        }
+    }
+    removePending(target) {
+        const index = this.pending.indexOf(target);
+        if (index !== -1) {
+            this.pending.splice(index, 1);
+        }
+    }
+    exitError() {
+        const detail = this.stderr.trim();
+        if (detail.length !== 0) {
+            return new Error(detail);
+        }
+        // Read the child's own exit fields (set synchronously by Node) so the
+        // message is accurate even before this instance's "exit" handler would run.
+        const code = this.child.exitCode;
+        const signalCode = this.child.signalCode;
+        const signal = signalCode === null ? "" : `, signal ${signalCode}`;
+        return new Error(`ttsc: resident transform host exited (code ${code ?? "null"}${signal})`);
+    }
+}
+exports.ResidentTransformProcess = ResidentTransformProcess;
+/**
+ * Parse one reply line into a plain object. A malformed line degrades to an
+ * empty object rather than throwing, so one bad line never rejects a request
+ * the FIFO has already advanced past; the caller reads missing fields as
+ * absent.
+ */
+function parseReply(line) {
+    try {
+        const parsed = JSON.parse(line);
+        if (typeof parsed === "object" &&
+            parsed !== null &&
+            !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // A non-object or unparseable line is treated as an empty reply.
+    }
+    return {};
+}
+//# sourceMappingURL=residentTransformProcess.js.map

package/lib/compiler/internal/residentTransformProcess.js.map

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

package/lib/compiler/internal/startResidentTransform.d.ts

@@ -0,0 +1,26 @@
+import type { ITtscCompilerContext } from "../../structures/ITtscCompilerContext";
+import { ResidentTransformProcess } from "./residentTransformProcess";
+/**
+ * A started resident transform host plus the project root its keys are relative
+ * to.
+ */
+export interface StartedResidentTransform {
+    process: ResidentTransformProcess;
+    projectRoot: string;
+}
+/**
+ * Start a resident `serve` host for the configured project.
+ *
+ * Mirrors the plugin spawn of `transformProjectInMemory`, but launches the
+ * shared host's `serve` subcommand as one long-lived process instead of a
+ * per-call `transform` subprocess. The host compiles the whole project once at
+ * startup and then answers per-file requests, so one caller pays the project
+ * compile once and reuses it across its own per-file requests.
+ *
+ * Resident mode runs through the linked-plugin shared host
+ * (`cmd/utility-host`), which is the only binary that exposes `serve`. It
+ * therefore requires at least one transform-stage plugin; executable transform
+ * hosts that own their own process are not served and must use the per-call
+ * transform path. Check-stage plugins are not run by the resident host.
+ */
+export declare function startResidentTransform(context: ITtscCompilerContext): StartedResidentTransform;

package/lib/compiler/internal/startResidentTransform.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startResidentTransform = startResidentTransform;
+const node_path_1 = __importDefault(require("node:path"));
+const loadProjectPlugins_1 = require("../../plugin/internal/loadProjectPlugins");
+const readProjectConfig_1 = require("./project/readProjectConfig");
+const residentTransformProcess_1 = require("./residentTransformProcess");
+const resolveBinary_1 = require("./resolveBinary");
+const resolveTsgo_1 = require("./resolveTsgo");
+const sharedHostHelpers_1 = require("./sharedHostHelpers");
+/**
+ * Start a resident `serve` host for the configured project.
+ *
+ * Mirrors the plugin spawn of `transformProjectInMemory`, but launches the
+ * shared host's `serve` subcommand as one long-lived process instead of a
+ * per-call `transform` subprocess. The host compiles the whole project once at
+ * startup and then answers per-file requests, so one caller pays the project
+ * compile once and reuses it across its own per-file requests.
+ *
+ * Resident mode runs through the linked-plugin shared host
+ * (`cmd/utility-host`), which is the only binary that exposes `serve`. It
+ * therefore requires at least one transform-stage plugin; executable transform
+ * hosts that own their own process are not served and must use the per-call
+ * transform path. Check-stage plugins are not run by the resident host.
+ */
+function startResidentTransform(context) {
+    const cwd = node_path_1.default.resolve(context.cwd ?? process.cwd());
+    const project = (0, readProjectConfig_1.readProjectConfig)({
+        cwd,
+        projectRoot: context.projectRoot,
+        tsconfig: context.tsconfig,
+    });
+    const loaded = (0, loadProjectPlugins_1.loadProjectPlugins)({
+        binary: (0, resolveBinary_1.resolveBinary)(context) ?? "",
+        cacheDir: context.cacheDir ?? context.env?.TTSC_CACHE_DIR,
+        cwd,
+        entries: context.plugins,
+        projectRoot: context.projectRoot,
+        tsconfig: project.path,
+    });
+    const transformers = loaded.nativePlugins.filter((plugin) => plugin.stage === "transform");
+    if (transformers.length === 0) {
+        throw new Error("ttsc: TtscService resident mode requires at least one transform-stage plugin; " +
+            "use TtscCompiler.transform for projects with only check-stage plugins or none");
+    }
+    (0, sharedHostHelpers_1.assertSharedHostCompatibility)(transformers, "source-to-source");
+    const host = (0, sharedHostHelpers_1.selectSharedHostPlugin)(transformers);
+    const tsgoBinary = (0, resolveTsgo_1.resolveTsgo)({ ...context, cwd: project.root }).binary;
+    const resident = new residentTransformProcess_1.ResidentTransformProcess({
+        args: [
+            "serve",
+            `--tsconfig=${project.path}`,
+            `--plugins-json=${serializeNativePlugins(transformers)}`,
+            `--cwd=${project.root}`,
+        ],
+        binary: host.binary,
+        cwd: project.root,
+        env: residentEnv(context, tsgoBinary, loaded.nativePlugins),
+    });
+    return { process: resident, projectRoot: project.root };
+}
+/**
+ * Build the environment for the resident host spawn. Matches the per-call
+ * transform spawn: injects the Node, tsgo, and ttsx binaries so the host never
+ * searches PATH, and forwards linked transform plugins via
+ * `TTSC_LINKED_PLUGINS_JSON`.
+ */
+function residentEnv(context, tsgoBinary, nativePlugins) {
+    const env = {
+        ...process.env,
+        TTSC_NODE_BINARY: process.env.TTSC_NODE_BINARY ?? process.execPath,
+        TTSC_TSGO_BINARY: process.env.TTSC_TSGO_BINARY ?? tsgoBinary,
+        TTSC_TTSX_BINARY: process.env.TTSC_TTSX_BINARY ??
+            node_path_1.default.join(__dirname, "..", "..", "launcher", "ttsx.js"),
+        ...context.env,
+    };
+    const linked = (0, sharedHostHelpers_1.linkedTransformPlugins)(nativePlugins);
+    if (linked.length !== 0) {
+        env.TTSC_LINKED_PLUGINS_JSON = serializeNativePlugins(linked);
+    }
+    return env;
+}
+/**
+ * Serialize the plugin list to the `--plugins-json` /
+ * `TTSC_LINKED_PLUGINS_JSON` shape the native host reads: only the fields it
+ * needs, to keep the arg short.
+ */
+function serializeNativePlugins(plugins) {
+    return JSON.stringify(plugins.map((plugin) => ({
+        config: plugin.config,
+        name: plugin.name,
+        stage: plugin.stage,
+    })));
+}
+//# sourceMappingURL=startResidentTransform.js.map

package/lib/compiler/internal/startResidentTransform.js.map

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

package/lib/index.d.ts

@@ -7,4 +7,5 @@
  * package surface remains small and stable.
  */
 export * from "./TtscCompiler";
+export * from "./TtscService";
 export * from "./structures/index";

package/lib/index.js

@@ -23,5 +23,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./TtscCompiler"), exports);
+__exportStar(require("./TtscService"), exports);
 __exportStar(require("./structures/index"), exports);
 //# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;;;;;;;;;;;;;;AAEH,iDAA+B;AAC/B,qDAAmC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;;;;;;;;;;;;;;AAEH,iDAA+B;AAC/B,gDAA8B;AAC9B,qDAAmC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ttsc",
-  "version": "0.16.3",
+  "version": "0.16.6",
   "description": "General-purpose TypeScript-Go compiler, runtime, plugin host, and LSP host.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -32,13 +32,13 @@
     "typescript": "7.0.1-rc"
   },
   "optionalDependencies": {
-    "@ttsc/linux-arm": "0.16.3",
-    "@ttsc/darwin-arm64": "0.16.3",
-    "@ttsc/win32-x64": "0.16.3",
-    "@ttsc/win32-arm64": "0.16.3",
-    "@ttsc/linux-arm64": "0.16.3",
-    "@ttsc/linux-x64": "0.16.3",
-    "@ttsc/darwin-x64": "0.16.3"
+    "@ttsc/linux-x64": "0.16.6",
+    "@ttsc/linux-arm": "0.16.6",
+    "@ttsc/linux-arm64": "0.16.6",
+    "@ttsc/darwin-x64": "0.16.6",
+    "@ttsc/win32-x64": "0.16.6",
+    "@ttsc/darwin-arm64": "0.16.6",
+    "@ttsc/win32-arm64": "0.16.6"
   },
   "sideEffects": false,
   "files": [

package/shim/ast/shim.go

@@ -189,6 +189,12 @@ func NewNodeVisitor(visit func(node *Node) *Node, factory *NodeFactory, options
   return innerast.NewNodeVisitor(visit, factory, options)
 }
 
+// GetCombinedModifierFlags returns syntactic modifiers combined across wrappers
+// such as variable statements and their declaration lists.
+func GetCombinedModifierFlags(node *Node) ModifierFlags {
+  return innerast.GetCombinedModifierFlags(node)
+}
+
 // IsFunctionLike reports whether node is any function-like construct
 // (function declaration, arrow function, method, constructor, accessor, etc.).
 func IsFunctionLike(node *Node) bool {

package/shim/checker/shim.go

@@ -81,7 +81,7 @@ func Checker_getPropertiesOfType(recv *innerchecker.Checker, t *innerchecker.Typ
 }
 
 // Checker_getApparentProperties returns the properties visible on t after
-// resolving primitive wrapper types (e.g. string → String).
+// resolving primitive wrapper types (e.g. string to String).
 func Checker_getApparentProperties(recv *innerchecker.Checker, t *innerchecker.Type) []*innerast.Symbol {
   return recv.GetApparentProperties(t)
 }
@@ -149,6 +149,16 @@ func Checker_getAliasedSymbol(recv *innerchecker.Checker, symbol *innerast.Symbo
   return recv.GetAliasedSymbol(symbol)
 }
 
+// Checker_getExportsOfModule returns the exported symbols of a source-file or
+// namespace module symbol, resolving export-star aggregation the same way the
+// checker does for emit and services.
+func Checker_getExportsOfModule(recv *innerchecker.Checker, symbol *innerast.Symbol) []*innerast.Symbol {
+  if recv == nil || symbol == nil {
+    return nil
+  }
+  return recv.GetExportsOfModule(symbol)
+}
+
 //go:linkname checkerResolveEntityName github.com/microsoft/typescript-go/internal/checker.(*Checker).resolveEntityName
 func checkerResolveEntityName(
   recv *innerchecker.Checker,
@@ -215,8 +225,8 @@ func Checker_getBaseTypes(recv *innerchecker.Checker, t *innerchecker.Type) []*i
 func checkerGetDeclaredTypeOfSymbol(recv *innerchecker.Checker, symbol *innerast.Symbol) *innerchecker.Type
 
 // Checker_getDeclaredTypeOfSymbol returns the declared (instance) type of a
-// class or interface symbol. Unlike Checker_getTypeOfSymbol — which yields the
-// constructor (static) type of a class symbol — the result IS a
+// class or interface symbol. Unlike Checker_getTypeOfSymbol, which yields the
+// constructor (static) type of a class symbol, the result IS a
 // ClassOrInterface type and is therefore safe to feed back into
 // Checker_getBaseTypes. This lets a consumer resolve a generic base's symbol to
 // its declared type and keep walking the base chain past the generic boundary
@@ -275,10 +285,10 @@ func Checker_getReturnTypeOfSignature(recv *innerchecker.Checker, signature *inn
 // parameter is excluded (it is held separately from the value parameters).
 //
 // Checker_getMinArgumentCount alone cannot tell a zero-parameter signature
-// (`()` — minimum 0) from a single-optional-parameter one (`(x?)` — also
+// (`()` minimum 0) from a single-optional-parameter one (`(x?)` also
 // minimum 0). A type-transform plugin needs that distinction to replicate the
-// type-level "single meaningful argument" rule — a FIRST parameter must exist
-// and every later parameter must be optional or rest — as
+// type-level "single meaningful argument" rule: a FIRST parameter must exist
+// and every later parameter must be optional or rest, as
 // `Signature_parameterCount(sig) >= 1 && Checker_getMinArgumentCount(c, sig) <= 1`.
 // Without it the `new C(x)` / `C.from(x)` strategies silently fall back to field
 // copy for every optional-first constructor or factory. Returns 0 if signature
@@ -297,7 +307,7 @@ func Signature_parameterCount(signature *innerchecker.Signature) int {
 // yields the seed TYPE the plugin must decode before constructing the instance.
 //
 // Signature_parameterCount is len() of this slice; the slice itself is needed
-// because detection (count + min-args) is not enough — emission requires the
+// because detection (count + min-args) is not enough; emission requires the
 // seed parameter's type. Returns nil if signature is nil.
 func Signature_parameters(signature *innerchecker.Signature) []*innerast.Symbol {
   if signature == nil {
@@ -308,8 +318,8 @@ func Signature_parameters(signature *innerchecker.Signature) []*innerast.Symbol
 
 // Signature_hasRestParameter reports whether the signature's last value
 // parameter is a rest parameter (`...xs: S[]`). It is the signal a from/new
-// transform needs to tell a rest-only single-seed call `(...xs: S[])` — whose
-// seed is the ELEMENT S — from a genuine array-typed parameter `(seed: S[])` —
+// transform needs to tell a rest-only single-seed call `(...xs: S[])`, whose
+// seed is the ELEMENT S, from a genuine array-typed parameter `(seed: S[])`,
 // whose seed is the array S[]: getTypeOfSymbol yields `S[]` for BOTH, so without
 // this flag they are indistinguishable and the rest case decodes the wrong
 // shape.
@@ -317,8 +327,8 @@ func Signature_parameters(signature *innerchecker.Signature) []*innerast.Symbol
 // The rest ELEMENT is the seed ONLY when the rest parameter is the sole value
 // parameter, i.e. `Signature_hasRestParameter(sig) && Signature_parameterCount(sig) == 1`.
 // A leading-required + rest-tail signature `(s: S, ...r: R[])` also has a rest
-// parameter (this returns true), but its seed is the FIRST parameter S — read it
-// from Signature_parameters(sig)[0], NOT the rest element — matching
+// parameter (this returns true), but its seed is the FIRST parameter S. Read it
+// from Signature_parameters(sig)[0], NOT the rest element, matching
 // ClassifiableSeed, whose `[infer P, ...Rest]` arm picks P=S there. Returns
 // false if signature is nil.
 func Signature_hasRestParameter(signature *innerchecker.Signature) bool {
@@ -330,7 +340,7 @@ func Signature_hasRestParameter(signature *innerchecker.Signature) bool {
 
 // Checker_getRestTypeOfSignature returns the ELEMENT type of the signature's
 // rest parameter (`...xs: S[]` -> S; a tuple rest unwraps to its element too),
-// which is the seed type for a rest-ONLY single-argument constructor/factory —
+// which is the seed type for a rest-ONLY single-argument constructor/factory,
 // matching ClassifiableSeed, which unwraps the rest to its element. When the
 // signature has NO rest parameter it falls back to `any` upstream; and a
 // leading-required + rest-tail `(s: S, ...r: R[])` has a rest parameter yet its