@ttsc/unplugin 0.30.3 → 0.31.0

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

@@ -0,0 +1,135 @@
+import path from 'node:path';
+import { formatUnknownError } from '../diagnostics/formatUnknownError.mjs';
+import { envelopeDerivation } from '../envelope/envelopeDerivation.mjs';
+import { hostSpelling } from '../envelope/hostSpelling.mjs';
+import { isTransformScratchInput } from '../tsconfig/isTransformScratchInput.mjs';
+import { evidencedWatchInput } from './evidencedWatchInput.mjs';
+import { handWatchInputs } from './handWatchInputs.mjs';
+import { notifyProjectRecord } from './notifyProjectRecord.mjs';
+import { projectMembershipInput } from './projectMembershipInput.mjs';
+import { selectionInputs } from './selectionInputs.mjs';
+
+/**
+ * Register the failed generation's project and external inputs so the host can
+ * observe the fix.
+ *
+ * A successful delivery registers the derived watch inputs, which is how a
+ * type-only file that no bundler graph contains still invalidates the modules
+ * depending on it. A failed one used to register nothing: `selectWatchInputs`
+ * returns an empty list for an `"exception"` envelope, and the throw happens
+ * before `notifyWatchInputs` is reached at all. When the failing compile is the
+ * first of a watching session, that leaves no channel through which the fix can
+ * arrive: the user repairs a file the bundler does not track, nothing is
+ * invalidated, and the error stays on screen (samchon/ttsc#1312).
+ *
+ * A failure envelope can retain exact external input spellings from its graph
+ * and host metadata, including missing resolution candidates on native
+ * typecheck failures. For hosts that return no graph, structured diagnostics or
+ * standard diagnostic lines provide only the paths they actually name. The cost
+ * is paid only on a failure, and only until the next compile succeeds and
+ * narrows the set back to the derived inputs.
+ *
+ * @param file The delivered module, as the host spelled it, which decides the
+ *   spelling every input is handed under (`hostSpelling`).
+ * @param selection The configs that routed the file to its project, handed
+ *   beside the failed generation's inputs.
+ * @evidence contracts/common.md#principled-implementation Failed deliveries retain walked/external inputs, named diagnostic paths and the known selected config alongside consulted routing configs, even when optional envelope lists omit it. Ordinary recovery paths omit generation evidence that a replayed failure did not revalidate; separately captured membership can still accompany them, while project-record delivery maps available retained facts under its own contract.
+ * @evidence contracts/common.md#clear-and-simple-design One append boundary owns scratch exclusion and lexical deduplication; module recovery and project-record delivery share the same routing observations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Diagnostic extraction accepts only supported TypeScript forms, and recovery absence is explicit rather than fabricated successful state or fixture-specific paths.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain recovery, external-path coverage and failed evidence ownership; parameter prose and separated tags follow documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path resolution and host spelling preserve absolute external paths, including drive-letter diagnostic forms; project-record locations remain host-selected capabilities.
+ * @evidence contracts/performance.md#efficient-algorithms Every call materializes project hash keys and scans retained external/diagnostic entries. Each occurrence pays path/scratch/key text work before accepted paths create ordinary carriers and recorded spellings. Exception extraction formats/splits text and runs two anchored diagnostic patterns per line; matching and caller conversion costs are not a fixed per-diagnostic operation. Routing byte/native observations, optional membership encoding, lazy record evidence/persistence and callback effects add delegated work. Arrays/sets and formatted lines retain their respective populations/text; routing evidence is shared between current notification branches.
+ * @evidence contracts/performance.md#reuse-equivalent-work notifyProjectRecord owns qualified generation snapshot/accepted-revision sharing; its input callback is derived only when required. This recovery traversal and host callback effects still run per delivery, with current routing observations added separately. No matching failure message or quiet watcher authorizes skipping the notification effect.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This delivery owns only local arrays and sets; the project-record and host watcher owners retain or release the transferred dependencies.
+ */
+function notifyFailedGenerationInputs(hooks, cached, file, selection) {
+    if (hooks === undefined ||
+        (hooks.project === undefined &&
+            hooks.addWatchFile === undefined &&
+            hooks.addWatchFiles === undefined)) {
+        return;
+    }
+    const state = envelopeDerivation(cached);
+    const spell = hostSpelling(state.project, file);
+    const inputs = [];
+    // The same paths as the compiler spelled them, for the record: what the
+    // failed generation did record of each, its walk hash or external state, is
+    // what the record holds, read again only where it recorded nothing.
+    const recorded = [];
+    const seen = new Set();
+    const append = (input) => {
+        const spelling = path.resolve(input);
+        if (seen.has(spelling) ||
+            isTransformScratchInput(spelling, cached.scratchDirectory)) {
+            return;
+        }
+        seen.add(spelling);
+        // No evidence, deliberately. A failed generation is replayed for the rest
+        // of its pass without re-proving its inputs, so the adapter must observe
+        // the current availability itself.
+        inputs.push({ file: spell(spelling) });
+        recorded.push(spelling);
+    };
+    for (const key of Object.keys(cached.inputHashes)) {
+        append(path.resolve(cached.projectRoot, key));
+    }
+    // The project walk deliberately excludes node_modules and cannot reach
+    // sibling-project or out-of-root inputs. The generation already retained
+    // their exact lexical spellings, so keep that ownership on the failure path
+    // instead of deriving a narrower second answer.
+    for (const input of cached.externalInputPaths ?? []) {
+        append(input);
+    }
+    if (cached.result.type === "failure") {
+        for (const diagnostic of cached.result.diagnostics) {
+            if (typeof diagnostic.file === "string" && diagnostic.file.length !== 0) {
+                append(path.resolve(cached.projectRoot, diagnostic.file));
+            }
+        }
+    }
+    else if (cached.result.type === "exception") {
+        for (const diagnostic of selectExceptionDiagnosticFiles(cached.result.error)) {
+            append(path.resolve(cached.projectRoot, diagnostic));
+        }
+    }
+    const routedInputs = selectionInputs([...new Set([...selection.consulted, selection.tsconfig])], selection.filesystem, (input) => input);
+    for (const entryToAppend of routedInputs.map((input) => ({
+        ...input,
+        file: spell(input.file),
+    })))
+        inputs.push(entryToAppend);
+    // A build host takes the record, written to what the failed compile
+    // consulted, so the repair moves it wherever it lands; a module handed over
+    // without it depends on its own bytes alone, and no persistent cache may
+    // keep it.
+    if (hooks.project !== undefined &&
+        !notifyProjectRecord(hooks.project, cached, true, () => recorded.map((input) => evidencedWatchInput(cached, state, input, (spelling) => spelling)), routedInputs)) {
+        hooks.markVolatile?.();
+    }
+    if (hooks.addWatchFile === undefined && hooks.addWatchFiles === undefined) {
+        return;
+    }
+    // A root file the tsconfig includes, such as the global declaration the
+    // failed compile was missing, can repair it too (samchon/ttsc#1419).
+    const membership = hooks.membership === true ? projectMembershipInput(cached) : undefined;
+    handWatchInputs(hooks, membership === undefined ? inputs : [...inputs, membership], true);
+}
+/**
+ * Extract file spellings only from the two standard TypeScript diagnostic
+ * forms.
+ */
+function selectExceptionDiagnosticFiles(error) {
+    const files = [];
+    for (const line of formatUnknownError(error).split(/\r?\n/)) {
+        const colon = /^(.+):\d+:\d+\s+-\s+(?:error|warning|suggestion|message)\s+TS\d+:\s+.+$/i.exec(line);
+        const parenthesized = /^(.+?)\(\d+,\d+\):\s+(?:error|warning|suggestion|message)\s+TS\d+:\s+.+$/i.exec(line);
+        const file = colon?.[1] ?? parenthesized?.[1];
+        if (file !== undefined && file.trim().length !== 0) {
+            files.push(file.trim());
+        }
+    }
+    return files;
+}
+
+export { notifyFailedGenerationInputs };
+//# sourceMappingURL=notifyFailedGenerationInputs.mjs.map

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

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

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

@@ -0,0 +1,72 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
+import type { TtscTransformHooks } from "./TtscTransformHooks.cjs";
+import type { TtscWatchInput } from "./TtscWatchInput.cjs";
+/**
+ * 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.
+ */
+export declare function notifyProjectRecord(project: NonNullable<TtscTransformHooks["project"]>, cached: TtscCachedProjectTransform, failed: boolean, inputs: () => readonly TtscWatchInput[], additionalInputs?: readonly TtscWatchInput[]): boolean;

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

@@ -0,0 +1,72 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
+import type { TtscTransformHooks } from "./TtscTransformHooks.mjs";
+import type { TtscWatchInput } from "./TtscWatchInput.mjs";
+/**
+ * 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.
+ */
+export declare function notifyProjectRecord(project: NonNullable<TtscTransformHooks["project"]>, cached: TtscCachedProjectTransform, failed: boolean, inputs: () => readonly TtscWatchInput[], additionalInputs?: readonly TtscWatchInput[]): boolean;

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

@@ -0,0 +1,72 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+import type { TtscTransformHooks } from "./TtscTransformHooks";
+import type { TtscWatchInput } from "./TtscWatchInput";
+/**
+ * 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.
+ */
+export declare function notifyProjectRecord(project: NonNullable<TtscTransformHooks["project"]>, cached: TtscCachedProjectTransform, failed: boolean, inputs: () => readonly TtscWatchInput[], additionalInputs?: readonly TtscWatchInput[]): boolean;

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

@@ -0,0 +1,233 @@
+'use strict';
+
+var fs = require('node:fs');
+var membershipRecordDigest = require('../../bridge/membershipRecordDigest.js');
+var projectRecordFile = require('../../bridge/projectRecordFile.js');
+var warnUnwritableProjectRecord = require('../../bridge/warnUnwritableProjectRecord.js');
+var writeProjectRecordFile = require('../../bridge/writeProjectRecordFile.js');
+var TtscProjectRecordUnwritableError = require('../errors/TtscProjectRecordUnwritableError.js');
+var createHostPathIdentityContext = require('../filesystem/createHostPathIdentityContext.js');
+var pathIdentityKey = require('../filesystem/pathIdentityKey.js');
+var hostInputStateHash = require('../inputs/hostInputStateHash.js');
+var MISSING_INPUT_STATE = require('../validation/MISSING_INPUT_STATE.js');
+var projectMembershipInput = require('./projectMembershipInput.js');
+
+/**
+ * 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.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.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.createHostPathIdentityContext();
+        handed.evidenced = [
+            ...handed.evidenced,
+            ...added.map((input) => readUnrecordedState(input, identities)),
+        ];
+        const membership = projectMembershipInput.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.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.writeProjectRecordFile(candidate, recordOf(cached, handed.evidenced)),
+                revision: handed.revision,
+            });
+            record = candidate;
+            break;
+        }
+        catch (error) {
+            refused ??= error;
+        }
+    }
+    record ??= records.find(recordAvailable);
+    if (record === undefined) {
+        warnUnwritableProjectRecord.warnUnwritableProjectRecord(records[0], refused);
+        if (project.watching === true && !failed) {
+            throw new TtscProjectRecordUnwritableError.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.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.hostInputStateHash(input.file) ?? MISSING_INPUT_STATE.MISSING_INPUT_STATE;
+    const missing = hash === MISSING_INPUT_STATE.MISSING_INPUT_STATE;
+    return {
+        evidence: {
+            identity: input.evidence?.identity ?? pathIdentityKey.pathIdentityKey(input.file, identities),
+            missing,
+            state: { codec: "host", hash },
+            ...(missing ? { unavailable: "missing" } : {}),
+        },
+        file: input.file,
+    };
+}
+
+exports.notifyProjectRecord = notifyProjectRecord;
+//# sourceMappingURL=notifyProjectRecord.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"notifyProjectRecord.js","sources":["../../../../src/core/transform/watch/notifyProjectRecord.ts"],"sourcesContent":[null],"names":["createHostPathIdentityContext","projectMembershipInput","projectRecordFile","writeProjectRecordFile","warnUnwritableProjectRecord","TtscProjectRecordUnwritableError","membershipRecordDigest","hostInputStateHash","MISSING_INPUT_STATE","pathIdentityKey"],"mappings":"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"}