ttsc 0.30.3 → 0.31.0

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

@@ -0,0 +1,102 @@
+import type { ResidentReplyKind } from "./ResidentReplyKind";
+/**
+ * FIFO promise slots and terminal rejection for one resident reply stream. The
+ * transport owns framing, writing, error construction and child shutdown; this
+ * state owner releases settled callbacks and abort listeners.
+ *
+ * @evidence contracts/common.md#principled-implementation Each admitted slot settles once, head advancement preserves FIFO reply ownership, and retirement becomes terminal before all remaining slots are rejected.
+ * @evidence contracts/common.md#clear-and-simple-design One state owner holds slots, cursor and terminal error; native transport actions remain with ResidentTransformProcess.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Actual promise callbacks and AbortSignals are retained without constructing a peer, replacing streams or inventing host replies.
+ * @evidence contracts/common.md#meaningful-documentation Native prose bounds this state operation separately from framing, cancellation error policy and native shutdown.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This owner uses JavaScript arrays, callbacks and standard AbortSignal listeners without filesystem or native process operations.
+ * @evidence contracts/performance.md#efficient-algorithms Cursor settlement is amortized constant queue work; consumed prefixes compact only after at least half is consumed, while retirement drains the retained slot array linearly. Callback work remains supplied and is not bounded here.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Slots represent distinct live requests, not equivalent computations or a reusable reply cache.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Settlement releases its queue reference and abort listener; retirement detaches the queue and rejects live slots. Live pending population has no cap or deadline, and native child lifetime remains outside this owner.
+ */
+export declare class ResidentTransformRequests {
+    /** First terminal error, preserved for later request rejection. */
+    failure: Error | undefined;
+    private readonly pending;
+    private pendingHead;
+    /**
+     * Current FIFO slot, or no queued reply owner. This read does not consume it.
+     *
+     * @evidence contracts/common.md#principled-implementation The current cursor identifies the single slot that may own the next reply without advancing or inventing an owner.
+     * @evidence contracts/common.md#clear-and-simple-design A read-only cursor lookup separates reply ownership from settlement.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Only an admitted array slot is returned; no synthetic request or reply is constructed.
+     * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes observing the slot from consuming it.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation In-memory array indexing has no native platform boundary.
+     * @evidence contracts/performance.md#efficient-algorithms One cursor-indexed array read does not scan the pending population.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This is a state lookup, not reusable computation coordination.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The returned slot remains owned by the queue and caller; this read creates no historical state or handle.
+     */
+    current(): PendingRequest | undefined;
+    /**
+     * Admit one already framed line to its FIFO owner. Malformed or unsolicited
+     * replies retire the stream; an invalid operation shape rejects only its own
+     * slot. Return whether native transport teardown is now required.
+     *
+     * @evidence contracts/common.md#principled-implementation Terminal tails and blank lines are ignored, malformed JSON retires all live slots to prevent shifted ownership, and valid JSON with the wrong operation shape consumes only the current slot.
+     * @evidence contracts/common.md#clear-and-simple-design Existing reply parsing and admission feed the same settlement and retirement owner without taking over native line framing.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Actual framed text and slot kind drive outcomes; no peer, compiler reply or native-close receipt is invented.
+     * @evidence contracts/common.md#meaningful-documentation Native prose separates stream corruption from operation-shape failure and transport teardown.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation String and JSON admission performs no native stream or process operation.
+     * @evidence contracts/performance.md#efficient-algorithms Trimming and JSON parsing cost line bytes; error echo is capped at 200 code units, settlement is amortized queue work and terminal retirement visits outstanding slots.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each line belongs to one request; no reply result is memoized or reused.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Settlement and retirement release slots/listeners; supplied framed lines have no length bound here, while retained error echoes are capped. Native pipes and child release remain with the transport.
+     */
+    accept(line: string): boolean;
+    /**
+     * Register one slot and its optional abort listener before enqueueing it. The
+     * transport performs its original post-enqueue aborted check and write.
+     *
+     * @evidence contracts/common.md#principled-implementation Resolver identity and expected reply kind stay with one slot; the standard signal listener invokes the owning transport's cancellation operation.
+     * @evidence contracts/common.md#clear-and-simple-design Admission creates the slot, installs its listener and appends it in that order, while write and cancellation policy remain with the transport.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The supplied callback is the production cancellation owner, with no fake stream, peer or host output.
+     * @evidence contracts/common.md#meaningful-documentation Native prose identifies listener order and the remaining post-enqueue/write responsibility.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation Array admission and standard AbortSignal registration perform no native platform operation.
+     * @evidence contracts/performance.md#efficient-algorithms Admission appends one slot and registers at most one listener; callback execution costs belong to the supplied cancellation operation.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Every slot represents a distinct request and no computation reuse is selected.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Each live slot retains resolver callbacks and at most one abort listener until settlement or retirement; pending population is uncapped.
+     */
+    add(kind: ResidentReplyKind, resolve: (reply: Record<string, unknown>) => void, reject: (reason: Error) => void, signal: AbortSignal | undefined, onAbort: (pending: PendingRequest) => void): PendingRequest;
+    /**
+     * Settle a slot once, releasing its listener and any matching FIFO head.
+     * Detached slots from retirement still settle but cannot shift a newer head.
+     *
+     * @evidence contracts/common.md#principled-implementation The settled guard prevents duplicate callbacks; head identity controls cursor advancement and Error results reject while object replies resolve.
+     * @evidence contracts/common.md#clear-and-simple-design One settlement operation handles normal replies, write errors, cancellation and detached retirement slots.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Settlement uses the actual supplied result and slot identity without inferring host status or replacing promise callbacks.
+     * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes head release, detached slots and exactly-once settlement.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation Standard signal listener removal and in-memory promise callbacks need no native platform branch.
+     * @evidence contracts/performance.md#efficient-algorithms Head movement is constant until half-consumed compaction copies the remaining array, giving amortized constant queue work; supplied callback work is additional.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Exactly-once slot settlement is request ownership, not reusable computation selection.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources A settled head clears its array reference, and settlement removes its abort listener before callbacks. A non-head slot can remain referenced until head progression or retirement, with no history retained after detachment.
+     */
+    settle(pending: PendingRequest, result: Error | Record<string, unknown>): void;
+    /**
+     * Preserve the first failure and reject all remaining slots before the
+     * transport tears down its reader and child. Return whether this call
+     * retired.
+     *
+     * @evidence contracts/common.md#principled-implementation Terminal error assignment precedes queue detachment and rejection, so reentrant callers observe failure and later retirement cannot replace the original error.
+     * @evidence contracts/common.md#clear-and-simple-design State retirement returns a transition indicator; the actual transport alone owns reader, pipe and child termination.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts No child exit or stream-close outcome is fabricated from terminal queue state.
+     * @evidence contracts/common.md#meaningful-documentation Native prose identifies ordering, first-error identity and the caller's remaining native teardown.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation Queue detachment and callback settlement are in-memory operations, independent of native signaling.
+     * @evidence contracts/performance.md#efficient-algorithms One array detachment and one visit per retained slot drain the queue; rejection callback work remains additional.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work The terminal guard makes a state transition idempotent rather than reusing a computation result.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Detached slots settle and remove listeners; only the terminal Error remains with this owner. Child handles and termination timers remain with the actual transport.
+     */
+    retire(error: Error): boolean;
+}
+/** Actual resolver callbacks and optional abort listener for one FIFO slot. */
+interface PendingRequest {
+    abort?: () => void;
+    kind: ResidentReplyKind;
+    reject: (reason: Error) => void;
+    resolve: (reply: Record<string, unknown>) => void;
+    settled: boolean;
+    signal?: AbortSignal;
+}
+export {};

package/lib/compiler/internal/ResidentTransformRequests.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResidentTransformRequests = void 0;
+const ResidentTransformReply_1 = require("./ResidentTransformReply");
+/**
+ * FIFO promise slots and terminal rejection for one resident reply stream. The
+ * transport owns framing, writing, error construction and child shutdown; this
+ * state owner releases settled callbacks and abort listeners.
+ *
+ * @evidence contracts/common.md#principled-implementation Each admitted slot settles once, head advancement preserves FIFO reply ownership, and retirement becomes terminal before all remaining slots are rejected.
+ * @evidence contracts/common.md#clear-and-simple-design One state owner holds slots, cursor and terminal error; native transport actions remain with ResidentTransformProcess.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Actual promise callbacks and AbortSignals are retained without constructing a peer, replacing streams or inventing host replies.
+ * @evidence contracts/common.md#meaningful-documentation Native prose bounds this state operation separately from framing, cancellation error policy and native shutdown.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This owner uses JavaScript arrays, callbacks and standard AbortSignal listeners without filesystem or native process operations.
+ * @evidence contracts/performance.md#efficient-algorithms Cursor settlement is amortized constant queue work; consumed prefixes compact only after at least half is consumed, while retirement drains the retained slot array linearly. Callback work remains supplied and is not bounded here.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Slots represent distinct live requests, not equivalent computations or a reusable reply cache.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Settlement releases its queue reference and abort listener; retirement detaches the queue and rejects live slots. Live pending population has no cap or deadline, and native child lifetime remains outside this owner.
+ */
+class ResidentTransformRequests {
+    /** First terminal error, preserved for later request rejection. */
+    failure;
+    pending = [];
+    pendingHead = 0;
+    /**
+     * Current FIFO slot, or no queued reply owner. This read does not consume it.
+     *
+     * @evidence contracts/common.md#principled-implementation The current cursor identifies the single slot that may own the next reply without advancing or inventing an owner.
+     * @evidence contracts/common.md#clear-and-simple-design A read-only cursor lookup separates reply ownership from settlement.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Only an admitted array slot is returned; no synthetic request or reply is constructed.
+     * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes observing the slot from consuming it.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation In-memory array indexing has no native platform boundary.
+     * @evidence contracts/performance.md#efficient-algorithms One cursor-indexed array read does not scan the pending population.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This is a state lookup, not reusable computation coordination.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The returned slot remains owned by the queue and caller; this read creates no historical state or handle.
+     */
+    current() {
+        return this.pending[this.pendingHead];
+    }
+    /**
+     * Admit one already framed line to its FIFO owner. Malformed or unsolicited
+     * replies retire the stream; an invalid operation shape rejects only its own
+     * slot. Return whether native transport teardown is now required.
+     *
+     * @evidence contracts/common.md#principled-implementation Terminal tails and blank lines are ignored, malformed JSON retires all live slots to prevent shifted ownership, and valid JSON with the wrong operation shape consumes only the current slot.
+     * @evidence contracts/common.md#clear-and-simple-design Existing reply parsing and admission feed the same settlement and retirement owner without taking over native line framing.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Actual framed text and slot kind drive outcomes; no peer, compiler reply or native-close receipt is invented.
+     * @evidence contracts/common.md#meaningful-documentation Native prose separates stream corruption from operation-shape failure and transport teardown.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation String and JSON admission performs no native stream or process operation.
+     * @evidence contracts/performance.md#efficient-algorithms Trimming and JSON parsing cost line bytes; error echo is capped at 200 code units, settlement is amortized queue work and terminal retirement visits outstanding slots.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each line belongs to one request; no reply result is memoized or reused.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Settlement and retirement release slots/listeners; supplied framed lines have no length bound here, while retained error echoes are capped. Native pipes and child release remain with the transport.
+     */
+    accept(line) {
+        if (this.failure !== undefined)
+            return false;
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            return false;
+        const request = this.current();
+        if (request === undefined) {
+            return this.retire(new Error("ttsc: resident transform host sent an unsolicited reply"));
+        }
+        const reply = ResidentTransformReply_1.ResidentTransformReply.parse(trimmed);
+        if (reply === undefined) {
+            const error = new Error(`ttsc: resident transform host sent a malformed reply: ${echoLine(trimmed)}`);
+            this.settle(request, error);
+            return this.retire(error);
+        }
+        if (!ResidentTransformReply_1.ResidentTransformReply.isValid(reply, request.kind)) {
+            this.settle(request, new Error(`ttsc: resident transform host sent an invalid ${request.kind} reply: ${echoLine(trimmed)}`));
+            return false;
+        }
+        this.settle(request, reply);
+        return false;
+    }
+    /**
+     * Register one slot and its optional abort listener before enqueueing it. The
+     * transport performs its original post-enqueue aborted check and write.
+     *
+     * @evidence contracts/common.md#principled-implementation Resolver identity and expected reply kind stay with one slot; the standard signal listener invokes the owning transport's cancellation operation.
+     * @evidence contracts/common.md#clear-and-simple-design Admission creates the slot, installs its listener and appends it in that order, while write and cancellation policy remain with the transport.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The supplied callback is the production cancellation owner, with no fake stream, peer or host output.
+     * @evidence contracts/common.md#meaningful-documentation Native prose identifies listener order and the remaining post-enqueue/write responsibility.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation Array admission and standard AbortSignal registration perform no native platform operation.
+     * @evidence contracts/performance.md#efficient-algorithms Admission appends one slot and registers at most one listener; callback execution costs belong to the supplied cancellation operation.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Every slot represents a distinct request and no computation reuse is selected.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Each live slot retains resolver callbacks and at most one abort listener until settlement or retirement; pending population is uncapped.
+     */
+    add(kind, resolve, reject, signal, onAbort) {
+        const pending = {
+            kind,
+            reject,
+            resolve,
+            settled: false,
+            signal,
+        };
+        if (signal !== undefined) {
+            pending.abort = () => onAbort(pending);
+            signal.addEventListener("abort", pending.abort, { once: true });
+        }
+        this.pending.push(pending);
+        return pending;
+    }
+    /**
+     * Settle a slot once, releasing its listener and any matching FIFO head.
+     * Detached slots from retirement still settle but cannot shift a newer head.
+     *
+     * @evidence contracts/common.md#principled-implementation The settled guard prevents duplicate callbacks; head identity controls cursor advancement and Error results reject while object replies resolve.
+     * @evidence contracts/common.md#clear-and-simple-design One settlement operation handles normal replies, write errors, cancellation and detached retirement slots.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Settlement uses the actual supplied result and slot identity without inferring host status or replacing promise callbacks.
+     * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes head release, detached slots and exactly-once settlement.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation Standard signal listener removal and in-memory promise callbacks need no native platform branch.
+     * @evidence contracts/performance.md#efficient-algorithms Head movement is constant until half-consumed compaction copies the remaining array, giving amortized constant queue work; supplied callback work is additional.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Exactly-once slot settlement is request ownership, not reusable computation selection.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources A settled head clears its array reference, and settlement removes its abort listener before callbacks. A non-head slot can remain referenced until head progression or retirement, with no history retained after detachment.
+     */
+    settle(pending, result) {
+        if (pending.settled)
+            return;
+        pending.settled = true;
+        if (this.pending[this.pendingHead] === pending) {
+            this.pending[this.pendingHead++] = undefined;
+            if (this.pendingHead * 2 >= this.pending.length) {
+                this.pending.splice(0, this.pendingHead);
+                this.pendingHead = 0;
+            }
+        }
+        if (pending.signal !== undefined && pending.abort !== undefined) {
+            pending.signal.removeEventListener("abort", pending.abort);
+        }
+        if (result instanceof Error)
+            pending.reject(result);
+        else
+            pending.resolve(result);
+    }
+    /**
+     * Preserve the first failure and reject all remaining slots before the
+     * transport tears down its reader and child. Return whether this call
+     * retired.
+     *
+     * @evidence contracts/common.md#principled-implementation Terminal error assignment precedes queue detachment and rejection, so reentrant callers observe failure and later retirement cannot replace the original error.
+     * @evidence contracts/common.md#clear-and-simple-design State retirement returns a transition indicator; the actual transport alone owns reader, pipe and child termination.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts No child exit or stream-close outcome is fabricated from terminal queue state.
+     * @evidence contracts/common.md#meaningful-documentation Native prose identifies ordering, first-error identity and the caller's remaining native teardown.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation Queue detachment and callback settlement are in-memory operations, independent of native signaling.
+     * @evidence contracts/performance.md#efficient-algorithms One array detachment and one visit per retained slot drain the queue; rejection callback work remains additional.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work The terminal guard makes a state transition idempotent rather than reusing a computation result.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Detached slots settle and remove listeners; only the terminal Error remains with this owner. Child handles and termination timers remain with the actual transport.
+     */
+    retire(error) {
+        if (this.failure !== undefined)
+            return false;
+        this.failure = error;
+        const pending = this.pending.splice(0);
+        this.pendingHead = 0;
+        for (const request of pending) {
+            if (request !== undefined)
+                this.settle(request, error);
+        }
+        return true;
+    }
+}
+exports.ResidentTransformRequests = ResidentTransformRequests;
+/** Cap on how much of an offending line an error message echoes back. */
+const REPLY_ECHO_LIMIT = 200;
+/** Truncate an offending reply line so error messages stay bounded. */
+function echoLine(line) {
+    return line.length > REPLY_ECHO_LIMIT
+        ? `${line.slice(0, REPLY_ECHO_LIMIT)}…`
+        : line;
+}
+//# sourceMappingURL=ResidentTransformRequests.js.map

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

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

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

@@ -0,0 +1,27 @@
+import { ResidentTransformProcess } from "./ResidentTransformProcess";
+/**
+ * A started resident transform host plus the project root its keys are relative
+ * to.
+ *
+ * Returned by {@link startResidentTransform}. The two travel together because a
+ * request names files by project-relative key; a differently selected root can
+ * produce a different key even when the caller intended the same file.
+ *
+ * @evidence contracts/common.md#principled-implementation Pairing the live client with the producer's project root preserves the identity needed to form its project-relative file keys.
+ * @evidence contracts/common.md#clear-and-simple-design One startup return record transfers the process and its key anchor together rather than asking callers to resolve the root again.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The root is the configured producer's actual anchor, not a guessed working directory or consumer-specific filename substitution.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain why the pair travels together, and separated members document disposal and root spelling following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The project root carries the native spelling used by the resident Program; callers derive keys relative to that same anchor instead of assuming a slash or case policy.
+ * @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 StartedResidentTransform {
+    /**
+     * Resident client handle transferred to the caller. Dispose it at shutdown;
+     * disposal requests retirement but is not an awaited child-close receipt.
+     */
+    process: ResidentTransformProcess;
+    /** Project root in the spelling the resident Program uses for its files. */
+    projectRoot: string;
+}

package/lib/compiler/internal/StartedResidentTransform.js

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

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

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

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

@@ -0,0 +1,34 @@
+import type { transformProjectInMemory } from "./transformProjectInMemory";
+/**
+ * A transform worker thread's answer to one
+ * {@link TransformProjectWorkerRequest}.
+ *
+ * `output` is what {@link transformProjectInMemory} returned. `thrown` describes
+ * what it threw instead. The shared error serializer preserves selected Error
+ * fields, enumerable custom data, causal failures and partial outcomes rather
+ * than relying on native Error cloning, which can drop aggregate failures. It
+ * describes repeated references and exceptional values with markers rather than
+ * preserving prototypes or every hidden property. A completed reply contains
+ * one branch; worker death or cloning failure can reject separately without
+ * delivering this envelope.
+ *
+ * @evidence contracts/common.md#principled-implementation Mutually exclusive output and thrown envelopes distinguish successful transform data from finite serialized causal failure graphs, including aggregate errors and partial compile outcomes that native Error cloning can omit.
+ * @evidence contracts/common.md#clear-and-simple-design One discriminated union carries the existing transform result or the shared serializer's unknown-valued description; API and worker failures use one causal-data policy rather than reconstructing only an outer Error message.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Exceptions remain failures with their original description rather than being converted to empty transform output or success-shaped default data.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraph explains both branches and the nonobvious custom-name transport requirement, following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The output branch carries transform result native path coordinates, input realpaths and graph/source identities across structured cloning without shell parsing or OS-name case reinterpretation. Exceptional values use the shared serializer's data markers; the carrier does not independently interpret native paths or reconstruct platform Error prototypes.
+ *
+ * @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 type TransformProjectWorkerReply = {
+    /** The complete synchronous transform result, copied back to its caller. */
+    output: ReturnType<typeof transformProjectInMemory>;
+} | {
+    /**
+     * Finite causal description from serializeCompilerError, preserved by the
+     * caller.
+     */
+    thrown: unknown;
+};

package/lib/compiler/internal/TransformProjectWorkerReply.js

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

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

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

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

@@ -0,0 +1,39 @@
+import type { ITtscCompilerContext } from "../../structures/ITtscCompilerContext";
+/**
+ * One project transform sent to a transform worker thread.
+ *
+ * The worker invokes {@link transformProjectInMemory} with the captured compiler
+ * context and invocation environment. Structured cloning and the plugin JSON
+ * channel transport caller data; they do not freeze filesystem state, scheduler
+ * timing or separate worker caches at request creation.
+ *
+ * @evidence contracts/common.md#principled-implementation The context determines project behavior, while a separate complete environment snapshot establishes invocation-time authority for the worker's in-process work and children.
+ * @evidence contracts/common.md#clear-and-simple-design Compiler selectors, plugin JSON payloads and thread-local ambient state remain distinct: a separate JSON channel preserves custom serialization when structured cloning drops the local adapter method.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Structured-clone data carries real caller authority without replacing the calling thread's global environment or adding measurement-only configuration.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain the snapshot timing and why scratch-directory authority must cover in-process work, with separated member comments following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The snapshot is merged by native environment-name identity before crossing the worker boundary; native project paths remain context values rather than shell command text.
+ * @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 TransformProjectWorkerRequest {
+    /** The compiler context of the {@link TtscCompiler} that asked. */
+    context: ITtscCompilerContext;
+    /**
+     * Captured JSON for each explicit plugin, paired by array index. Existing
+     * constructor-captured payloads are reused; an uncaptured context is encoded
+     * when the request is made. The worker restores local adapters without
+     * reevaluating custom toJSON. Undefined preserves configuration-discovered or
+     * disabled plugin selection.
+     */
+    serializedPlugins?: readonly (string | undefined)[];
+    /**
+     * The calling thread's `process.env` at the call with the compiler's own
+     * `env` merged over it, as its child processes take it. The worker makes it
+     * its own `process.env` before the transform and retains it until the next
+     * request adopts another environment or the worker exits. An environment the
+     * caller configured on the compiler, such as a scratch `TEMP`, covers the
+     * whole transform without the caller changing its own globals.
+     */
+    env: Record<string, string | undefined>;
+}

package/lib/compiler/internal/TransformProjectWorkerRequest.js

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

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

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