@ttsc/unplugin 0.30.4 → 0.31.0

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

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

@@ -0,0 +1,33 @@
+'use strict';
+
+var envelopeDerivation = require('../envelope/envelopeDerivation.js');
+var isVolatileFile = require('../envelope/isVolatileFile.js');
+
+/**
+ * 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.
+ */
+function notifyVolatileDelivery(hooks, cached, file) {
+    if (isVolatileFile.isVolatileFile(envelopeDerivation.envelopeDerivation(cached), {
+        file,
+        projectRoot: cached.projectRoot,
+        result: cached.result,
+    })) {
+        hooks?.markVolatile?.();
+    }
+}
+
+exports.notifyVolatileDelivery = notifyVolatileDelivery;
+//# sourceMappingURL=notifyVolatileDelivery.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"notifyVolatileDelivery.js","sources":["../../../../src/core/transform/watch/notifyVolatileDelivery.ts"],"sourcesContent":[null],"names":["isVolatileFile","envelopeDerivation"],"mappings":";;;;;AAKA;;;;;;;;;;;;;;;AAeG;SACa,sBAAsB,CACpC,KAAqC,EACrC,MAAkC,EAClC,IAAY,EAAA;AAEZ,IAAA,IACEA,6BAAc,CAACC,qCAAkB,CAAC,MAAM,CAAC,EAAE;QACzC,IAAI;QACJ,WAAW,EAAE,MAAM,CAAC,WAAW;QAC/B,MAAM,EAAE,MAAM,CAAC,MAAM;AACtB,KAAA,CAAC,EACF;AACA,QAAA,KAAK,EAAE,YAAY,IAAI;IACzB;AACF;;;;"}

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

@@ -0,0 +1,31 @@
+import { envelopeDerivation } from '../envelope/envelopeDerivation.mjs';
+import { isVolatileFile } from '../envelope/isVolatileFile.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.
+ */
+function notifyVolatileDelivery(hooks, cached, file) {
+    if (isVolatileFile(envelopeDerivation(cached), {
+        file,
+        projectRoot: cached.projectRoot,
+        result: cached.result,
+    })) {
+        hooks?.markVolatile?.();
+    }
+}
+
+export { notifyVolatileDelivery };
+//# sourceMappingURL=notifyVolatileDelivery.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"notifyVolatileDelivery.mjs","sources":["../../../../src/core/transform/watch/notifyVolatileDelivery.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAKA;;;;;;;;;;;;;;;AAeG;SACa,sBAAsB,CACpC,KAAqC,EACrC,MAAkC,EAClC,IAAY,EAAA;AAEZ,IAAA,IACE,cAAc,CAAC,kBAAkB,CAAC,MAAM,CAAC,EAAE;QACzC,IAAI;QACJ,WAAW,EAAE,MAAM,CAAC,WAAW;QAC/B,MAAM,EAAE,MAAM,CAAC,MAAM;AACtB,KAAA,CAAC,EACF;AACA,QAAA,KAAK,EAAE,YAAY,IAAI;IACzB;AACF;;;;"}

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

@@ -0,0 +1,32 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
+import type { TtscTransformHooks } from "./TtscTransformHooks.cjs";
+import type { TtscWatchSelection } from "./TtscWatchSelection.cjs";
+/**
+ * Hand the host what a successful delivery of `file` depends on.
+ *
+ * A host keyed on the module's own inputs (`addWatchFile`, `addWatchFiles`)
+ * receives the inputs derived for `file`: the plugin-reported
+ * `dependencies[file]` list unioned with the host-owned reference graph's
+ * contribution (`reach(edges, file)`, `globals`, `configs`, and resolution
+ * candidates), each with the evidence the generation recorded, plus the config
+ * selection. Envelope keys mirror the `typescript` keys (project-relative);
+ * values may be project-relative or absolute. Every path is absolutized against
+ * the project root and deduplicated; the file itself is dropped (the host
+ * already watches the module it transforms), and so is every path in the
+ * disposed transform scratch tree (see
+ * {@link TtscCachedProjectTransform.scratchDirectory}).
+ *
+ * A project hook receives the generation's record through notifyProjectRecord.
+ * When both project and module hooks are present, both receive their respective
+ * registrations; without module hooks, delivery stops after project handoff.
+ *
+ * @evidence contracts/common.md#principled-implementation Module delivery derives the selected file's dependency set, while project delivery records the full generation plus the known selected config and consulted routing configs. Optional producer input lists need not supply that selection-owned recovery input; membership remains an explicitly requested additional input.
+ * @evidence contracts/common.md#clear-and-simple-design Both host models share one routing observation batch, with dependency selection, evidence mapping and record persistence delegated to their actual owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Generation derivation removes disposed scratch inputs. A refused project record requests volatility through a supplied markVolatile callback instead of inventing a record; host-owned cache withdrawal remains that callback's responsibility, not an effect fabricated by this orchestrator.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish module and project dependencies, scratch exclusion and routing, followed by separated tags under documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Generation-owned identity and hostSpelling keep native physical identity separate from adapter spelling; routing observations use the delivery's filesystem capability.
+ * @evidence contracts/performance.md#efficient-algorithms No consuming hooks short-circuit all work. Otherwise every routing occurrence is observed once for this delivery, then shared between record and module branches. A project branch delegates full generation/record costs; a module branch delegates selected closure/index/native identity work, maps fresh evidence carriers, copies/spells routed entries and performs final keyed handoff. Costs include bytes, key/path text, cold native observations, membership encoding and callback effects, with call-local arrays sized by these populations even when some underlying generation lists are memoized.
+ * @evidence contracts/performance.md#reuse-equivalent-work Generation lists, identities and membership use their owners' qualified immutable/root/options/native-view memos. Routing evidence is observed once here and shared between current branches; actual callbacks still run for each delivery, and new routing spellings extend the record snapshot rather than being dropped because a generation is reused.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This orchestrator owns call-local batches; generation snapshots, persistent records and watchers have separate retention owners.
+ */
+export declare function notifyWatchInputs(hooks: TtscTransformHooks | undefined, cached: TtscCachedProjectTransform, file: string, selection: TtscWatchSelection): void;

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

@@ -0,0 +1,32 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.mjs";
+import type { TtscTransformHooks } from "./TtscTransformHooks.mjs";
+import type { TtscWatchSelection } from "./TtscWatchSelection.mjs";
+/**
+ * Hand the host what a successful delivery of `file` depends on.
+ *
+ * A host keyed on the module's own inputs (`addWatchFile`, `addWatchFiles`)
+ * receives the inputs derived for `file`: the plugin-reported
+ * `dependencies[file]` list unioned with the host-owned reference graph's
+ * contribution (`reach(edges, file)`, `globals`, `configs`, and resolution
+ * candidates), each with the evidence the generation recorded, plus the config
+ * selection. Envelope keys mirror the `typescript` keys (project-relative);
+ * values may be project-relative or absolute. Every path is absolutized against
+ * the project root and deduplicated; the file itself is dropped (the host
+ * already watches the module it transforms), and so is every path in the
+ * disposed transform scratch tree (see
+ * {@link TtscCachedProjectTransform.scratchDirectory}).
+ *
+ * A project hook receives the generation's record through notifyProjectRecord.
+ * When both project and module hooks are present, both receive their respective
+ * registrations; without module hooks, delivery stops after project handoff.
+ *
+ * @evidence contracts/common.md#principled-implementation Module delivery derives the selected file's dependency set, while project delivery records the full generation plus the known selected config and consulted routing configs. Optional producer input lists need not supply that selection-owned recovery input; membership remains an explicitly requested additional input.
+ * @evidence contracts/common.md#clear-and-simple-design Both host models share one routing observation batch, with dependency selection, evidence mapping and record persistence delegated to their actual owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Generation derivation removes disposed scratch inputs. A refused project record requests volatility through a supplied markVolatile callback instead of inventing a record; host-owned cache withdrawal remains that callback's responsibility, not an effect fabricated by this orchestrator.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish module and project dependencies, scratch exclusion and routing, followed by separated tags under documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Generation-owned identity and hostSpelling keep native physical identity separate from adapter spelling; routing observations use the delivery's filesystem capability.
+ * @evidence contracts/performance.md#efficient-algorithms No consuming hooks short-circuit all work. Otherwise every routing occurrence is observed once for this delivery, then shared between record and module branches. A project branch delegates full generation/record costs; a module branch delegates selected closure/index/native identity work, maps fresh evidence carriers, copies/spells routed entries and performs final keyed handoff. Costs include bytes, key/path text, cold native observations, membership encoding and callback effects, with call-local arrays sized by these populations even when some underlying generation lists are memoized.
+ * @evidence contracts/performance.md#reuse-equivalent-work Generation lists, identities and membership use their owners' qualified immutable/root/options/native-view memos. Routing evidence is observed once here and shared between current branches; actual callbacks still run for each delivery, and new routing spellings extend the record snapshot rather than being dropped because a generation is reused.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This orchestrator owns call-local batches; generation snapshots, persistent records and watchers have separate retention owners.
+ */
+export declare function notifyWatchInputs(hooks: TtscTransformHooks | undefined, cached: TtscCachedProjectTransform, file: string, selection: TtscWatchSelection): void;

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

@@ -0,0 +1,32 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+import type { TtscTransformHooks } from "./TtscTransformHooks";
+import type { TtscWatchSelection } from "./TtscWatchSelection";
+/**
+ * Hand the host what a successful delivery of `file` depends on.
+ *
+ * A host keyed on the module's own inputs (`addWatchFile`, `addWatchFiles`)
+ * receives the inputs derived for `file`: the plugin-reported
+ * `dependencies[file]` list unioned with the host-owned reference graph's
+ * contribution (`reach(edges, file)`, `globals`, `configs`, and resolution
+ * candidates), each with the evidence the generation recorded, plus the config
+ * selection. Envelope keys mirror the `typescript` keys (project-relative);
+ * values may be project-relative or absolute. Every path is absolutized against
+ * the project root and deduplicated; the file itself is dropped (the host
+ * already watches the module it transforms), and so is every path in the
+ * disposed transform scratch tree (see
+ * {@link TtscCachedProjectTransform.scratchDirectory}).
+ *
+ * A project hook receives the generation's record through notifyProjectRecord.
+ * When both project and module hooks are present, both receive their respective
+ * registrations; without module hooks, delivery stops after project handoff.
+ *
+ * @evidence contracts/common.md#principled-implementation Module delivery derives the selected file's dependency set, while project delivery records the full generation plus the known selected config and consulted routing configs. Optional producer input lists need not supply that selection-owned recovery input; membership remains an explicitly requested additional input.
+ * @evidence contracts/common.md#clear-and-simple-design Both host models share one routing observation batch, with dependency selection, evidence mapping and record persistence delegated to their actual owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Generation derivation removes disposed scratch inputs. A refused project record requests volatility through a supplied markVolatile callback instead of inventing a record; host-owned cache withdrawal remains that callback's responsibility, not an effect fabricated by this orchestrator.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish module and project dependencies, scratch exclusion and routing, followed by separated tags under documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Generation-owned identity and hostSpelling keep native physical identity separate from adapter spelling; routing observations use the delivery's filesystem capability.
+ * @evidence contracts/performance.md#efficient-algorithms No consuming hooks short-circuit all work. Otherwise every routing occurrence is observed once for this delivery, then shared between record and module branches. A project branch delegates full generation/record costs; a module branch delegates selected closure/index/native identity work, maps fresh evidence carriers, copies/spells routed entries and performs final keyed handoff. Costs include bytes, key/path text, cold native observations, membership encoding and callback effects, with call-local arrays sized by these populations even when some underlying generation lists are memoized.
+ * @evidence contracts/performance.md#reuse-equivalent-work Generation lists, identities and membership use their owners' qualified immutable/root/options/native-view memos. Routing evidence is observed once here and shared between current branches; actual callbacks still run for each delivery, and new routing spellings extend the record snapshot rather than being dropped because a generation is reused.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This orchestrator owns call-local batches; generation snapshots, persistent records and watchers have separate retention owners.
+ */
+export declare function notifyWatchInputs(hooks: TtscTransformHooks | undefined, cached: TtscCachedProjectTransform, file: string, selection: TtscWatchSelection): void;

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

@@ -0,0 +1,81 @@
+'use strict';
+
+var envelopeDerivation = require('../envelope/envelopeDerivation.js');
+var hostSpelling = require('../envelope/hostSpelling.js');
+var selectWatchInputs = require('../envelope/selectWatchInputs.js');
+var evidencedWatchInput = require('./evidencedWatchInput.js');
+var generationWatchInputs = require('./generationWatchInputs.js');
+var handWatchInputs = require('./handWatchInputs.js');
+var notifyProjectRecord = require('./notifyProjectRecord.js');
+var projectMembershipInput = require('./projectMembershipInput.js');
+var selectionInputs = require('./selectionInputs.js');
+
+/**
+ * Hand the host what a successful delivery of `file` depends on.
+ *
+ * A host keyed on the module's own inputs (`addWatchFile`, `addWatchFiles`)
+ * receives the inputs derived for `file`: the plugin-reported
+ * `dependencies[file]` list unioned with the host-owned reference graph's
+ * contribution (`reach(edges, file)`, `globals`, `configs`, and resolution
+ * candidates), each with the evidence the generation recorded, plus the config
+ * selection. Envelope keys mirror the `typescript` keys (project-relative);
+ * values may be project-relative or absolute. Every path is absolutized against
+ * the project root and deduplicated; the file itself is dropped (the host
+ * already watches the module it transforms), and so is every path in the
+ * disposed transform scratch tree (see
+ * {@link TtscCachedProjectTransform.scratchDirectory}).
+ *
+ * A project hook receives the generation's record through notifyProjectRecord.
+ * When both project and module hooks are present, both receive their respective
+ * registrations; without module hooks, delivery stops after project handoff.
+ *
+ * @evidence contracts/common.md#principled-implementation Module delivery derives the selected file's dependency set, while project delivery records the full generation plus the known selected config and consulted routing configs. Optional producer input lists need not supply that selection-owned recovery input; membership remains an explicitly requested additional input.
+ * @evidence contracts/common.md#clear-and-simple-design Both host models share one routing observation batch, with dependency selection, evidence mapping and record persistence delegated to their actual owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Generation derivation removes disposed scratch inputs. A refused project record requests volatility through a supplied markVolatile callback instead of inventing a record; host-owned cache withdrawal remains that callback's responsibility, not an effect fabricated by this orchestrator.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish module and project dependencies, scratch exclusion and routing, followed by separated tags under documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Generation-owned identity and hostSpelling keep native physical identity separate from adapter spelling; routing observations use the delivery's filesystem capability.
+ * @evidence contracts/performance.md#efficient-algorithms No consuming hooks short-circuit all work. Otherwise every routing occurrence is observed once for this delivery, then shared between record and module branches. A project branch delegates full generation/record costs; a module branch delegates selected closure/index/native identity work, maps fresh evidence carriers, copies/spells routed entries and performs final keyed handoff. Costs include bytes, key/path text, cold native observations, membership encoding and callback effects, with call-local arrays sized by these populations even when some underlying generation lists are memoized.
+ * @evidence contracts/performance.md#reuse-equivalent-work Generation lists, identities and membership use their owners' qualified immutable/root/options/native-view memos. Routing evidence is observed once here and shared between current branches; actual callbacks still run for each delivery, and new routing spellings extend the record snapshot rather than being dropped because a generation is reused.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This orchestrator owns call-local batches; generation snapshots, persistent records and watchers have separate retention owners.
+ */
+function notifyWatchInputs(hooks, cached, file, selection) {
+    if (hooks === undefined ||
+        (hooks.project === undefined &&
+            hooks.addWatchFile === undefined &&
+            hooks.addWatchFiles === undefined)) {
+        return;
+    }
+    const state = envelopeDerivation.envelopeDerivation(cached);
+    const routedInputs = selectionInputs.selectionInputs([...new Set([...selection.consulted, selection.tsconfig])], selection.filesystem, (input) => input);
+    // A module handed over without its record depends on its own bytes alone,
+    // so no persistent cache may keep it.
+    if (hooks.project !== undefined &&
+        !notifyProjectRecord.notifyProjectRecord(hooks.project, cached, false, () => generationWatchInputs.generationWatchInputs(cached), routedInputs)) {
+        hooks.markVolatile?.();
+    }
+    if (hooks.addWatchFile === undefined && hooks.addWatchFiles === undefined) {
+        return;
+    }
+    const spell = hostSpelling.hostSpelling(state.project, file);
+    const inputs = selectWatchInputs.selectWatchInputs({
+        file,
+        projectRoot: cached.projectRoot,
+        result: cached.result,
+        scratchDirectory: cached.scratchDirectory,
+        temporaryTsconfig: cached.temporaryTsconfig,
+    }).map((input) => evidencedWatchInput.evidencedWatchInput(cached, state, input, spell));
+    // The root files are the adapter's own decision rather than a compiler
+    // input, so a host that asked for them gets them beside the derived ones.
+    const membership = hooks.membership === true ? projectMembershipInput.projectMembershipInput(cached) : undefined;
+    if (membership !== undefined)
+        inputs.push(membership);
+    for (const entryToAppend of routedInputs.map((input) => ({
+        ...input,
+        file: spell(input.file),
+    })))
+        inputs.push(entryToAppend);
+    handWatchInputs.handWatchInputs(hooks, inputs);
+}
+
+exports.notifyWatchInputs = notifyWatchInputs;
+//# sourceMappingURL=notifyWatchInputs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"notifyWatchInputs.js","sources":["../../../../src/core/transform/watch/notifyWatchInputs.ts"],"sourcesContent":[null],"names":["envelopeDerivation","selectionInputs","notifyProjectRecord","generationWatchInputs","hostSpelling","selectWatchInputs","evidencedWatchInput","projectMembershipInput","handWatchInputs"],"mappings":";;;;;;;;;;;;AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACG,SAAU,iBAAiB,CAC/B,KAAqC,EACrC,MAAkC,EAClC,IAAY,EACZ,SAA6B,EAAA;IAE7B,IACE,KAAK,KAAK,SAAS;AACnB,SAAC,KAAK,CAAC,OAAO,KAAK,SAAS;YAC1B,KAAK,CAAC,YAAY,KAAK,SAAS;AAChC,YAAA,KAAK,CAAC,aAAa,KAAK,SAAS,CAAC,EACpC;QACA;IACF;AACA,IAAA,MAAM,KAAK,GAAGA,qCAAkB,CAAC,MAAM,CAAC;AACxC,IAAA,MAAM,YAAY,GAAGC,+BAAe,CAClC,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,SAAS,CAAC,SAAS,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,EAC1D,SAAS,CAAC,UAAU,EACpB,CAAC,KAAK,KAAK,KAAK,CACjB;;;AAGD,IAAA,IACE,KAAK,CAAC,OAAO,KAAK,SAAS;QAC3B,CAACC,uCAAmB,CAClB,KAAK,CAAC,OAAO,EACb,MAAM,EACN,KAAK,EACL,MAAMC,2CAAqB,CAAC,MAAM,CAAC,EACnC,YAAY,CACb,EACD;AACA,QAAA,KAAK,CAAC,YAAY,IAAI;IACxB;AACA,IAAA,IAAI,KAAK,CAAC,YAAY,KAAK,SAAS,IAAI,KAAK,CAAC,aAAa,KAAK,SAAS,EAAE;QACzE;IACF;IACA,MAAM,KAAK,GAAGC,yBAAY,CAAC,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC;IAC/C,MAAM,MAAM,GAAqBC,mCAAiB,CAAC;QACjD,IAAI;QACJ,WAAW,EAAE,MAAM,CAAC,WAAW;QAC/B,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;QACzC,iBAAiB,EAAE,MAAM,CAAC,iBAAiB;AAC5C,KAAA,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,KAAKC,uCAAmB,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;;;AAGnE,IAAA,MAAM,UAAU,GACd,KAAK,CAAC,UAAU,KAAK,IAAI,GAAGC,6CAAsB,CAAC,MAAM,CAAC,GAAG,SAAS;IACxE,IAAI,UAAU,KAAK,SAAS;AAAE,QAAA,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC;AACrD,IAAA,KAAK,MAAM,aAAa,IAAI,YAAY,CAAC,GAAG,CAAC,CAAC,KAAK,MAAM;AACvD,QAAA,GAAG,KAAK;AACR,QAAA,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC;AACxB,KAAA,CAAC,CAAC;AACD,QAAA,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC;AAC5B,IAAAC,+BAAe,CAAC,KAAK,EAAE,MAAM,CAAC;AAChC;;;;"}

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

@@ -0,0 +1,79 @@
+import { envelopeDerivation } from '../envelope/envelopeDerivation.mjs';
+import { hostSpelling } from '../envelope/hostSpelling.mjs';
+import { selectWatchInputs } from '../envelope/selectWatchInputs.mjs';
+import { evidencedWatchInput } from './evidencedWatchInput.mjs';
+import { generationWatchInputs } from './generationWatchInputs.mjs';
+import { handWatchInputs } from './handWatchInputs.mjs';
+import { notifyProjectRecord } from './notifyProjectRecord.mjs';
+import { projectMembershipInput } from './projectMembershipInput.mjs';
+import { selectionInputs } from './selectionInputs.mjs';
+
+/**
+ * Hand the host what a successful delivery of `file` depends on.
+ *
+ * A host keyed on the module's own inputs (`addWatchFile`, `addWatchFiles`)
+ * receives the inputs derived for `file`: the plugin-reported
+ * `dependencies[file]` list unioned with the host-owned reference graph's
+ * contribution (`reach(edges, file)`, `globals`, `configs`, and resolution
+ * candidates), each with the evidence the generation recorded, plus the config
+ * selection. Envelope keys mirror the `typescript` keys (project-relative);
+ * values may be project-relative or absolute. Every path is absolutized against
+ * the project root and deduplicated; the file itself is dropped (the host
+ * already watches the module it transforms), and so is every path in the
+ * disposed transform scratch tree (see
+ * {@link TtscCachedProjectTransform.scratchDirectory}).
+ *
+ * A project hook receives the generation's record through notifyProjectRecord.
+ * When both project and module hooks are present, both receive their respective
+ * registrations; without module hooks, delivery stops after project handoff.
+ *
+ * @evidence contracts/common.md#principled-implementation Module delivery derives the selected file's dependency set, while project delivery records the full generation plus the known selected config and consulted routing configs. Optional producer input lists need not supply that selection-owned recovery input; membership remains an explicitly requested additional input.
+ * @evidence contracts/common.md#clear-and-simple-design Both host models share one routing observation batch, with dependency selection, evidence mapping and record persistence delegated to their actual owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Generation derivation removes disposed scratch inputs. A refused project record requests volatility through a supplied markVolatile callback instead of inventing a record; host-owned cache withdrawal remains that callback's responsibility, not an effect fabricated by this orchestrator.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish module and project dependencies, scratch exclusion and routing, followed by separated tags under documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Generation-owned identity and hostSpelling keep native physical identity separate from adapter spelling; routing observations use the delivery's filesystem capability.
+ * @evidence contracts/performance.md#efficient-algorithms No consuming hooks short-circuit all work. Otherwise every routing occurrence is observed once for this delivery, then shared between record and module branches. A project branch delegates full generation/record costs; a module branch delegates selected closure/index/native identity work, maps fresh evidence carriers, copies/spells routed entries and performs final keyed handoff. Costs include bytes, key/path text, cold native observations, membership encoding and callback effects, with call-local arrays sized by these populations even when some underlying generation lists are memoized.
+ * @evidence contracts/performance.md#reuse-equivalent-work Generation lists, identities and membership use their owners' qualified immutable/root/options/native-view memos. Routing evidence is observed once here and shared between current branches; actual callbacks still run for each delivery, and new routing spellings extend the record snapshot rather than being dropped because a generation is reused.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This orchestrator owns call-local batches; generation snapshots, persistent records and watchers have separate retention owners.
+ */
+function notifyWatchInputs(hooks, cached, file, selection) {
+    if (hooks === undefined ||
+        (hooks.project === undefined &&
+            hooks.addWatchFile === undefined &&
+            hooks.addWatchFiles === undefined)) {
+        return;
+    }
+    const state = envelopeDerivation(cached);
+    const routedInputs = selectionInputs([...new Set([...selection.consulted, selection.tsconfig])], selection.filesystem, (input) => input);
+    // A module handed over without its record depends on its own bytes alone,
+    // so no persistent cache may keep it.
+    if (hooks.project !== undefined &&
+        !notifyProjectRecord(hooks.project, cached, false, () => generationWatchInputs(cached), routedInputs)) {
+        hooks.markVolatile?.();
+    }
+    if (hooks.addWatchFile === undefined && hooks.addWatchFiles === undefined) {
+        return;
+    }
+    const spell = hostSpelling(state.project, file);
+    const inputs = selectWatchInputs({
+        file,
+        projectRoot: cached.projectRoot,
+        result: cached.result,
+        scratchDirectory: cached.scratchDirectory,
+        temporaryTsconfig: cached.temporaryTsconfig,
+    }).map((input) => evidencedWatchInput(cached, state, input, spell));
+    // The root files are the adapter's own decision rather than a compiler
+    // input, so a host that asked for them gets them beside the derived ones.
+    const membership = hooks.membership === true ? projectMembershipInput(cached) : undefined;
+    if (membership !== undefined)
+        inputs.push(membership);
+    for (const entryToAppend of routedInputs.map((input) => ({
+        ...input,
+        file: spell(input.file),
+    })))
+        inputs.push(entryToAppend);
+    handWatchInputs(hooks, inputs);
+}
+
+export { notifyWatchInputs };
+//# sourceMappingURL=notifyWatchInputs.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"notifyWatchInputs.mjs","sources":["../../../../src/core/transform/watch/notifyWatchInputs.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACG,SAAU,iBAAiB,CAC/B,KAAqC,EACrC,MAAkC,EAClC,IAAY,EACZ,SAA6B,EAAA;IAE7B,IACE,KAAK,KAAK,SAAS;AACnB,SAAC,KAAK,CAAC,OAAO,KAAK,SAAS;YAC1B,KAAK,CAAC,YAAY,KAAK,SAAS;AAChC,YAAA,KAAK,CAAC,aAAa,KAAK,SAAS,CAAC,EACpC;QACA;IACF;AACA,IAAA,MAAM,KAAK,GAAG,kBAAkB,CAAC,MAAM,CAAC;AACxC,IAAA,MAAM,YAAY,GAAG,eAAe,CAClC,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,SAAS,CAAC,SAAS,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,EAC1D,SAAS,CAAC,UAAU,EACpB,CAAC,KAAK,KAAK,KAAK,CACjB;;;AAGD,IAAA,IACE,KAAK,CAAC,OAAO,KAAK,SAAS;QAC3B,CAAC,mBAAmB,CAClB,KAAK,CAAC,OAAO,EACb,MAAM,EACN,KAAK,EACL,MAAM,qBAAqB,CAAC,MAAM,CAAC,EACnC,YAAY,CACb,EACD;AACA,QAAA,KAAK,CAAC,YAAY,IAAI;IACxB;AACA,IAAA,IAAI,KAAK,CAAC,YAAY,KAAK,SAAS,IAAI,KAAK,CAAC,aAAa,KAAK,SAAS,EAAE;QACzE;IACF;IACA,MAAM,KAAK,GAAG,YAAY,CAAC,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC;IAC/C,MAAM,MAAM,GAAqB,iBAAiB,CAAC;QACjD,IAAI;QACJ,WAAW,EAAE,MAAM,CAAC,WAAW;QAC/B,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;QACzC,iBAAiB,EAAE,MAAM,CAAC,iBAAiB;AAC5C,KAAA,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,KAAK,mBAAmB,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;;;AAGnE,IAAA,MAAM,UAAU,GACd,KAAK,CAAC,UAAU,KAAK,IAAI,GAAG,sBAAsB,CAAC,MAAM,CAAC,GAAG,SAAS;IACxE,IAAI,UAAU,KAAK,SAAS;AAAE,QAAA,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC;AACrD,IAAA,KAAK,MAAM,aAAa,IAAI,YAAY,CAAC,GAAG,CAAC,CAAC,KAAK,MAAM;AACvD,QAAA,GAAG,KAAK;AACR,QAAA,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC;AACxB,KAAA,CAAC,CAAC;AACD,QAAA,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC;AAC5B,IAAA,eAAe,CAAC,KAAK,EAAE,MAAM,CAAC;AAChC;;;;"}

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

@@ -0,0 +1,22 @@
+import type { TtscTransformHooks } from "./TtscTransformHooks.cjs";
+/**
+ * Acquire the host's record directories before a generation observes inputs.
+ *
+ * A record is handed over after capture. Creating its parent then would change
+ * a native directory witness that includes the host root. Both accepted storage
+ * locations are acquired now, including a fallback the later writer may need.
+ * This creates no record and proves no writability. Failed acquisition remains
+ * subject to the existing writer's fallback, warning and watching-error
+ * policy.
+ *
+ * @param project The current host's optional record registration owner.
+ * @evidence contracts/common.md#principled-implementation Owned parent acquisition precedes generation observation; actual record writes and refusals retain their existing owner.
+ * @evidence contracts/common.md#clear-and-simple-design One common transform boundary prepares both accepted record locations without changing adapter path conventions.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No input witness is excluded and no failed mkdir is treated as a successful record handoff.
+ * @evidence contracts/common.md#meaningful-documentation Acquisition, later fallback and the absence of a writability promise are separated explicitly.
+ * @evidence contracts/portability.md#os-neutral-implementation Native joins and recursive mkdir retain each host's supplied path and platform errors.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources No handle, timer, task or cache is retained; persistent directories belong to the existing record lifetime.
+ * @evidence contracts/performance.md#efficient-algorithms At most two recursive mkdir calls precede selection, with native ancestor traversal and path text allocation; no directory listing, record serialization or compiler invocation is added.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Acquisition is attempted per eligible delivery so deletion or repaired permissions are not hidden by a permanent success cache.
+ */
+export declare function prepareProjectRecordDirectories(project: TtscTransformHooks["project"]): void;

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

@@ -0,0 +1,22 @@
+import type { TtscTransformHooks } from "./TtscTransformHooks.mjs";
+/**
+ * Acquire the host's record directories before a generation observes inputs.
+ *
+ * A record is handed over after capture. Creating its parent then would change
+ * a native directory witness that includes the host root. Both accepted storage
+ * locations are acquired now, including a fallback the later writer may need.
+ * This creates no record and proves no writability. Failed acquisition remains
+ * subject to the existing writer's fallback, warning and watching-error
+ * policy.
+ *
+ * @param project The current host's optional record registration owner.
+ * @evidence contracts/common.md#principled-implementation Owned parent acquisition precedes generation observation; actual record writes and refusals retain their existing owner.
+ * @evidence contracts/common.md#clear-and-simple-design One common transform boundary prepares both accepted record locations without changing adapter path conventions.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No input witness is excluded and no failed mkdir is treated as a successful record handoff.
+ * @evidence contracts/common.md#meaningful-documentation Acquisition, later fallback and the absence of a writability promise are separated explicitly.
+ * @evidence contracts/portability.md#os-neutral-implementation Native joins and recursive mkdir retain each host's supplied path and platform errors.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources No handle, timer, task or cache is retained; persistent directories belong to the existing record lifetime.
+ * @evidence contracts/performance.md#efficient-algorithms At most two recursive mkdir calls precede selection, with native ancestor traversal and path text allocation; no directory listing, record serialization or compiler invocation is added.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Acquisition is attempted per eligible delivery so deletion or repaired permissions are not hidden by a permanent success cache.
+ */
+export declare function prepareProjectRecordDirectories(project: TtscTransformHooks["project"]): void;

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

@@ -0,0 +1,22 @@
+import type { TtscTransformHooks } from "./TtscTransformHooks";
+/**
+ * Acquire the host's record directories before a generation observes inputs.
+ *
+ * A record is handed over after capture. Creating its parent then would change
+ * a native directory witness that includes the host root. Both accepted storage
+ * locations are acquired now, including a fallback the later writer may need.
+ * This creates no record and proves no writability. Failed acquisition remains
+ * subject to the existing writer's fallback, warning and watching-error
+ * policy.
+ *
+ * @param project The current host's optional record registration owner.
+ * @evidence contracts/common.md#principled-implementation Owned parent acquisition precedes generation observation; actual record writes and refusals retain their existing owner.
+ * @evidence contracts/common.md#clear-and-simple-design One common transform boundary prepares both accepted record locations without changing adapter path conventions.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No input witness is excluded and no failed mkdir is treated as a successful record handoff.
+ * @evidence contracts/common.md#meaningful-documentation Acquisition, later fallback and the absence of a writability promise are separated explicitly.
+ * @evidence contracts/portability.md#os-neutral-implementation Native joins and recursive mkdir retain each host's supplied path and platform errors.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources No handle, timer, task or cache is retained; persistent directories belong to the existing record lifetime.
+ * @evidence contracts/performance.md#efficient-algorithms At most two recursive mkdir calls precede selection, with native ancestor traversal and path text allocation; no directory listing, record serialization or compiler invocation is added.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Acquisition is attempted per eligible delivery so deletion or repaired permissions are not hidden by a permanent success cache.
+ */
+export declare function prepareProjectRecordDirectories(project: TtscTransformHooks["project"]): void;

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

@@ -0,0 +1,50 @@
+'use strict';
+
+var fs = require('node:fs');
+var path = require('node:path');
+var PROJECT_RECORD_DIRECTORY = require('../../bridge/PROJECT_RECORD_DIRECTORY.js');
+
+/**
+ * Acquire the host's record directories before a generation observes inputs.
+ *
+ * A record is handed over after capture. Creating its parent then would change
+ * a native directory witness that includes the host root. Both accepted storage
+ * locations are acquired now, including a fallback the later writer may need.
+ * This creates no record and proves no writability. Failed acquisition remains
+ * subject to the existing writer's fallback, warning and watching-error
+ * policy.
+ *
+ * @param project The current host's optional record registration owner.
+ * @evidence contracts/common.md#principled-implementation Owned parent acquisition precedes generation observation; actual record writes and refusals retain their existing owner.
+ * @evidence contracts/common.md#clear-and-simple-design One common transform boundary prepares both accepted record locations without changing adapter path conventions.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No input witness is excluded and no failed mkdir is treated as a successful record handoff.
+ * @evidence contracts/common.md#meaningful-documentation Acquisition, later fallback and the absence of a writability promise are separated explicitly.
+ * @evidence contracts/portability.md#os-neutral-implementation Native joins and recursive mkdir retain each host's supplied path and platform errors.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources No handle, timer, task or cache is retained; persistent directories belong to the existing record lifetime.
+ * @evidence contracts/performance.md#efficient-algorithms At most two recursive mkdir calls precede selection, with native ancestor traversal and path text allocation; no directory listing, record serialization or compiler invocation is added.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Acquisition is attempted per eligible delivery so deletion or repaired permissions are not hidden by a permanent success cache.
+ */
+function prepareProjectRecordDirectories(project) {
+    if (project === undefined)
+        return;
+    const directories = [
+        project.toolDirectory,
+        ...(project.fallbackToolDirectory === undefined
+            ? []
+            : [project.fallbackToolDirectory]),
+    ];
+    for (const directory of directories) {
+        try {
+            fs.mkdirSync(path.join(directory, PROJECT_RECORD_DIRECTORY.PROJECT_RECORD_DIRECTORY), {
+                recursive: true,
+            });
+        }
+        catch {
+            // Preparation cannot decide whether the later record can be written.
+            // The existing writer owns its actual error and fallback semantics.
+        }
+    }
+}
+
+exports.prepareProjectRecordDirectories = prepareProjectRecordDirectories;
+//# sourceMappingURL=prepareProjectRecordDirectories.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prepareProjectRecordDirectories.js","sources":["../../../../src/core/transform/watch/prepareProjectRecordDirectories.ts"],"sourcesContent":[null],"names":["PROJECT_RECORD_DIRECTORY"],"mappings":";;;;;;AAMA;;;;;;;;;;;;;;;;;;;AAmBG;AACG,SAAU,+BAA+B,CAC7C,OAAsC,EAAA;IAEtC,IAAI,OAAO,KAAK,SAAS;QAAE;AAC3B,IAAA,MAAM,WAAW,GAAG;AAClB,QAAA,OAAO,CAAC,aAAa;AACrB,QAAA,IAAI,OAAO,CAAC,qBAAqB,KAAK;AACpC,cAAE;AACF,cAAE,CAAC,OAAO,CAAC,qBAAqB,CAAC,CAAC;KACrC;AACD,IAAA,KAAK,MAAM,SAAS,IAAI,WAAW,EAAE;AACnC,QAAA,IAAI;YACF,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAEA,iDAAwB,CAAC,EAAE;AAC3D,gBAAA,SAAS,EAAE,IAAI;AAChB,aAAA,CAAC;QACJ;AAAE,QAAA,MAAM;;;QAGR;IACF;AACF;;;;"}

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

@@ -0,0 +1,48 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { PROJECT_RECORD_DIRECTORY } from '../../bridge/PROJECT_RECORD_DIRECTORY.mjs';
+
+/**
+ * Acquire the host's record directories before a generation observes inputs.
+ *
+ * A record is handed over after capture. Creating its parent then would change
+ * a native directory witness that includes the host root. Both accepted storage
+ * locations are acquired now, including a fallback the later writer may need.
+ * This creates no record and proves no writability. Failed acquisition remains
+ * subject to the existing writer's fallback, warning and watching-error
+ * policy.
+ *
+ * @param project The current host's optional record registration owner.
+ * @evidence contracts/common.md#principled-implementation Owned parent acquisition precedes generation observation; actual record writes and refusals retain their existing owner.
+ * @evidence contracts/common.md#clear-and-simple-design One common transform boundary prepares both accepted record locations without changing adapter path conventions.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No input witness is excluded and no failed mkdir is treated as a successful record handoff.
+ * @evidence contracts/common.md#meaningful-documentation Acquisition, later fallback and the absence of a writability promise are separated explicitly.
+ * @evidence contracts/portability.md#os-neutral-implementation Native joins and recursive mkdir retain each host's supplied path and platform errors.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources No handle, timer, task or cache is retained; persistent directories belong to the existing record lifetime.
+ * @evidence contracts/performance.md#efficient-algorithms At most two recursive mkdir calls precede selection, with native ancestor traversal and path text allocation; no directory listing, record serialization or compiler invocation is added.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Acquisition is attempted per eligible delivery so deletion or repaired permissions are not hidden by a permanent success cache.
+ */
+function prepareProjectRecordDirectories(project) {
+    if (project === undefined)
+        return;
+    const directories = [
+        project.toolDirectory,
+        ...(project.fallbackToolDirectory === undefined
+            ? []
+            : [project.fallbackToolDirectory]),
+    ];
+    for (const directory of directories) {
+        try {
+            fs.mkdirSync(path.join(directory, PROJECT_RECORD_DIRECTORY), {
+                recursive: true,
+            });
+        }
+        catch {
+            // Preparation cannot decide whether the later record can be written.
+            // The existing writer owns its actual error and fallback semantics.
+        }
+    }
+}
+
+export { prepareProjectRecordDirectories };
+//# sourceMappingURL=prepareProjectRecordDirectories.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prepareProjectRecordDirectories.mjs","sources":["../../../../src/core/transform/watch/prepareProjectRecordDirectories.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAMA;;;;;;;;;;;;;;;;;;;AAmBG;AACG,SAAU,+BAA+B,CAC7C,OAAsC,EAAA;IAEtC,IAAI,OAAO,KAAK,SAAS;QAAE;AAC3B,IAAA,MAAM,WAAW,GAAG;AAClB,QAAA,OAAO,CAAC,aAAa;AACrB,QAAA,IAAI,OAAO,CAAC,qBAAqB,KAAK;AACpC,cAAE;AACF,cAAE,CAAC,OAAO,CAAC,qBAAqB,CAAC,CAAC;KACrC;AACD,IAAA,KAAK,MAAM,SAAS,IAAI,WAAW,EAAE;AACnC,QAAA,IAAI;YACF,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,wBAAwB,CAAC,EAAE;AAC3D,gBAAA,SAAS,EAAE,IAAI;AAChB,aAAA,CAAC;QACJ;AAAE,QAAA,MAAM;;;QAGR;IACF;AACF;;;;"}

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

@@ -0,0 +1,28 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
+import type { TtscWatchInput } from "./TtscWatchInput.cjs";
+/**
+ * The watch input for a generation's root-file membership, or `undefined` for a
+ * generation that recorded no project walk (samchon/ttsc#1419).
+ *
+ * The compiler reports what it observed while building the program, and the
+ * `include` expansion that decides the root files is not among it: the adapter
+ * decides membership itself, through the project walk. So a file the tsconfig
+ * includes, such as a new global declaration, changed no watch input a host
+ * had, and a watching host never re-ran the modules whose generated code it
+ * changes. This input carries that membership to the host: its path is the
+ * project root, and its evidence is the walk's digest, every directory the walk
+ * entered, and the policy it applied.
+ *
+ * Built once per recorded directory list, so every module of a generation hands
+ * the host the same object.
+ *
+ * @evidence contracts/common.md#principled-implementation The root path carries the adapter's actual membership digest, directory population and walk policy, expressing root-file selection rather than equating it with one compiler input hash.
+ * @evidence contracts/common.md#clear-and-simple-design One optional carrier represents a recorded project walk, with a memo keyed by generation and the recorded directory-list reference.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A generation without a recorded walk returns undefined rather than inventing a default membership result from its root name.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain membership ownership, absent walks and reference reuse, with separated tags following documentation guidance.
+ * @evidence contracts/portability.md#os-neutral-implementation Root identity comes from the generation's native context and directory spellings retain the walk's observed policy rather than relying on an OS-wide case model.
+ * @evidence contracts/performance.md#efficient-algorithms Missing directory state returns immediately and a matching list needs only keyed/reference access. Construction additionally resolves root identity through the generation context, scans all D records, sorts relevant directory pairs, serializes/hashes policy and selected text, then maps all D directory paths. Native cold observations, path/key text and digest temporary arrays/encoding costs remain included; no new project walk occurs.
+ * @evidence contracts/performance.md#reuse-equivalent-work The weak memo shares by generation and directory-array identity, requiring immutable policy/entries, fixed root and a valid generation native identity view. A replacement list rebuilds the carrier, and callers must not mutate shared evidence; array identity alone does not establish those premises.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The memo retains one current directory-list reference and membership carrier per generation, including D path references, policy reference, digest and native identity text. Replacement drops the owner's previous entry; borrowers can retain earlier carriers, policies or lists. Weak keys do not keep generations alive, but provide no byte cap on these payloads. No watcher or descriptor is acquired here.
+ */
+export declare function projectMembershipInput(cached: TtscCachedProjectTransform): TtscWatchInput | undefined;