@ttsc/unplugin 0.30.3 → 0.31.0

package/lib/core/transform/envelope/declaredProjectInputKeys.d.ts

@@ -0,0 +1,27 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+import type { TtscEnvelopeDerivation } from "./TtscEnvelopeDerivation";
+/**
+ * Memoize the declared project-walk keys for one envelope generation.
+ *
+ * A completed undefined result requests comparison of the whole project walk;
+ * the separate built flag prevents treating that result as an unbuilt cache.
+ * The cached project hashes, root and scratch policy must remain stable for the
+ * lifetime of this generation state.
+ *
+ * @evidence contracts/common.md#principled-implementation The built flag distinguishes a legitimate undefined whole-walk policy from an uncomputed selection, preserving conservative comparison for graph-free results.
+ * @evidence contracts/common.md#clear-and-simple-design Selection stays in selectDeclaredProjectInputKeys while this wrapper owns exactly its generation memo and completed-state marker.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Undefined remains the supported conservative policy instead of being replaced by an empty set that would silently authorize narrowing.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain completed undefined, the built flag and stable-generation premises; descriptive prose and tags are separated under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Selection receives the envelope's identity context and native project root, sharing filesystem-aware key matching rather than introducing its own separator or case policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One selected set and one built flag live in weakly owned envelope state; set population cannot exceed declared keys actually present in the project snapshot and no independent resources are acquired.
+ * @evidence contracts/performance.md#efficient-algorithms A cold state pays the selector's declaration populations, entry-array allocations and native project-key/path/ancestor/case costs; delegation does not reduce that selection to one field lookup. Completed states need fixed flag/result reads, including a completed undefined whole-walk policy.
+ * @evidence contracts/performance.md#reuse-equivalent-work Reuse keys the envelope generation and requires unchanged project hashes, root and scratch exclusions; both a set and the whole-walk undefined outcome are reused.
+ */
+export declare function declaredProjectInputKeys(
+/**
+ * Generation state owning the completed selection and its separate built
+ * flag.
+ */
+state: TtscEnvelopeDerivation, 
+/** Stable generation root, project hashes, envelope and scratch exclusions. */
+cached: TtscCachedProjectTransform): Set<string> | undefined;

package/lib/core/transform/envelope/declaredProjectInputKeys.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var selectDeclaredProjectInputKeys = require('./selectDeclaredProjectInputKeys.js');
+
+/**
+ * Memoize the declared project-walk keys for one envelope generation.
+ *
+ * A completed undefined result requests comparison of the whole project walk;
+ * the separate built flag prevents treating that result as an unbuilt cache.
+ * The cached project hashes, root and scratch policy must remain stable for the
+ * lifetime of this generation state.
+ *
+ * @evidence contracts/common.md#principled-implementation The built flag distinguishes a legitimate undefined whole-walk policy from an uncomputed selection, preserving conservative comparison for graph-free results.
+ * @evidence contracts/common.md#clear-and-simple-design Selection stays in selectDeclaredProjectInputKeys while this wrapper owns exactly its generation memo and completed-state marker.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Undefined remains the supported conservative policy instead of being replaced by an empty set that would silently authorize narrowing.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain completed undefined, the built flag and stable-generation premises; descriptive prose and tags are separated under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Selection receives the envelope's identity context and native project root, sharing filesystem-aware key matching rather than introducing its own separator or case policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One selected set and one built flag live in weakly owned envelope state; set population cannot exceed declared keys actually present in the project snapshot and no independent resources are acquired.
+ * @evidence contracts/performance.md#efficient-algorithms A cold state pays the selector's declaration populations, entry-array allocations and native project-key/path/ancestor/case costs; delegation does not reduce that selection to one field lookup. Completed states need fixed flag/result reads, including a completed undefined whole-walk policy.
+ * @evidence contracts/performance.md#reuse-equivalent-work Reuse keys the envelope generation and requires unchanged project hashes, root and scratch exclusions; both a set and the whole-walk undefined outcome are reused.
+ */
+function declaredProjectInputKeys(
+/**
+ * Generation state owning the completed selection and its separate built
+ * flag.
+ */
+state, 
+/** Stable generation root, project hashes, envelope and scratch exclusions. */
+cached) {
+    if (state.declaredInputKeysBuilt !== true) {
+        state.declaredInputKeys = selectDeclaredProjectInputKeys.selectDeclaredProjectInputKeys({
+            identities: state.identityContext,
+            projectInputHashes: cached.inputHashes,
+            projectRoot: cached.projectRoot,
+            result: cached.result,
+            scratchDirectory: cached.scratchDirectory,
+        });
+        state.declaredInputKeysBuilt = true;
+    }
+    return state.declaredInputKeys;
+}
+
+exports.declaredProjectInputKeys = declaredProjectInputKeys;
+//# sourceMappingURL=declaredProjectInputKeys.js.map

package/lib/core/transform/envelope/declaredProjectInputKeys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"declaredProjectInputKeys.js","sources":["../../../../src/core/transform/envelope/declaredProjectInputKeys.ts"],"sourcesContent":[null],"names":["selectDeclaredProjectInputKeys"],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;AAgBG;SACa,wBAAwB;AACtC;;;AAGG;AACH,KAA6B;AAC7B;AACA,MAAkC,EAAA;AAElC,IAAA,IAAI,KAAK,CAAC,sBAAsB,KAAK,IAAI,EAAE;AACzC,QAAA,KAAK,CAAC,iBAAiB,GAAGA,6DAA8B,CAAC;YACvD,UAAU,EAAE,KAAK,CAAC,eAAe;YACjC,kBAAkB,EAAE,MAAM,CAAC,WAAW;YACtC,WAAW,EAAE,MAAM,CAAC,WAAW;YAC/B,MAAM,EAAE,MAAM,CAAC,MAAM;YACrB,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;AAC1C,SAAA,CAAC;AACF,QAAA,KAAK,CAAC,sBAAsB,GAAG,IAAI;IACrC;IACA,OAAO,KAAK,CAAC,iBAAiB;AAChC;;;;"}

package/lib/core/transform/envelope/declaredProjectInputKeys.mjs

@@ -0,0 +1,42 @@
+import { selectDeclaredProjectInputKeys } from './selectDeclaredProjectInputKeys.mjs';
+
+/**
+ * Memoize the declared project-walk keys for one envelope generation.
+ *
+ * A completed undefined result requests comparison of the whole project walk;
+ * the separate built flag prevents treating that result as an unbuilt cache.
+ * The cached project hashes, root and scratch policy must remain stable for the
+ * lifetime of this generation state.
+ *
+ * @evidence contracts/common.md#principled-implementation The built flag distinguishes a legitimate undefined whole-walk policy from an uncomputed selection, preserving conservative comparison for graph-free results.
+ * @evidence contracts/common.md#clear-and-simple-design Selection stays in selectDeclaredProjectInputKeys while this wrapper owns exactly its generation memo and completed-state marker.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Undefined remains the supported conservative policy instead of being replaced by an empty set that would silently authorize narrowing.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain completed undefined, the built flag and stable-generation premises; descriptive prose and tags are separated under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Selection receives the envelope's identity context and native project root, sharing filesystem-aware key matching rather than introducing its own separator or case policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One selected set and one built flag live in weakly owned envelope state; set population cannot exceed declared keys actually present in the project snapshot and no independent resources are acquired.
+ * @evidence contracts/performance.md#efficient-algorithms A cold state pays the selector's declaration populations, entry-array allocations and native project-key/path/ancestor/case costs; delegation does not reduce that selection to one field lookup. Completed states need fixed flag/result reads, including a completed undefined whole-walk policy.
+ * @evidence contracts/performance.md#reuse-equivalent-work Reuse keys the envelope generation and requires unchanged project hashes, root and scratch exclusions; both a set and the whole-walk undefined outcome are reused.
+ */
+function declaredProjectInputKeys(
+/**
+ * Generation state owning the completed selection and its separate built
+ * flag.
+ */
+state, 
+/** Stable generation root, project hashes, envelope and scratch exclusions. */
+cached) {
+    if (state.declaredInputKeysBuilt !== true) {
+        state.declaredInputKeys = selectDeclaredProjectInputKeys({
+            identities: state.identityContext,
+            projectInputHashes: cached.inputHashes,
+            projectRoot: cached.projectRoot,
+            result: cached.result,
+            scratchDirectory: cached.scratchDirectory,
+        });
+        state.declaredInputKeysBuilt = true;
+    }
+    return state.declaredInputKeys;
+}
+
+export { declaredProjectInputKeys };
+//# sourceMappingURL=declaredProjectInputKeys.mjs.map

package/lib/core/transform/envelope/declaredProjectInputKeys.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"declaredProjectInputKeys.mjs","sources":["../../../../src/core/transform/envelope/declaredProjectInputKeys.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;AAgBG;SACa,wBAAwB;AACtC;;;AAGG;AACH,KAA6B;AAC7B;AACA,MAAkC,EAAA;AAElC,IAAA,IAAI,KAAK,CAAC,sBAAsB,KAAK,IAAI,EAAE;AACzC,QAAA,KAAK,CAAC,iBAAiB,GAAG,8BAA8B,CAAC;YACvD,UAAU,EAAE,KAAK,CAAC,eAAe;YACjC,kBAAkB,EAAE,MAAM,CAAC,WAAW;YACtC,WAAW,EAAE,MAAM,CAAC,WAAW;YAC/B,MAAM,EAAE,MAAM,CAAC,MAAM;YACrB,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;AAC1C,SAAA,CAAC;AACF,QAAA,KAAK,CAAC,sBAAsB,GAAG,IAAI;IACrC;IACA,OAAO,KAAK,CAAC,iBAAiB;AAChC;;;;"}

package/lib/core/transform/envelope/declaresCompleteDependencies.d.cts

@@ -0,0 +1,22 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscEnvelopeDerivation } from "./TtscEnvelopeDerivation.cjs";
+/**
+ * Report whether the envelope declared `dependencies[file]` complete, i.e. the
+ * plugin took responsibility for that file's whole input set beyond the file
+ * itself and the universal config chain. Callers must still keep the baseline
+ * for a file the same envelope declared volatile.
+ *
+ * @evidence contracts/common.md#principled-implementation Membership in the producer's explicit completeness declaration transfers input responsibility; exceptions assert no membership, and callers retain the conservative baseline for contradictory volatility.
+ * @evidence contracts/common.md#clear-and-simple-design This predicate owns declaration lookup only; deriveWatchInputs owns which host inputs that declaration may remove.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Completeness requires an actual envelope declaration and never follows from a short dependency list or a successful transform.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains the producer's responsibility, universal config exception and volatility caveat rather than merely naming the boolean; tag separation follows the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Declaration membership compares identities through the envelope context, so native case and realpath behavior are shared with the queried file rather than inferred from textual spelling.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The cached set has at most one entry per declared physical identity and belongs to the weakly owned envelope state; the predicate opens no handles and retains no separate history.
+ * @evidence contracts/performance.md#efficient-algorithms The first query folds the declaration list once; later membership uses a set and memoized identity instead of rescanning all declarations per module.
+ * @evidence contracts/performance.md#reuse-equivalent-work The set is cached on one envelope's state and reused for that generation's files; this requires a stable producer declaration and the same root/context throughout the generation.
+ */
+export declare function declaresCompleteDependencies(state: TtscEnvelopeDerivation, props: {
+    file: string;
+    projectRoot: string;
+    result: ITtscCompilerTransformation;
+}): boolean;

package/lib/core/transform/envelope/declaresCompleteDependencies.d.mts

@@ -0,0 +1,22 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscEnvelopeDerivation } from "./TtscEnvelopeDerivation.mjs";
+/**
+ * Report whether the envelope declared `dependencies[file]` complete, i.e. the
+ * plugin took responsibility for that file's whole input set beyond the file
+ * itself and the universal config chain. Callers must still keep the baseline
+ * for a file the same envelope declared volatile.
+ *
+ * @evidence contracts/common.md#principled-implementation Membership in the producer's explicit completeness declaration transfers input responsibility; exceptions assert no membership, and callers retain the conservative baseline for contradictory volatility.
+ * @evidence contracts/common.md#clear-and-simple-design This predicate owns declaration lookup only; deriveWatchInputs owns which host inputs that declaration may remove.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Completeness requires an actual envelope declaration and never follows from a short dependency list or a successful transform.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains the producer's responsibility, universal config exception and volatility caveat rather than merely naming the boolean; tag separation follows the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Declaration membership compares identities through the envelope context, so native case and realpath behavior are shared with the queried file rather than inferred from textual spelling.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The cached set has at most one entry per declared physical identity and belongs to the weakly owned envelope state; the predicate opens no handles and retains no separate history.
+ * @evidence contracts/performance.md#efficient-algorithms The first query folds the declaration list once; later membership uses a set and memoized identity instead of rescanning all declarations per module.
+ * @evidence contracts/performance.md#reuse-equivalent-work The set is cached on one envelope's state and reused for that generation's files; this requires a stable producer declaration and the same root/context throughout the generation.
+ */
+export declare function declaresCompleteDependencies(state: TtscEnvelopeDerivation, props: {
+    file: string;
+    projectRoot: string;
+    result: ITtscCompilerTransformation;
+}): boolean;

package/lib/core/transform/envelope/declaresCompleteDependencies.d.ts

@@ -0,0 +1,22 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscEnvelopeDerivation } from "./TtscEnvelopeDerivation";
+/**
+ * Report whether the envelope declared `dependencies[file]` complete, i.e. the
+ * plugin took responsibility for that file's whole input set beyond the file
+ * itself and the universal config chain. Callers must still keep the baseline
+ * for a file the same envelope declared volatile.
+ *
+ * @evidence contracts/common.md#principled-implementation Membership in the producer's explicit completeness declaration transfers input responsibility; exceptions assert no membership, and callers retain the conservative baseline for contradictory volatility.
+ * @evidence contracts/common.md#clear-and-simple-design This predicate owns declaration lookup only; deriveWatchInputs owns which host inputs that declaration may remove.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Completeness requires an actual envelope declaration and never follows from a short dependency list or a successful transform.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains the producer's responsibility, universal config exception and volatility caveat rather than merely naming the boolean; tag separation follows the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Declaration membership compares identities through the envelope context, so native case and realpath behavior are shared with the queried file rather than inferred from textual spelling.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The cached set has at most one entry per declared physical identity and belongs to the weakly owned envelope state; the predicate opens no handles and retains no separate history.
+ * @evidence contracts/performance.md#efficient-algorithms The first query folds the declaration list once; later membership uses a set and memoized identity instead of rescanning all declarations per module.
+ * @evidence contracts/performance.md#reuse-equivalent-work The set is cached on one envelope's state and reused for that generation's files; this requires a stable producer declaration and the same root/context throughout the generation.
+ */
+export declare function declaresCompleteDependencies(state: TtscEnvelopeDerivation, props: {
+    file: string;
+    projectRoot: string;
+    result: ITtscCompilerTransformation;
+}): boolean;

package/lib/core/transform/envelope/declaresCompleteDependencies.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var collectDeclaredIdentities = require('./collectDeclaredIdentities.js');
+var derivationIdentity = require('./derivationIdentity.js');
+
+/**
+ * Report whether the envelope declared `dependencies[file]` complete, i.e. the
+ * plugin took responsibility for that file's whole input set beyond the file
+ * itself and the universal config chain. Callers must still keep the baseline
+ * for a file the same envelope declared volatile.
+ *
+ * @evidence contracts/common.md#principled-implementation Membership in the producer's explicit completeness declaration transfers input responsibility; exceptions assert no membership, and callers retain the conservative baseline for contradictory volatility.
+ * @evidence contracts/common.md#clear-and-simple-design This predicate owns declaration lookup only; deriveWatchInputs owns which host inputs that declaration may remove.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Completeness requires an actual envelope declaration and never follows from a short dependency list or a successful transform.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains the producer's responsibility, universal config exception and volatility caveat rather than merely naming the boolean; tag separation follows the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Declaration membership compares identities through the envelope context, so native case and realpath behavior are shared with the queried file rather than inferred from textual spelling.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The cached set has at most one entry per declared physical identity and belongs to the weakly owned envelope state; the predicate opens no handles and retains no separate history.
+ * @evidence contracts/performance.md#efficient-algorithms The first query folds the declaration list once; later membership uses a set and memoized identity instead of rescanning all declarations per module.
+ * @evidence contracts/performance.md#reuse-equivalent-work The set is cached on one envelope's state and reused for that generation's files; this requires a stable producer declaration and the same root/context throughout the generation.
+ */
+function declaresCompleteDependencies(state, props) {
+    if (props.result.type === "exception") {
+        return false;
+    }
+    const declared = (state.dependenciesComplete ??= collectDeclaredIdentities.collectDeclaredIdentities(state, props.projectRoot, props.result.dependenciesComplete));
+    return declared.has(derivationIdentity.derivationIdentity(state, props.file));
+}
+
+exports.declaresCompleteDependencies = declaresCompleteDependencies;
+//# sourceMappingURL=declaresCompleteDependencies.js.map

package/lib/core/transform/envelope/declaresCompleteDependencies.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"declaresCompleteDependencies.js","sources":["../../../../src/core/transform/envelope/declaresCompleteDependencies.ts"],"sourcesContent":[null],"names":["collectDeclaredIdentities","derivationIdentity"],"mappings":";;;;;AAMA;;;;;;;;;;;;;;AAcG;AACG,SAAU,4BAA4B,CAC1C,KAA6B,EAC7B,KAIC,EAAA;IAED,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,WAAW,EAAE;AACrC,QAAA,OAAO,KAAK;IACd;IACA,MAAM,QAAQ,IAAI,KAAK,CAAC,oBAAoB,KAAKA,mDAAyB,CACxE,KAAK,EACL,KAAK,CAAC,WAAW,EACjB,KAAK,CAAC,MAAM,CAAC,oBAAoB,CAClC,CAAC;AACF,IAAA,OAAO,QAAQ,CAAC,GAAG,CAACC,qCAAkB,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;AAC5D;;;;"}

package/lib/core/transform/envelope/declaresCompleteDependencies.mjs

@@ -0,0 +1,28 @@
+import { collectDeclaredIdentities } from './collectDeclaredIdentities.mjs';
+import { derivationIdentity } from './derivationIdentity.mjs';
+
+/**
+ * Report whether the envelope declared `dependencies[file]` complete, i.e. the
+ * plugin took responsibility for that file's whole input set beyond the file
+ * itself and the universal config chain. Callers must still keep the baseline
+ * for a file the same envelope declared volatile.
+ *
+ * @evidence contracts/common.md#principled-implementation Membership in the producer's explicit completeness declaration transfers input responsibility; exceptions assert no membership, and callers retain the conservative baseline for contradictory volatility.
+ * @evidence contracts/common.md#clear-and-simple-design This predicate owns declaration lookup only; deriveWatchInputs owns which host inputs that declaration may remove.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Completeness requires an actual envelope declaration and never follows from a short dependency list or a successful transform.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains the producer's responsibility, universal config exception and volatility caveat rather than merely naming the boolean; tag separation follows the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Declaration membership compares identities through the envelope context, so native case and realpath behavior are shared with the queried file rather than inferred from textual spelling.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The cached set has at most one entry per declared physical identity and belongs to the weakly owned envelope state; the predicate opens no handles and retains no separate history.
+ * @evidence contracts/performance.md#efficient-algorithms The first query folds the declaration list once; later membership uses a set and memoized identity instead of rescanning all declarations per module.
+ * @evidence contracts/performance.md#reuse-equivalent-work The set is cached on one envelope's state and reused for that generation's files; this requires a stable producer declaration and the same root/context throughout the generation.
+ */
+function declaresCompleteDependencies(state, props) {
+    if (props.result.type === "exception") {
+        return false;
+    }
+    const declared = (state.dependenciesComplete ??= collectDeclaredIdentities(state, props.projectRoot, props.result.dependenciesComplete));
+    return declared.has(derivationIdentity(state, props.file));
+}
+
+export { declaresCompleteDependencies };
+//# sourceMappingURL=declaresCompleteDependencies.mjs.map

package/lib/core/transform/envelope/declaresCompleteDependencies.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"declaresCompleteDependencies.mjs","sources":["../../../../src/core/transform/envelope/declaresCompleteDependencies.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAMA;;;;;;;;;;;;;;AAcG;AACG,SAAU,4BAA4B,CAC1C,KAA6B,EAC7B,KAIC,EAAA;IAED,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,WAAW,EAAE;AACrC,QAAA,OAAO,KAAK;IACd;IACA,MAAM,QAAQ,IAAI,KAAK,CAAC,oBAAoB,KAAK,yBAAyB,CACxE,KAAK,EACL,KAAK,CAAC,WAAW,EACjB,KAAK,CAAC,MAAM,CAAC,oBAAoB,CAClC,CAAC;AACF,IAAA,OAAO,QAAQ,CAAC,GAAG,CAAC,kBAAkB,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;AAC5D;;;;"}

package/lib/core/transform/envelope/derivationIdentity.d.cts

@@ -0,0 +1,21 @@
+import type { TtscEnvelopeDerivation } from "./TtscEnvelopeDerivation.cjs";
+/**
+ * {@link pathIdentityKey} memoized inside one envelope's derivation state. Pass
+ * an already-resolved native absolute spelling. The raw input string is the
+ * memo key; a relative spelling would introduce current-directory state which
+ * is not represented in that key.
+ *
+ * @evidence contracts/common.md#principled-implementation The context computes filesystem identity, and memoization preserves that result for an already-resolved absolute spelling within one stable generation snapshot.
+ * @evidence contracts/common.md#clear-and-simple-design A lookup-compute-store adapter centralizes identity reuse for all envelope selectors without giving each selector its own filesystem policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Identity comes from the supported pathIdentityKey boundary; the memo does not guess identity from case-folded text or alter foreign filesystem methods.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states the absolute-path precondition and per-envelope memo ownership; tags are separated from that usage information under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The supplied identity context owns native realpath and case semantics; this wrapper keys exact input strings without replacing those semantics with platform-name heuristics.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The map retains exact spelling and identity text for distinct generation queries; its context also retains observed path/ancestor/case entries. There is no separate per-query eviction or byte cap. Storage becomes collectible with unretained envelope state; this adapter opens no independent handle.
+ * @evidence contracts/performance.md#efficient-algorithms A hit avoids native identity replay but still pays map key text hashing/comparison. A first spelling additionally resolves path text and uncached native realpath/ancestor/case observations through the shared context, then stores its identity; one resolver request is not constant-cost native work.
+ * @evidence contracts/performance.md#reuse-equivalent-work Exact absolute spellings reuse identity within the same envelope/context snapshot; callers must not reuse the state after the generation's relevant filesystem identity changes.
+ */
+export declare function derivationIdentity(
+/** Generation state retaining one qualified identity observation lifetime. */
+state: TtscEnvelopeDerivation, 
+/** Already-resolved native absolute spelling used unchanged as the memo key. */
+file: string): string;

package/lib/core/transform/envelope/derivationIdentity.d.mts

@@ -0,0 +1,21 @@
+import type { TtscEnvelopeDerivation } from "./TtscEnvelopeDerivation.mjs";
+/**
+ * {@link pathIdentityKey} memoized inside one envelope's derivation state. Pass
+ * an already-resolved native absolute spelling. The raw input string is the
+ * memo key; a relative spelling would introduce current-directory state which
+ * is not represented in that key.
+ *
+ * @evidence contracts/common.md#principled-implementation The context computes filesystem identity, and memoization preserves that result for an already-resolved absolute spelling within one stable generation snapshot.
+ * @evidence contracts/common.md#clear-and-simple-design A lookup-compute-store adapter centralizes identity reuse for all envelope selectors without giving each selector its own filesystem policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Identity comes from the supported pathIdentityKey boundary; the memo does not guess identity from case-folded text or alter foreign filesystem methods.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states the absolute-path precondition and per-envelope memo ownership; tags are separated from that usage information under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The supplied identity context owns native realpath and case semantics; this wrapper keys exact input strings without replacing those semantics with platform-name heuristics.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The map retains exact spelling and identity text for distinct generation queries; its context also retains observed path/ancestor/case entries. There is no separate per-query eviction or byte cap. Storage becomes collectible with unretained envelope state; this adapter opens no independent handle.
+ * @evidence contracts/performance.md#efficient-algorithms A hit avoids native identity replay but still pays map key text hashing/comparison. A first spelling additionally resolves path text and uncached native realpath/ancestor/case observations through the shared context, then stores its identity; one resolver request is not constant-cost native work.
+ * @evidence contracts/performance.md#reuse-equivalent-work Exact absolute spellings reuse identity within the same envelope/context snapshot; callers must not reuse the state after the generation's relevant filesystem identity changes.
+ */
+export declare function derivationIdentity(
+/** Generation state retaining one qualified identity observation lifetime. */
+state: TtscEnvelopeDerivation, 
+/** Already-resolved native absolute spelling used unchanged as the memo key. */
+file: string): string;

package/lib/core/transform/envelope/derivationIdentity.d.ts

@@ -0,0 +1,21 @@
+import type { TtscEnvelopeDerivation } from "./TtscEnvelopeDerivation";
+/**
+ * {@link pathIdentityKey} memoized inside one envelope's derivation state. Pass
+ * an already-resolved native absolute spelling. The raw input string is the
+ * memo key; a relative spelling would introduce current-directory state which
+ * is not represented in that key.
+ *
+ * @evidence contracts/common.md#principled-implementation The context computes filesystem identity, and memoization preserves that result for an already-resolved absolute spelling within one stable generation snapshot.
+ * @evidence contracts/common.md#clear-and-simple-design A lookup-compute-store adapter centralizes identity reuse for all envelope selectors without giving each selector its own filesystem policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Identity comes from the supported pathIdentityKey boundary; the memo does not guess identity from case-folded text or alter foreign filesystem methods.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states the absolute-path precondition and per-envelope memo ownership; tags are separated from that usage information under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The supplied identity context owns native realpath and case semantics; this wrapper keys exact input strings without replacing those semantics with platform-name heuristics.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The map retains exact spelling and identity text for distinct generation queries; its context also retains observed path/ancestor/case entries. There is no separate per-query eviction or byte cap. Storage becomes collectible with unretained envelope state; this adapter opens no independent handle.
+ * @evidence contracts/performance.md#efficient-algorithms A hit avoids native identity replay but still pays map key text hashing/comparison. A first spelling additionally resolves path text and uncached native realpath/ancestor/case observations through the shared context, then stores its identity; one resolver request is not constant-cost native work.
+ * @evidence contracts/performance.md#reuse-equivalent-work Exact absolute spellings reuse identity within the same envelope/context snapshot; callers must not reuse the state after the generation's relevant filesystem identity changes.
+ */
+export declare function derivationIdentity(
+/** Generation state retaining one qualified identity observation lifetime. */
+state: TtscEnvelopeDerivation, 
+/** Already-resolved native absolute spelling used unchanged as the memo key. */
+file: string): string;

package/lib/core/transform/envelope/derivationIdentity.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var pathIdentityKey = require('../filesystem/pathIdentityKey.js');
+
+/**
+ * {@link pathIdentityKey} memoized inside one envelope's derivation state. Pass
+ * an already-resolved native absolute spelling. The raw input string is the
+ * memo key; a relative spelling would introduce current-directory state which
+ * is not represented in that key.
+ *
+ * @evidence contracts/common.md#principled-implementation The context computes filesystem identity, and memoization preserves that result for an already-resolved absolute spelling within one stable generation snapshot.
+ * @evidence contracts/common.md#clear-and-simple-design A lookup-compute-store adapter centralizes identity reuse for all envelope selectors without giving each selector its own filesystem policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Identity comes from the supported pathIdentityKey boundary; the memo does not guess identity from case-folded text or alter foreign filesystem methods.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states the absolute-path precondition and per-envelope memo ownership; tags are separated from that usage information under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The supplied identity context owns native realpath and case semantics; this wrapper keys exact input strings without replacing those semantics with platform-name heuristics.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The map retains exact spelling and identity text for distinct generation queries; its context also retains observed path/ancestor/case entries. There is no separate per-query eviction or byte cap. Storage becomes collectible with unretained envelope state; this adapter opens no independent handle.
+ * @evidence contracts/performance.md#efficient-algorithms A hit avoids native identity replay but still pays map key text hashing/comparison. A first spelling additionally resolves path text and uncached native realpath/ancestor/case observations through the shared context, then stores its identity; one resolver request is not constant-cost native work.
+ * @evidence contracts/performance.md#reuse-equivalent-work Exact absolute spellings reuse identity within the same envelope/context snapshot; callers must not reuse the state after the generation's relevant filesystem identity changes.
+ */
+function derivationIdentity(
+/** Generation state retaining one qualified identity observation lifetime. */
+state, 
+/** Already-resolved native absolute spelling used unchanged as the memo key. */
+file) {
+    const existing = state.identities.get(file);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const identity = pathIdentityKey.pathIdentityKey(file, state.identityContext);
+    state.identities.set(file, identity);
+    return identity;
+}
+
+exports.derivationIdentity = derivationIdentity;
+//# sourceMappingURL=derivationIdentity.js.map

package/lib/core/transform/envelope/derivationIdentity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivationIdentity.js","sources":["../../../../src/core/transform/envelope/derivationIdentity.ts"],"sourcesContent":[null],"names":["pathIdentityKey"],"mappings":";;;;AAGA;;;;;;;;;;;;;;AAcG;SACa,kBAAkB;AAChC;AACA,KAA6B;AAC7B;AACA,IAAY,EAAA;IAEZ,MAAM,QAAQ,GAAG,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC;AAC3C,IAAA,IAAI,QAAQ,KAAK,SAAS,EAAE;AAC1B,QAAA,OAAO,QAAQ;IACjB;IACA,MAAM,QAAQ,GAAGA,+BAAe,CAAC,IAAI,EAAE,KAAK,CAAC,eAAe,CAAC;IAC7D,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC;AACpC,IAAA,OAAO,QAAQ;AACjB;;;;"}

package/lib/core/transform/envelope/derivationIdentity.mjs

@@ -0,0 +1,33 @@
+import { pathIdentityKey } from '../filesystem/pathIdentityKey.mjs';
+
+/**
+ * {@link pathIdentityKey} memoized inside one envelope's derivation state. Pass
+ * an already-resolved native absolute spelling. The raw input string is the
+ * memo key; a relative spelling would introduce current-directory state which
+ * is not represented in that key.
+ *
+ * @evidence contracts/common.md#principled-implementation The context computes filesystem identity, and memoization preserves that result for an already-resolved absolute spelling within one stable generation snapshot.
+ * @evidence contracts/common.md#clear-and-simple-design A lookup-compute-store adapter centralizes identity reuse for all envelope selectors without giving each selector its own filesystem policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Identity comes from the supported pathIdentityKey boundary; the memo does not guess identity from case-folded text or alter foreign filesystem methods.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states the absolute-path precondition and per-envelope memo ownership; tags are separated from that usage information under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The supplied identity context owns native realpath and case semantics; this wrapper keys exact input strings without replacing those semantics with platform-name heuristics.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The map retains exact spelling and identity text for distinct generation queries; its context also retains observed path/ancestor/case entries. There is no separate per-query eviction or byte cap. Storage becomes collectible with unretained envelope state; this adapter opens no independent handle.
+ * @evidence contracts/performance.md#efficient-algorithms A hit avoids native identity replay but still pays map key text hashing/comparison. A first spelling additionally resolves path text and uncached native realpath/ancestor/case observations through the shared context, then stores its identity; one resolver request is not constant-cost native work.
+ * @evidence contracts/performance.md#reuse-equivalent-work Exact absolute spellings reuse identity within the same envelope/context snapshot; callers must not reuse the state after the generation's relevant filesystem identity changes.
+ */
+function derivationIdentity(
+/** Generation state retaining one qualified identity observation lifetime. */
+state, 
+/** Already-resolved native absolute spelling used unchanged as the memo key. */
+file) {
+    const existing = state.identities.get(file);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const identity = pathIdentityKey(file, state.identityContext);
+    state.identities.set(file, identity);
+    return identity;
+}
+
+export { derivationIdentity };
+//# sourceMappingURL=derivationIdentity.mjs.map

package/lib/core/transform/envelope/derivationIdentity.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivationIdentity.mjs","sources":["../../../../src/core/transform/envelope/derivationIdentity.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;AAcG;SACa,kBAAkB;AAChC;AACA,KAA6B;AAC7B;AACA,IAAY,EAAA;IAEZ,MAAM,QAAQ,GAAG,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC;AAC3C,IAAA,IAAI,QAAQ,KAAK,SAAS,EAAE;AAC1B,QAAA,OAAO,QAAQ;IACjB;IACA,MAAM,QAAQ,GAAG,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,eAAe,CAAC;IAC7D,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC;AACpC,IAAA,OAAO,QAAQ;AACjB;;;;"}

package/lib/core/transform/envelope/deriveWatchInputs.d.cts

@@ -0,0 +1,46 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscEnvelopeDerivation } from "./TtscEnvelopeDerivation.cjs";
+/**
+ * Compute one file's watch-input list over the shared per-envelope state.
+ *
+ * Plugin, resolver and host inputs retain distinct lexical aliases, since a
+ * symlink retarget can change one spelling independently of another. Graph
+ * reachability inputs coalesce by physical identity. The delivered file,
+ * temporary configuration and scratch inputs are excluded in their respective
+ * spelling or identity domain.
+ *
+ * The supplied file identity must come from this state's context. The caller
+ * owns memoization of the final ordered array; this operation only constructs
+ * it.
+ *
+ * @evidence contracts/common.md#principled-implementation Separate lexical and physical seen sets preserve alias-sensitive inputs while coalescing realized graph files; completeness narrows graph inputs only when the same file is not declared volatile.
+ * @evidence contracts/common.md#clear-and-simple-design Two local append policies make the different equivalence domains explicit, while specialized selectors own dependency, graph, resolver, host and plugin-source selection.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Temporary and scratch exclusions refer to generated implementation inputs, and contradictory completeness/volatility retains the conservative bound instead of compensating for missing producer evidence.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain alias preservation, exclusions, the identity precondition and memo ownership; they stay separate from acknowledgment tags under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path.resolve establishes lexical names and derivationIdentity uses the shared filesystem context for physical names; neither case folding nor separators are guessed from an OS label.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   First use can build the shared graph and declaration/key indexes; selection
+ *   then traverses reachable edges/importers and scans selected dependency,
+ *   resolver, host and plugin lists. Each appended occurrence pays native
+ *   lexical path/scratch checks and keyed text queries, with cold physical
+ *   spellings adding native identity observations. Local sets and output grow
+ *   with selected inputs and their text; delegated temporary populations remain
+ *   part of this computation rather than disappearing behind append helpers.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   Lexical duplicates share one emitted entry, while distinct lexical aliases
+ *   remain separate. Graph inputs reuse an already-emitted physical identity.
+ *   Generation state shares parsed indexes and qualified identity observations;
+ *   the caller selectWatchInputs owns completed per-spelling list reuse under
+ *   fixed result/root/options and a stable native identity view.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Local sets retain no invocation history or handles. The returned array is
+ *   transferred to the caller, which owns its storage and memo lifetime;
+ *   generation state owns the shared indexes and identity observations.
+ */
+export declare function deriveWatchInputs(state: TtscEnvelopeDerivation, props: {
+    file: string;
+    projectRoot: string;
+    result: ITtscCompilerTransformation;
+    scratchDirectory?: string;
+    temporaryTsconfig?: string;
+}, fileIdentity: string): string[];

package/lib/core/transform/envelope/deriveWatchInputs.d.mts

@@ -0,0 +1,46 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscEnvelopeDerivation } from "./TtscEnvelopeDerivation.mjs";
+/**
+ * Compute one file's watch-input list over the shared per-envelope state.
+ *
+ * Plugin, resolver and host inputs retain distinct lexical aliases, since a
+ * symlink retarget can change one spelling independently of another. Graph
+ * reachability inputs coalesce by physical identity. The delivered file,
+ * temporary configuration and scratch inputs are excluded in their respective
+ * spelling or identity domain.
+ *
+ * The supplied file identity must come from this state's context. The caller
+ * owns memoization of the final ordered array; this operation only constructs
+ * it.
+ *
+ * @evidence contracts/common.md#principled-implementation Separate lexical and physical seen sets preserve alias-sensitive inputs while coalescing realized graph files; completeness narrows graph inputs only when the same file is not declared volatile.
+ * @evidence contracts/common.md#clear-and-simple-design Two local append policies make the different equivalence domains explicit, while specialized selectors own dependency, graph, resolver, host and plugin-source selection.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Temporary and scratch exclusions refer to generated implementation inputs, and contradictory completeness/volatility retains the conservative bound instead of compensating for missing producer evidence.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain alias preservation, exclusions, the identity precondition and memo ownership; they stay separate from acknowledgment tags under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path.resolve establishes lexical names and derivationIdentity uses the shared filesystem context for physical names; neither case folding nor separators are guessed from an OS label.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   First use can build the shared graph and declaration/key indexes; selection
+ *   then traverses reachable edges/importers and scans selected dependency,
+ *   resolver, host and plugin lists. Each appended occurrence pays native
+ *   lexical path/scratch checks and keyed text queries, with cold physical
+ *   spellings adding native identity observations. Local sets and output grow
+ *   with selected inputs and their text; delegated temporary populations remain
+ *   part of this computation rather than disappearing behind append helpers.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   Lexical duplicates share one emitted entry, while distinct lexical aliases
+ *   remain separate. Graph inputs reuse an already-emitted physical identity.
+ *   Generation state shares parsed indexes and qualified identity observations;
+ *   the caller selectWatchInputs owns completed per-spelling list reuse under
+ *   fixed result/root/options and a stable native identity view.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Local sets retain no invocation history or handles. The returned array is
+ *   transferred to the caller, which owns its storage and memo lifetime;
+ *   generation state owns the shared indexes and identity observations.
+ */
+export declare function deriveWatchInputs(state: TtscEnvelopeDerivation, props: {
+    file: string;
+    projectRoot: string;
+    result: ITtscCompilerTransformation;
+    scratchDirectory?: string;
+    temporaryTsconfig?: string;
+}, fileIdentity: string): string[];

package/lib/core/transform/envelope/deriveWatchInputs.d.ts

@@ -0,0 +1,46 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscEnvelopeDerivation } from "./TtscEnvelopeDerivation";
+/**
+ * Compute one file's watch-input list over the shared per-envelope state.
+ *
+ * Plugin, resolver and host inputs retain distinct lexical aliases, since a
+ * symlink retarget can change one spelling independently of another. Graph
+ * reachability inputs coalesce by physical identity. The delivered file,
+ * temporary configuration and scratch inputs are excluded in their respective
+ * spelling or identity domain.
+ *
+ * The supplied file identity must come from this state's context. The caller
+ * owns memoization of the final ordered array; this operation only constructs
+ * it.
+ *
+ * @evidence contracts/common.md#principled-implementation Separate lexical and physical seen sets preserve alias-sensitive inputs while coalescing realized graph files; completeness narrows graph inputs only when the same file is not declared volatile.
+ * @evidence contracts/common.md#clear-and-simple-design Two local append policies make the different equivalence domains explicit, while specialized selectors own dependency, graph, resolver, host and plugin-source selection.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Temporary and scratch exclusions refer to generated implementation inputs, and contradictory completeness/volatility retains the conservative bound instead of compensating for missing producer evidence.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain alias preservation, exclusions, the identity precondition and memo ownership; they stay separate from acknowledgment tags under the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path.resolve establishes lexical names and derivationIdentity uses the shared filesystem context for physical names; neither case folding nor separators are guessed from an OS label.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   First use can build the shared graph and declaration/key indexes; selection
+ *   then traverses reachable edges/importers and scans selected dependency,
+ *   resolver, host and plugin lists. Each appended occurrence pays native
+ *   lexical path/scratch checks and keyed text queries, with cold physical
+ *   spellings adding native identity observations. Local sets and output grow
+ *   with selected inputs and their text; delegated temporary populations remain
+ *   part of this computation rather than disappearing behind append helpers.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   Lexical duplicates share one emitted entry, while distinct lexical aliases
+ *   remain separate. Graph inputs reuse an already-emitted physical identity.
+ *   Generation state shares parsed indexes and qualified identity observations;
+ *   the caller selectWatchInputs owns completed per-spelling list reuse under
+ *   fixed result/root/options and a stable native identity view.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Local sets retain no invocation history or handles. The returned array is
+ *   transferred to the caller, which owns its storage and memo lifetime;
+ *   generation state owns the shared indexes and identity observations.
+ */
+export declare function deriveWatchInputs(state: TtscEnvelopeDerivation, props: {
+    file: string;
+    projectRoot: string;
+    result: ITtscCompilerTransformation;
+    scratchDirectory?: string;
+    temporaryTsconfig?: string;
+}, fileIdentity: string): string[];