@ttsc/unplugin 0.30.3 → 0.31.0

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

@@ -0,0 +1,58 @@
+import path from 'node:path';
+
+/**
+ * Attempt one warning per native resolved spelling and generation when a module
+ * arrives with text that differs from the file it names.
+ *
+ * The spelling is recorded before stderr is written, so a synchronous write
+ * failure propagates but does not authorize another attempt for that key.
+ * Physical aliases remain separate warning keys; this reporting set does not
+ * decide compiler input identity or generation freshness.
+ *
+ * Ttsc compiles the whole project from disk, so the delivered text never
+ * reaches the output: the module is served from the compile of the file on
+ * disk. That is right when the host read the file just before it changed, and
+ * the host's next delivery resolves it. It is wrong when a plugin ordered
+ * before ttsc rewrote the module, because that rewrite is then dropped, so the
+ * report names the likely cause instead of letting the rewrite vanish
+ * silently.
+ *
+ * @evidence contracts/common.md#principled-implementation A generation-owned set suppresses repeated warning attempts for the same native resolved spelling while the message distinguishes delivered text from the disk program. Recording precedes writing, independently of stream success or backpressure.
+ * @evidence contracts/common.md#clear-and-simple-design One membership check and one stderr message own the warning; compilation and delivery policy remain outside reporting.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Divergence is exposed rather than hidden by returning the host's uncompiled text or rewriting expected module output.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain the disk-compilation premise, rewrite causes, lexical suppression scope and pre-write recording rather than promising successful output.
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Node native resolve and relative choose the displayed address, including
+ *   native cross-root behavior. Splitting native separators and joining with /
+ *   is presentation only, not a guarantee of equal paths across filesystems.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Native resolution and set-key lookup cost path text. An unsuppressed report
+ *   also computes a relative address, allocates split/join and message strings,
+ *   then writes their bytes to stderr; repeated keys return before those steps.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The per-generation set suppresses repeated message construction and write
+ *   attempts for the same resolved spelling, not every physical alias.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The generation-owned set grows with distinct divergent spelling keys and
+ *   their text, then becomes collectible with the generation. Native stderr
+ *   owns stream buffering/backpressure; this reporter retains no separate task.
+ */
+function reportDivergentDelivery(
+/** Generation owning warning suppression and the diagnostic root. */
+cached, 
+/** Native source spelling normalized only for suppression and display. */
+file) {
+    const reported = (cached.divergentDeliveryReported ??= new Set());
+    const key = path.resolve(file);
+    if (reported.has(key))
+        return;
+    reported.add(key);
+    const name = path.relative(cached.projectRoot, key).split(path.sep).join("/");
+    process.stderr.write(`ttsc: ${name} reached ttsc with text that differs from the file on disk. ` +
+        "ttsc transforms the file as it is on disk, so the delivered text was " +
+        "not used. If another plugin rewrites this module, order it after ttsc " +
+        '(ttsc runs with enforce: "pre").\n');
+}
+
+export { reportDivergentDelivery };
+//# sourceMappingURL=reportDivergentDelivery.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reportDivergentDelivery.mjs","sources":["../../../../src/core/transform/diagnostics/reportDivergentDelivery.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCG;SACa,uBAAuB;AACrC;AACA,MAAkC;AAClC;AACA,IAAY,EAAA;IAEZ,MAAM,QAAQ,IAAI,MAAM,CAAC,yBAAyB,KAAK,IAAI,GAAG,EAAU,CAAC;IACzE,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;AAC9B,IAAA,IAAI,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC;QAAE;AACvB,IAAA,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC;IACjB,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;AAC7E,IAAA,OAAO,CAAC,MAAM,CAAC,KAAK,CAClB,CAAA,MAAA,EAAS,IAAI,CAAA,4DAAA,CAA8D;QACzE,uEAAuE;QACvE,wEAAwE;AACxE,QAAA,oCAAoC,CACvC;AACH;;;;"}

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

@@ -0,0 +1,43 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
+import type { TtscMissingProgramOutputError } from "../errors/TtscMissingProgramOutputError.cjs";
+/**
+ * Attempt one warning per supplied file spelling and generation/epoch when a
+ * module is left untransformed.
+ *
+ * The condition is ordinary and the build continues, but it must never be
+ * silent: a file the program does not contain keeps whatever plugin syntax it
+ * carries, which can defer a missing plugin transformation to runtime. The
+ * generation's nonfatal stderr channel names that condition without repeating
+ * the same spelling per delivery. The typed error owns its message text; this
+ * reporter appends a newline but does not enforce a one-line message.
+ *
+ * Epoch changes clear the old file population; undefined is the persistent
+ * host's single reporting epoch. Recording precedes writing, so synchronous
+ * stream failure propagates without removing the attempted key.
+ *
+ * @evidence contracts/common.md#principled-implementation A per-generation set and delivery epoch distinguish already-attempted spelling keys from a new pass; the typed missing-output error supplies message text without changing the host's continuation policy or certifying stream success.
+ * @evidence contracts/common.md#clear-and-simple-design Epoch reset, membership suppression and stderr delivery form a single reporting responsibility.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The reporter forwards the typed continuation reason rather than manufacturing output or classifying a diagnostic substring; duplicate suppression follows the recorded generation/epoch key.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain pass/persistent suppression, caller-owned message text and recording before stream output without promising one line or successful delivery.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   The supplied file is an opaque suppression key; this reporter parses no
+ *   native path, resolves no alias and selects no filesystem/backend policy.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Key lookup/insertion retains file-text cost; an unsuppressed attempt
+ *   constructs and writes the full message plus newline. Epoch change clears
+ *   prior entry references, while repeated keys skip message construction/IO.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The generation set suppresses repeated write attempts for the same supplied
+ *   file spelling in one epoch; it does not deduplicate physical aliases.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The set grows with distinct file spellings and text in the current epoch,
+ *   clears on epoch change and becomes collectible with the generation. Stderr
+ *   owns buffered bytes/backpressure; no separate task or history is retained.
+ */
+export declare function reportMissingProgramOutput(
+/** Generation owning epoch and warning-key population. */
+cached: TtscCachedProjectTransform, 
+/** Typed continuation context supplying an opaque file key and message. */
+error: TtscMissingProgramOutputError, 
+/** Pass identity, or undefined for persistent generation reporting. */
+epoch: number | undefined): void;

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

@@ -0,0 +1,43 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
+import type { TtscMissingProgramOutputError } from "../errors/TtscMissingProgramOutputError.mjs";
+/**
+ * Attempt one warning per supplied file spelling and generation/epoch when a
+ * module is left untransformed.
+ *
+ * The condition is ordinary and the build continues, but it must never be
+ * silent: a file the program does not contain keeps whatever plugin syntax it
+ * carries, which can defer a missing plugin transformation to runtime. The
+ * generation's nonfatal stderr channel names that condition without repeating
+ * the same spelling per delivery. The typed error owns its message text; this
+ * reporter appends a newline but does not enforce a one-line message.
+ *
+ * Epoch changes clear the old file population; undefined is the persistent
+ * host's single reporting epoch. Recording precedes writing, so synchronous
+ * stream failure propagates without removing the attempted key.
+ *
+ * @evidence contracts/common.md#principled-implementation A per-generation set and delivery epoch distinguish already-attempted spelling keys from a new pass; the typed missing-output error supplies message text without changing the host's continuation policy or certifying stream success.
+ * @evidence contracts/common.md#clear-and-simple-design Epoch reset, membership suppression and stderr delivery form a single reporting responsibility.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The reporter forwards the typed continuation reason rather than manufacturing output or classifying a diagnostic substring; duplicate suppression follows the recorded generation/epoch key.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain pass/persistent suppression, caller-owned message text and recording before stream output without promising one line or successful delivery.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   The supplied file is an opaque suppression key; this reporter parses no
+ *   native path, resolves no alias and selects no filesystem/backend policy.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Key lookup/insertion retains file-text cost; an unsuppressed attempt
+ *   constructs and writes the full message plus newline. Epoch change clears
+ *   prior entry references, while repeated keys skip message construction/IO.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The generation set suppresses repeated write attempts for the same supplied
+ *   file spelling in one epoch; it does not deduplicate physical aliases.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The set grows with distinct file spellings and text in the current epoch,
+ *   clears on epoch change and becomes collectible with the generation. Stderr
+ *   owns buffered bytes/backpressure; no separate task or history is retained.
+ */
+export declare function reportMissingProgramOutput(
+/** Generation owning epoch and warning-key population. */
+cached: TtscCachedProjectTransform, 
+/** Typed continuation context supplying an opaque file key and message. */
+error: TtscMissingProgramOutputError, 
+/** Pass identity, or undefined for persistent generation reporting. */
+epoch: number | undefined): void;

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

@@ -0,0 +1,43 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+import type { TtscMissingProgramOutputError } from "../errors/TtscMissingProgramOutputError";
+/**
+ * Attempt one warning per supplied file spelling and generation/epoch when a
+ * module is left untransformed.
+ *
+ * The condition is ordinary and the build continues, but it must never be
+ * silent: a file the program does not contain keeps whatever plugin syntax it
+ * carries, which can defer a missing plugin transformation to runtime. The
+ * generation's nonfatal stderr channel names that condition without repeating
+ * the same spelling per delivery. The typed error owns its message text; this
+ * reporter appends a newline but does not enforce a one-line message.
+ *
+ * Epoch changes clear the old file population; undefined is the persistent
+ * host's single reporting epoch. Recording precedes writing, so synchronous
+ * stream failure propagates without removing the attempted key.
+ *
+ * @evidence contracts/common.md#principled-implementation A per-generation set and delivery epoch distinguish already-attempted spelling keys from a new pass; the typed missing-output error supplies message text without changing the host's continuation policy or certifying stream success.
+ * @evidence contracts/common.md#clear-and-simple-design Epoch reset, membership suppression and stderr delivery form a single reporting responsibility.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The reporter forwards the typed continuation reason rather than manufacturing output or classifying a diagnostic substring; duplicate suppression follows the recorded generation/epoch key.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain pass/persistent suppression, caller-owned message text and recording before stream output without promising one line or successful delivery.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   The supplied file is an opaque suppression key; this reporter parses no
+ *   native path, resolves no alias and selects no filesystem/backend policy.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Key lookup/insertion retains file-text cost; an unsuppressed attempt
+ *   constructs and writes the full message plus newline. Epoch change clears
+ *   prior entry references, while repeated keys skip message construction/IO.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The generation set suppresses repeated write attempts for the same supplied
+ *   file spelling in one epoch; it does not deduplicate physical aliases.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The set grows with distinct file spellings and text in the current epoch,
+ *   clears on epoch change and becomes collectible with the generation. Stderr
+ *   owns buffered bytes/backpressure; no separate task or history is retained.
+ */
+export declare function reportMissingProgramOutput(
+/** Generation owning epoch and warning-key population. */
+cached: TtscCachedProjectTransform, 
+/** Typed continuation context supplying an opaque file key and message. */
+error: TtscMissingProgramOutputError, 
+/** Pass identity, or undefined for persistent generation reporting. */
+epoch: number | undefined): void;

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

@@ -0,0 +1,57 @@
+'use strict';
+
+/**
+ * Attempt one warning per supplied file spelling and generation/epoch when a
+ * module is left untransformed.
+ *
+ * The condition is ordinary and the build continues, but it must never be
+ * silent: a file the program does not contain keeps whatever plugin syntax it
+ * carries, which can defer a missing plugin transformation to runtime. The
+ * generation's nonfatal stderr channel names that condition without repeating
+ * the same spelling per delivery. The typed error owns its message text; this
+ * reporter appends a newline but does not enforce a one-line message.
+ *
+ * Epoch changes clear the old file population; undefined is the persistent
+ * host's single reporting epoch. Recording precedes writing, so synchronous
+ * stream failure propagates without removing the attempted key.
+ *
+ * @evidence contracts/common.md#principled-implementation A per-generation set and delivery epoch distinguish already-attempted spelling keys from a new pass; the typed missing-output error supplies message text without changing the host's continuation policy or certifying stream success.
+ * @evidence contracts/common.md#clear-and-simple-design Epoch reset, membership suppression and stderr delivery form a single reporting responsibility.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The reporter forwards the typed continuation reason rather than manufacturing output or classifying a diagnostic substring; duplicate suppression follows the recorded generation/epoch key.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain pass/persistent suppression, caller-owned message text and recording before stream output without promising one line or successful delivery.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   The supplied file is an opaque suppression key; this reporter parses no
+ *   native path, resolves no alias and selects no filesystem/backend policy.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Key lookup/insertion retains file-text cost; an unsuppressed attempt
+ *   constructs and writes the full message plus newline. Epoch change clears
+ *   prior entry references, while repeated keys skip message construction/IO.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The generation set suppresses repeated write attempts for the same supplied
+ *   file spelling in one epoch; it does not deduplicate physical aliases.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The set grows with distinct file spellings and text in the current epoch,
+ *   clears on epoch change and becomes collectible with the generation. Stderr
+ *   owns buffered bytes/backpressure; no separate task or history is retained.
+ */
+function reportMissingProgramOutput(
+/** Generation owning epoch and warning-key population. */
+cached, 
+/** Typed continuation context supplying an opaque file key and message. */
+error, 
+/** Pass identity, or undefined for persistent generation reporting. */
+epoch) {
+    const reported = (cached.missingOutputReported ??= new Set());
+    if (cached.missingOutputEpoch !== epoch) {
+        cached.missingOutputEpoch = epoch;
+        reported.clear();
+    }
+    if (reported.has(error.file)) {
+        return;
+    }
+    reported.add(error.file);
+    process.stderr.write(`${error.message}\n`);
+}
+
+exports.reportMissingProgramOutput = reportMissingProgramOutput;
+//# sourceMappingURL=reportMissingProgramOutput.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reportMissingProgramOutput.js","sources":["../../../../src/core/transform/diagnostics/reportMissingProgramOutput.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;SACa,0BAA0B;AACxC;AACA,MAAkC;AAClC;AACA,KAAoC;AACpC;AACA,KAAyB,EAAA;IAEzB,MAAM,QAAQ,IAAI,MAAM,CAAC,qBAAqB,KAAK,IAAI,GAAG,EAAU,CAAC;AACrE,IAAA,IAAI,MAAM,CAAC,kBAAkB,KAAK,KAAK,EAAE;AACvC,QAAA,MAAM,CAAC,kBAAkB,GAAG,KAAK;QACjC,QAAQ,CAAC,KAAK,EAAE;IAClB;IACA,IAAI,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE;QAC5B;IACF;AACA,IAAA,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC;IACxB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA,EAAG,KAAK,CAAC,OAAO,CAAA,EAAA,CAAI,CAAC;AAC5C;;;;"}

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

@@ -0,0 +1,55 @@
+/**
+ * Attempt one warning per supplied file spelling and generation/epoch when a
+ * module is left untransformed.
+ *
+ * The condition is ordinary and the build continues, but it must never be
+ * silent: a file the program does not contain keeps whatever plugin syntax it
+ * carries, which can defer a missing plugin transformation to runtime. The
+ * generation's nonfatal stderr channel names that condition without repeating
+ * the same spelling per delivery. The typed error owns its message text; this
+ * reporter appends a newline but does not enforce a one-line message.
+ *
+ * Epoch changes clear the old file population; undefined is the persistent
+ * host's single reporting epoch. Recording precedes writing, so synchronous
+ * stream failure propagates without removing the attempted key.
+ *
+ * @evidence contracts/common.md#principled-implementation A per-generation set and delivery epoch distinguish already-attempted spelling keys from a new pass; the typed missing-output error supplies message text without changing the host's continuation policy or certifying stream success.
+ * @evidence contracts/common.md#clear-and-simple-design Epoch reset, membership suppression and stderr delivery form a single reporting responsibility.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The reporter forwards the typed continuation reason rather than manufacturing output or classifying a diagnostic substring; duplicate suppression follows the recorded generation/epoch key.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain pass/persistent suppression, caller-owned message text and recording before stream output without promising one line or successful delivery.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation
+ *   The supplied file is an opaque suppression key; this reporter parses no
+ *   native path, resolves no alias and selects no filesystem/backend policy.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Key lookup/insertion retains file-text cost; an unsuppressed attempt
+ *   constructs and writes the full message plus newline. Epoch change clears
+ *   prior entry references, while repeated keys skip message construction/IO.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The generation set suppresses repeated write attempts for the same supplied
+ *   file spelling in one epoch; it does not deduplicate physical aliases.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   The set grows with distinct file spellings and text in the current epoch,
+ *   clears on epoch change and becomes collectible with the generation. Stderr
+ *   owns buffered bytes/backpressure; no separate task or history is retained.
+ */
+function reportMissingProgramOutput(
+/** Generation owning epoch and warning-key population. */
+cached, 
+/** Typed continuation context supplying an opaque file key and message. */
+error, 
+/** Pass identity, or undefined for persistent generation reporting. */
+epoch) {
+    const reported = (cached.missingOutputReported ??= new Set());
+    if (cached.missingOutputEpoch !== epoch) {
+        cached.missingOutputEpoch = epoch;
+        reported.clear();
+    }
+    if (reported.has(error.file)) {
+        return;
+    }
+    reported.add(error.file);
+    process.stderr.write(`${error.message}\n`);
+}
+
+export { reportMissingProgramOutput };
+//# sourceMappingURL=reportMissingProgramOutput.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reportMissingProgramOutput.mjs","sources":["../../../../src/core/transform/diagnostics/reportMissingProgramOutput.ts"],"sourcesContent":[null],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;SACa,0BAA0B;AACxC;AACA,MAAkC;AAClC;AACA,KAAoC;AACpC;AACA,KAAyB,EAAA;IAEzB,MAAM,QAAQ,IAAI,MAAM,CAAC,qBAAqB,KAAK,IAAI,GAAG,EAAU,CAAC;AACrE,IAAA,IAAI,MAAM,CAAC,kBAAkB,KAAK,KAAK,EAAE;AACvC,QAAA,MAAM,CAAC,kBAAkB,GAAG,KAAK;QACjC,QAAQ,CAAC,KAAK,EAAE;IAClB;IACA,IAAI,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE;QAC5B;IACF;AACA,IAAA,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC;IACxB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA,EAAG,KAAK,CAAC,OAAO,CAAA,EAAA,CAAI,CAAC;AAC5C;;;;"}

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

@@ -0,0 +1,48 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
+/**
+ * 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.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;;;;"}