ttsc 0.30.3 → 0.31.0

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

@@ -0,0 +1,83 @@
+import type { ResidentReplyKind } from "./ResidentReplyKind";
+import type { ResidentTransformProcessOptions } from "./ResidentTransformProcessOptions";
+import type { ResidentTransformRequestOptions } from "./ResidentTransformRequestOptions";
+/**
+ * Async client for the long-lived `utility-host serve` process.
+ *
+ * The serve host answers newline-delimited requests within one process; its
+ * producer owns project loading, transformed text and update semantics. 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. Client construction does
+ * not await startup compilation or certify a custom host's caching behavior.
+ *
+ * The caller owns disposal. Live requests have no deadline; queue population
+ * and reply-line size depend on the caller and host, without a fixed cap.
+ *
+ * @evidence contracts/common.md#principled-implementation FIFO ownership follows the host's ordered request loop; malformed framing retires all slots, while a valid object with an invalid operation shape consumes and rejects only its own slot.
+ * @evidence contracts/common.md#clear-and-simple-design The client owns one child, line reader, queue and terminal state; reply validation and settlement are private transport responsibilities distinct from the service's project policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing files and rejected edits remain legitimate negative replies; corrupt lines reject instead of becoming synthetic empty results or being rescued through foreign method replacement.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish operations, startup reuse, caller ownership and uncapped live requests, following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Node receives the executable, separate argv, native cwd and environment directly; supported pipe APIs carry protocol text without platform-specific shell quoting.
+ * @evidence contracts/performance.md#efficient-algorithms A cursor advances through the FIFO with amortized constant queue settlement; consumed prefixes compact only when at least half the array has been consumed, and retirement drains outstanding calls once. Request serialization and reply parsing cost observed data/text volume, with caller serialization callbacks adding arbitrary work. Stderr conversion and concatenation scan each chunk plus the retained tail before truncation; native startup and host processing remain delegated.
+ * @evidence contracts/performance.md#reuse-equivalent-work One startup-selected host is shared across requests; the client does not memoize responses across edits. Transformed-text state and ordered update behavior belong to the serve producer, not a custom-host cache guarantee established by this client.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Consumed slots release callbacks, settlement removes abort listeners, and retirement clears outstanding state and closes pipes. Stderr has a fixed tail cap, but pending calls and line bytes are uncapped and OS signaling may fail to terminate the child.
+ */
+export declare class ResidentTransformProcess {
+    private readonly child;
+    private readonly reader;
+    private readonly requests;
+    private stderr;
+    constructor(options: ResidentTransformProcessOptions);
+    /**
+     * Send one request to the host and resolve with its validated JSON reply. The
+     * host answers in FIFO order; `kind` tells the client which reply shape the
+     * payload asks for, so the reply is validated as a well-formed `kind` reply
+     * before it resolves. Rejects when the reply is not a valid `kind` reply,
+     * when the host has already failed or exited, or if writing the request
+     * fails.
+     *
+     * An abort before enqueueing affects only this call. Once enqueued, aborting
+     * retires the whole FIFO because the reply stream has no request identifiers.
+     * Serialization failure leaves the healthy host available for another call.
+     * Payload serialization can invoke caller-defined conversion; exceptional
+     * thrown values can also execute or fail conversion while being normalized.
+     *
+     * @evidence contracts/common.md#principled-implementation Each queued request carries its expected operation and resolves only from its own validated FIFO reply; cancellation after enqueueing retires the stream to prevent shifted reply ownership.
+     * @evidence contracts/common.md#clear-and-simple-design Local serialization and pre-abort checks precede shared queue ownership; one settlement helper handles replies, cancellation and write failure with listener cleanup.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Cancellation does not remove a positional reply and continue under a false framing assumption; invalid replies cannot masquerade as missing files or rejected edits.
+     * @evidence contracts/common.md#meaningful-documentation The separate lifecycle paragraph explains which failures affect one caller and which retire the shared host, applying the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Requests are JSON data written through the existing native pipe; filenames remain producer-owned values rather than command strings or assumed POSIX paths.
+     * @evidence contracts/performance.md#efficient-algorithms Serialization visits supplied properties and encoded data, with caller-defined conversion costs not bounded by final JSON size. FIFO insertion and ordered settlement have amortized constant queue work; reply text parsing precedes fixed field checks, and host execution is delegated.
+     * @evidence contracts/performance.md#reuse-equivalent-work File requests share the existing producer's committed transformation; effectful updates keep distinct ordered slots, and the client caches no response across producer state transitions.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Each pending call owns resolver callbacks and at most one abort listener; settlement removes the listener and queue reference, while cancellation retires every outstanding call. Live uncancelled work has no implicit timeout or queue cap.
+     */
+    request(payload: Record<string, unknown>, kind: ResidentReplyKind, options?: ResidentTransformRequestOptions): Promise<Record<string, unknown>>;
+    /**
+     * Retire the client, reject in-flight requests and attempt child termination.
+     * Safe to call more than once; this void operation does not await child close
+     * or prove OS signaling succeeded.
+     *
+     * @evidence contracts/common.md#principled-implementation Failure becomes terminal before all queued callers are rejected, so buffered lines cannot settle new callers after disposal.
+     * @evidence contracts/common.md#clear-and-simple-design Disposal reuses the transport retirement path and preserves the child's real exit error when it has already died.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Cleanup uses supported child and stream APIs and rejects outstanding calls rather than synthesizing successful results. Destroy/signal attempts are not a child-close receipt or a guaranteed process-tree shutdown.
+     * @evidence contracts/common.md#meaningful-documentation The native comment states caller-visible rejection and idempotence, following the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Node destroys its own pipes and performs child signaling with its supported platform behavior; no process-tree shell command or signal assumption is imposed on callers.
+     * @evidence contracts/performance.md#efficient-algorithms The queue is detached once and each outstanding request is settled once, making shutdown linear in pending population.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Disposal ends the shared producer rather than computing or validating a reusable result.
+     *
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Retirement removes all abort listeners, queue references and pipes; a single unreferenced grace timer attempts forced termination and is cleared on exit. OS failure to signal can still leave a running child.
+     */
+    dispose(): void;
+    private onLine;
+    private onReaderClose;
+    private fail;
+    private cancel;
+    private terminate;
+    private exitError;
+}

package/lib/compiler/internal/ResidentTransformProcess.js

@@ -0,0 +1,261 @@
+"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");
+const E2ETrace_1 = require("../../internal/E2ETrace");
+const ResidentTransformRequests_1 = require("./ResidentTransformRequests");
+/**
+ * Async client for the long-lived `utility-host serve` process.
+ *
+ * The serve host answers newline-delimited requests within one process; its
+ * producer owns project loading, transformed text and update semantics. 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. Client construction does
+ * not await startup compilation or certify a custom host's caching behavior.
+ *
+ * The caller owns disposal. Live requests have no deadline; queue population
+ * and reply-line size depend on the caller and host, without a fixed cap.
+ *
+ * @evidence contracts/common.md#principled-implementation FIFO ownership follows the host's ordered request loop; malformed framing retires all slots, while a valid object with an invalid operation shape consumes and rejects only its own slot.
+ * @evidence contracts/common.md#clear-and-simple-design The client owns one child, line reader, queue and terminal state; reply validation and settlement are private transport responsibilities distinct from the service's project policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing files and rejected edits remain legitimate negative replies; corrupt lines reject instead of becoming synthetic empty results or being rescued through foreign method replacement.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish operations, startup reuse, caller ownership and uncapped live requests, following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Node receives the executable, separate argv, native cwd and environment directly; supported pipe APIs carry protocol text without platform-specific shell quoting.
+ * @evidence contracts/performance.md#efficient-algorithms A cursor advances through the FIFO with amortized constant queue settlement; consumed prefixes compact only when at least half the array has been consumed, and retirement drains outstanding calls once. Request serialization and reply parsing cost observed data/text volume, with caller serialization callbacks adding arbitrary work. Stderr conversion and concatenation scan each chunk plus the retained tail before truncation; native startup and host processing remain delegated.
+ * @evidence contracts/performance.md#reuse-equivalent-work One startup-selected host is shared across requests; the client does not memoize responses across edits. Transformed-text state and ordered update behavior belong to the serve producer, not a custom-host cache guarantee established by this client.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Consumed slots release callbacks, settlement removes abort listeners, and retirement clears outstanding state and closes pipes. Stderr has a fixed tail cap, but pending calls and line bytes are uncapped and OS signaling may fail to terminate the child.
+ */
+class ResidentTransformProcess {
+    child;
+    reader;
+    requests = new ResidentTransformRequests_1.ResidentTransformRequests();
+    stderr = "";
+    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.
+        const nativeArgs = [...options.args];
+        const trace = E2ETrace_1.E2ETrace.begin(options.binary, nativeArgs, options, "resident-transform");
+        this.child = (0, node_child_process_1.spawn)(options.binary, nativeArgs, {
+            cwd: options.cwd,
+            env: options.env,
+            windowsHide: true,
+        });
+        E2ETrace_1.E2ETrace.asynchronous(trace, this.child);
+        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 validated JSON reply. The
+     * host answers in FIFO order; `kind` tells the client which reply shape the
+     * payload asks for, so the reply is validated as a well-formed `kind` reply
+     * before it resolves. Rejects when the reply is not a valid `kind` reply,
+     * when the host has already failed or exited, or if writing the request
+     * fails.
+     *
+     * An abort before enqueueing affects only this call. Once enqueued, aborting
+     * retires the whole FIFO because the reply stream has no request identifiers.
+     * Serialization failure leaves the healthy host available for another call.
+     * Payload serialization can invoke caller-defined conversion; exceptional
+     * thrown values can also execute or fail conversion while being normalized.
+     *
+     * @evidence contracts/common.md#principled-implementation Each queued request carries its expected operation and resolves only from its own validated FIFO reply; cancellation after enqueueing retires the stream to prevent shifted reply ownership.
+     * @evidence contracts/common.md#clear-and-simple-design Local serialization and pre-abort checks precede shared queue ownership; one settlement helper handles replies, cancellation and write failure with listener cleanup.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Cancellation does not remove a positional reply and continue under a false framing assumption; invalid replies cannot masquerade as missing files or rejected edits.
+     * @evidence contracts/common.md#meaningful-documentation The separate lifecycle paragraph explains which failures affect one caller and which retire the shared host, applying the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Requests are JSON data written through the existing native pipe; filenames remain producer-owned values rather than command strings or assumed POSIX paths.
+     * @evidence contracts/performance.md#efficient-algorithms Serialization visits supplied properties and encoded data, with caller-defined conversion costs not bounded by final JSON size. FIFO insertion and ordered settlement have amortized constant queue work; reply text parsing precedes fixed field checks, and host execution is delegated.
+     * @evidence contracts/performance.md#reuse-equivalent-work File requests share the existing producer's committed transformation; effectful updates keep distinct ordered slots, and the client caches no response across producer state transitions.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Each pending call owns resolver callbacks and at most one abort listener; settlement removes the listener and queue reference, while cancellation retires every outstanding call. Live uncancelled work has no implicit timeout or queue cap.
+     */
+    request(payload, kind, options = {}) {
+        if (this.requests.failure !== undefined) {
+            return Promise.reject(this.requests.failure);
+        }
+        if (options.signal?.aborted) {
+            return Promise.reject(cancelledError(options.signal));
+        }
+        const stdin = this.child.stdin;
+        if (stdin === null || stdin.destroyed) {
+            const error = new Error("ttsc: resident transform host stdin is closed");
+            this.fail(error);
+            return Promise.reject(error);
+        }
+        let line;
+        try {
+            line = `${JSON.stringify(payload)}\n`;
+        }
+        catch (error) {
+            return Promise.reject(asError(error));
+        }
+        return new Promise((resolve, reject) => {
+            const pending = this.requests.add(kind, resolve, reject, options.signal, (request) => this.cancel(request, options.signal));
+            if (options.signal?.aborted) {
+                pending.abort();
+                return;
+            }
+            try {
+                stdin.write(line, (error) => {
+                    if (error === null || error === undefined || pending.settled) {
+                        return;
+                    }
+                    this.requests.settle(pending, error);
+                    this.fail(new Error(`ttsc: resident transform host could not write a request: ${error.message}`));
+                });
+            }
+            catch (error) {
+                if (pending.settled)
+                    return;
+                const reason = asError(error);
+                this.requests.settle(pending, reason);
+                this.fail(new Error(`ttsc: resident transform host could not write a request: ${reason.message}`));
+            }
+        });
+    }
+    /**
+     * Retire the client, reject in-flight requests and attempt child termination.
+     * Safe to call more than once; this void operation does not await child close
+     * or prove OS signaling succeeded.
+     *
+     * @evidence contracts/common.md#principled-implementation Failure becomes terminal before all queued callers are rejected, so buffered lines cannot settle new callers after disposal.
+     * @evidence contracts/common.md#clear-and-simple-design Disposal reuses the transport retirement path and preserves the child's real exit error when it has already died.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Cleanup uses supported child and stream APIs and rejects outstanding calls rather than synthesizing successful results. Destroy/signal attempts are not a child-close receipt or a guaranteed process-tree shutdown.
+     * @evidence contracts/common.md#meaningful-documentation The native comment states caller-visible rejection and idempotence, following the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Node destroys its own pipes and performs child signaling with its supported platform behavior; no process-tree shell command or signal assumption is imposed on callers.
+     * @evidence contracts/performance.md#efficient-algorithms The queue is detached once and each outstanding request is settled once, making shutdown linear in pending population.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Disposal ends the shared producer rather than computing or validating a reusable result.
+     *
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Retirement removes all abort listeners, queue references and pipes; a single unreferenced grace timer attempts forced termination and is cleared on exit. OS failure to signal can still leave a running child.
+     */
+    dispose() {
+        if (this.requests.failure !== undefined)
+            return;
+        // If the host already died, reject with its real exit error (stderr + exit
+        // code) rather than a bland "disposed" message.
+        this.fail(this.child.exitCode !== null || this.child.signalCode !== null
+            ? this.exitError()
+            : new Error("ttsc: resident transform host disposed"));
+    }
+    onLine(line) {
+        if (this.requests.accept(line))
+            this.terminate();
+    }
+    onReaderClose() {
+        if (this.requests.failure === undefined)
+            this.fail(this.exitError());
+    }
+    fail(error) {
+        if (!this.requests.retire(error))
+            return;
+        this.terminate();
+    }
+    cancel(pending, signal) {
+        if (pending.settled)
+            return;
+        this.requests.settle(pending, cancelledError(signal));
+        this.fail(new Error(`ttsc: resident transform host retired after another request was cancelled${abortDetail(signal)}${stderrSuffix(this.stderr)}`));
+    }
+    terminate() {
+        this.reader.close();
+        this.child.stdout?.destroy();
+        this.child.stderr?.destroy();
+        const stdin = this.child.stdin;
+        if (stdin !== null && !stdin.destroyed)
+            stdin.destroy();
+        if (this.child.exitCode !== null || this.child.signalCode !== null)
+            return;
+        try {
+            this.child.kill();
+        }
+        catch {
+            // A failed cooperative signal does not cancel the forced attempt.
+        }
+        const force = setTimeout(() => {
+            if (this.child.exitCode !== null || this.child.signalCode !== null) {
+                return;
+            }
+            try {
+                this.child.kill("SIGKILL");
+            }
+            catch {
+                // The host exited between the liveness check and the forced signal.
+            }
+        }, TERMINATION_GRACE_MS);
+        force.unref();
+        this.child.once("exit", () => clearTimeout(force));
+    }
+    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;
+/** Cap on retained stderr so a long-lived host cannot grow it without bound. */
+const STDERR_TAIL_LIMIT = 64 * 1024;
+/** Allow a cooperative host a short shutdown window before forcing it down. */
+const TERMINATION_GRACE_MS = 1_000;
+function cancelledError(signal) {
+    const error = new Error(`ttsc: resident transform request cancelled${abortDetail(signal)}`);
+    error.name = "AbortError";
+    return error;
+}
+function abortDetail(signal) {
+    const reason = signal.reason;
+    if (reason === undefined)
+        return "";
+    try {
+        return `: ${reason instanceof Error ? reason.message : String(reason)}`;
+    }
+    catch {
+        return "";
+    }
+}
+function stderrSuffix(stderr) {
+    const detail = stderr.trim();
+    return detail.length === 0 ? "" : `: ${detail}`;
+}
+function asError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+//# 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/ResidentTransformProcessOptions.d.ts

@@ -0,0 +1,27 @@
+/**
+ * How to start the resident transform host behind {@link TtscService}.
+ *
+ * The host is spawned once and then answers transform requests over its line
+ * protocol. This record fixes startup executable, argv and spawn authority;
+ * later operation data belongs to the request lane. It does not freeze files or
+ * certify how a custom host responds to configuration changes.
+ *
+ * @evidence contracts/common.md#principled-implementation A fixed executable and argv identify the resident producer; optional cwd and environment retain Node's explicitly documented spawn defaults.
+ * @evidence contracts/common.md#clear-and-simple-design This startup record contains only spawn inputs, keeping later operation and cancellation data outside the fixed project configuration.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Native invocation is caller-supplied data rather than a recognized consumer name or a patched child-process implementation.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraph explains fixed configuration, and separated member comments state paths and default meanings following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native executable and cwd representations stay distinct from argv strings; optional environment delegates to Node's supported native spawn behavior.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+ */
+export interface ResidentTransformProcessOptions {
+    /** Full argv of the host, including its serve subcommand. */
+    args: readonly string[];
+    /** Absolute path of the native transform host executable. */
+    binary: string;
+    /** Working directory of the host; defaults to the current directory. */
+    cwd?: string;
+    /** Environment of the host; defaults to this process's environment. */
+    env?: NodeJS.ProcessEnv;
+}

package/lib/compiler/internal/ResidentTransformProcessOptions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ResidentTransformProcessOptions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ResidentTransformProcessOptions.js","sourceRoot":"","sources":["../../../src/compiler/internal/ResidentTransformProcessOptions.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,51 @@
+import type { ResidentReplyKind } from "./ResidentReplyKind";
+/**
+ * Decode resident reply objects and validate their operation-specific fields.
+ *
+ * Parsing distinguishes malformed JSON or a non-object value from an object
+ * with the wrong reply shape. The transport owns how either failure settles its
+ * FIFO; these operations do not read pipes or manage a resident child.
+ *
+ * @evidence contracts/common.md#principled-implementation Separate object decoding and operation admission preserve the distinction the transport uses for framing failure versus one invalid reply.
+ * @evidence contracts/common.md#clear-and-simple-design One internal namespace owns the two reply-data operations used by the resident transport without acquiring its queue or process state.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The decoder and predicate retain ordinary JSON and field checks; no synthetic reply, foreign mutation or alternate host is introduced.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs identify the failure distinction and leave FIFO settlement and child lifetime with the transport.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This namespace groups JSON data operations and defines no native file, path or process boundary.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The namespace container performs no computation; its members own decoding and field checks.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The namespace stores no completed or in-flight results and coordinates no shared request work.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The namespace holds no mutable state, handles or running tasks.
+ */
+export declare namespace ResidentTransformReply {
+    /**
+     * Parse one JSON object, returning `undefined` for malformed JSON, arrays,
+     * primitives and `null`. An empty object remains an object for the separate
+     * operation-shape check; corrupt data never becomes a synthetic empty reply.
+     *
+     * @evidence contracts/common.md#principled-implementation JSON.parse owns JSON syntax and values; the nonnull object and nonarray checks admit only decoded object records.
+     * @evidence contracts/common.md#clear-and-simple-design One parse attempt followed by object admission leaves reply fields and transport settlement to their owning operations.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Parse failure remains undefined rather than being repaired or replaced with a successful negative reply.
+     * @evidence contracts/common.md#meaningful-documentation The native paragraph distinguishes malformed data from the empty object passed to shape validation.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation JSON text and decoded values are data; this operation accesses no filesystem or process.
+     * @evidence contracts/performance.md#efficient-algorithms The native JSON decoder scans the supplied text and allocates its decoded value; object admission uses fixed checks without a second traversal. Input text and decoded population determine time and temporary space.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call decodes its supplied reply; this operation coordinates no completed or in-flight work across requests.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The returned record transfers to the caller; this operation retains no historical values, handles or tasks and sets no input-size bound.
+     */
+    function parse(line: string): Record<string, unknown> | undefined;
+    /**
+     * Admit a decoded object for the operation the caller requested.
+     *
+     * Transform replies need boolean `found`; a found file also needs string
+     * `typescript`, including empty text. A missing file leaves text irrelevant.
+     * Update replies need boolean `updated`. Extra fields are allowed.
+     *
+     * @evidence contracts/common.md#principled-implementation The requested operation selects its required boolean field, and only a found transform requires text, preserving legitimate negative replies.
+     * @evidence contracts/common.md#clear-and-simple-design Fixed field checks consume the parsed record and operation discriminant without copying payloads or consulting transport state.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing and rejected outcomes remain valid booleans; wrong field types are rejected rather than coerced or inferred from unrelated fields.
+     * @evidence contracts/common.md#meaningful-documentation The native paragraph explains empty text, negative replies and permitted extra fields without claiming FIFO or lifecycle coverage.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation The operation inspects decoded fields without interpreting filenames or accessing native resources.
+     * @evidence contracts/performance.md#efficient-algorithms Admission performs a fixed number of property reads and type checks on ordinary JSON-decoded records, independent of text or extra-field count. Supplying a different accessor-bearing record can add caller-defined property-read work.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work The predicate coordinates no cross-request computation or cached admission result.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Field checks retain no reply, callback, handle or running task after return.
+     */
+    function isValid(reply: Record<string, unknown>, kind: ResidentReplyKind): boolean;
+}

package/lib/compiler/internal/ResidentTransformReply.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResidentTransformReply = void 0;
+/**
+ * Decode resident reply objects and validate their operation-specific fields.
+ *
+ * Parsing distinguishes malformed JSON or a non-object value from an object
+ * with the wrong reply shape. The transport owns how either failure settles its
+ * FIFO; these operations do not read pipes or manage a resident child.
+ *
+ * @evidence contracts/common.md#principled-implementation Separate object decoding and operation admission preserve the distinction the transport uses for framing failure versus one invalid reply.
+ * @evidence contracts/common.md#clear-and-simple-design One internal namespace owns the two reply-data operations used by the resident transport without acquiring its queue or process state.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The decoder and predicate retain ordinary JSON and field checks; no synthetic reply, foreign mutation or alternate host is introduced.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs identify the failure distinction and leave FIFO settlement and child lifetime with the transport.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This namespace groups JSON data operations and defines no native file, path or process boundary.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The namespace container performs no computation; its members own decoding and field checks.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The namespace stores no completed or in-flight results and coordinates no shared request work.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The namespace holds no mutable state, handles or running tasks.
+ */
+var ResidentTransformReply;
+(function (ResidentTransformReply) {
+    /**
+     * Parse one JSON object, returning `undefined` for malformed JSON, arrays,
+     * primitives and `null`. An empty object remains an object for the separate
+     * operation-shape check; corrupt data never becomes a synthetic empty reply.
+     *
+     * @evidence contracts/common.md#principled-implementation JSON.parse owns JSON syntax and values; the nonnull object and nonarray checks admit only decoded object records.
+     * @evidence contracts/common.md#clear-and-simple-design One parse attempt followed by object admission leaves reply fields and transport settlement to their owning operations.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Parse failure remains undefined rather than being repaired or replaced with a successful negative reply.
+     * @evidence contracts/common.md#meaningful-documentation The native paragraph distinguishes malformed data from the empty object passed to shape validation.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation JSON text and decoded values are data; this operation accesses no filesystem or process.
+     * @evidence contracts/performance.md#efficient-algorithms The native JSON decoder scans the supplied text and allocates its decoded value; object admission uses fixed checks without a second traversal. Input text and decoded population determine time and temporary space.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call decodes its supplied reply; this operation coordinates no completed or in-flight work across requests.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The returned record transfers to the caller; this operation retains no historical values, handles or tasks and sets no input-size bound.
+     */
+    function parse(line) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            return undefined;
+        }
+        if (typeof parsed === "object" &&
+            parsed !== null &&
+            !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return undefined;
+    }
+    ResidentTransformReply.parse = parse;
+    /**
+     * Admit a decoded object for the operation the caller requested.
+     *
+     * Transform replies need boolean `found`; a found file also needs string
+     * `typescript`, including empty text. A missing file leaves text irrelevant.
+     * Update replies need boolean `updated`. Extra fields are allowed.
+     *
+     * @evidence contracts/common.md#principled-implementation The requested operation selects its required boolean field, and only a found transform requires text, preserving legitimate negative replies.
+     * @evidence contracts/common.md#clear-and-simple-design Fixed field checks consume the parsed record and operation discriminant without copying payloads or consulting transport state.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing and rejected outcomes remain valid booleans; wrong field types are rejected rather than coerced or inferred from unrelated fields.
+     * @evidence contracts/common.md#meaningful-documentation The native paragraph explains empty text, negative replies and permitted extra fields without claiming FIFO or lifecycle coverage.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation The operation inspects decoded fields without interpreting filenames or accessing native resources.
+     * @evidence contracts/performance.md#efficient-algorithms Admission performs a fixed number of property reads and type checks on ordinary JSON-decoded records, independent of text or extra-field count. Supplying a different accessor-bearing record can add caller-defined property-read work.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work The predicate coordinates no cross-request computation or cached admission result.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Field checks retain no reply, callback, handle or running task after return.
+     */
+    function isValid(reply, kind) {
+        if (kind === "transform") {
+            if (typeof reply.found !== "boolean") {
+                return false;
+            }
+            return reply.found ? typeof reply.typescript === "string" : true;
+        }
+        return typeof reply.updated === "boolean";
+    }
+    ResidentTransformReply.isValid = isValid;
+})(ResidentTransformReply || (exports.ResidentTransformReply = ResidentTransformReply = {}));
+//# sourceMappingURL=ResidentTransformReply.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ResidentTransformReply.js","sourceRoot":"","sources":["../../../src/compiler/internal/ResidentTransformReply.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;GAeG;AACH,IAAiB,sBAAsB,CA4DtC;AA5DD,WAAiB,sBAAsB;IACrC;;;;;;;;;;;;;OAaG;IACH,SAAgB,KAAK,CAAC,IAAY;QAChC,IAAI,MAAe,CAAC;QACpB,IAAI,CAAC;YACH,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC5B,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,IACE,OAAO,MAAM,KAAK,QAAQ;YAC1B,MAAM,KAAK,IAAI;YACf,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EACtB,CAAC;YACD,OAAO,MAAiC,CAAC;QAC3C,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAfe,uBAAA,KAAK,QAepB,CAAA;IAED;;;;;;;;;;;;;;;OAeG;IACH,SAAgB,OAAO,CACrB,KAA8B,EAC9B,IAAuB;QAEvB,IAAI,IAAI,KAAK,WAAW,EAAE,CAAC;YACzB,IAAI,OAAO,KAAK,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;gBACrC,OAAO,KAAK,CAAC;YACf,CAAC;YACD,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,UAAU,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC;QACnE,CAAC;QACD,OAAO,OAAO,KAAK,CAAC,OAAO,KAAK,SAAS,CAAC;IAC5C,CAAC;IAXe,uBAAA,OAAO,UAWtB,CAAA;AACH,CAAC,EA5DgB,sBAAsB,aAAtB,sBAAsB,GAAtB,sBAAsB,QA4DtC"}

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

@@ -0,0 +1,16 @@
+/**
+ * Per-request lifecycle controls for a resident transform host.
+ *
+ * @evidence contracts/common.md#principled-implementation An optional AbortSignal represents caller cancellation, with omission leaving the live operation pending until reply or host retirement.
+ * @evidence contracts/common.md#clear-and-simple-design Cancellation belongs to one request rather than the fixed startup record; the transport owns the shared FIFO consequence after enqueueing.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The signal uses the supported cancellation interface and introduces no inferred deadline or fixture-dependent abort policy.
+ * @evidence contracts/common.md#meaningful-documentation The native member comment states the otherwise nonobvious in-flight retirement consequence, following the documentation skill.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
+ */
+export interface ResidentTransformRequestOptions {
+    /** Abort this request. An in-flight abort retires the FIFO host. */
+    signal?: AbortSignal;
+}

package/lib/compiler/internal/ResidentTransformRequestOptions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ResidentTransformRequestOptions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ResidentTransformRequestOptions.js","sourceRoot":"","sources":["../../../src/compiler/internal/ResidentTransformRequestOptions.ts"],"names":[],"mappings":""}