@ttsc/unplugin 0.31.0 → 0.31.1

package/src/core/transform/tracker/broker/drainWatchBroker.ts

@@ -1,16 +1,17 @@
 import { WATCH_PROBE_TIMEOUT_MS } from "./WATCH_PROBE_TIMEOUT_MS";
 import type { WatchBroker } from "./WatchBroker";
+import { WatchBrokerTransport } from "./WatchBrokerTransport";
 
 /**
  * Ask the watch broker to acknowledge, and resolve with whether it did.
  *
- * The child answers after two turns of its own loop, so a watch callback it had
- * already queued has run, and the ordered IPC channel puts every message it
- * sent before the reply ahead of the reply. That is the same proof an
- * in-process watcher gets from a macrotask turn, rather than the fixed wait
- * this replaces, which guessed at the crossing (samchon/ttsc#1272). On macOS
- * the child answers once each stream it can prove has delivered a probe, which
- * takes the service's latency (samchon/ttsc#1453).
+ * Windows answers after consuming currently queued native completions to an
+ * observed empty port. macOS answers once each provable stream has delivered a
+ * probe, including the service's latency (#1453). Ordered transport applies
+ * every preceding event before the reply. These are current backend frontiers,
+ * not atomic timestamp classification of concurrent writes. The optional direct
+ * fs.watch program retains its explicit two-turn frontier for protocol tests;
+ * it does not supply Windows production proof (#1719).
  *
  * A broker that never answers must not hold a delivery, so the wait gives up
  * after a threshold of twice the probe timeout: the child itself gives up on a
@@ -50,7 +51,7 @@ import type { WatchBroker } from "./WatchBroker";
  *   Native paragraphs and parameters explain ordering, coverage, sharing and
  *   false deadlines under the documentation skill.
  * @evidence contracts/portability.md#os-neutral-implementation
- *   OS-neutral host delivery delegates Windows loop ordering and macOS stream
+ *   OS-neutral host delivery delegates Windows completion-port drainage and macOS stream
  *   probing to the native broker rather than applying one universal timing guess.
  * @evidence contracts/performance.md#efficient-algorithms
  *   A covering memo query uses fixed identity/id lookup. New requests copy all N
@@ -123,8 +124,7 @@ function startWatchBrokerDrain(
       broker.drainScopes?.delete(id);
       broker.pendingDrains -= 1;
       if (broker.pendingDrains === 0 && broker.pendingRegistrations === 0) {
-        broker.child.unref();
-        broker.child.channel?.unref?.();
+        WatchBrokerTransport.reference(broker, false);
       }
       resolve(answered);
     };
@@ -134,12 +134,11 @@ function startWatchBrokerDrain(
     // the reference the loop can empty while a delivery waits here, and the
     // process exits mid-build with nothing to report.
     broker.pendingDrains += 1;
-    broker.child.ref();
-    broker.child.channel?.ref?.();
+    WatchBrokerTransport.reference(broker, true);
     const timer = setTimeout(() => release(false), timeout);
     broker.drains.set(id, release);
     (broker.drainScopes ??= new Map()).set(id, scope);
-    if (broker.child.send?.({ id, op: "drain" }) !== true) {
+    if (WatchBrokerTransport.send(broker, { id, op: "drain" }) !== true) {
       release(false);
     }
   });

package/src/core/transform/tracker/broker/getWatchBroker.ts

@@ -1,3 +1,6 @@
+import readline from "node:readline";
+import { resolveBinary } from "ttsc/binary";
+
 import { traceProcessSpawn } from "../../../tracing/traceProcessSpawn";
 import { WATCH_BROKER } from "./WATCH_BROKER";
 import type { WatchBroker } from "./WatchBroker";
@@ -13,11 +16,11 @@ import { watchBrokerSource } from "./watchBrokerSource";
  * caller-supplied watch capabilities can bypass it. Isolation has a reason on
  * each native backend:
  *
- * - Node's Windows fs-event backend can hit a native assertion that aborts the
- *   whole process when a watched temporary tree is deleted. In the child that
- *   crash becomes an ordinary exit that fails the affected trackers, and those
- *   generations fall back to proving themselves from recorded state instead of
- *   taking the host down.
+ * - Windows runs ttsc's native completion-port helper directly. Its directory
+ *   filter excludes access-time notifications: reads must not masquerade as
+ *   writes (#1719). Actual writes, metadata changes, native loss and failed
+ *   coverage remain observable; equal bytes cannot erase an A-B-A event. No
+ *   Node fs-event handle is opened in the host or an intermediate process.
  * - On macOS, libuv serves every directory watch of one event loop through a
  *   single FSEventStream and re-creates it whenever any watch in that loop
  *   opens or closes, losing the events in between (samchon/ttsc#1418), and it
@@ -26,10 +29,11 @@ import { watchBrokerSource } from "./watchBrokerSource";
  *   passes each drop on as a gap (samchon/ttsc#1425); see
  *   {@link watchBrokerSource}.
  *
- * Registration/drain owners unreference the child and IPC channel after their
+ * Registration/drain owners unreference the child and its transport after their
  * outstanding acknowledgments finish; startup itself returns a referenced
- * child. Last-registration closure attempts disconnection and termination. This
- * accessor has no independent shutdown deadline or exit wait.
+ * child. Last-registration closure ends the request stream and attempts
+ * termination. This accessor has no independent shutdown deadline or exit
+ * wait.
  *
  * @evidence contracts/common.md#principled-implementation
  *   Native watches run in a protocol child. Error/exit dispatch reports failure
@@ -45,13 +49,15 @@ import { watchBrokerSource } from "./watchBrokerSource";
  *   Native platform-reason list and lifecycle paragraph explain isolation and
  *   process ownership under the documentation skill.
  * @evidence contracts/portability.md#os-neutral-implementation
- *   OS-neutral startup uses this process's executable and argument-array spawn;
- *   native FSEvents loading and platform differences remain in this boundary.
+ *   Windows resolves the same ttsc binary as its compiler owner and uses the
+ *   native __watch command; macOS uses this runtime and supported FSEvents.
+ *   Argument-array spawn, hidden Windows processes and ordered transport stay
+ *   inside this boundary.
  * @evidence contracts/performance.md#efficient-algorithms
- *   A current-holder read is fixed work. Cold startup includes optional native
- *   module resolution/warning, child source construction and native process/IPC
- *   creation; resolution/path/source bytes and process startup cost do not
- *   vanish into one spawn call. Failure visits R registrations and D drain
+ *   A current-holder read is fixed work. Windows cold startup resolves the ttsc
+ *   binary and opens native protocol pipes; macOS resolves the optional binding,
+ *   reports missing capability and constructs its child program and IPC channel.
+ *   Resolution/path/source bytes and native process startup cost remain real. Failure visits R registrations and D drain
  *   callbacks, whose native/reference/sink work remains delegated; it does not
  *   enumerate watched source trees.
  *   Enabled private tracing serializes the actual executable/source argv and
@@ -63,7 +69,7 @@ import { watchBrokerSource } from "./watchBrokerSource";
  *   a health certificate; binding installation changes are not re-resolved
  *   while it remains current, and sink exceptions can interrupt failure handling.
  * @evidence contracts/performance.md#bound-retention-and-release-resources
- *   One current module holder retains a child and registration/drain maps;
+ *   One current module holder retains a direct child and registration/drain maps;
  *   those populations and caller-retained retired brokers have no cap here.
  *   Request owners manage references/timers, and last closure attempts native
  *   disconnection/kill rather than proving exit. Completed failure routing
@@ -77,11 +83,17 @@ export function getWatchBroker(): WatchBroker {
   const fsevents =
     process.platform === "darwin" ? fseventsBindingPath() : undefined;
   if (fsevents === null) warnMissingFseventsBinding();
+  const native = process.platform === "win32";
+  const binary = native ? resolveBinary() : process.execPath;
+  if (binary === null)
+    throw new Error("No ttsc native watch helper is available");
   const child = traceProcessSpawn(
-    process.execPath,
-    ["-e", watchBrokerSource(fsevents)],
+    binary,
+    native ? ["__watch"] : ["-e", watchBrokerSource(fsevents)],
     {
-      stdio: ["ignore", "ignore", "ignore", "ipc"],
+      stdio: native
+        ? ["pipe", "pipe", "ignore"]
+        : ["ignore", "ignore", "ignore", "ipc"],
       windowsHide: true,
     },
   );
@@ -110,6 +122,65 @@ export function getWatchBroker(): WatchBroker {
       WATCH_BROKER.current = undefined;
     }
   };
+  if (native) {
+    // All Windows registrations share one direct native child. No Node watcher,
+    // nested child, global runtime patch, or access-time system change is needed.
+    const input = child.stdin;
+    const output = child.stdout;
+    if (input === null || output === null) {
+      child.kill();
+      throw new Error("The native watch helper has no protocol pipes");
+    }
+    broker.transport = {
+      send(message) {
+        if (input.destroyed || input.writableEnded) return false;
+        // write(false) means buffered backpressure, not refusal. The callback
+        // reports a real transport failure to every still-live registration.
+        input.write(JSON.stringify(message) + "\n", (error) => {
+          if (error !== null && error !== undefined) {
+            fail();
+            child.kill();
+          }
+        });
+        return true;
+      },
+      reference(active) {
+        const pipe = output as typeof output & {
+          ref?: () => void;
+          unref?: () => void;
+        };
+        if (active) {
+          child.ref();
+          pipe.ref?.();
+        } else {
+          child.unref();
+          pipe.unref?.();
+        }
+      },
+      close() {
+        input.end();
+      },
+    };
+    const lost = (): void => {
+      fail();
+      child.kill();
+    };
+    input.on("error", lost);
+    output.on("error", lost);
+    output.on("end", lost);
+    readline
+      .createInterface({ input: output, crlfDelay: Infinity })
+      .on("line", (line) => {
+        let message: unknown;
+        try {
+          message = JSON.parse(line) as unknown;
+        } catch {
+          lost();
+          return;
+        }
+        routeWatchBrokerMessage(broker, message);
+      });
+  }
   child.on("error", fail);
   child.on("exit", fail);
   child.on("message", (message: unknown) =>

package/src/core/transform/tracker/broker/openBrokeredWatch.ts

@@ -7,6 +7,7 @@ import { WATCH_PROBE_DIRECTORY_PREFIX } from "./WATCH_PROBE_DIRECTORY_PREFIX";
 import { WATCH_PROBE_TIMEOUT_MS } from "./WATCH_PROBE_TIMEOUT_MS";
 import type { WatchBrokerLocation } from "./WatchBrokerLocation";
 import type { WatchBrokerSink } from "./WatchBrokerSink";
+import { WatchBrokerTransport } from "./WatchBrokerTransport";
 import { drainWatchBroker } from "./drainWatchBroker";
 import { getWatchBroker } from "./getWatchBroker";
 import { probeForLocation } from "./probeForLocation";
@@ -16,11 +17,11 @@ import { sweepAbandonedWatchProbes } from "./sweepAbandonedWatchProbes";
  * Open directory watches in the isolated watch process for one sink, and report
  * when they hear.
  *
- * On Windows, Node's fs-event backend can assert in native code when a watched
- * temporary tree is deleted. Isolation turns that unrecoverable process abort
- * into an ordinary broker exit and a conservative fallback in the host. On
- * macOS, each registration's watches are streams of their own, started before
- * the child reports ready, and a dropped event reaches the sink as a gap
+ * On Windows, ttsc's native helper owns completion-port directory subscriptions
+ * and omits access-only notifications (#1719). Native loss and failure withdraw
+ * coverage; actual change events remain authoritative even after A-B-A writes.
+ * On macOS, each registration's watches are streams of their own, started
+ * before the child reports ready, and a dropped event reaches the sink as a gap
  * (samchon/ttsc#1425). A stream that can be probed reports ready only once its
  * opening probe came back through it; the child suppresses ordinary callbacks
  * received before that probe. This is its backend protocol, not a guarantee
@@ -143,10 +144,7 @@ export function openBrokeredWatch(
     };
   });
   broker.pendingRegistrations += 1;
-  broker.child.ref();
-  // Bun's IPC channel omits Node's Control.ref/unref methods. The child itself
-  // still owns the outstanding acknowledgement on that runtime.
-  broker.child.channel?.ref?.();
+  WatchBrokerTransport.reference(broker, true);
   const id = broker.nextId++;
   let resolveReady!: () => void;
   const answered = new Promise<void>((resolve) => {
@@ -166,7 +164,7 @@ export function openBrokeredWatch(
     let failed = false;
     let failure: unknown;
     try {
-      broker.child.send?.({ id, op: "remove" });
+      WatchBrokerTransport.send(broker, { id, op: "remove" });
     } catch (error) {
       failed = true;
       failure = error;
@@ -176,7 +174,7 @@ export function openBrokeredWatch(
         WATCH_BROKER.current = undefined;
       }
       try {
-        broker.child.disconnect?.();
+        WatchBrokerTransport.close(broker);
       } catch (error) {
         if (!failed) {
           failed = true;
@@ -194,7 +192,7 @@ export function openBrokeredWatch(
     }
     if (failed) throw failure;
   };
-  broker.child.send?.({
+  WatchBrokerTransport.send(broker, {
     allEvents: options.allEvents,
     locations: normalized,
     id,
@@ -226,8 +224,7 @@ export function openBrokeredWatch(
     // a reply over an unreferenced channel lets the loop empty and the process
     // exit mid-build.
     if (broker.pendingRegistrations === 0 && broker.pendingDrains === 0) {
-      broker.child.unref();
-      broker.child.channel?.unref?.();
+      WatchBrokerTransport.reference(broker, false);
     }
   });
   return {

package/src/core/transform/tracker/broker/usesWatchBroker.ts

@@ -4,13 +4,13 @@ import type { TtscTransformFilesystemOperations } from "../../filesystem/TtscTra
  * Whether a tracker over `filesystem` opens its watches in the isolated watch
  * broker rather than in this process.
  *
- * The host filesystem on Windows and macOS does: Windows so that a native
- * fs-event abort cannot take the host down, and macOS so that each watch is its
- * own FSEventStream, whose dropped events are reported, rather than one libuv
- * re-creates whenever any watch in the host opens or closes, and whose drops it
- * discards (samchon/ttsc#1418, samchon/ttsc#1425). An embedder that supplies
- * its own `watch` retains that capability, including for a host-filesystem
- * view.
+ * The host filesystem on Windows and macOS does: Windows so that native
+ * mutation filters exclude access-time noise without a Node fs-event handle,
+ * and macOS so that each watch is its own FSEventStream, whose dropped events
+ * are reported, rather than one libuv re-creates whenever any watch in the host
+ * opens or closes, and whose drops it discards (samchon/ttsc#1418,
+ * samchon/ttsc#1425). An embedder that supplies its own `watch` retains that
+ * capability, including for a host-filesystem view.
  *
  * @evidence contracts/common.md#principled-implementation
  *   A supplied filesystem watcher is authoritative; only the native host

package/src/core/transform/tracker/broker/watchBrokerSource.ts

@@ -8,13 +8,10 @@ import { WATCH_PROBE_TIMEOUT_MS } from "./WATCH_PROBE_TIMEOUT_MS";
  * frontier described below; a reply alone does not certify every scope, since
  * probe-dependent streams can be named unproven and gaps withdraw authority.
  *
- * On Windows the watches are `fs.watch`. A drain yields through two immediate
- * turns to allow the loop to poll and deliver queued callbacks before replying.
- * The real Windows scenario checks two hundred synchronous write/drain pairs;
- * the scripted unit checks this scheduling boundary separately. These checks
- * are not a universal kernel-order proof: FIFO completion-port queueing alone
- * does not guarantee dequeue order or establish when notification completion
- * becomes observable relative to a write and IPC request.
+ * Windows production registrations use ttsc's native helper, not this program
+ * (#1719). The optional fs.watch backend remains an explicit direct program
+ * capability used by its scripted protocol tests; it never supplies Windows
+ * production cache proof. Its drain yields through two immediate turns.
  *
  * On macOS the watches go through the `fsevents` binding, one FSEventStream per
  * location, instead of relying on `fs.watch` for stream and loss authority
@@ -59,11 +56,13 @@ import { WATCH_PROBE_TIMEOUT_MS } from "./WATCH_PROBE_TIMEOUT_MS";
  *   The child protocol keeps per-registration streams and ordered drains;
  *   macOS proof requires clean probe delivery. Loss flags withdraw coverage
  *   before probe recognition, so matching a probe name cannot erase that warning.
- *   The Windows two-turn frontier retains its runtime/backend ordering premise;
+ *   The optional fs.watch two-turn frontier retains its runtime/backend ordering premise;
  *   this source does not independently prove kernel completeness.
  * @evidence contracts/common.md#clear-and-simple-design
- *   One maintained child program serves both native backends; this function only
- *   injects resolved capability and the shared timeout, with JSON-safe path encoding.
+ *   One maintained child program serves macOS and the explicitly selected
+ *   fs.watch protocol capability; Windows production uses its native helper.
+ *   This function injects resolved capability and the shared timeout with
+ *   JSON-safe path encoding.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts
  *   Native flags and deadlines express backend contracts, not fixture-specific
  *   repairs. Missing bindings and probes report uncertainty rather than silent success.
@@ -351,7 +350,7 @@ function drain(requestId) {
       entry.abandon();
     }
   }
-  // Windows watches, and streams already proven, answer after two turns: the
+  // Explicit fs.watch watches, and streams already proven, answer after two turns: the
   // first lets the loop poll for completions the kernel had already queued,
   // the second answers after their callbacks.
   outstanding += 1;

package/src/core/transform/transformTtsc.ts

@@ -10,37 +10,28 @@ import { TRANSFORM_RESULT_FILESYSTEM } from "./cache/TRANSFORM_RESULT_FILESYSTEM
 import type { TtscTransformCache } from "./cache/TtscTransformCache";
 import { awaitOrEvict } from "./cache/awaitOrEvict";
 import { createTransformCacheKey } from "./cache/createTransformCacheKey";
-import { disposeCachedTransform } from "./cache/disposeCachedTransform";
 import { evictGeneration } from "./cache/evictGeneration";
 import { replaysTerminalGeneration } from "./cache/replaysTerminalGeneration";
 import { selectCachedGenerationAction } from "./cache/selectCachedGenerationAction";
-import { selectOrEvict } from "./cache/selectOrEvict";
 import { transformCacheEpoch } from "./cache/transformCacheEpoch";
 import { transformCacheTrustsNotifications } from "./cache/transformCacheTrustsNotifications";
 import { transformFilesystem } from "./cache/transformFilesystem";
 import { withdrawGenerationNotifications } from "./cache/withdrawGenerationNotifications";
-import { reportMissingProgramOutput } from "./diagnostics/reportMissingProgramOutput";
-import { reportSuccessDiagnostics } from "./diagnostics/reportSuccessDiagnostics";
-import type { TtscTransformedOutput } from "./envelope/TtscTransformedOutput";
-import { TtscMissingProgramOutputError } from "./errors/TtscMissingProgramOutputError";
+import { deliverCachedTransform } from "./deliverCachedTransform";
 import { TtscUnstableGenerationError } from "./errors/TtscUnstableGenerationError";
 import { transformProject } from "./generation/transformProject";
 import { preparePluginBuildEnvironments } from "./inputs/preparePluginBuildEnvironments";
 import { TRANSFORM_CACHE_SESSIONS } from "./session/TRANSFORM_CACHE_SESSIONS";
 import { settleProjectMutationEvents } from "./tracker/settleProjectMutationEvents";
 import { resolveProjectSelection } from "./tsconfig/resolveProjectSelection";
-import { createTransformResult } from "./utils/createTransformResult";
 import { isDeclarationFile } from "./utils/isDeclarationFile";
 import { isHostWrapperQuery } from "./utils/isHostWrapperQuery";
 import { pluginsAreDisabled } from "./utils/pluginsAreDisabled";
 import { stripQuery } from "./utils/stripQuery";
-import { markCachedSourceServed } from "./validation/markCachedSourceServed";
+import { TtscGenerationProof } from "./validation/TtscGenerationProof";
 import type { TtscTransformHooks } from "./watch/TtscTransformHooks";
 import type { TtscWatchSelection } from "./watch/TtscWatchSelection";
-import { notifyFailedGenerationInputs } from "./watch/notifyFailedGenerationInputs";
 import { notifyRejectedGenerationInputs } from "./watch/notifyRejectedGenerationInputs";
-import { notifyVolatileDelivery } from "./watch/notifyVolatileDelivery";
-import { notifyWatchInputs } from "./watch/notifyWatchInputs";
 import { prepareProjectRecordDirectories } from "./watch/prepareProjectRecordDirectories";
 
 /**
@@ -78,7 +69,7 @@ import { prepareProjectRecordDirectories } from "./watch/prepareProjectRecordDir
  *   per build, not per compilation.
  * @evidence contracts/common.md#principled-implementation Project selection and generation-qualified cache admission preserve compiler disk authority; fresh-only success additionally needs an explicit nonwatching lifecycle, coherent project declaration and actual host-cache withdrawal, because incomplete observation cannot support watch invalidation.
  * @evidence contracts/common.md#clear-and-simple-design One delivery coordinator composes project selection, cache admission, compilation, output selection and host notifications; dedicated owners handle proof and lifetime internals.
- * @evidence contracts/common.md#prohibited-implementation-shortcuts Wrapper modules cannot poison source baselines and incomplete generations cannot authorize reuse; a separately admitted fresh-only result is evicted before capability checks, unknown or watching lifecycles fail explicitly, and unsupported withdrawal cannot be replaced by a fake record or guessed dependency closure.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Wrapper modules cannot poison source baselines; incomplete local results can share only explicitly nonwatching first deliveries in their exact pass. Unknown/watching lifecycles or unsupported withdrawal reject and evict them rather than invent persistent records or dependency closure.
  * @evidence contracts/common.md#meaningful-documentation Native paragraphs and argument tags explain project scope, no-transform outcomes, cache epochs and per-build notification responsibilities with links to maintained reference context.
  * @evidence contracts/performance.md#efficient-algorithms
  *   Selection/key construction pays ancestor/config/alias/option/path text work.
@@ -86,15 +77,18 @@ import { prepareProjectRecordDirectories } from "./watch/prepareProjectRecordDir
  *   replay source/project/external/universal proofs before selecting output.
  *   In-flight/valid completed reuse avoids compilation, not those checks or
  *   output/map/notification/record work. Capture misses pay whole native compile
- *   and input populations; concurrent supersession can repeat the outer loop
+ *   and input populations. The common proof owner skips redundant environment
+ *   preparation for proven first deliveries and shares synchronous native proof
+ *   queries; persistent/repeated delivery establishes fresh authority. Concurrent supersession can repeat the outer loop
  *   without a delivery-level retry/time bound here.
  * @evidence contracts/performance.md#reuse-equivalent-work Cache identity covers config/options/plugins/aliases; current generations, pass-qualified terminal verdicts and in-flight Promises are shared only while their source and dependency proof remains valid.
  * @evidence contracts/performance.md#bound-retention-and-release-resources
  *   Optional cache state retains current generation Promises/results and
  *   per-key dependency/case facts without a byte/key cap here. Native tasks
  *   belong to compiler/capture owners; uncached captures retain no notification
- *   or persistent clock probe. Fresh-only delivery detaches its generation
- *   before host callbacks; eviction/disposal attempt independent resource release
+ *   or persistent clock probe. Fresh-only delivery releases capture resources,
+ *   retaining only an explicitly admitted local pass result; rejected or failed
+ *   incomplete handoff detaches its generation. Eviction/disposal attempt independent resource release
  *   and native failures need not close every handle or remove every probe.
  * @evidence contracts/portability.md#os-neutral-implementation Native module paths and project coordinates use supported path/filesystem abstractions, while actual case policy and watcher capability come from generation proof rather than OS-name assumptions.
  */
@@ -218,15 +212,18 @@ export async function transformTtsc(
       if (!transformCacheTrustsNotifications(cache)) {
         withdrawGenerationNotifications(cached);
       }
-      await preparePluginBuildEnvironments(cached.result, filesystem, cached);
-      if (cache?.get(key) !== transformed) continue;
       if (epoch === undefined) {
         await settleProjectMutationEvents(cached);
         if (cache?.get(key) !== transformed) {
           continue;
         }
       }
+      await TtscGenerationProof.prepare(cached, file, epoch);
+      if (cache?.get(key) !== transformed) continue;
+      // No await between this observation and synchronous admission.
+      const proof = TtscGenerationProof.create(cached, file, epoch);
       const action = selectCachedGenerationAction({
+        proof,
         cache,
         cached,
         epoch,
@@ -239,36 +236,17 @@ export async function transformTtsc(
         continue;
       }
       if (action === "serve") {
-        reportSuccessDiagnostics(cached, epoch);
-        // A resolved `"exception"` / `"failure"` envelope makes this throw;
-        // that is a failed generation too, so it is retained for this pass or
-        // evicted outside one before being surfaced.
-        let output: TtscTransformedOutput;
-        try {
-          output = selectOrEvict(cache, key, transformed, epoch, {
-            file,
-            projectRoot: cached.projectRoot,
-            result: cached.result,
-            tsconfig: cached.tsconfig,
-          });
-        } catch (error) {
-          if (!(error instanceof TtscMissingProgramOutputError)) {
-            notifyFailedGenerationInputs(hooks, cached, file, watchSelection);
-            throw error;
-          }
-          // The compile is fine and simply has nothing for this module, so the
-          // module goes back to the host untransformed rather than failing the
-          // build (samchon/ttsc#1308). Its project config and selection inputs
-          // still decide whether a later generation will contain this module,
-          // so hosts must receive the same universal watch-input batch.
-          reportMissingProgramOutput(cached, error, epoch);
-          notifyWatchInputs(hooks, cached, file, watchSelection);
-          markCachedSourceServed(cached, file);
-          return undefined;
-        }
-        notifyWatchInputs(hooks, cached, file, watchSelection);
-        markCachedSourceServed(cached, file);
-        return createTransformResult(file, source, output);
+        return deliverCachedTransform({
+          cache,
+          cached,
+          generation: transformed,
+          key,
+          epoch,
+          file,
+          source,
+          hooks,
+          selection: watchSelection,
+        });
       }
       transformed = undefined;
     }
@@ -336,50 +314,16 @@ export async function transformTtsc(
         policies.set(key, reported);
       }
     }
-    const { projectRoot, result } = cached;
-    if (cached.freshDeliveryOnly === true) {
-      // This delivery owns a newly compiled answer, but unavailable observer
-      // authority cannot certify any later resident or host-cache delivery.
-      // Eviction schedules resource release even if a host callback throws.
-      if (cache === undefined) disposeCachedTransform(cached);
-      else evictGeneration(cache, key, generation);
-      if (
-        result.type === "success" &&
-        (hooks?.watching !== false ||
-          hooks.markVolatile === undefined ||
-          (hooks.project?.watching !== undefined &&
-            hooks.project.watching !== hooks.watching))
-      ) {
-        throw new Error(
-          "@ttsc/unplugin: plugin input observation is unavailable; fresh output " +
-            "requires an explicitly nonwatching host with supported cache withdrawal. " +
-            "Watching, unknown or contradictory lifecycles cannot safely observe its changes.",
-        );
-      }
-      hooks?.markVolatile?.();
-    }
-    reportSuccessDiagnostics(cached, epoch);
-    let output: TtscTransformedOutput;
-    try {
-      output = selectOrEvict(cache, key, generation, epoch, {
-        file,
-        projectRoot,
-        result,
-        tsconfig: cached.tsconfig,
-      });
-    } catch (error) {
-      if (!(error instanceof TtscMissingProgramOutputError)) {
-        notifyFailedGenerationInputs(hooks, cached, file, watchSelection);
-        throw error;
-      }
-      reportMissingProgramOutput(cached, error, epoch);
-      notifyWatchInputs(hooks, cached, file, watchSelection);
-      markCachedSourceServed(cached, file);
-      return undefined;
-    }
-    notifyWatchInputs(hooks, cached, file, watchSelection);
-    markCachedSourceServed(cached, file);
-    notifyVolatileDelivery(hooks, cached, file);
-    return createTransformResult(file, source, output);
+    return deliverCachedTransform({
+      cache,
+      cached,
+      generation,
+      key,
+      epoch,
+      file,
+      source,
+      hooks,
+      selection: watchSelection,
+    });
   }
 }