ttsc 0.16.3 → 0.16.5

package/internal/graph/value_call_edges_cover_methods_and_constructors_test.go

@@ -0,0 +1,70 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestValueCallEdgesCoverMethodsAndConstructors verifies that the value-call walk
+// reaches what the checker resolves but the first cut dropped: a method-to-method
+// call lands on the callee's method node, and a `new T()` lands on T's class node,
+// both attributed to the calling method.
+//
+// Before method nodes existed, a callee that resolved to a method symbol was
+// dropped (no node to point at) and a `new` expression was never visited, so a
+// class whose logic lived in method bodies showed almost no outgoing edges. This
+// pins that gap closed — the load-bearing reason a model could trust the graph
+// for an architecture question instead of re-reading the source.
+//
+//  1. Compile a fixture where Controller.handle calls Service.run (via a parameter
+//     and a constructed value) and constructs a Service.
+//  2. Build the graph.
+//  3. Assert handle -> Service.run (value-call, deduped) and handle -> Service
+//     (the new-expression constructor edge) both exist.
+func TestValueCallEdgesCoverMethodsAndConstructors(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export class Service {
+  run(): void {}
+}
+export class Controller {
+  handle(s: Service): void {
+    s.run();
+    const made = new Service();
+    made.run();
+  }
+}
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  graph := Build(prog)
+  path := sourceFile(t, prog, "main.ts").FileName()
+
+  handle := nodeID(path, "Controller.handle", NodeMethod)
+  run := nodeID(path, "Service.run", NodeMethod)
+  service := nodeID(path, "Service", NodeClass)
+
+  // The callee method node both endpoints need must exist as a real node.
+  if _, ok := graph.Nodes[run]; !ok {
+    t.Fatalf("Build did not record the method node Service.run; have %v", nodeIDSet(graph))
+  }
+  // Method-to-method: handle calls Service.run (from s.run() and made.run(),
+  // deduped to a single edge) — the call the first cut dropped.
+  if !hasEdge(graph, handle, run, EdgeValueCall) {
+    t.Fatalf("missing value-call edge Controller.handle -> Service.run; edges: %v", graph.Edges)
+  }
+  // Constructor: `new Service()` is a value-call from handle to the class node.
+  if !hasEdge(graph, handle, service, EdgeValueCall) {
+    t.Fatalf("missing value-call edge Controller.handle -> Service (new); edges: %v", graph.Edges)
+  }
+}

package/internal/graph/value_call_edges_cover_variable_bound_callables_test.go

@@ -0,0 +1,46 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestValueCallEdgesCoverVariableBoundCallables verifies that a call made inside a
+// top-level variable-bound function (a `const fn = () => …`) is an edge from that
+// variable node. The first cut never walked a variable initializer, so an
+// arrow-const that called a function produced no edge — a common modern-TS shape
+// the graph silently missed.
+//
+//  1. Compile a fixture where `const handler = () => { helper(); }`.
+//  2. Build the graph.
+//  3. Assert a handler -> helper value-call edge exists.
+func TestValueCallEdgesCoverVariableBoundCallables(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export function helper(): void {}
+export const handler = (): void => {
+  helper();
+};
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  graph := Build(prog)
+  path := sourceFile(t, prog, "main.ts").FileName()
+
+  handler := nodeID(path, "handler", NodeVariable)
+  helper := nodeID(path, "helper", NodeFunction)
+
+  if !hasEdge(graph, handler, helper, EdgeValueCall) {
+    t.Fatalf("missing value-call edge handler -> helper (variable-bound callable body); edges: %v", graph.Edges)
+  }
+}

package/internal/graph/value_call_edges_do_not_double_record_invoked_member_access_test.go

@@ -0,0 +1,65 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestValueCallEdgesDoNotDoubleRecordInvokedMemberAccess verifies a property
+// access used as an invocation target remains only a value-call edge.
+//
+// Splitting value-call from value-access is useful only if method calls and
+// tagged-template calls do not also look like plain property reads. Otherwise MCP
+// flow ranking cannot tell invoked behavior from state/accessor evidence.
+//
+//  1. Compile method, constructor, and tagged-template calls whose callee/tag is
+//     a property access expression.
+//  2. Build the graph.
+//  3. Assert each target has a value-call edge and no duplicate value-access
+//     edge from the same caller.
+func TestValueCallEdgesDoNotDoubleRecordInvokedMemberAccess(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), "export namespace Providers {\n"+
+    "  export class Service {\n"+
+    "    run(): void {}\n"+
+    "  }\n"+
+    "}\n"+
+    "export namespace Tags {\n"+
+    "  export function html(strings: TemplateStringsArray): string {\n"+
+    "    return strings[0]\n"+
+    "  }\n"+
+    "}\n"+
+    "export function handle(service: Providers.Service): string {\n"+
+    "  service.run()\n"+
+    "  new Providers.Service()\n"+
+    "  return Tags.html`ok`\n"+
+    "}\n")
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  graph := Build(prog)
+  path := sourceFile(t, prog, "main.ts").FileName()
+  handle := nodeID(path, "handle", NodeFunction)
+  run := nodeID(path, "Providers.Service.run", NodeMethod)
+  service := nodeID(path, "Providers.Service", NodeClass)
+  html := nodeID(path, "Tags.html", NodeFunction)
+
+  for _, target := range []string{run, service, html} {
+    if !hasEdge(graph, handle, target, EdgeValueCall) {
+      t.Fatalf("missing value-call edge handle -> %s; edges: %v", target, graph.Edges)
+    }
+    if hasEdge(graph, handle, target, EdgeValueAccess) {
+      t.Fatalf("invoked member access was also recorded as value-access handle -> %s; edges: %v", target, graph.Edges)
+    }
+  }
+}

package/internal/graph/value_call_edges_record_construct_versus_call_origin_test.go

@@ -0,0 +1,75 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestValueCallEdgesRecordConstructVersusCallOrigin verifies that a value-call
+// edge carries the syntactic Origin the dump splits into the schema's `calls`
+// versus `instantiates` kinds: a plain call records "call", a `new T()` records
+// "new".
+//
+// The internal model keeps one EdgeValueCall kind so the existing MCP stays
+// untouched; the finer distinction the redesigned graph schema requires
+// (`new Foo()` is an instantiation, not a call) rides on Edge.Origin. Without it
+// the dump could not recover a constructor from an invocation after the fact, so
+// this pins the discriminator at its source.
+//
+//  1. Compile a fixture where Controller.handle both calls Service.run and
+//     constructs `new Service()`.
+//  2. Build the graph.
+//  3. Assert the handle->Service.run edge has Origin "call" and the
+//     handle->Service edge has Origin "new".
+func TestValueCallEdgesRecordConstructVersusCallOrigin(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export class Service {
+  run(): void {}
+}
+export class Controller {
+  handle(s: Service): void {
+    s.run();
+    const made = new Service();
+    void made;
+  }
+}
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  graph := Build(prog)
+  path := sourceFile(t, prog, "main.ts").FileName()
+
+  handle := nodeID(path, "Controller.handle", NodeMethod)
+  run := nodeID(path, "Service.run", NodeMethod)
+  service := nodeID(path, "Service", NodeClass)
+
+  if got := edgeOrigin(graph, handle, run, EdgeValueCall); got != "call" {
+    t.Fatalf("Controller.handle -> Service.run: want Origin \"call\", got %q; edges: %v", got, graph.Edges)
+  }
+  if got := edgeOrigin(graph, handle, service, EdgeValueCall); got != "new" {
+    t.Fatalf("Controller.handle -> Service (new): want Origin \"new\", got %q; edges: %v", got, graph.Edges)
+  }
+}
+
+// edgeOrigin returns the Origin of the first from->to edge of kind, or the
+// sentinel "<missing>" when no such edge exists, so a test distinguishes a wrong
+// origin from an absent edge.
+func edgeOrigin(graph *Graph, from, to string, kind EdgeKind) string {
+  for _, edge := range graph.Edges {
+    if edge.From == from && edge.To == to && edge.Kind == kind {
+      return edge.Origin
+    }
+  }
+  return "<missing>"
+}

package/internal/graph/value_call_edges_resolve_across_files_and_dedupe_test.go

@@ -0,0 +1,55 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestValueCallEdgesResolveAcrossFilesAndDedupe verifies that a runtime call is
+// recorded as a single value-call edge to the callee's real declaration, even
+// when the caller invokes it from several sites. Cross-file resolution proves the
+// edge rides the checker; the dedup keeps the call graph one-edge-per-pair so an
+// impact query is not skewed by how many times a function is called.
+//
+//  1. Compile a fixture where caller() calls helper() (declared in another file)
+//     twice.
+//  2. Build the graph.
+//  3. Assert exactly one caller -> helper value-call edge.
+func TestValueCallEdgesResolveAcrossFilesAndDedupe(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "util.ts"), `export function helper(): number {
+  return 1;
+}
+`)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `import { helper } from "./util";
+export function caller(): number {
+  return helper() + helper();
+}
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  graph := Build(prog)
+  caller := nodeID(sourceFile(t, prog, "main.ts").FileName(), "caller", NodeFunction)
+  helper := nodeID(sourceFile(t, prog, "util.ts").FileName(), "helper", NodeFunction)
+
+  count := 0
+  for _, edge := range graph.Edges {
+    if edge.From == caller && edge.To == helper && edge.Kind == EdgeValueCall {
+      count++
+    }
+  }
+  if count != 1 {
+    t.Fatalf("expected exactly one caller -> helper value-call edge, got %d; edges: %v", count, graph.Edges)
+  }
+}

package/internal/graph/value_call_edges_skip_self_and_unresolved_test.go

@@ -0,0 +1,74 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestValueCallEdgesSkipSelfAndUnresolved verifies that callEdge drops the two
+// edges it is documented to skip while still recording an ordinary cross-call:
+// a self-call (`rec` calling `rec`) yields no edge because `to == from`, and a
+// call whose callee the checker cannot bind to a declaration (a method on an
+// `any`-typed value) yields no edge because Resolve returns nil.
+//
+// The positive caller->helper edge is the load-bearing twin: without it the test
+// would also pass if callEdge recorded nothing at all, so it proves the two skips
+// are specific to a self-call and an unresolved callee, not a blanket failure to
+// emit value-call edges.
+//
+//  1. Compile a fixture with `rec()` returning `rec()`, `caller()` calling a
+//     separate `helper()`, and `dynamic(host: any)` calling `host.run()`.
+//  2. Build the graph.
+//  3. Assert no rec->rec edge and no edge out of dynamic, but a caller->helper
+//     value-call edge.
+func TestValueCallEdgesSkipSelfAndUnresolved(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export function rec(): unknown {
+  return rec();
+}
+export function helper(): void {}
+export function caller(): void {
+  helper();
+}
+export function dynamic(host: any): void {
+  host.run();
+}
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  graph := Build(prog)
+  path := sourceFile(t, prog, "main.ts").FileName()
+
+  rec := nodeID(path, "rec", NodeFunction)
+  helper := nodeID(path, "helper", NodeFunction)
+  caller := nodeID(path, "caller", NodeFunction)
+  dynamic := nodeID(path, "dynamic", NodeFunction)
+
+  // Self-call: callEdge skips `to == from`, so rec never points at itself.
+  if hasEdge(graph, rec, rec, EdgeValueCall) {
+    t.Fatalf("a self-call recorded a rec -> rec value-call edge; edges: %v", graph.Edges)
+  }
+  // Unresolved callee: `host.run()` binds to no declaration, so dynamic gains no
+  // outgoing value-call edge.
+  for _, edge := range graph.Edges {
+    if edge.From == dynamic && edge.Kind == EdgeValueCall {
+      t.Fatalf("an unresolved callee recorded a value-call edge out of dynamic: %+v", edge)
+    }
+  }
+  // Positive twin: an ordinary cross-call is still recorded, proving the skips
+  // above are specific and not a blanket suppression.
+  if !hasEdge(graph, caller, helper, EdgeValueCall) {
+    t.Fatalf("missing value-call edge caller -> helper; edges: %v", graph.Edges)
+  }
+}

package/lib/TtscService.d.ts

@@ -0,0 +1,55 @@
+import type { ITtscCompilerContext } from "./structures/ITtscCompilerContext";
+/**
+ * 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}.
+ */
+export declare class TtscService {
+    private readonly resident;
+    private readonly 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?: ITtscCompilerContext);
+    /**
+     * 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.
+     */
+    transformFile(fileName: string): Promise<string | 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.
+     */
+    updateFile(fileName: string, content: string): Promise<boolean>;
+    /** Terminate the resident host and reject any in-flight requests. */
+    dispose(): void;
+    private absolutePath;
+}

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;
+}