@ttsc/unplugin 0.30.4 → 0.31.1

package/lib/core/transform/diagnostics/reportSuccessDiagnostics.d.mts

@@ -0,0 +1,48 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
+/**
+ * Attempt non-fatal diagnostic reporting once per generation per pass.
+ *
+ * A `success` result may still carry warnings or informational messages from
+ * plugins — `@ttsc/lint` reports every rule below error severity this way. The
+ * ordinary reporting path uses stderr without turning diagnostics into a
+ * compile error. Failure and exception envelopes are handled by the caller.
+ *
+ * They describe one compile of one program, so writing them per delivery
+ * printed the same warning once per module and scaled the noise with exactly
+ * the reuse the cache exists to provide (samchon/ttsc#1304). A pass that reuses
+ * a retained generation still attempts reporting once, because a build's
+ * warnings are part of what that build reports; a host with no pass boundary
+ * attempts them once per generation, which is the same rule with one pass.
+ * Reporting state is recorded before formatting and writing. A synchronous
+ * formatter or stream failure propagates without undoing suppression; this
+ * state does not certify that the stream successfully displayed a message.
+ *
+ * @evidence contracts/common.md#principled-implementation Only nonempty success-envelope diagnostics enter a reporting attempt per delivery epoch, so the failure formatter's empty-list fallback cannot turn an ordinary success into a misleading failure report. Reporting state records the attempt before formatting or stream output.
+ * @evidence contracts/common.md#clear-and-simple-design Result gating and generation-owned reporting state keep nonfatal reporting separate from compilation failure handling.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Severity and success follow the structured envelope rather than warning-text matching, and an empty success list does not manufacture a failure diagnostic.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain nonfatal diagnostics and why both retained generations and fresh passes must report them once.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   Forwards formatted structured text to the existing stderr stream, without
+ *   resolving supplied locations, selecting an executable or interpreting
+ *   native path identity or capabilities. Text can contain multiple lines.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Fixed envelope/epoch gates avoid formatting on suppressed deliveries.
+ *   An admitted attempt projects every diagnostic, strips CSI escapes and
+ *   joins locations/messages: work and temporary text scale with diagnostic
+ *   count and total rendered text. Stream output adds the message byte cost.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The generation's fixed diagnostic envelope and mutable reporting fields
+ *   skip formatting and writing for repeated requests in the recorded epoch.
+ *   Undefined persistent epochs still admit the first attempt because the
+ *   boolean is separate. Failed attempts retain suppression rather than
+ *   claiming success.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   Two scalar reporting fields remain with the generation without per-request
+ *   history. Formatted text is not cached here; stderr owns buffered bytes and
+ *   backpressure. This reporter acquires no independent handle or running task.
+ */
+export declare function reportSuccessDiagnostics(
+/** Generation owning structured diagnostics and attempted-report state. */
+cached: TtscCachedProjectTransform, 
+/** Delivery pass, or undefined for persistent generation reporting. */
+epoch: number | undefined): void;

package/lib/core/transform/diagnostics/reportSuccessDiagnostics.d.ts

@@ -0,0 +1,48 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+/**
+ * Attempt non-fatal diagnostic reporting once per generation per pass.
+ *
+ * A `success` result may still carry warnings or informational messages from
+ * plugins — `@ttsc/lint` reports every rule below error severity this way. The
+ * ordinary reporting path uses stderr without turning diagnostics into a
+ * compile error. Failure and exception envelopes are handled by the caller.
+ *
+ * They describe one compile of one program, so writing them per delivery
+ * printed the same warning once per module and scaled the noise with exactly
+ * the reuse the cache exists to provide (samchon/ttsc#1304). A pass that reuses
+ * a retained generation still attempts reporting once, because a build's
+ * warnings are part of what that build reports; a host with no pass boundary
+ * attempts them once per generation, which is the same rule with one pass.
+ * Reporting state is recorded before formatting and writing. A synchronous
+ * formatter or stream failure propagates without undoing suppression; this
+ * state does not certify that the stream successfully displayed a message.
+ *
+ * @evidence contracts/common.md#principled-implementation Only nonempty success-envelope diagnostics enter a reporting attempt per delivery epoch, so the failure formatter's empty-list fallback cannot turn an ordinary success into a misleading failure report. Reporting state records the attempt before formatting or stream output.
+ * @evidence contracts/common.md#clear-and-simple-design Result gating and generation-owned reporting state keep nonfatal reporting separate from compilation failure handling.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Severity and success follow the structured envelope rather than warning-text matching, and an empty success list does not manufacture a failure diagnostic.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain nonfatal diagnostics and why both retained generations and fresh passes must report them once.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   Forwards formatted structured text to the existing stderr stream, without
+ *   resolving supplied locations, selecting an executable or interpreting
+ *   native path identity or capabilities. Text can contain multiple lines.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Fixed envelope/epoch gates avoid formatting on suppressed deliveries.
+ *   An admitted attempt projects every diagnostic, strips CSI escapes and
+ *   joins locations/messages: work and temporary text scale with diagnostic
+ *   count and total rendered text. Stream output adds the message byte cost.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The generation's fixed diagnostic envelope and mutable reporting fields
+ *   skip formatting and writing for repeated requests in the recorded epoch.
+ *   Undefined persistent epochs still admit the first attempt because the
+ *   boolean is separate. Failed attempts retain suppression rather than
+ *   claiming success.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   Two scalar reporting fields remain with the generation without per-request
+ *   history. Formatted text is not cached here; stderr owns buffered bytes and
+ *   backpressure. This reporter acquires no independent handle or running task.
+ */
+export declare function reportSuccessDiagnostics(
+/** Generation owning structured diagnostics and attempted-report state. */
+cached: TtscCachedProjectTransform, 
+/** Delivery pass, or undefined for persistent generation reporting. */
+epoch: number | undefined): void;

package/lib/core/transform/diagnostics/reportSuccessDiagnostics.js

@@ -0,0 +1,71 @@
+'use strict';
+
+var formatDiagnostics = require('./formatDiagnostics.js');
+
+/**
+ * Attempt non-fatal diagnostic reporting once per generation per pass.
+ *
+ * A `success` result may still carry warnings or informational messages from
+ * plugins — `@ttsc/lint` reports every rule below error severity this way. The
+ * ordinary reporting path uses stderr without turning diagnostics into a
+ * compile error. Failure and exception envelopes are handled by the caller.
+ *
+ * They describe one compile of one program, so writing them per delivery
+ * printed the same warning once per module and scaled the noise with exactly
+ * the reuse the cache exists to provide (samchon/ttsc#1304). A pass that reuses
+ * a retained generation still attempts reporting once, because a build's
+ * warnings are part of what that build reports; a host with no pass boundary
+ * attempts them once per generation, which is the same rule with one pass.
+ * Reporting state is recorded before formatting and writing. A synchronous
+ * formatter or stream failure propagates without undoing suppression; this
+ * state does not certify that the stream successfully displayed a message.
+ *
+ * @evidence contracts/common.md#principled-implementation Only nonempty success-envelope diagnostics enter a reporting attempt per delivery epoch, so the failure formatter's empty-list fallback cannot turn an ordinary success into a misleading failure report. Reporting state records the attempt before formatting or stream output.
+ * @evidence contracts/common.md#clear-and-simple-design Result gating and generation-owned reporting state keep nonfatal reporting separate from compilation failure handling.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Severity and success follow the structured envelope rather than warning-text matching, and an empty success list does not manufacture a failure diagnostic.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain nonfatal diagnostics and why both retained generations and fresh passes must report them once.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   Forwards formatted structured text to the existing stderr stream, without
+ *   resolving supplied locations, selecting an executable or interpreting
+ *   native path identity or capabilities. Text can contain multiple lines.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Fixed envelope/epoch gates avoid formatting on suppressed deliveries.
+ *   An admitted attempt projects every diagnostic, strips CSI escapes and
+ *   joins locations/messages: work and temporary text scale with diagnostic
+ *   count and total rendered text. Stream output adds the message byte cost.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The generation's fixed diagnostic envelope and mutable reporting fields
+ *   skip formatting and writing for repeated requests in the recorded epoch.
+ *   Undefined persistent epochs still admit the first attempt because the
+ *   boolean is separate. Failed attempts retain suppression rather than
+ *   claiming success.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   Two scalar reporting fields remain with the generation without per-request
+ *   history. Formatted text is not cached here; stderr owns buffered bytes and
+ *   backpressure. This reporter acquires no independent handle or running task.
+ */
+function reportSuccessDiagnostics(
+/** Generation owning structured diagnostics and attempted-report state. */
+cached, 
+/** Delivery pass, or undefined for persistent generation reporting. */
+epoch) {
+    const result = cached.result;
+    if (result.type !== "success" ||
+        result.diagnostics === undefined ||
+        result.diagnostics.length === 0) {
+        return;
+    }
+    if (cached.diagnosticsReported === true &&
+        cached.diagnosticsEpoch === epoch) {
+        return;
+    }
+    cached.diagnosticsReported = true;
+    cached.diagnosticsEpoch = epoch;
+    const text = formatDiagnostics.formatDiagnostics(result.diagnostics);
+    if (text.length !== 0) {
+        process.stderr.write(`${text}\n`);
+    }
+}
+
+exports.reportSuccessDiagnostics = reportSuccessDiagnostics;
+//# sourceMappingURL=reportSuccessDiagnostics.js.map

package/lib/core/transform/diagnostics/reportSuccessDiagnostics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reportSuccessDiagnostics.js","sources":["../../../../src/core/transform/diagnostics/reportSuccessDiagnostics.ts"],"sourcesContent":[null],"names":["formatDiagnostics"],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCG;SACa,wBAAwB;AACtC;AACA,MAAkC;AAClC;AACA,KAAyB,EAAA;AAEzB,IAAA,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM;AAC5B,IAAA,IACE,MAAM,CAAC,IAAI,KAAK,SAAS;QACzB,MAAM,CAAC,WAAW,KAAK,SAAS;AAChC,QAAA,MAAM,CAAC,WAAW,CAAC,MAAM,KAAK,CAAC,EAC/B;QACA;IACF;AACA,IAAA,IACE,MAAM,CAAC,mBAAmB,KAAK,IAAI;AACnC,QAAA,MAAM,CAAC,gBAAgB,KAAK,KAAK,EACjC;QACA;IACF;AACA,IAAA,MAAM,CAAC,mBAAmB,GAAG,IAAI;AACjC,IAAA,MAAM,CAAC,gBAAgB,GAAG,KAAK;IAC/B,MAAM,IAAI,GAAGA,mCAAiB,CAAC,MAAM,CAAC,WAAW,CAAC;AAClD,IAAA,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;QACrB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA,EAAG,IAAI,CAAA,EAAA,CAAI,CAAC;IACnC;AACF;;;;"}

package/lib/core/transform/diagnostics/reportSuccessDiagnostics.mjs

@@ -0,0 +1,69 @@
+import { formatDiagnostics } from './formatDiagnostics.mjs';
+
+/**
+ * Attempt non-fatal diagnostic reporting once per generation per pass.
+ *
+ * A `success` result may still carry warnings or informational messages from
+ * plugins — `@ttsc/lint` reports every rule below error severity this way. The
+ * ordinary reporting path uses stderr without turning diagnostics into a
+ * compile error. Failure and exception envelopes are handled by the caller.
+ *
+ * They describe one compile of one program, so writing them per delivery
+ * printed the same warning once per module and scaled the noise with exactly
+ * the reuse the cache exists to provide (samchon/ttsc#1304). A pass that reuses
+ * a retained generation still attempts reporting once, because a build's
+ * warnings are part of what that build reports; a host with no pass boundary
+ * attempts them once per generation, which is the same rule with one pass.
+ * Reporting state is recorded before formatting and writing. A synchronous
+ * formatter or stream failure propagates without undoing suppression; this
+ * state does not certify that the stream successfully displayed a message.
+ *
+ * @evidence contracts/common.md#principled-implementation Only nonempty success-envelope diagnostics enter a reporting attempt per delivery epoch, so the failure formatter's empty-list fallback cannot turn an ordinary success into a misleading failure report. Reporting state records the attempt before formatting or stream output.
+ * @evidence contracts/common.md#clear-and-simple-design Result gating and generation-owned reporting state keep nonfatal reporting separate from compilation failure handling.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Severity and success follow the structured envelope rather than warning-text matching, and an empty success list does not manufacture a failure diagnostic.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain nonfatal diagnostics and why both retained generations and fresh passes must report them once.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   Forwards formatted structured text to the existing stderr stream, without
+ *   resolving supplied locations, selecting an executable or interpreting
+ *   native path identity or capabilities. Text can contain multiple lines.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Fixed envelope/epoch gates avoid formatting on suppressed deliveries.
+ *   An admitted attempt projects every diagnostic, strips CSI escapes and
+ *   joins locations/messages: work and temporary text scale with diagnostic
+ *   count and total rendered text. Stream output adds the message byte cost.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The generation's fixed diagnostic envelope and mutable reporting fields
+ *   skip formatting and writing for repeated requests in the recorded epoch.
+ *   Undefined persistent epochs still admit the first attempt because the
+ *   boolean is separate. Failed attempts retain suppression rather than
+ *   claiming success.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   Two scalar reporting fields remain with the generation without per-request
+ *   history. Formatted text is not cached here; stderr owns buffered bytes and
+ *   backpressure. This reporter acquires no independent handle or running task.
+ */
+function reportSuccessDiagnostics(
+/** Generation owning structured diagnostics and attempted-report state. */
+cached, 
+/** Delivery pass, or undefined for persistent generation reporting. */
+epoch) {
+    const result = cached.result;
+    if (result.type !== "success" ||
+        result.diagnostics === undefined ||
+        result.diagnostics.length === 0) {
+        return;
+    }
+    if (cached.diagnosticsReported === true &&
+        cached.diagnosticsEpoch === epoch) {
+        return;
+    }
+    cached.diagnosticsReported = true;
+    cached.diagnosticsEpoch = epoch;
+    const text = formatDiagnostics(result.diagnostics);
+    if (text.length !== 0) {
+        process.stderr.write(`${text}\n`);
+    }
+}
+
+export { reportSuccessDiagnostics };
+//# sourceMappingURL=reportSuccessDiagnostics.mjs.map

package/lib/core/transform/diagnostics/reportSuccessDiagnostics.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"reportSuccessDiagnostics.mjs","sources":["../../../../src/core/transform/diagnostics/reportSuccessDiagnostics.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCG;SACa,wBAAwB;AACtC;AACA,MAAkC;AAClC;AACA,KAAyB,EAAA;AAEzB,IAAA,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM;AAC5B,IAAA,IACE,MAAM,CAAC,IAAI,KAAK,SAAS;QACzB,MAAM,CAAC,WAAW,KAAK,SAAS;AAChC,QAAA,MAAM,CAAC,WAAW,CAAC,MAAM,KAAK,CAAC,EAC/B;QACA;IACF;AACA,IAAA,IACE,MAAM,CAAC,mBAAmB,KAAK,IAAI;AACnC,QAAA,MAAM,CAAC,gBAAgB,KAAK,KAAK,EACjC;QACA;IACF;AACA,IAAA,MAAM,CAAC,mBAAmB,GAAG,IAAI;AACjC,IAAA,MAAM,CAAC,gBAAgB,GAAG,KAAK;IAC/B,MAAM,IAAI,GAAG,iBAAiB,CAAC,MAAM,CAAC,WAAW,CAAC;AAClD,IAAA,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;QACrB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA,EAAG,IAAI,CAAA,EAAA,CAAI,CAAC;IACnC;AACF;;;;"}

package/lib/core/transform/diagnostics/stripTerminalEscapes.d.cts

@@ -0,0 +1,34 @@
+/**
+ * Remove ANSI CSI colour and cursor sequences from surfaced text.
+ *
+ * An opaque host exception can contain the host's own rendered output, colour
+ * and all, with no structured diagnostics to format instead. What the adapter
+ * hands back is not going to a terminal: it becomes the `Error` a bundler
+ * reports, so it lands in a Vite overlay, a webpack error report or a CI
+ * annotation, where the escapes render as literal noise around the file and
+ * line the reader needs. Other terminal protocols, including OSC hyperlinks,
+ * are outside this grammar and remain in the returned text.
+ *
+ * The colour originates in the host's rendering rather than in anything this
+ * adapter configures, so this is the adapter-side repair, applied to every
+ * message it surfaces rather than to one call site.
+ *
+ * @evidence contracts/common.md#principled-implementation The regular expression removes ANSI CSI control sequences from the presentation string, retaining ordinary diagnostic text; other terminal protocols are outside its current grammar.
+ * @evidence contracts/common.md#clear-and-simple-design One replacement owns the supported escape grammar, so every caller uses the same presentation boundary.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The grammar follows control-sequence syntax without matching fixture-specific colours, exception messages or expected output.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain the nonterminal destination and inline comments explain the deliberately visible expression construction.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   Performs no filesystem, path or process operation of its own.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   One CSI replacement scans message text in linear time; the two repeated
+ *   character classes are disjoint and cannot consume the escape introducer.
+ *   Output storage is at most the input length.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   All message formatters reuse the same private compiled CSI expression.
+ *   Global String.replace resets its matching position for each synchronous
+ *   call; no input-dependent result or mutable caller text is cached.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   One fixed compiled expression lives with the module; no input text or
+ *   replacement result survives a call. No handle or running task is acquired.
+ */
+export declare function stripTerminalEscapes(text: string): string;

package/lib/core/transform/diagnostics/stripTerminalEscapes.d.mts

@@ -0,0 +1,34 @@
+/**
+ * Remove ANSI CSI colour and cursor sequences from surfaced text.
+ *
+ * An opaque host exception can contain the host's own rendered output, colour
+ * and all, with no structured diagnostics to format instead. What the adapter
+ * hands back is not going to a terminal: it becomes the `Error` a bundler
+ * reports, so it lands in a Vite overlay, a webpack error report or a CI
+ * annotation, where the escapes render as literal noise around the file and
+ * line the reader needs. Other terminal protocols, including OSC hyperlinks,
+ * are outside this grammar and remain in the returned text.
+ *
+ * The colour originates in the host's rendering rather than in anything this
+ * adapter configures, so this is the adapter-side repair, applied to every
+ * message it surfaces rather than to one call site.
+ *
+ * @evidence contracts/common.md#principled-implementation The regular expression removes ANSI CSI control sequences from the presentation string, retaining ordinary diagnostic text; other terminal protocols are outside its current grammar.
+ * @evidence contracts/common.md#clear-and-simple-design One replacement owns the supported escape grammar, so every caller uses the same presentation boundary.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The grammar follows control-sequence syntax without matching fixture-specific colours, exception messages or expected output.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain the nonterminal destination and inline comments explain the deliberately visible expression construction.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   Performs no filesystem, path or process operation of its own.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   One CSI replacement scans message text in linear time; the two repeated
+ *   character classes are disjoint and cannot consume the escape introducer.
+ *   Output storage is at most the input length.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   All message formatters reuse the same private compiled CSI expression.
+ *   Global String.replace resets its matching position for each synchronous
+ *   call; no input-dependent result or mutable caller text is cached.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   One fixed compiled expression lives with the module; no input text or
+ *   replacement result survives a call. No handle or running task is acquired.
+ */
+export declare function stripTerminalEscapes(text: string): string;

package/lib/core/transform/diagnostics/stripTerminalEscapes.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Remove ANSI CSI colour and cursor sequences from surfaced text.
+ *
+ * An opaque host exception can contain the host's own rendered output, colour
+ * and all, with no structured diagnostics to format instead. What the adapter
+ * hands back is not going to a terminal: it becomes the `Error` a bundler
+ * reports, so it lands in a Vite overlay, a webpack error report or a CI
+ * annotation, where the escapes render as literal noise around the file and
+ * line the reader needs. Other terminal protocols, including OSC hyperlinks,
+ * are outside this grammar and remain in the returned text.
+ *
+ * The colour originates in the host's rendering rather than in anything this
+ * adapter configures, so this is the adapter-side repair, applied to every
+ * message it surfaces rather than to one call site.
+ *
+ * @evidence contracts/common.md#principled-implementation The regular expression removes ANSI CSI control sequences from the presentation string, retaining ordinary diagnostic text; other terminal protocols are outside its current grammar.
+ * @evidence contracts/common.md#clear-and-simple-design One replacement owns the supported escape grammar, so every caller uses the same presentation boundary.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The grammar follows control-sequence syntax without matching fixture-specific colours, exception messages or expected output.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain the nonterminal destination and inline comments explain the deliberately visible expression construction.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   Performs no filesystem, path or process operation of its own.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   One CSI replacement scans message text in linear time; the two repeated
+ *   character classes are disjoint and cannot consume the escape introducer.
+ *   Output storage is at most the input length.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   All message formatters reuse the same private compiled CSI expression.
+ *   Global String.replace resets its matching position for each synchronous
+ *   call; no input-dependent result or mutable caller text is cached.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   One fixed compiled expression lives with the module; no input text or
+ *   replacement result survives a call. No handle or running task is acquired.
+ */
+export declare function stripTerminalEscapes(text: string): string;

package/lib/core/transform/diagnostics/stripTerminalEscapes.js

@@ -0,0 +1,44 @@
+'use strict';
+
+/**
+ * Remove ANSI CSI colour and cursor sequences from surfaced text.
+ *
+ * An opaque host exception can contain the host's own rendered output, colour
+ * and all, with no structured diagnostics to format instead. What the adapter
+ * hands back is not going to a terminal: it becomes the `Error` a bundler
+ * reports, so it lands in a Vite overlay, a webpack error report or a CI
+ * annotation, where the escapes render as literal noise around the file and
+ * line the reader needs. Other terminal protocols, including OSC hyperlinks,
+ * are outside this grammar and remain in the returned text.
+ *
+ * The colour originates in the host's rendering rather than in anything this
+ * adapter configures, so this is the adapter-side repair, applied to every
+ * message it surfaces rather than to one call site.
+ *
+ * @evidence contracts/common.md#principled-implementation The regular expression removes ANSI CSI control sequences from the presentation string, retaining ordinary diagnostic text; other terminal protocols are outside its current grammar.
+ * @evidence contracts/common.md#clear-and-simple-design One replacement owns the supported escape grammar, so every caller uses the same presentation boundary.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The grammar follows control-sequence syntax without matching fixture-specific colours, exception messages or expected output.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain the nonterminal destination and inline comments explain the deliberately visible expression construction.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   Performs no filesystem, path or process operation of its own.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   One CSI replacement scans message text in linear time; the two repeated
+ *   character classes are disjoint and cannot consume the escape introducer.
+ *   Output storage is at most the input length.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   All message formatters reuse the same private compiled CSI expression.
+ *   Global String.replace resets its matching position for each synchronous
+ *   call; no input-dependent result or mutable caller text is cached.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   One fixed compiled expression lives with the module; no input text or
+ *   replacement result survives a call. No handle or running task is acquired.
+ */
+function stripTerminalEscapes(text) {
+    return text.replace(CONTROL_SEQUENCE, "");
+}
+// A character code keeps the control byte out of maintained source. `[[]`
+// spells one literal bracket without an additional string-escape layer.
+const CONTROL_SEQUENCE = new RegExp(String.fromCharCode(27) + "[[][0-9;?]*[ -/]*[@-~]", "g");
+
+exports.stripTerminalEscapes = stripTerminalEscapes;
+//# sourceMappingURL=stripTerminalEscapes.js.map

package/lib/core/transform/diagnostics/stripTerminalEscapes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripTerminalEscapes.js","sources":["../../../../src/core/transform/diagnostics/stripTerminalEscapes.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;AACG,SAAU,oBAAoB,CAAC,IAAY,EAAA;IAC/C,OAAO,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE,EAAE,CAAC;AAC3C;AAEA;AACA;AACA,MAAM,gBAAgB,GAAG,IAAI,MAAM,CACjC,MAAM,CAAC,YAAY,CAAC,EAAE,CAAC,GAAG,wBAAwB,EAClD,GAAG,CACJ;;;;"}

package/lib/core/transform/diagnostics/stripTerminalEscapes.mjs

@@ -0,0 +1,42 @@
+/**
+ * Remove ANSI CSI colour and cursor sequences from surfaced text.
+ *
+ * An opaque host exception can contain the host's own rendered output, colour
+ * and all, with no structured diagnostics to format instead. What the adapter
+ * hands back is not going to a terminal: it becomes the `Error` a bundler
+ * reports, so it lands in a Vite overlay, a webpack error report or a CI
+ * annotation, where the escapes render as literal noise around the file and
+ * line the reader needs. Other terminal protocols, including OSC hyperlinks,
+ * are outside this grammar and remain in the returned text.
+ *
+ * The colour originates in the host's rendering rather than in anything this
+ * adapter configures, so this is the adapter-side repair, applied to every
+ * message it surfaces rather than to one call site.
+ *
+ * @evidence contracts/common.md#principled-implementation The regular expression removes ANSI CSI control sequences from the presentation string, retaining ordinary diagnostic text; other terminal protocols are outside its current grammar.
+ * @evidence contracts/common.md#clear-and-simple-design One replacement owns the supported escape grammar, so every caller uses the same presentation boundary.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The grammar follows control-sequence syntax without matching fixture-specific colours, exception messages or expected output.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain the nonterminal destination and inline comments explain the deliberately visible expression construction.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   Performs no filesystem, path or process operation of its own.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   One CSI replacement scans message text in linear time; the two repeated
+ *   character classes are disjoint and cannot consume the escape introducer.
+ *   Output storage is at most the input length.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   All message formatters reuse the same private compiled CSI expression.
+ *   Global String.replace resets its matching position for each synchronous
+ *   call; no input-dependent result or mutable caller text is cached.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   One fixed compiled expression lives with the module; no input text or
+ *   replacement result survives a call. No handle or running task is acquired.
+ */
+function stripTerminalEscapes(text) {
+    return text.replace(CONTROL_SEQUENCE, "");
+}
+// A character code keeps the control byte out of maintained source. `[[]`
+// spells one literal bracket without an additional string-escape layer.
+const CONTROL_SEQUENCE = new RegExp(String.fromCharCode(27) + "[[][0-9;?]*[ -/]*[@-~]", "g");
+
+export { stripTerminalEscapes };
+//# sourceMappingURL=stripTerminalEscapes.mjs.map

package/lib/core/transform/diagnostics/stripTerminalEscapes.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripTerminalEscapes.mjs","sources":["../../../../src/core/transform/diagnostics/stripTerminalEscapes.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;AACG,SAAU,oBAAoB,CAAC,IAAY,EAAA;IAC/C,OAAO,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE,EAAE,CAAC;AAC3C;AAEA;AACA;AACA,MAAM,gBAAgB,GAAG,IAAI,MAAM,CACjC,MAAM,CAAC,YAAY,CAAC,EAAE,CAAC,GAAG,wBAAwB,EAClD,GAAG,CACJ;;;;"}

package/lib/core/transform/envelope/TtscEnvelopeDerivation.d.cts

@@ -0,0 +1,85 @@
+import type { FilesystemPathIdentityContext } from "ttsc/path-identity";
+import type { TtscProjectSpellings } from "../filesystem/TtscProjectSpellings.cjs";
+import type { TtscEnvelopeGraphIndexes } from "./TtscEnvelopeGraphIndexes.cjs";
+/**
+ * Per-envelope derivation state: every index the per-delivery paths need, built
+ * at most once and shared by all deliveries of one compiler result.
+ *
+ * Index builders share parsed producer records and native path identities
+ * across consumers. Cold identity queries can require realpath, ancestor and
+ * case observations; a completed watch list avoids another closure traversal
+ * without eliminating every path query performed before its lookup.
+ *
+ * Every optional index is lazy. Graph indexes also serve external input
+ * capture, validation and tracker scopes, so their construction does not depend
+ * solely on whether a host installs a watch hook.
+ *
+ * Safe sharing requires one immutable envelope, fixed project/options and a
+ * still-valid native identity view. Admission owns current-input proof; these
+ * indexes do not independently certify freshness. The owner associates state
+ * weakly with the envelope, but a caller retaining state or returned arrays can
+ * extend their storage lifetime.
+ *
+ * @evidence contracts/common.md#principled-implementation Optional indexes distinguish unbuilt state from completed results, and declaredInputKeysBuilt separately represents a completed undefined result; shared physical identities and lexical watch keys preserve their different equivalence relations.
+ * @evidence contracts/common.md#clear-and-simple-design One generation state groups lazy indexes and memo tables behind envelopeDerivation rather than requiring every delivery to maintain an independent cache.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts First-match key indexes preserve the supported producer lookup precedence, and the built flag represents a genuine optional outcome rather than manufacturing an empty declared input set.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain generation ownership, laziness, freshness and costs; each optional member documents its unbuilt meaning and the built flag's distinct role with documentation-skill spacing.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This interface represents memo tables but acquires or releases none. envelopeDerivation and the populating selectors own their allocation, growth, transfer and lifetime; the shape supplies no capacity or release guarantee.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms This interface declares identity, index and completion-state fields rather than executing their builders or lookup strategy. The concrete builders and selectors own those computations and their costs.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This shape records optional completion states and lexical/physical key domains. It does not decide when a request may share their values; actual association and selector owners establish immutable generation and native-view validity premises.
+ * @evidence contracts/portability.md#os-neutral-implementation A FilesystemPathIdentityContext owns physical identity and native case semantics; explicit physical and lexical root spellings avoid hardcoded separator or OS-based case rules in the state representation.
+ */
+export interface TtscEnvelopeDerivation {
+    /** One filesystem snapshot for every identity comparison in this envelope. */
+    readonly identityContext: FilesystemPathIdentityContext;
+    /**
+     * The project root's two spellings, the one it was named by and the physical
+     * one, resolved once for the envelope: the compiler reports its inputs
+     * physically, and a host is handed each under the spelling it uses
+     * (samchon/ttsc#1451).
+     */
+    readonly project: TtscProjectSpellings;
+    /** Memoized `pathIdentityKey` results, keyed by the exact input. */
+    readonly identities: Map<string, string>;
+    /**
+     * Lazily built reference-graph indexes, `undefined` until the first
+     * graph-index consumer, including watch derivation, external capture,
+     * validation or tracker scope selection.
+     */
+    graph?: TtscEnvelopeGraphIndexes;
+    /**
+     * Lazily collected identities of the envelope's `volatile` member files,
+     * `undefined` until the first volatility predicate.
+     */
+    volatileFiles?: Set<string>;
+    /**
+     * Lazily collected identities of the envelope's `dependenciesComplete` member
+     * files, `undefined` until the first completeness predicate.
+     */
+    dependenciesComplete?: Set<string>;
+    /**
+     * Lazily built identity -> envelope key index of the `typescript` map (first
+     * match wins, mirroring the historical scan). `undefined` until the first
+     * project-relative key miss.
+     */
+    outputIndex?: Map<string, string>;
+    /**
+     * Lazily built identity -> `dependencies` entries index (first match wins,
+     * mirroring the historical scan). `undefined` until the first key miss.
+     */
+    dependencyIndex?: Map<string, unknown>;
+    /** Per lexical delivered-module spelling memo of its final watch-input list. */
+    readonly watchInputs: Map<string, string[]>;
+    /**
+     * Lazily built project-walk keys of the envelope's declared inputs, and
+     * whether that build already ran. A graph-free envelope declares no input
+     * set, so `undefined` after a completed build means "compare the whole walk";
+     * see `sameHashes`.
+     */
+    declaredInputKeys?: Set<string>;
+    /**
+     * Whether {@link declaredInputKeys} was already derived, since `undefined` is
+     * also a valid result.
+     */
+    declaredInputKeysBuilt?: boolean;
+}

package/lib/core/transform/envelope/TtscEnvelopeDerivation.d.mts

@@ -0,0 +1,85 @@
+import type { FilesystemPathIdentityContext } from "ttsc/path-identity";
+import type { TtscProjectSpellings } from "../filesystem/TtscProjectSpellings.mjs";
+import type { TtscEnvelopeGraphIndexes } from "./TtscEnvelopeGraphIndexes.mjs";
+/**
+ * Per-envelope derivation state: every index the per-delivery paths need, built
+ * at most once and shared by all deliveries of one compiler result.
+ *
+ * Index builders share parsed producer records and native path identities
+ * across consumers. Cold identity queries can require realpath, ancestor and
+ * case observations; a completed watch list avoids another closure traversal
+ * without eliminating every path query performed before its lookup.
+ *
+ * Every optional index is lazy. Graph indexes also serve external input
+ * capture, validation and tracker scopes, so their construction does not depend
+ * solely on whether a host installs a watch hook.
+ *
+ * Safe sharing requires one immutable envelope, fixed project/options and a
+ * still-valid native identity view. Admission owns current-input proof; these
+ * indexes do not independently certify freshness. The owner associates state
+ * weakly with the envelope, but a caller retaining state or returned arrays can
+ * extend their storage lifetime.
+ *
+ * @evidence contracts/common.md#principled-implementation Optional indexes distinguish unbuilt state from completed results, and declaredInputKeysBuilt separately represents a completed undefined result; shared physical identities and lexical watch keys preserve their different equivalence relations.
+ * @evidence contracts/common.md#clear-and-simple-design One generation state groups lazy indexes and memo tables behind envelopeDerivation rather than requiring every delivery to maintain an independent cache.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts First-match key indexes preserve the supported producer lookup precedence, and the built flag represents a genuine optional outcome rather than manufacturing an empty declared input set.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain generation ownership, laziness, freshness and costs; each optional member documents its unbuilt meaning and the built flag's distinct role with documentation-skill spacing.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This interface represents memo tables but acquires or releases none. envelopeDerivation and the populating selectors own their allocation, growth, transfer and lifetime; the shape supplies no capacity or release guarantee.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms This interface declares identity, index and completion-state fields rather than executing their builders or lookup strategy. The concrete builders and selectors own those computations and their costs.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This shape records optional completion states and lexical/physical key domains. It does not decide when a request may share their values; actual association and selector owners establish immutable generation and native-view validity premises.
+ * @evidence contracts/portability.md#os-neutral-implementation A FilesystemPathIdentityContext owns physical identity and native case semantics; explicit physical and lexical root spellings avoid hardcoded separator or OS-based case rules in the state representation.
+ */
+export interface TtscEnvelopeDerivation {
+    /** One filesystem snapshot for every identity comparison in this envelope. */
+    readonly identityContext: FilesystemPathIdentityContext;
+    /**
+     * The project root's two spellings, the one it was named by and the physical
+     * one, resolved once for the envelope: the compiler reports its inputs
+     * physically, and a host is handed each under the spelling it uses
+     * (samchon/ttsc#1451).
+     */
+    readonly project: TtscProjectSpellings;
+    /** Memoized `pathIdentityKey` results, keyed by the exact input. */
+    readonly identities: Map<string, string>;
+    /**
+     * Lazily built reference-graph indexes, `undefined` until the first
+     * graph-index consumer, including watch derivation, external capture,
+     * validation or tracker scope selection.
+     */
+    graph?: TtscEnvelopeGraphIndexes;
+    /**
+     * Lazily collected identities of the envelope's `volatile` member files,
+     * `undefined` until the first volatility predicate.
+     */
+    volatileFiles?: Set<string>;
+    /**
+     * Lazily collected identities of the envelope's `dependenciesComplete` member
+     * files, `undefined` until the first completeness predicate.
+     */
+    dependenciesComplete?: Set<string>;
+    /**
+     * Lazily built identity -> envelope key index of the `typescript` map (first
+     * match wins, mirroring the historical scan). `undefined` until the first
+     * project-relative key miss.
+     */
+    outputIndex?: Map<string, string>;
+    /**
+     * Lazily built identity -> `dependencies` entries index (first match wins,
+     * mirroring the historical scan). `undefined` until the first key miss.
+     */
+    dependencyIndex?: Map<string, unknown>;
+    /** Per lexical delivered-module spelling memo of its final watch-input list. */
+    readonly watchInputs: Map<string, string[]>;
+    /**
+     * Lazily built project-walk keys of the envelope's declared inputs, and
+     * whether that build already ran. A graph-free envelope declares no input
+     * set, so `undefined` after a completed build means "compare the whole walk";
+     * see `sameHashes`.
+     */
+    declaredInputKeys?: Set<string>;
+    /**
+     * Whether {@link declaredInputKeys} was already derived, since `undefined` is
+     * also a valid result.
+     */
+    declaredInputKeysBuilt?: boolean;
+}