@ttsc/unplugin 0.30.4 → 0.31.0

package/lib/core/transform/watch/notifyProjectRecord.mjs

@@ -0,0 +1,231 @@
+import fs from 'node:fs';
+import { membershipRecordDigest } from '../../bridge/membershipRecordDigest.mjs';
+import { projectRecordFile } from '../../bridge/projectRecordFile.mjs';
+import { warnUnwritableProjectRecord } from '../../bridge/warnUnwritableProjectRecord.mjs';
+import { writeProjectRecordFile } from '../../bridge/writeProjectRecordFile.mjs';
+import { TtscProjectRecordUnwritableError } from '../errors/TtscProjectRecordUnwritableError.mjs';
+import { createHostPathIdentityContext } from '../filesystem/createHostPathIdentityContext.mjs';
+import { pathIdentityKey } from '../filesystem/pathIdentityKey.mjs';
+import { hostInputStateHash } from '../inputs/hostInputStateHash.mjs';
+import { MISSING_INPUT_STATE } from '../validation/MISSING_INPUT_STATE.mjs';
+import { projectMembershipInput } from './projectMembershipInput.mjs';
+
+/**
+ * What each generation hands a build host in this process: the inputs read for
+ * it, what is handed over with its record, and the records that hold them.
+ */
+const HANDED = new WeakMap();
+/**
+ * Write the project's record to a generation's state and hand it to the host
+ * (`TtscTransformHooks.project`), once per delivery.
+ *
+ * The generation's inputs are read once per generation and process, and the
+ * record below the root of each host the generation is delivered to is written
+ * from them until a write lands. Configs consulted while routing another module
+ * are added to the same generation's input set. Only that expansion replaces
+ * the watching snapshot and requires another write at each host.
+ *
+ * A fresh-only result with unavailable host observations has no complete
+ * dependency closure to put in a record. It returns false without writing or
+ * handing over an older record; its delivery marks the host cache volatile.
+ *
+ * The record's path is the host root's, while a generation is the cache's, and
+ * one cache can reach hosts whose roots differ: a caller of `transformTtsc` can
+ * hand one cache to hosts of its own, and the adapters' process-wide cache
+ * names the root of each delivery by the directory the process runs in at the
+ * time. Each host takes the record below its own root, the one place it accepts
+ * one. An input the generation recorded no state for, a failed compile's
+ * recovery input or a walk file no graph names, is read now, so a refresh at
+ * the next build start has a state to compare against. A failed byte read can
+ * record an observed directory kind or unavailable-content marker; that marker
+ * does not certify physical absence.
+ *
+ * Persistence writes changed bytes or accepts an identical existing record
+ * before initial handoff. Later deliveries reuse that accepted revision while
+ * its path still resolves to a regular file. A missing or unavailable record
+ * loses acceptance and enters persistence again without rereading generation
+ * inputs. Hosts and bridge readers own current byte proof, including concurrent
+ * changes and unreadable/torn bytes; availability here cannot exclude removal
+ * after the check. A host that keeps no
+ * snapshot of the file, Rollup's cache, is handed the digest of the bytes
+ * written for the generation to compare against instead
+ * (`TtscProjectRegistration.digest`).
+ *
+ * A record lives below the host's tool directory, or, when that cannot be
+ * written, below the fallback the host accepts (`fallbackToolDirectory`,
+ * samchon/ttsc#1480): the first place a write lands is the one handed over,
+ * since only a record the adapter can write can move. When no write lands this
+ * time, a record that is there is handed over all the same: a module handed
+ * over without it depends on its own bytes alone, and a host's persistent cache
+ * restores it on those whatever its types did; the bytes it holds stand for the
+ * last state written, and the next delivery of the generation writes it again.
+ * A record that is not there is not handed over, since what a host does with a
+ * dependency on a path that does not exist differs per host: the user is told
+ * once that the host watches each module alone (`warnUnwritableProjectRecord`),
+ * and the caller marks the module uncacheable, which keeps a one-shot build and
+ * a persistent cache correct. A watching session would serve the module from
+ * its watcher's silence after a type-only edit, so a successful delivery there
+ * fails instead (`TtscProjectRecordUnwritableError`); a failed one keeps its
+ * own diagnostics.
+ *
+ * @param inputs The generation's inputs, derived on first call.
+ * @param additionalInputs This delivery's config-selection inputs, which can
+ *   differ between modules served from the same generation.
+ * @returns Whether the host was handed the record.
+ * @throws {TtscProjectRecordUnwritableError} When a watching session's
+ *   successful delivery can be handed no record.
+ * @evidence contracts/common.md#principled-implementation Generation observations are retained by lexical input spelling and extended with new routing inputs; each host record is reusable only for the same evidenced snapshot, and bridge registrations receive a new array when that snapshot expands.
+ * @evidence contracts/common.md#clear-and-simple-design One generation-owned handoff state separates evidenced inputs, watching snapshot and per-record written version; record serialization and unrecorded host-byte capture remain private helpers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A fresh-only result cannot manufacture persistent proof from current bytes or an older record; an unavailable accepted record loses persistence acceptance and is recovered by the existing writer rather than forcing a new compile. Fallback remains an explicit host capability, and unavailable records preserve the supported volatility or watching error path.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain snapshot expansion, host roots, write-before-registration, fallback and watching failure; parameters and separated tags follow documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Record paths come from host-owned directories and actual write/existence outcomes; observation identities use the shared native filesystem context without OS-wide permission or case assumptions.
+ * @evidence contracts/performance.md#efficient-algorithms First handoff scans/maps generation inputs and observes current host bytes/native identities for entries lacking state. Every delivery scans selection spellings, with key-text cost; expansion copies the growing union and derives membership. An accepted revision pays one native path stat, without serialization or byte reads. New/unaccepted or unavailable host revisions build records, scan membership, sort/encode nested dictionary keys, hash/compare persisted bytes and perform native path/parent/write work. Input/policy/text/query populations determine temporary storage and bytes, while registration callback work remains a delivery effect even for accepted revisions.
+ * @evidence contracts/performance.md#reuse-equivalent-work Retained generation evidence and accepted per-host snapshot digests are shared while input-set revision agrees and the path resolves to a regular file, under fixed generation/root/policy and caller nonmutation. Selection expansion or lost availability invalidates the host's persistence acceptance without suppressing registration effects or discarding generation evidence. An available accepted version skips persistence here, so this memo does not prove current on-disk bytes; record readers and host digest/snapshot comparison own that proof.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources WeakMap state retains unique lexical inputs/evidence, spelling keys and one digest/revision per reached host record path without a capacity or byte cap. Expansion replaces arrays, but registration closures and borrowers can retain earlier snapshots after replacement or generation release. Native record files also outlive the generation and this operation supplies no historical on-disk reclamation policy; no live watcher handle is owned here.
+ */
+function notifyProjectRecord(project, cached, failed, inputs, additionalInputs = []) {
+    // A fresh-only result has no complete dependency closure to persist. A
+    // current read cannot manufacture the evaluation-time facts it lacks.
+    if (cached.freshDeliveryOnly === true)
+        return false;
+    let handed = HANDED.get(cached);
+    if (handed === undefined) {
+        const identities = createHostPathIdentityContext();
+        const evidenced = inputs().map((input) => readUnrecordedState(input, identities));
+        // Stable snapshots let the bridge skip repeat registrations. A new routing
+        // input below replaces the snapshot so its watcher index is refreshed.
+        const membership = projectMembershipInput(cached);
+        handed = {
+            evidenced,
+            inputs: membership === undefined ? evidenced : [...evidenced, membership],
+            revision: 0,
+            spellings: new Set(evidenced.map((input) => input.file)),
+            written: new Map(),
+        };
+        HANDED.set(cached, handed);
+    }
+    const added = [];
+    for (const input of additionalInputs) {
+        if (handed.spellings.has(input.file))
+            continue;
+        handed.spellings.add(input.file);
+        added.push(input);
+    }
+    if (added.length !== 0) {
+        const identities = createHostPathIdentityContext();
+        handed.evidenced = [
+            ...handed.evidenced,
+            ...added.map((input) => readUnrecordedState(input, identities)),
+        ];
+        const membership = projectMembershipInput(cached);
+        handed.inputs =
+            membership === undefined
+                ? handed.evidenced
+                : [...handed.evidenced, membership];
+        ++handed.revision;
+    }
+    const records = [
+        project.toolDirectory,
+        ...(project.fallbackToolDirectory === undefined
+            ? []
+            : [project.fallbackToolDirectory]),
+    ].map((directory) => projectRecordFile(directory, cached.tsconfig));
+    let record;
+    let refused;
+    for (const candidate of records) {
+        if (handed.written.get(candidate)?.revision === handed.revision) {
+            if (recordAvailable(candidate)) {
+                record = candidate;
+                break;
+            }
+            handed.written.delete(candidate);
+        }
+        try {
+            handed.written.set(candidate, {
+                digest: writeProjectRecordFile(candidate, recordOf(cached, handed.evidenced)),
+                revision: handed.revision,
+            });
+            record = candidate;
+            break;
+        }
+        catch (error) {
+            refused ??= error;
+        }
+    }
+    record ??= records.find(recordAvailable);
+    if (record === undefined) {
+        warnUnwritableProjectRecord(records[0], refused);
+        if (project.watching === true && !failed) {
+            throw new TtscProjectRecordUnwritableError(records[0], refused);
+        }
+        return false;
+    }
+    const registered = handed.inputs;
+    const written = handed.written.get(record);
+    const digest = written?.revision === handed.revision ? written.digest : undefined;
+    project.register({
+        ...(digest === undefined ? {} : { digest }),
+        failed,
+        inputs: () => registered,
+        record,
+    });
+    return true;
+}
+/**
+ * Availability of the host's file, following linked targets without changing
+ * lexical spelling. Byte readability and generation proof remain with readers;
+ * an unavailable path must re-enter writing and the host's fallback policy.
+ */
+function recordAvailable(file) {
+    try {
+        return fs.statSync(file).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/** The record of a generation over its evidenced inputs. */
+function recordOf(cached, inputs) {
+    const record = {
+        inputs: {},
+        membership: cached.projectDirectories === undefined
+            ? null
+            : {
+                digest: membershipRecordDigest(cached.membershipPolicy, cached.projectDirectories),
+                directories: cached.projectDirectories.map((directory) => directory.path),
+                policy: cached.membershipPolicy,
+            },
+        root: cached.projectRoot,
+        signal: 0,
+        tsconfig: cached.tsconfig,
+    };
+    for (const input of inputs) {
+        if (input.evidence !== undefined)
+            record.inputs[input.file] = input.evidence;
+    }
+    return record;
+}
+/**
+ * An input as the record can hold it: with the state the generation recorded,
+ * or, for one it recorded none for, the host bytes' state read now, one read
+ * per input, since a failed compile's recovery inputs are every file of the
+ * walk.
+ */
+function readUnrecordedState(input, identities) {
+    if (input.evidence?.state !== undefined)
+        return input;
+    const hash = hostInputStateHash(input.file) ?? MISSING_INPUT_STATE;
+    const missing = hash === MISSING_INPUT_STATE;
+    return {
+        evidence: {
+            identity: input.evidence?.identity ?? pathIdentityKey(input.file, identities),
+            missing,
+            state: { codec: "host", hash },
+            ...(missing ? { unavailable: "missing" } : {}),
+        },
+        file: input.file,
+    };
+}
+
+export { notifyProjectRecord };
+//# sourceMappingURL=notifyProjectRecord.mjs.map

package/lib/core/transform/watch/notifyProjectRecord.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"notifyProjectRecord.mjs","sources":["../../../../src/core/transform/watch/notifyProjectRecord.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/lib/core/transform/watch/notifyRejectedGenerationInputs.d.cts

@@ -0,0 +1,38 @@
+import type { TtscTransformHooks } from "./TtscTransformHooks.cjs";
+import type { TtscWatchSelection } from "./TtscWatchSelection.cjs";
+/**
+ * Register the recovery inputs of a delivery whose generation was rejected
+ * before it produced a result, so the host re-runs the module when they
+ * change.
+ *
+ * A generation can end in a rejection rather than a failed envelope: the
+ * project moved under two consecutive attempts (`TtscUnstableGenerationError`),
+ * or the compile could not start at all. A delivery that surfaced such a
+ * rejection without registering anything left its module with no dependencies
+ * on a host that records them per run, as Turbopack does, so no later edit
+ * re-ran it and the page kept the error. Measured on real `next dev` in about
+ * one run of twenty, when the four modules of the page compiled in parallel
+ * right after a breaking edit (samchon/ttsc#1446).
+ *
+ * An unstable generation keeps its last attempt as the validation baseline,
+ * whose inputs are exactly what a failed envelope of that attempt would
+ * register. Any other rejection has no generation to describe; the delivery
+ * then registers its known selected config along with reported routing inputs.
+ * An explicit project has no discovery history, but its config must still reach
+ * recovery callbacks. These registrations provide a config-edit recovery
+ * channel; they do not claim the unknown compiler input closure is complete.
+ *
+ * @param file The delivered module, as the host spelled it.
+ * @param selection The configs that routed the file to its project, and the
+ *   project's tsconfig, which spells the project for a rejection that has no
+ *   generation to spell it.
+ * @evidence contracts/common.md#principled-implementation An unstable attempt delegates its retained validation generation to normal failed delivery. A generation-free rejection registers the already-selected config as well as reported routing dependencies, including empty explicit-discovery history; current recovery facts do not manufacture compiler output or claim an unknown complete closure.
+ * @evidence contracts/common.md#clear-and-simple-design The unstable branch delegates generation recovery, while the generation-free branch has one routing batch shared by record and module callbacks.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The selected config comes from actual project selection, not a guessed dependency. Existing project records gain no newly accepted digest; absent records request a supplied volatility callback rather than inventing persistence or guaranteeing a host cache effect.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish rejection categories and limited recovery coverage, with documented parameters and separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation The delivery's filesystem supplies project physical identity, native path operations provide spelling and actual record existence selects only a host-approved directory.
+ * @evidence contracts/performance.md#efficient-algorithms The generation-free path resolves the selected root's native identity, chooses host spelling, dedupes reported routing names plus the selected config and observes each retained spelling's current host state. Cost includes bytes, path/key text, cold native ancestor/case observations and callback work; optional native record lookup considers at most two approved addresses. Arrays/context entries and callback-transferred inputs follow these populations. Unstable recovery includes its delegated retained-path/diagnostic/record computation rather than fixed work.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Recovery registration is a delivery effect and rejection without a generation offers no equivalent completed compiler computation to cache here.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The recovery batch and record candidate list are local; host watchers own any retained dependencies after callbacks return.
+ */
+export declare function notifyRejectedGenerationInputs(hooks: TtscTransformHooks | undefined, rejection: unknown, file: string, selection: TtscWatchSelection): void;

package/lib/core/transform/watch/notifyRejectedGenerationInputs.d.mts

@@ -0,0 +1,38 @@
+import type { TtscTransformHooks } from "./TtscTransformHooks.mjs";
+import type { TtscWatchSelection } from "./TtscWatchSelection.mjs";
+/**
+ * Register the recovery inputs of a delivery whose generation was rejected
+ * before it produced a result, so the host re-runs the module when they
+ * change.
+ *
+ * A generation can end in a rejection rather than a failed envelope: the
+ * project moved under two consecutive attempts (`TtscUnstableGenerationError`),
+ * or the compile could not start at all. A delivery that surfaced such a
+ * rejection without registering anything left its module with no dependencies
+ * on a host that records them per run, as Turbopack does, so no later edit
+ * re-ran it and the page kept the error. Measured on real `next dev` in about
+ * one run of twenty, when the four modules of the page compiled in parallel
+ * right after a breaking edit (samchon/ttsc#1446).
+ *
+ * An unstable generation keeps its last attempt as the validation baseline,
+ * whose inputs are exactly what a failed envelope of that attempt would
+ * register. Any other rejection has no generation to describe; the delivery
+ * then registers its known selected config along with reported routing inputs.
+ * An explicit project has no discovery history, but its config must still reach
+ * recovery callbacks. These registrations provide a config-edit recovery
+ * channel; they do not claim the unknown compiler input closure is complete.
+ *
+ * @param file The delivered module, as the host spelled it.
+ * @param selection The configs that routed the file to its project, and the
+ *   project's tsconfig, which spells the project for a rejection that has no
+ *   generation to spell it.
+ * @evidence contracts/common.md#principled-implementation An unstable attempt delegates its retained validation generation to normal failed delivery. A generation-free rejection registers the already-selected config as well as reported routing dependencies, including empty explicit-discovery history; current recovery facts do not manufacture compiler output or claim an unknown complete closure.
+ * @evidence contracts/common.md#clear-and-simple-design The unstable branch delegates generation recovery, while the generation-free branch has one routing batch shared by record and module callbacks.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The selected config comes from actual project selection, not a guessed dependency. Existing project records gain no newly accepted digest; absent records request a supplied volatility callback rather than inventing persistence or guaranteeing a host cache effect.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish rejection categories and limited recovery coverage, with documented parameters and separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation The delivery's filesystem supplies project physical identity, native path operations provide spelling and actual record existence selects only a host-approved directory.
+ * @evidence contracts/performance.md#efficient-algorithms The generation-free path resolves the selected root's native identity, chooses host spelling, dedupes reported routing names plus the selected config and observes each retained spelling's current host state. Cost includes bytes, path/key text, cold native ancestor/case observations and callback work; optional native record lookup considers at most two approved addresses. Arrays/context entries and callback-transferred inputs follow these populations. Unstable recovery includes its delegated retained-path/diagnostic/record computation rather than fixed work.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Recovery registration is a delivery effect and rejection without a generation offers no equivalent completed compiler computation to cache here.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The recovery batch and record candidate list are local; host watchers own any retained dependencies after callbacks return.
+ */
+export declare function notifyRejectedGenerationInputs(hooks: TtscTransformHooks | undefined, rejection: unknown, file: string, selection: TtscWatchSelection): void;

package/lib/core/transform/watch/notifyRejectedGenerationInputs.d.ts

@@ -0,0 +1,38 @@
+import type { TtscTransformHooks } from "./TtscTransformHooks";
+import type { TtscWatchSelection } from "./TtscWatchSelection";
+/**
+ * Register the recovery inputs of a delivery whose generation was rejected
+ * before it produced a result, so the host re-runs the module when they
+ * change.
+ *
+ * A generation can end in a rejection rather than a failed envelope: the
+ * project moved under two consecutive attempts (`TtscUnstableGenerationError`),
+ * or the compile could not start at all. A delivery that surfaced such a
+ * rejection without registering anything left its module with no dependencies
+ * on a host that records them per run, as Turbopack does, so no later edit
+ * re-ran it and the page kept the error. Measured on real `next dev` in about
+ * one run of twenty, when the four modules of the page compiled in parallel
+ * right after a breaking edit (samchon/ttsc#1446).
+ *
+ * An unstable generation keeps its last attempt as the validation baseline,
+ * whose inputs are exactly what a failed envelope of that attempt would
+ * register. Any other rejection has no generation to describe; the delivery
+ * then registers its known selected config along with reported routing inputs.
+ * An explicit project has no discovery history, but its config must still reach
+ * recovery callbacks. These registrations provide a config-edit recovery
+ * channel; they do not claim the unknown compiler input closure is complete.
+ *
+ * @param file The delivered module, as the host spelled it.
+ * @param selection The configs that routed the file to its project, and the
+ *   project's tsconfig, which spells the project for a rejection that has no
+ *   generation to spell it.
+ * @evidence contracts/common.md#principled-implementation An unstable attempt delegates its retained validation generation to normal failed delivery. A generation-free rejection registers the already-selected config as well as reported routing dependencies, including empty explicit-discovery history; current recovery facts do not manufacture compiler output or claim an unknown complete closure.
+ * @evidence contracts/common.md#clear-and-simple-design The unstable branch delegates generation recovery, while the generation-free branch has one routing batch shared by record and module callbacks.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The selected config comes from actual project selection, not a guessed dependency. Existing project records gain no newly accepted digest; absent records request a supplied volatility callback rather than inventing persistence or guaranteeing a host cache effect.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish rejection categories and limited recovery coverage, with documented parameters and separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation The delivery's filesystem supplies project physical identity, native path operations provide spelling and actual record existence selects only a host-approved directory.
+ * @evidence contracts/performance.md#efficient-algorithms The generation-free path resolves the selected root's native identity, chooses host spelling, dedupes reported routing names plus the selected config and observes each retained spelling's current host state. Cost includes bytes, path/key text, cold native ancestor/case observations and callback work; optional native record lookup considers at most two approved addresses. Arrays/context entries and callback-transferred inputs follow these populations. Unstable recovery includes its delegated retained-path/diagnostic/record computation rather than fixed work.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Recovery registration is a delivery effect and rejection without a generation offers no equivalent completed compiler computation to cache here.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The recovery batch and record candidate list are local; host watchers own any retained dependencies after callbacks return.
+ */
+export declare function notifyRejectedGenerationInputs(hooks: TtscTransformHooks | undefined, rejection: unknown, file: string, selection: TtscWatchSelection): void;

package/lib/core/transform/watch/notifyRejectedGenerationInputs.js

@@ -0,0 +1,93 @@
+'use strict';
+
+var fs = require('node:fs');
+var path = require('node:path');
+var projectRecordFile = require('../../bridge/projectRecordFile.js');
+var hostSpelling = require('../envelope/hostSpelling.js');
+var TtscUnstableGenerationError = require('../errors/TtscUnstableGenerationError.js');
+var createHostPathIdentityContext = require('../filesystem/createHostPathIdentityContext.js');
+var handWatchInputs = require('./handWatchInputs.js');
+var notifyFailedGenerationInputs = require('./notifyFailedGenerationInputs.js');
+var selectionInputs = require('./selectionInputs.js');
+
+/**
+ * Register the recovery inputs of a delivery whose generation was rejected
+ * before it produced a result, so the host re-runs the module when they
+ * change.
+ *
+ * A generation can end in a rejection rather than a failed envelope: the
+ * project moved under two consecutive attempts (`TtscUnstableGenerationError`),
+ * or the compile could not start at all. A delivery that surfaced such a
+ * rejection without registering anything left its module with no dependencies
+ * on a host that records them per run, as Turbopack does, so no later edit
+ * re-ran it and the page kept the error. Measured on real `next dev` in about
+ * one run of twenty, when the four modules of the page compiled in parallel
+ * right after a breaking edit (samchon/ttsc#1446).
+ *
+ * An unstable generation keeps its last attempt as the validation baseline,
+ * whose inputs are exactly what a failed envelope of that attempt would
+ * register. Any other rejection has no generation to describe; the delivery
+ * then registers its known selected config along with reported routing inputs.
+ * An explicit project has no discovery history, but its config must still reach
+ * recovery callbacks. These registrations provide a config-edit recovery
+ * channel; they do not claim the unknown compiler input closure is complete.
+ *
+ * @param file The delivered module, as the host spelled it.
+ * @param selection The configs that routed the file to its project, and the
+ *   project's tsconfig, which spells the project for a rejection that has no
+ *   generation to spell it.
+ * @evidence contracts/common.md#principled-implementation An unstable attempt delegates its retained validation generation to normal failed delivery. A generation-free rejection registers the already-selected config as well as reported routing dependencies, including empty explicit-discovery history; current recovery facts do not manufacture compiler output or claim an unknown complete closure.
+ * @evidence contracts/common.md#clear-and-simple-design The unstable branch delegates generation recovery, while the generation-free branch has one routing batch shared by record and module callbacks.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The selected config comes from actual project selection, not a guessed dependency. Existing project records gain no newly accepted digest; absent records request a supplied volatility callback rather than inventing persistence or guaranteeing a host cache effect.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish rejection categories and limited recovery coverage, with documented parameters and separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation The delivery's filesystem supplies project physical identity, native path operations provide spelling and actual record existence selects only a host-approved directory.
+ * @evidence contracts/performance.md#efficient-algorithms The generation-free path resolves the selected root's native identity, chooses host spelling, dedupes reported routing names plus the selected config and observes each retained spelling's current host state. Cost includes bytes, path/key text, cold native ancestor/case observations and callback work; optional native record lookup considers at most two approved addresses. Arrays/context entries and callback-transferred inputs follow these populations. Unstable recovery includes its delegated retained-path/diagnostic/record computation rather than fixed work.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Recovery registration is a delivery effect and rejection without a generation offers no equivalent completed compiler computation to cache here.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The recovery batch and record candidate list are local; host watchers own any retained dependencies after callbacks return.
+ */
+function notifyRejectedGenerationInputs(hooks, rejection, file, selection) {
+    if (rejection instanceof TtscUnstableGenerationError.TtscUnstableGenerationError) {
+        notifyFailedGenerationInputs.notifyFailedGenerationInputs(hooks, rejection.validation.cached, file, selection);
+        return;
+    }
+    if (hooks === undefined)
+        return;
+    const spelling = path.dirname(selection.tsconfig);
+    const spell = hostSpelling.hostSpelling({
+        physical: createHostPathIdentityContext.createHostPathIdentityContext(selection.filesystem).resolve(spelling).path,
+        spelling,
+    }, file);
+    const consulted = [...new Set([...selection.consulted, selection.tsconfig])];
+    const inputs = selectionInputs.selectionInputs(consulted, selection.filesystem, spell);
+    // A generation the adapter rejected has no state to record beyond the
+    // known selected config and reported routing names: a build host keeps its last
+    // generation wrote, which its bridge moves when the selection changes. A
+    // record no generation wrote is not handed over, as `notifyProjectRecord`
+    // hands over none that is not there, and the module is marked uncacheable
+    // as one that function could not hand its record to is.
+    if (hooks.project !== undefined) {
+        // Below the host's tool directory, or the fallback it accepts, where the
+        // last generation may have written it (samchon/ttsc#1480).
+        const record = [
+            hooks.project.toolDirectory,
+            ...(hooks.project.fallbackToolDirectory === undefined
+                ? []
+                : [hooks.project.fallbackToolDirectory]),
+        ]
+            .map((directory) => projectRecordFile.projectRecordFile(directory, selection.tsconfig))
+            .find((candidate) => fs.existsSync(candidate));
+        if (record !== undefined) {
+            hooks.project.register({ failed: true, inputs: () => inputs, record });
+        }
+        else {
+            hooks.markVolatile?.();
+        }
+    }
+    if (hooks.addWatchFile === undefined && hooks.addWatchFiles === undefined) {
+        return;
+    }
+    handWatchInputs.handWatchInputs(hooks, inputs, true);
+}
+
+exports.notifyRejectedGenerationInputs = notifyRejectedGenerationInputs;
+//# sourceMappingURL=notifyRejectedGenerationInputs.js.map

package/lib/core/transform/watch/notifyRejectedGenerationInputs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"notifyRejectedGenerationInputs.js","sources":["../../../../src/core/transform/watch/notifyRejectedGenerationInputs.ts"],"sourcesContent":[null],"names":["TtscUnstableGenerationError","notifyFailedGenerationInputs","hostSpelling","createHostPathIdentityContext","selectionInputs","projectRecordFile","handWatchInputs"],"mappings":";;;;;;;;;;;;AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCG;AACG,SAAU,8BAA8B,CAC5C,KAAqC,EACrC,SAAkB,EAClB,IAAY,EACZ,SAA6B,EAAA;AAE7B,IAAA,IAAI,SAAS,YAAYA,uDAA2B,EAAE;AACpD,QAAAC,yDAA4B,CAC1B,KAAK,EACL,SAAS,CAAC,UAAU,CAAC,MAAM,EAC3B,IAAI,EACJ,SAAS,CACV;QACD;IACF;IACA,IAAI,KAAK,KAAK,SAAS;QAAE;IACzB,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,QAAQ,CAAC;IACjD,MAAM,KAAK,GAAGC,yBAAY,CACxB;AACE,QAAA,QAAQ,EAAEC,2DAA6B,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,OAAO,CACnE,QAAQ,CACT,CAAC,IAAI;QACN,QAAQ;KACT,EACD,IAAI,CACL;AACD,IAAA,MAAM,SAAS,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,SAAS,CAAC,SAAS,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;AAC5E,IAAA,MAAM,MAAM,GAAGC,+BAAe,CAAC,SAAS,EAAE,SAAS,CAAC,UAAU,EAAE,KAAK,CAAC;;;;;;;AAOtE,IAAA,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS,EAAE;;;AAG/B,QAAA,MAAM,MAAM,GAAG;YACb,KAAK,CAAC,OAAO,CAAC,aAAa;AAC3B,YAAA,IAAI,KAAK,CAAC,OAAO,CAAC,qBAAqB,KAAK;AAC1C,kBAAE;kBACA,CAAC,KAAK,CAAC,OAAO,CAAC,qBAAqB,CAAC,CAAC;AAC3C;AACE,aAAA,GAAG,CAAC,CAAC,SAAS,KAAKC,mCAAiB,CAAC,SAAS,EAAE,SAAS,CAAC,QAAQ,CAAC;AACnE,aAAA,IAAI,CAAC,CAAC,SAAS,KAAK,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;AAChD,QAAA,IAAI,MAAM,KAAK,SAAS,EAAE;YACxB,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,MAAM,EAAE,MAAM,EAAE,CAAC;QACxE;aAAO;AACL,YAAA,KAAK,CAAC,YAAY,IAAI;QACxB;IACF;AACA,IAAA,IAAI,KAAK,CAAC,YAAY,KAAK,SAAS,IAAI,KAAK,CAAC,aAAa,KAAK,SAAS,EAAE;QACzE;IACF;AACA,IAAAC,+BAAe,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC;AACtC;;;;"}

package/lib/core/transform/watch/notifyRejectedGenerationInputs.mjs

@@ -0,0 +1,91 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { projectRecordFile } from '../../bridge/projectRecordFile.mjs';
+import { hostSpelling } from '../envelope/hostSpelling.mjs';
+import { TtscUnstableGenerationError } from '../errors/TtscUnstableGenerationError.mjs';
+import { createHostPathIdentityContext } from '../filesystem/createHostPathIdentityContext.mjs';
+import { handWatchInputs } from './handWatchInputs.mjs';
+import { notifyFailedGenerationInputs } from './notifyFailedGenerationInputs.mjs';
+import { selectionInputs } from './selectionInputs.mjs';
+
+/**
+ * Register the recovery inputs of a delivery whose generation was rejected
+ * before it produced a result, so the host re-runs the module when they
+ * change.
+ *
+ * A generation can end in a rejection rather than a failed envelope: the
+ * project moved under two consecutive attempts (`TtscUnstableGenerationError`),
+ * or the compile could not start at all. A delivery that surfaced such a
+ * rejection without registering anything left its module with no dependencies
+ * on a host that records them per run, as Turbopack does, so no later edit
+ * re-ran it and the page kept the error. Measured on real `next dev` in about
+ * one run of twenty, when the four modules of the page compiled in parallel
+ * right after a breaking edit (samchon/ttsc#1446).
+ *
+ * An unstable generation keeps its last attempt as the validation baseline,
+ * whose inputs are exactly what a failed envelope of that attempt would
+ * register. Any other rejection has no generation to describe; the delivery
+ * then registers its known selected config along with reported routing inputs.
+ * An explicit project has no discovery history, but its config must still reach
+ * recovery callbacks. These registrations provide a config-edit recovery
+ * channel; they do not claim the unknown compiler input closure is complete.
+ *
+ * @param file The delivered module, as the host spelled it.
+ * @param selection The configs that routed the file to its project, and the
+ *   project's tsconfig, which spells the project for a rejection that has no
+ *   generation to spell it.
+ * @evidence contracts/common.md#principled-implementation An unstable attempt delegates its retained validation generation to normal failed delivery. A generation-free rejection registers the already-selected config as well as reported routing dependencies, including empty explicit-discovery history; current recovery facts do not manufacture compiler output or claim an unknown complete closure.
+ * @evidence contracts/common.md#clear-and-simple-design The unstable branch delegates generation recovery, while the generation-free branch has one routing batch shared by record and module callbacks.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The selected config comes from actual project selection, not a guessed dependency. Existing project records gain no newly accepted digest; absent records request a supplied volatility callback rather than inventing persistence or guaranteeing a host cache effect.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish rejection categories and limited recovery coverage, with documented parameters and separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation The delivery's filesystem supplies project physical identity, native path operations provide spelling and actual record existence selects only a host-approved directory.
+ * @evidence contracts/performance.md#efficient-algorithms The generation-free path resolves the selected root's native identity, chooses host spelling, dedupes reported routing names plus the selected config and observes each retained spelling's current host state. Cost includes bytes, path/key text, cold native ancestor/case observations and callback work; optional native record lookup considers at most two approved addresses. Arrays/context entries and callback-transferred inputs follow these populations. Unstable recovery includes its delegated retained-path/diagnostic/record computation rather than fixed work.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Recovery registration is a delivery effect and rejection without a generation offers no equivalent completed compiler computation to cache here.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The recovery batch and record candidate list are local; host watchers own any retained dependencies after callbacks return.
+ */
+function notifyRejectedGenerationInputs(hooks, rejection, file, selection) {
+    if (rejection instanceof TtscUnstableGenerationError) {
+        notifyFailedGenerationInputs(hooks, rejection.validation.cached, file, selection);
+        return;
+    }
+    if (hooks === undefined)
+        return;
+    const spelling = path.dirname(selection.tsconfig);
+    const spell = hostSpelling({
+        physical: createHostPathIdentityContext(selection.filesystem).resolve(spelling).path,
+        spelling,
+    }, file);
+    const consulted = [...new Set([...selection.consulted, selection.tsconfig])];
+    const inputs = selectionInputs(consulted, selection.filesystem, spell);
+    // A generation the adapter rejected has no state to record beyond the
+    // known selected config and reported routing names: a build host keeps its last
+    // generation wrote, which its bridge moves when the selection changes. A
+    // record no generation wrote is not handed over, as `notifyProjectRecord`
+    // hands over none that is not there, and the module is marked uncacheable
+    // as one that function could not hand its record to is.
+    if (hooks.project !== undefined) {
+        // Below the host's tool directory, or the fallback it accepts, where the
+        // last generation may have written it (samchon/ttsc#1480).
+        const record = [
+            hooks.project.toolDirectory,
+            ...(hooks.project.fallbackToolDirectory === undefined
+                ? []
+                : [hooks.project.fallbackToolDirectory]),
+        ]
+            .map((directory) => projectRecordFile(directory, selection.tsconfig))
+            .find((candidate) => fs.existsSync(candidate));
+        if (record !== undefined) {
+            hooks.project.register({ failed: true, inputs: () => inputs, record });
+        }
+        else {
+            hooks.markVolatile?.();
+        }
+    }
+    if (hooks.addWatchFile === undefined && hooks.addWatchFiles === undefined) {
+        return;
+    }
+    handWatchInputs(hooks, inputs, true);
+}
+
+export { notifyRejectedGenerationInputs };
+//# sourceMappingURL=notifyRejectedGenerationInputs.mjs.map

package/lib/core/transform/watch/notifyRejectedGenerationInputs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"notifyRejectedGenerationInputs.mjs","sources":["../../../../src/core/transform/watch/notifyRejectedGenerationInputs.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCG;AACG,SAAU,8BAA8B,CAC5C,KAAqC,EACrC,SAAkB,EAClB,IAAY,EACZ,SAA6B,EAAA;AAE7B,IAAA,IAAI,SAAS,YAAY,2BAA2B,EAAE;AACpD,QAAA,4BAA4B,CAC1B,KAAK,EACL,SAAS,CAAC,UAAU,CAAC,MAAM,EAC3B,IAAI,EACJ,SAAS,CACV;QACD;IACF;IACA,IAAI,KAAK,KAAK,SAAS;QAAE;IACzB,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,QAAQ,CAAC;IACjD,MAAM,KAAK,GAAG,YAAY,CACxB;AACE,QAAA,QAAQ,EAAE,6BAA6B,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,OAAO,CACnE,QAAQ,CACT,CAAC,IAAI;QACN,QAAQ;KACT,EACD,IAAI,CACL;AACD,IAAA,MAAM,SAAS,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,SAAS,CAAC,SAAS,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;AAC5E,IAAA,MAAM,MAAM,GAAG,eAAe,CAAC,SAAS,EAAE,SAAS,CAAC,UAAU,EAAE,KAAK,CAAC;;;;;;;AAOtE,IAAA,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS,EAAE;;;AAG/B,QAAA,MAAM,MAAM,GAAG;YACb,KAAK,CAAC,OAAO,CAAC,aAAa;AAC3B,YAAA,IAAI,KAAK,CAAC,OAAO,CAAC,qBAAqB,KAAK;AAC1C,kBAAE;kBACA,CAAC,KAAK,CAAC,OAAO,CAAC,qBAAqB,CAAC,CAAC;AAC3C;AACE,aAAA,GAAG,CAAC,CAAC,SAAS,KAAK,iBAAiB,CAAC,SAAS,EAAE,SAAS,CAAC,QAAQ,CAAC;AACnE,aAAA,IAAI,CAAC,CAAC,SAAS,KAAK,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;AAChD,QAAA,IAAI,MAAM,KAAK,SAAS,EAAE;YACxB,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,MAAM,EAAE,MAAM,EAAE,CAAC;QACxE;aAAO;AACL,YAAA,KAAK,CAAC,YAAY,IAAI;QACxB;IACF;AACA,IAAA,IAAI,KAAK,CAAC,YAAY,KAAK,SAAS,IAAI,KAAK,CAAC,aAAa,KAAK,SAAS,EAAE;QACzE;IACF;AACA,IAAA,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC;AACtC;;;;"}

package/lib/core/transform/watch/notifyVolatileDelivery.d.cts

@@ -0,0 +1,19 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
+import type { TtscTransformHooks } from "./TtscTransformHooks.cjs";
+/**
+ * Notify the host when the captured generation declares this absolute delivery
+ * path volatile. The cached result and root belong to one immutable generation.
+ * The declaration is checked even without a callback. A supplied callback runs
+ * with the hooks object as its receiver, and its exception reaches the caller.
+ * This notification does not acquire or certify compiler metadata.
+ *
+ * @evidence contracts/common.md#principled-implementation Only the generation's explicit volatile file membership requests host cache withdrawal; ordinary deliveries do not invoke the callback.
+ * @evidence contracts/common.md#clear-and-simple-design Generation declaration matching remains with isVolatileFile, while this operation owns the conditional delivery notification used by transformTtsc.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No output-text inference or fabricated compiler declaration replaces recorded membership, and callback failures are not suppressed.
+ * @evidence contracts/common.md#meaningful-documentation Native prose identifies declaration evaluation, callback receiver and exception behavior, and excludes compiler acquisition certification.
+ * @evidence contracts/portability.md#os-neutral-implementation Declared and delivered paths are compared through the generation's native filesystem identity context, rather than lexical case or separator guesses.
+ * @evidence contracts/performance.md#efficient-algorithms Delegated cold matching folds the declared population and resolves native identities; warm matching uses its identity set and per-spelling memo. This operation adds one conditional callback without copying or rescanning the declaration.
+ * @evidence contracts/performance.md#reuse-equivalent-work The predicate shares indexes only within its immutable result/root and qualified filesystem identity snapshot. Host notification still occurs on each volatile delivery, including repeated deliveries; an absent callback does not skip the existing declaration evaluation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The operation acquires no resource and controls no retained generation lifetime; derivation state and host cache withdrawal have separate owners.
+ */
+export declare function notifyVolatileDelivery(hooks: TtscTransformHooks | undefined, cached: TtscCachedProjectTransform, file: string): void;

package/lib/core/transform/watch/notifyVolatileDelivery.d.mts

@@ -0,0 +1,19 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
+import type { TtscTransformHooks } from "./TtscTransformHooks.mjs";
+/**
+ * Notify the host when the captured generation declares this absolute delivery
+ * path volatile. The cached result and root belong to one immutable generation.
+ * The declaration is checked even without a callback. A supplied callback runs
+ * with the hooks object as its receiver, and its exception reaches the caller.
+ * This notification does not acquire or certify compiler metadata.
+ *
+ * @evidence contracts/common.md#principled-implementation Only the generation's explicit volatile file membership requests host cache withdrawal; ordinary deliveries do not invoke the callback.
+ * @evidence contracts/common.md#clear-and-simple-design Generation declaration matching remains with isVolatileFile, while this operation owns the conditional delivery notification used by transformTtsc.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No output-text inference or fabricated compiler declaration replaces recorded membership, and callback failures are not suppressed.
+ * @evidence contracts/common.md#meaningful-documentation Native prose identifies declaration evaluation, callback receiver and exception behavior, and excludes compiler acquisition certification.
+ * @evidence contracts/portability.md#os-neutral-implementation Declared and delivered paths are compared through the generation's native filesystem identity context, rather than lexical case or separator guesses.
+ * @evidence contracts/performance.md#efficient-algorithms Delegated cold matching folds the declared population and resolves native identities; warm matching uses its identity set and per-spelling memo. This operation adds one conditional callback without copying or rescanning the declaration.
+ * @evidence contracts/performance.md#reuse-equivalent-work The predicate shares indexes only within its immutable result/root and qualified filesystem identity snapshot. Host notification still occurs on each volatile delivery, including repeated deliveries; an absent callback does not skip the existing declaration evaluation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The operation acquires no resource and controls no retained generation lifetime; derivation state and host cache withdrawal have separate owners.
+ */
+export declare function notifyVolatileDelivery(hooks: TtscTransformHooks | undefined, cached: TtscCachedProjectTransform, file: string): void;