@ttsc/unplugin 0.30.4 → 0.31.1

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

@@ -0,0 +1,34 @@
+import type { TtscEnvelopeDerivation } from "./TtscEnvelopeDerivation.mjs";
+/**
+ * Build a first-match identity index over one envelope key map (`typescript`,
+ * `dependencies`), mirroring the historical per-delivery scan that returned the
+ * first entry whose resolved key matched by filesystem identity.
+ *
+ * @evidence contracts/common.md#principled-implementation Resolving every producer key against the same root and retaining the first value per physical identity preserves first-match lookup when distinct spellings name one file.
+ * @evidence contracts/common.md#clear-and-simple-design The generic key/value adapter isolates identity indexing from the output-key and dependency-array consumers that choose when to build it.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts First-match precedence is a supported lookup rule, not a special-case alias mapping; the input record is not rewritten to conceal ambiguous producer spellings.
+ * @evidence contracts/common.md#meaningful-documentation Native prose identifies the supported key maps and duplicate precedence, with a blank line before acknowledgments following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Keys use native project-relative resolution and the supplied physical identity context, preserving filesystem-specific alias and case semantics without string-based OS guesses.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Materializes the input's entry pairs, then resolves each producer spelling
+ *   once in iteration order. Path text and uncached native identity/ancestor/
+ *   case observations precede expected-constant Map operations, whose key
+ *   hashing/comparison still processes text. Temporary pairs follow all keys;
+ *   the output holds at most one referenced value per resolved identity.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The immutable generation's callers retain the completed index instead of
+ *   rescanning the same keyed record/root; native observations share its
+ *   identity context. This builder retains no separate cross-call index.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   The index is local to the call and handed to the caller.
+ */
+export declare function createEnvelopeKeyIndex<T>(
+/** Generation state whose identity observation memo qualifies producer keys. */
+state: TtscEnvelopeDerivation, 
+/** Stable native root used to expand this producer's relative keys. */
+projectRoot: string, 
+/**
+ * Immutable producer record; own enumeration order determines alias
+ * precedence.
+ */
+keyed: Record<string, T>): Map<string, T>;

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

@@ -0,0 +1,34 @@
+import type { TtscEnvelopeDerivation } from "./TtscEnvelopeDerivation";
+/**
+ * Build a first-match identity index over one envelope key map (`typescript`,
+ * `dependencies`), mirroring the historical per-delivery scan that returned the
+ * first entry whose resolved key matched by filesystem identity.
+ *
+ * @evidence contracts/common.md#principled-implementation Resolving every producer key against the same root and retaining the first value per physical identity preserves first-match lookup when distinct spellings name one file.
+ * @evidence contracts/common.md#clear-and-simple-design The generic key/value adapter isolates identity indexing from the output-key and dependency-array consumers that choose when to build it.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts First-match precedence is a supported lookup rule, not a special-case alias mapping; the input record is not rewritten to conceal ambiguous producer spellings.
+ * @evidence contracts/common.md#meaningful-documentation Native prose identifies the supported key maps and duplicate precedence, with a blank line before acknowledgments following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Keys use native project-relative resolution and the supplied physical identity context, preserving filesystem-specific alias and case semantics without string-based OS guesses.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Materializes the input's entry pairs, then resolves each producer spelling
+ *   once in iteration order. Path text and uncached native identity/ancestor/
+ *   case observations precede expected-constant Map operations, whose key
+ *   hashing/comparison still processes text. Temporary pairs follow all keys;
+ *   the output holds at most one referenced value per resolved identity.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The immutable generation's callers retain the completed index instead of
+ *   rescanning the same keyed record/root; native observations share its
+ *   identity context. This builder retains no separate cross-call index.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   The index is local to the call and handed to the caller.
+ */
+export declare function createEnvelopeKeyIndex<T>(
+/** Generation state whose identity observation memo qualifies producer keys. */
+state: TtscEnvelopeDerivation, 
+/** Stable native root used to expand this producer's relative keys. */
+projectRoot: string, 
+/**
+ * Immutable producer record; own enumeration order determines alias
+ * precedence.
+ */
+keyed: Record<string, T>): Map<string, T>;

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

@@ -0,0 +1,50 @@
+'use strict';
+
+var path = require('node:path');
+var derivationIdentity = require('./derivationIdentity.js');
+
+/**
+ * Build a first-match identity index over one envelope key map (`typescript`,
+ * `dependencies`), mirroring the historical per-delivery scan that returned the
+ * first entry whose resolved key matched by filesystem identity.
+ *
+ * @evidence contracts/common.md#principled-implementation Resolving every producer key against the same root and retaining the first value per physical identity preserves first-match lookup when distinct spellings name one file.
+ * @evidence contracts/common.md#clear-and-simple-design The generic key/value adapter isolates identity indexing from the output-key and dependency-array consumers that choose when to build it.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts First-match precedence is a supported lookup rule, not a special-case alias mapping; the input record is not rewritten to conceal ambiguous producer spellings.
+ * @evidence contracts/common.md#meaningful-documentation Native prose identifies the supported key maps and duplicate precedence, with a blank line before acknowledgments following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Keys use native project-relative resolution and the supplied physical identity context, preserving filesystem-specific alias and case semantics without string-based OS guesses.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Materializes the input's entry pairs, then resolves each producer spelling
+ *   once in iteration order. Path text and uncached native identity/ancestor/
+ *   case observations precede expected-constant Map operations, whose key
+ *   hashing/comparison still processes text. Temporary pairs follow all keys;
+ *   the output holds at most one referenced value per resolved identity.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The immutable generation's callers retain the completed index instead of
+ *   rescanning the same keyed record/root; native observations share its
+ *   identity context. This builder retains no separate cross-call index.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   The index is local to the call and handed to the caller.
+ */
+function createEnvelopeKeyIndex(
+/** Generation state whose identity observation memo qualifies producer keys. */
+state, 
+/** Stable native root used to expand this producer's relative keys. */
+projectRoot, 
+/**
+ * Immutable producer record; own enumeration order determines alias
+ * precedence.
+ */
+keyed) {
+    const index = new Map();
+    for (const [candidate, value] of Object.entries(keyed)) {
+        const identity = derivationIdentity.derivationIdentity(state, path.resolve(projectRoot, candidate));
+        if (!index.has(identity)) {
+            index.set(identity, value);
+        }
+    }
+    return index;
+}
+
+exports.createEnvelopeKeyIndex = createEnvelopeKeyIndex;
+//# sourceMappingURL=createEnvelopeKeyIndex.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createEnvelopeKeyIndex.js","sources":["../../../../src/core/transform/envelope/createEnvelopeKeyIndex.ts"],"sourcesContent":[null],"names":["derivationIdentity"],"mappings":";;;;;AAKA;;;;;;;;;;;;;;;;;;;;;;AAsBG;SACa,sBAAsB;AACpC;AACA,KAA6B;AAC7B;AACA,WAAmB;AACnB;;;AAGG;AACH,KAAwB,EAAA;AAExB,IAAA,MAAM,KAAK,GAAG,IAAI,GAAG,EAAa;AAClC,IAAA,KAAK,MAAM,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;AACtD,QAAA,MAAM,QAAQ,GAAGA,qCAAkB,CACjC,KAAK,EACL,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,SAAS,CAAC,CACrC;QACD,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE;AACxB,YAAA,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC;QAC5B;IACF;AACA,IAAA,OAAO,KAAK;AACd;;;;"}

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

@@ -0,0 +1,48 @@
+import path from 'node:path';
+import { derivationIdentity } from './derivationIdentity.mjs';
+
+/**
+ * Build a first-match identity index over one envelope key map (`typescript`,
+ * `dependencies`), mirroring the historical per-delivery scan that returned the
+ * first entry whose resolved key matched by filesystem identity.
+ *
+ * @evidence contracts/common.md#principled-implementation Resolving every producer key against the same root and retaining the first value per physical identity preserves first-match lookup when distinct spellings name one file.
+ * @evidence contracts/common.md#clear-and-simple-design The generic key/value adapter isolates identity indexing from the output-key and dependency-array consumers that choose when to build it.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts First-match precedence is a supported lookup rule, not a special-case alias mapping; the input record is not rewritten to conceal ambiguous producer spellings.
+ * @evidence contracts/common.md#meaningful-documentation Native prose identifies the supported key maps and duplicate precedence, with a blank line before acknowledgments following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Keys use native project-relative resolution and the supplied physical identity context, preserving filesystem-specific alias and case semantics without string-based OS guesses.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Materializes the input's entry pairs, then resolves each producer spelling
+ *   once in iteration order. Path text and uncached native identity/ancestor/
+ *   case observations precede expected-constant Map operations, whose key
+ *   hashing/comparison still processes text. Temporary pairs follow all keys;
+ *   the output holds at most one referenced value per resolved identity.
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The immutable generation's callers retain the completed index instead of
+ *   rescanning the same keyed record/root; native observations share its
+ *   identity context. This builder retains no separate cross-call index.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   The index is local to the call and handed to the caller.
+ */
+function createEnvelopeKeyIndex(
+/** Generation state whose identity observation memo qualifies producer keys. */
+state, 
+/** Stable native root used to expand this producer's relative keys. */
+projectRoot, 
+/**
+ * Immutable producer record; own enumeration order determines alias
+ * precedence.
+ */
+keyed) {
+    const index = new Map();
+    for (const [candidate, value] of Object.entries(keyed)) {
+        const identity = derivationIdentity(state, path.resolve(projectRoot, candidate));
+        if (!index.has(identity)) {
+            index.set(identity, value);
+        }
+    }
+    return index;
+}
+
+export { createEnvelopeKeyIndex };
+//# sourceMappingURL=createEnvelopeKeyIndex.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createEnvelopeKeyIndex.mjs","sources":["../../../../src/core/transform/envelope/createEnvelopeKeyIndex.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAKA;;;;;;;;;;;;;;;;;;;;;;AAsBG;SACa,sBAAsB;AACpC;AACA,KAA6B;AAC7B;AACA,WAAmB;AACnB;;;AAGG;AACH,KAAwB,EAAA;AAExB,IAAA,MAAM,KAAK,GAAG,IAAI,GAAG,EAAa;AAClC,IAAA,KAAK,MAAM,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;AACtD,QAAA,MAAM,QAAQ,GAAG,kBAAkB,CACjC,KAAK,EACL,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,SAAS,CAAC,CACrC;QACD,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE;AACxB,YAAA,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC;QAC5B;IACF;AACA,IAAA,OAAO,KAAK;AACd;;;;"}

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

@@ -0,0 +1,27 @@
+import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform.cjs";
+import type { TtscEnvelopeDerivation } from "./TtscEnvelopeDerivation.cjs";
+/**
+ * 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.d.mts

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