ttsc 0.30.4 → 0.31.0

package/lib/plugin/internal/load/PluginDescriptorAdmission.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginDescriptorAdmission = void 0;
+/**
+ * Admit an evaluated descriptor object and its supported execution stage.
+ * Evaluation, JS-transform rejection and native source acquisition remain
+ * separate owners; object admission does not validate every descriptor field.
+ *
+ * @evidence contracts/common.md#principled-implementation The actual loader uses object admission before its existing JS-function guard and stage selection before native preparation.
+ * @evidence contracts/common.md#clear-and-simple-design One descriptor concern groups shape admission and stage defaults/errors without an evaluator abstraction.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Supplied evaluated values are not synthetic producer certificates and these members execute no loader.
+ * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes shallow shape admission from evaluation and other field validation.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This namespace groups supplied-value policies without native filesystem or process operations.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The grouping chooses no input-processing algorithm.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The grouping owns no cached evaluation result.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The namespace retains no runtime registry, task or native handle.
+ */
+var PluginDescriptorAdmission;
+(function (PluginDescriptorAdmission) {
+    /**
+     * Return the same non-null, non-array object or reject the named export.
+     * Other field validation remains with the loader's subsequent guards.
+     *
+     * @evidence contracts/common.md#principled-implementation The former loader predicate admits exactly non-null objects except arrays and preserves admitted reference identity.
+     * @evidence contracts/common.md#clear-and-simple-design One return-or-throw boundary owns the actual invalid-export diagnostic.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts No descriptor is evaluated or fabricated by this shallow admission.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states accepted shape, identity and the remaining field-validation responsibility.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation Supplied values and diagnostic text require no native path, file or process operation.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms Scalar shape checks select no growing-population algorithm.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Admission uses the current supplied value and owns no evaluation cache.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The same object returns to the caller; no handle, task or history is retained.
+     */
+    function descriptor(value, specifier) {
+        if (typeof value === "object" && value !== null && !Array.isArray(value))
+            return value;
+        throw new Error(`ttsc: plugin "${specifier}" does not export a valid ttsc plugin`);
+    }
+    PluginDescriptorAdmission.descriptor = descriptor;
+    /**
+     * Default an omitted stage to transform and reject removed/unknown stages.
+     * The removed output stage retains its specific upgrade diagnostic.
+     *
+     * @evidence contracts/common.md#principled-implementation Omission defaults to transform, transform/check retain their values, and removed output remains distinct from unsupported stage text.
+     * @evidence contracts/common.md#clear-and-simple-design Stage selection owns its default and two rejection diagnostics in one supplied-descriptor operation.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts No successful evaluator or native host is inferred from an accepted stage.
+     * @evidence contracts/common.md#meaningful-documentation Native prose names the default, admitted stages and removed-stage distinction.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation Supplied stage/name values are interpreted without native paths, files or processes.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms Scalar stage selection and diagnostic formatting choose no growing-population algorithm.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Current descriptor fields are read without retained stage-result caching.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This operation retains no descriptor population, handle or task.
+     */
+    function stage(plugin) {
+        if (plugin.stage === undefined)
+            return "transform";
+        if (!isPluginStage(plugin.stage)) {
+            if (plugin.stage === "output")
+                throw new Error(`ttsc: plugin "${plugin.name}" requested removed stage "output"; ` +
+                    "upgrade the plugin to a transform-stage descriptor compatible with this ttsc version");
+            throw new Error(`ttsc: plugin "${plugin.name}" requested unsupported stage ${JSON.stringify(plugin.stage)}`);
+        }
+        return plugin.stage;
+    }
+    PluginDescriptorAdmission.stage = stage;
+})(PluginDescriptorAdmission || (exports.PluginDescriptorAdmission = PluginDescriptorAdmission = {}));
+/**
+ * Retain the loader's scalar stage predicate without rereading descriptor
+ * fields.
+ */
+function isPluginStage(value) {
+    return value === "transform" || value === "check";
+}
+//# sourceMappingURL=PluginDescriptorAdmission.js.map

package/lib/plugin/internal/load/PluginDescriptorAdmission.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginDescriptorAdmission.js","sourceRoot":"","sources":["../../../../src/plugin/internal/load/PluginDescriptorAdmission.ts"],"names":[],"mappings":";;;AAGA;;;;;;;;;;;;;GAaG;AACH,IAAiB,yBAAyB,CAiDzC;AAjDD,WAAiB,yBAAyB;IACxC;;;;;;;;;;;;OAYG;IACH,SAAgB,UAAU,CAAC,KAAc,EAAE,SAAiB;QAC1D,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;YACtE,OAAO,KAAoB,CAAC;QAC9B,MAAM,IAAI,KAAK,CACb,iBAAiB,SAAS,uCAAuC,CAClE,CAAC;IACJ,CAAC;IANe,0BAAA,UAAU,aAMzB,CAAA;IAED;;;;;;;;;;;;OAYG;IACH,SAAgB,KAAK,CAAC,MAAmB;QACvC,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS;YAAE,OAAO,WAAW,CAAC;QACnD,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;YACjC,IAAI,MAAM,CAAC,KAAK,KAAK,QAAQ;gBAC3B,MAAM,IAAI,KAAK,CACb,iBAAiB,MAAM,CAAC,IAAI,sCAAsC;oBAChE,sFAAsF,CACzF,CAAC;YACJ,MAAM,IAAI,KAAK,CACb,iBAAiB,MAAM,CAAC,IAAI,iCAAiC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAC5F,CAAC;QACJ,CAAC;QACD,OAAO,MAAM,CAAC,KAAK,CAAC;IACtB,CAAC;IAbe,0BAAA,KAAK,QAapB,CAAA;AACH,CAAC,EAjDgB,yBAAyB,aAAzB,yBAAyB,GAAzB,yBAAyB,QAiDzC;AAED;;;GAGG;AACH,SAAS,aAAa,CAAC,KAAa;IAClC,OAAO,KAAK,KAAK,WAAW,IAAI,KAAK,KAAK,OAAO,CAAC;AACpD,CAAC"}

package/lib/plugin/internal/load/PluginDescriptorEvaluationCache.d.ts

@@ -0,0 +1,154 @@
+/**
+ * The persistent answers of isolated CommonJS descriptor evaluations, each
+ * recorded with the state it was computed from.
+ *
+ * Isolated evaluation loads the descriptor graph in a fresh runtime module
+ * cache. Its recorded module/candidate content and physical paths, plus the
+ * descriptor's own external-read declarations, supply persistence premises;
+ * their presence is not detection of every omitted read or side effect. An
+ * answer is kept under everything else the evaluation was given: the
+ * descriptor, its factory context, the effective environment it ran under, the
+ * runtimes that ran it, and this ttsc build. A hit requires matching current
+ * stored content/realpath projections; these sequential observations are not an
+ * atomic filesystem snapshot and do not distinguish every cause of an
+ * unavailable null value.
+ *
+ * The files a descriptor reads outside its module graph are its own to declare
+ * (`hostInputHashes`), so only the answer of a descriptor supplying that
+ * declaration is recorded (`declaresHostInputReads`); a declared fingerprint is
+ * compared as content on a later read; a separately observed physical target
+ * exists only for recorded evaluation inputs. Missing or contradictory input
+ * observations refuse a write. The caller also excludes evaluations whose
+ * captured diagnostics file is nonempty, since a hit replays no diagnostics.
+ * Startup preloads run before these observations and cannot authorize
+ * persistence merely through a stable NODE_OPTIONS string.
+ *
+ * @evidence contracts/common.md#principled-implementation Persistent evaluation identity includes evaluator format, descriptor/context, effective environment, actual primary/secondary executable content identities and ttsc version. Acceptance checks recorded input observations and producer-declared external content, not every possible read; unobserved startup preload authority refuses persistence.
+ * @evidence contracts/common.md#clear-and-simple-design Locate/read/write separate key construction, proof validation and publication while the loader owns evaluation and its diagnostics.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A descriptor without its explicit external-read declaration is not persisted, and the caller excludes nonempty captured diagnostics because a cache hit cannot replay them.
+ * @evidence contracts/common.md#meaningful-documentation Native JSDoc explains isolation cost, input-proof responsibility, environment identity and write refusal in distinct paragraphs; exported operation comments and tag spacing follow the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native executable identity and same-directory publication handle OS-neutral paths; sorted environment data and actual content/lexical/physical observations detect replacement without OS-name guesses.
+ * @evidence contracts/performance.md#efficient-algorithms Key construction includes environment/name sorting, context serialization, executable hashing and delegated cache-root lookup. Reads validate full JSON/maps and observe content/realpaths; writes normalize proof keys and serialize complete entries. Native path/query work and environment/context/record/file bytes contribute cost; a valid hit avoids evaluation without establishing an unmeasured launch-time ranking.
+ * @evidence contracts/performance.md#reuse-equivalent-work Entries share only fully keyed evaluations whose declared inputs still match; incomplete or contradictory fingerprints refuse persistence rather than reviving an unproved answer.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Default JSON entries and staging leftovers are eligible for single-file pruning subject to its interval/protection/error policy; explicit roots remain caller-owned. Hits attempt usage refresh, and writes attempt staging removal in finally. Cleanup or later pruning can fail; no unconditional deletion, entry-count or byte ceiling is supplied here.
+ */
+export declare namespace PluginDescriptorEvaluationCache {
+    /**
+     * One evaluation's answer and the state it was computed from.
+     *
+     * @evidence contracts/common.md#principled-implementation Unknown descriptor data remains untrusted until the loader validates it; input hashes and physical paths preserve the evaluation's own observations rather than later filesystem readings.
+     * @evidence contracts/common.md#clear-and-simple-design One serializable payload transfers the evaluation result and its input proof together without retaining the child's module cache.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The record does not assume a descriptor shape or promote absent proof to a valid cached answer.
+     * @evidence contracts/common.md#meaningful-documentation Native member comments identify unvalidated answer, observed content/identity and input population; member and tag spacing follow the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Input keys and realpaths are separate native identities supplied by the evaluator; the data shape imposes neither slash-only spelling nor blanket case folding.
+     *
+     * @evidenceExclude contracts/performance.md#efficient-algorithms This payload type performs no computation; cache operations own the hashing and collection algorithms.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work The representation records evidence but establishes no reuse identity by itself; locate/read/write own acceptance.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources These fields contain serialized data, not child handles or a retained cache population; the cache namespace owns entry lifetime.
+     */
+    interface IEvaluation {
+        /** Serialized factory answer, validated by the plugin loader. */
+        descriptor: unknown;
+        /** Content observations captured during evaluation, including null. */
+        hostInputHashes: Record<string, string | null>;
+        /** Physical-path observations captured alongside the input reads. */
+        hostInputRealpaths: Record<string, string | null>;
+        /** Module and resolution-candidate inputs that the evaluator observed. */
+        inputs: string[];
+        /**
+         * Whether the owning runtime finished recording every observation without
+         * failure.
+         */
+        observationsComplete: boolean;
+    }
+    /**
+     * Where the answer for one evaluation lives, or `null` when no cache root can
+     * be resolved, either runtime cannot be identified, or startup preloads are
+     * unobserved.
+     *
+     * @param props.projectRoot The project whose cache root holds the entry.
+     * @param props.cacheDir The plugin cache directory the caller selected.
+     * @param props.request The resolved descriptor module.
+     * @param props.context The factory context the descriptor is invoked with.
+     * @param props.env The complete environment the evaluation runs under.
+     * @param props.runtime The runtime executable that evaluates it.
+     * @param props.additionalRuntime Selected Node executable exposed to the
+     *   descriptor and used by ttsx/config loaders, when distinct from runtime.
+     * @param props.version This ttsc build's version.
+     * @evidence contracts/common.md#principled-implementation Canonical identity includes factory context, sorted effective environment and fresh content/lexical/physical proof of both actual runtime authorities; unobserved startup preloads and unreadable runtimes cannot select a reusable entry.
+     * @evidence contracts/common.md#clear-and-simple-design The locator delegates cache-root policy and runtime observation, then constructs only the descriptor entry identity.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Unidentifiable runtime/storage returns null for uncached evaluation rather than weakening the key or selecting a fixture-specific runtime.
+     * @evidence contracts/common.md#meaningful-documentation Native JSDoc identifies every key premise and null result; parameter entries and separate tags follow the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Native realpath/stat and path.resolve/join preserve executable and cache paths; environment ordering is lexical map data, not shell syntax.
+     * @evidence contracts/performance.md#efficient-algorithms Environment entries are merged/filtered/sorted by name bytes; context and key fields are serialized and hashed. Primary/secondary executable observation uses bounded read buffers but native metadata/path and escaping identity text also cost work; identical supplied spellings share one proof. Delegated root selection can walk ancestors/read manifests and inspect cache layout, so environment/runtime bytes are not the complete cost dimensions.
+     * @evidence contracts/performance.md#reuse-equivalent-work The key shares only evaluations with identical descriptor/context/environment/runtime/version authorities; observed source state is separately checked by read.
+     *
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The locator stores no handle or historical entry population; executable observation owns its transient descriptor/close attempt and returns an unproved result on failure. Serialized key/context and returned path transfer without freezing mutable caller authority; persistence/pruning own stored entry lifetime.
+     */
+    function locate(props: {
+        /** Additional actual Node authority used by the descriptor host. */
+        additionalRuntime?: string;
+        /** Explicit caller-owned cache root, or default workspace policy. */
+        cacheDir: string | undefined;
+        /** Complete JSON-serializable factory context passed to evaluation. */
+        context: unknown;
+        /** Complete child environment, with undefined values omitted from identity. */
+        env: NodeJS.ProcessEnv;
+        /** Consumer project anchoring cache-root selection. */
+        projectRoot: string;
+        /** Resolved descriptor entry module whose evaluation is cached. */
+        request: string;
+        /** Executable that runs evaluation, identified by actual bytes and paths. */
+        runtime: string;
+        /** Ttsc build version, invalidating answers from another build. */
+        version: string;
+    }): string | null;
+    /**
+     * The recorded answer when its validated content/realpath projections match
+     * fresh observations, otherwise `null` meaning "evaluate the descriptor".
+     * Declared external content need not have a separately observed realpath;
+     * sequential matching is not atomic and unavailable null values do not
+     * distinguish every failure cause.
+     *
+     * @evidence contracts/common.md#principled-implementation Record/format validation, complete-observation status and bidirectional current hash/realpath projections require nonempty fingerprint data before returning the evaluation. Producer-declared external content and separately observed physical targets remain distinct premises, not a complete-world identity certificate.
+     * @evidence contracts/common.md#clear-and-simple-design The reader answers only valid-entry or null; real descriptor execution remains the caller's response to a miss.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Unreadable, malformed or changed entries become misses, without accepting stale descriptor data because the file exists.
+     * @evidence contracts/common.md#meaningful-documentation Native JSDoc states the exact observation-state condition and null fallback, with separate acknowledgment prose under the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Current native hash/realpath observations preserve content and physical selection independently, including symlink/junction retargeting.
+     * @evidence contracts/performance.md#efficient-algorithms Complete UTF-8 entry read/JSON parse and state-map validation precede key/value comparisons, current full file hashing and native realpath queries. Entry/key/path/file bytes and native lookup contribute processing and transient storage; a valid hit also performs usage metadata queries and avoids actual child evaluation.
+     * @evidence contracts/performance.md#reuse-equivalent-work Recorded content and physical-path projections must match current observations and the content map must be nonempty. External declarations can contribute content without separate physical observations; this is the existing proof scope, not atomic or complete-world equivalence.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources The returned parsed data belongs to the caller; recordCacheFileUse attempts disk-entry last-use refresh for pruning and can skip or fail, with no global in-memory answer map.
+     */
+    function read(file: string): IEvaluation | null;
+    /**
+     * Record an evaluation's answer with the state it was computed from.
+     *
+     * The state is the one the evaluation proved while it ran, never a reading
+     * taken now: hashing the inputs here would pair the answer with a state it
+     * may not have been computed from. An evaluation input without both proofs
+     * leaves nothing that could prove the entry later, so nothing is recorded,
+     * and neither is a fingerprint declaration no proof can use, nor the answer
+     * of a descriptor lacking its explicit external-read declaration
+     * (`declaresHostInputReads`). Declaration completeness still depends on the
+     * producer; this writer cannot detect omitted reads. The owning runtime must
+     * explicitly finish its observations; a partial side channel cannot establish
+     * the population. A write failure only costs the next launch an evaluation.
+     *
+     * `defaultWorkspaceRoot` is supplied only when the caller selected default
+     * storage. Its ownership marker precedes the first answer, so a later root
+     * search does not mistake this newly populated cache for an older orphan. The
+     * answer uses the marker's returned physical spelling to avoid the original
+     * alias. That spelling is not a retained directory handle: placement still
+     * requires the resulting path to remain stable through publication.
+     *
+     * @evidence contracts/common.md#principled-implementation Persistence requires explicit external-read declarations, the producer's complete-observation flag and both recorded states for evaluation inputs; conflicting declared content refuses publication. A caller-authorized default root is marked before publication, subject to the resulting native path remaining stable.
+     * @evidence contracts/common.md#clear-and-simple-design One writer assembles proof and publishes the copied serialization while the loader decides whether printed side effects permit caching.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Fresh hashing is not used to bless a past answer, and missing or contradictory declaration proof refuses a write rather than compensating with guesses.
+     * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain evaluation-time identity, non-persistable inputs, best-effort writing and the caller's default-root authority before the tags.
+     * @evidence contracts/portability.md#os-neutral-implementation Native path operations and the shared physical-root marker precede same-directory staging/rename without OS-specific shell publication.
+     * @evidence contracts/performance.md#efficient-algorithms Input path normalization/Set deduplication and declared key/value checks assemble proof without rereading source bytes. Full entry serialization, native root/marker/directory publication, staging write/rename and cleanup still cost path/key/context/record bytes and native queries; copied proof maps and serialized text coexist transiently.
+     * @evidence contracts/performance.md#reuse-equivalent-work Recorded evaluation states and producer-declared external content are persisted under the locate key. A declaration conflicting with an observed content value refuses the write; otherwise extra declared content is added without manufacturing a physical observation.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Publication transfers the JSON entry to its cache-root owner and finally attempts temporary staging removal. Cleanup errors are tolerated and default pruning has interval/protection/failure limits; explicit roots stay caller-owned. Entry/staging bytes scale with full serialization, with no independent byte/count bound or guaranteed reclamation here.
+     */
+    function write(file: string, evaluation: IEvaluation, defaultWorkspaceRoot?: string): void;
+}

package/lib/plugin/internal/load/PluginDescriptorEvaluationCache.js

@@ -0,0 +1,317 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginDescriptorEvaluationCache = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const SidecarEnvironment_1 = require("../../../compiler/internal/sharedHost/SidecarEnvironment");
+const runtimeExecutableIdentity_1 = require("../../../internal/runtimeExecutableIdentity");
+const SourceBuildCacheLayout_1 = require("../source/SourceBuildCacheLayout");
+const recordCacheFileUse_1 = require("../source/recordCacheFileUse");
+const resolveSourceBuildCachePaths_1 = require("../source/resolveSourceBuildCachePaths");
+const declaresHostInputReads_1 = require("./declaresHostInputReads");
+const hashHostInputPaths_1 = require("./hashHostInputPaths");
+const realpathHostInputPaths_1 = require("./realpathHostInputPaths");
+/**
+ * The persistent answers of isolated CommonJS descriptor evaluations, each
+ * recorded with the state it was computed from.
+ *
+ * Isolated evaluation loads the descriptor graph in a fresh runtime module
+ * cache. Its recorded module/candidate content and physical paths, plus the
+ * descriptor's own external-read declarations, supply persistence premises;
+ * their presence is not detection of every omitted read or side effect. An
+ * answer is kept under everything else the evaluation was given: the
+ * descriptor, its factory context, the effective environment it ran under, the
+ * runtimes that ran it, and this ttsc build. A hit requires matching current
+ * stored content/realpath projections; these sequential observations are not an
+ * atomic filesystem snapshot and do not distinguish every cause of an
+ * unavailable null value.
+ *
+ * The files a descriptor reads outside its module graph are its own to declare
+ * (`hostInputHashes`), so only the answer of a descriptor supplying that
+ * declaration is recorded (`declaresHostInputReads`); a declared fingerprint is
+ * compared as content on a later read; a separately observed physical target
+ * exists only for recorded evaluation inputs. Missing or contradictory input
+ * observations refuse a write. The caller also excludes evaluations whose
+ * captured diagnostics file is nonempty, since a hit replays no diagnostics.
+ * Startup preloads run before these observations and cannot authorize
+ * persistence merely through a stable NODE_OPTIONS string.
+ *
+ * @evidence contracts/common.md#principled-implementation Persistent evaluation identity includes evaluator format, descriptor/context, effective environment, actual primary/secondary executable content identities and ttsc version. Acceptance checks recorded input observations and producer-declared external content, not every possible read; unobserved startup preload authority refuses persistence.
+ * @evidence contracts/common.md#clear-and-simple-design Locate/read/write separate key construction, proof validation and publication while the loader owns evaluation and its diagnostics.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A descriptor without its explicit external-read declaration is not persisted, and the caller excludes nonempty captured diagnostics because a cache hit cannot replay them.
+ * @evidence contracts/common.md#meaningful-documentation Native JSDoc explains isolation cost, input-proof responsibility, environment identity and write refusal in distinct paragraphs; exported operation comments and tag spacing follow the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native executable identity and same-directory publication handle OS-neutral paths; sorted environment data and actual content/lexical/physical observations detect replacement without OS-name guesses.
+ * @evidence contracts/performance.md#efficient-algorithms Key construction includes environment/name sorting, context serialization, executable hashing and delegated cache-root lookup. Reads validate full JSON/maps and observe content/realpaths; writes normalize proof keys and serialize complete entries. Native path/query work and environment/context/record/file bytes contribute cost; a valid hit avoids evaluation without establishing an unmeasured launch-time ranking.
+ * @evidence contracts/performance.md#reuse-equivalent-work Entries share only fully keyed evaluations whose declared inputs still match; incomplete or contradictory fingerprints refuse persistence rather than reviving an unproved answer.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Default JSON entries and staging leftovers are eligible for single-file pruning subject to its interval/protection/error policy; explicit roots remain caller-owned. Hits attempt usage refresh, and writes attempt staging removal in finally. Cleanup or later pruning can fail; no unconditional deletion, entry-count or byte ceiling is supplied here.
+ */
+var PluginDescriptorEvaluationCache;
+(function (PluginDescriptorEvaluationCache) {
+    /**
+     * Where the answer for one evaluation lives, or `null` when no cache root can
+     * be resolved, either runtime cannot be identified, or startup preloads are
+     * unobserved.
+     *
+     * @param props.projectRoot The project whose cache root holds the entry.
+     * @param props.cacheDir The plugin cache directory the caller selected.
+     * @param props.request The resolved descriptor module.
+     * @param props.context The factory context the descriptor is invoked with.
+     * @param props.env The complete environment the evaluation runs under.
+     * @param props.runtime The runtime executable that evaluates it.
+     * @param props.additionalRuntime Selected Node executable exposed to the
+     *   descriptor and used by ttsx/config loaders, when distinct from runtime.
+     * @param props.version This ttsc build's version.
+     * @evidence contracts/common.md#principled-implementation Canonical identity includes factory context, sorted effective environment and fresh content/lexical/physical proof of both actual runtime authorities; unobserved startup preloads and unreadable runtimes cannot select a reusable entry.
+     * @evidence contracts/common.md#clear-and-simple-design The locator delegates cache-root policy and runtime observation, then constructs only the descriptor entry identity.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Unidentifiable runtime/storage returns null for uncached evaluation rather than weakening the key or selecting a fixture-specific runtime.
+     * @evidence contracts/common.md#meaningful-documentation Native JSDoc identifies every key premise and null result; parameter entries and separate tags follow the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Native realpath/stat and path.resolve/join preserve executable and cache paths; environment ordering is lexical map data, not shell syntax.
+     * @evidence contracts/performance.md#efficient-algorithms Environment entries are merged/filtered/sorted by name bytes; context and key fields are serialized and hashed. Primary/secondary executable observation uses bounded read buffers but native metadata/path and escaping identity text also cost work; identical supplied spellings share one proof. Delegated root selection can walk ancestors/read manifests and inspect cache layout, so environment/runtime bytes are not the complete cost dimensions.
+     * @evidence contracts/performance.md#reuse-equivalent-work The key shares only evaluations with identical descriptor/context/environment/runtime/version authorities; observed source state is separately checked by read.
+     *
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The locator stores no handle or historical entry population; executable observation owns its transient descriptor/close attempt and returns an unproved result on failure. Serialized key/context and returned path transfer without freezing mutable caller authority; persistence/pruning own stored entry lifetime.
+     */
+    function locate(props) {
+        const environment = SidecarEnvironment_1.SidecarEnvironment.merge(props.env);
+        // Startup preloads can run before the descriptor recorder and read inputs
+        // it never sees; a stable option string cannot prove their current meaning.
+        if (SidecarEnvironment_1.SidecarEnvironment.read(environment, "NODE_OPTIONS")?.trim())
+            return null;
+        const runtime = runtimeIdentity(props.runtime);
+        if (runtime === null)
+            return null;
+        const additionalRuntime = props.additionalRuntime === undefined
+            ? undefined
+            : props.additionalRuntime === props.runtime
+                ? runtime
+                : runtimeIdentity(props.additionalRuntime);
+        if (additionalRuntime === null)
+            return null;
+        let root;
+        try {
+            root = (0, resolveSourceBuildCachePaths_1.resolveSourceBuildCachePaths)(props.projectRoot, props.cacheDir, environment).root;
+        }
+        catch {
+            return null;
+        }
+        const key = node_crypto_1.default
+            .createHash("sha256")
+            .update(JSON.stringify([
+            FORMAT,
+            props.version,
+            node_path_1.default.resolve(props.request),
+            props.context,
+            Object.entries(environment)
+                .filter((entry) => entry[1] !== undefined)
+                .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0),
+            runtime,
+            additionalRuntime,
+        ]))
+            .digest("hex");
+        return node_path_1.default.join(root, SourceBuildCacheLayout_1.SourceBuildCacheLayout.DESCRIPTOR_CACHE_DIRNAME, `${key}.json`);
+    }
+    PluginDescriptorEvaluationCache.locate = locate;
+    /**
+     * The recorded answer when its validated content/realpath projections match
+     * fresh observations, otherwise `null` meaning "evaluate the descriptor".
+     * Declared external content need not have a separately observed realpath;
+     * sequential matching is not atomic and unavailable null values do not
+     * distinguish every failure cause.
+     *
+     * @evidence contracts/common.md#principled-implementation Record/format validation, complete-observation status and bidirectional current hash/realpath projections require nonempty fingerprint data before returning the evaluation. Producer-declared external content and separately observed physical targets remain distinct premises, not a complete-world identity certificate.
+     * @evidence contracts/common.md#clear-and-simple-design The reader answers only valid-entry or null; real descriptor execution remains the caller's response to a miss.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Unreadable, malformed or changed entries become misses, without accepting stale descriptor data because the file exists.
+     * @evidence contracts/common.md#meaningful-documentation Native JSDoc states the exact observation-state condition and null fallback, with separate acknowledgment prose under the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Current native hash/realpath observations preserve content and physical selection independently, including symlink/junction retargeting.
+     * @evidence contracts/performance.md#efficient-algorithms Complete UTF-8 entry read/JSON parse and state-map validation precede key/value comparisons, current full file hashing and native realpath queries. Entry/key/path/file bytes and native lookup contribute processing and transient storage; a valid hit also performs usage metadata queries and avoids actual child evaluation.
+     * @evidence contracts/performance.md#reuse-equivalent-work Recorded content and physical-path projections must match current observations and the content map must be nonempty. External declarations can contribute content without separate physical observations; this is the existing proof scope, not atomic or complete-world equivalence.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources The returned parsed data belongs to the caller; recordCacheFileUse attempts disk-entry last-use refresh for pruning and can skip or fail, with no global in-memory answer map.
+     */
+    function read(file) {
+        let entry;
+        try {
+            entry = JSON.parse(node_fs_1.default.readFileSync(file, "utf8"));
+        }
+        catch {
+            return null;
+        }
+        if (!isEntry(entry) || entry.format !== FORMAT)
+            return null;
+        const hashed = Object.keys(entry.proof.hashes);
+        if (hashed.length === 0 ||
+            !sameMap(entry.proof.hashes, (0, hashHostInputPaths_1.hashHostInputPaths)(hashed)) ||
+            !sameMap(entry.proof.realpaths, (0, realpathHostInputPaths_1.realpathHostInputPaths)(Object.keys(entry.proof.realpaths))))
+            return null;
+        (0, recordCacheFileUse_1.recordCacheFileUse)(file);
+        return entry.evaluation;
+    }
+    PluginDescriptorEvaluationCache.read = read;
+    /**
+     * Record an evaluation's answer with the state it was computed from.
+     *
+     * The state is the one the evaluation proved while it ran, never a reading
+     * taken now: hashing the inputs here would pair the answer with a state it
+     * may not have been computed from. An evaluation input without both proofs
+     * leaves nothing that could prove the entry later, so nothing is recorded,
+     * and neither is a fingerprint declaration no proof can use, nor the answer
+     * of a descriptor lacking its explicit external-read declaration
+     * (`declaresHostInputReads`). Declaration completeness still depends on the
+     * producer; this writer cannot detect omitted reads. The owning runtime must
+     * explicitly finish its observations; a partial side channel cannot establish
+     * the population. A write failure only costs the next launch an evaluation.
+     *
+     * `defaultWorkspaceRoot` is supplied only when the caller selected default
+     * storage. Its ownership marker precedes the first answer, so a later root
+     * search does not mistake this newly populated cache for an older orphan. The
+     * answer uses the marker's returned physical spelling to avoid the original
+     * alias. That spelling is not a retained directory handle: placement still
+     * requires the resulting path to remain stable through publication.
+     *
+     * @evidence contracts/common.md#principled-implementation Persistence requires explicit external-read declarations, the producer's complete-observation flag and both recorded states for evaluation inputs; conflicting declared content refuses publication. A caller-authorized default root is marked before publication, subject to the resulting native path remaining stable.
+     * @evidence contracts/common.md#clear-and-simple-design One writer assembles proof and publishes the copied serialization while the loader decides whether printed side effects permit caching.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Fresh hashing is not used to bless a past answer, and missing or contradictory declaration proof refuses a write rather than compensating with guesses.
+     * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain evaluation-time identity, non-persistable inputs, best-effort writing and the caller's default-root authority before the tags.
+     * @evidence contracts/portability.md#os-neutral-implementation Native path operations and the shared physical-root marker precede same-directory staging/rename without OS-specific shell publication.
+     * @evidence contracts/performance.md#efficient-algorithms Input path normalization/Set deduplication and declared key/value checks assemble proof without rereading source bytes. Full entry serialization, native root/marker/directory publication, staging write/rename and cleanup still cost path/key/context/record bytes and native queries; copied proof maps and serialized text coexist transiently.
+     * @evidence contracts/performance.md#reuse-equivalent-work Recorded evaluation states and producer-declared external content are persisted under the locate key. A declaration conflicting with an observed content value refuses the write; otherwise extra declared content is added without manufacturing a physical observation.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Publication transfers the JSON entry to its cache-root owner and finally attempts temporary staging removal. Cleanup errors are tolerated and default pruning has interval/protection/failure limits; explicit roots stay caller-owned. Entry/staging bytes scale with full serialization, with no independent byte/count bound or guaranteed reclamation here.
+     */
+    function write(file, evaluation, defaultWorkspaceRoot) {
+        if (evaluation.observationsComplete !== true ||
+            !(0, declaresHostInputReads_1.declaresHostInputReads)(evaluation.descriptor))
+            return;
+        const hashes = {};
+        const realpaths = {};
+        for (const input of new Set(evaluation.inputs.map((input) => node_path_1.default.resolve(input)))) {
+            if (!Object.prototype.hasOwnProperty.call(evaluation.hostInputHashes, input) ||
+                !Object.prototype.hasOwnProperty.call(evaluation.hostInputRealpaths, input))
+                return;
+            hashes[input] = evaluation.hostInputHashes[input];
+            realpaths[input] = evaluation.hostInputRealpaths[input];
+        }
+        const declared = declaredFingerprints(evaluation.descriptor);
+        if (declared === null)
+            return;
+        for (const [input, hash] of Object.entries(declared)) {
+            if (Object.prototype.hasOwnProperty.call(hashes, input) &&
+                hashes[input] !== hash)
+                return;
+            // The descriptor's fingerprint of a file it read itself proves its
+            // content; the physical path is proven only for what the evaluation saw.
+            hashes[input] = hash;
+        }
+        if (Object.keys(hashes).length === 0)
+            return;
+        const entry = {
+            evaluation,
+            format: FORMAT,
+            proof: { hashes, realpaths },
+        };
+        let output = file;
+        if (defaultWorkspaceRoot !== undefined) {
+            if (node_path_1.default.dirname(file) !==
+                node_path_1.default.join(defaultWorkspaceRoot, SourceBuildCacheLayout_1.SourceBuildCacheLayout.DESCRIPTOR_CACHE_DIRNAME))
+                return;
+            try {
+                const physicalRoot = SourceBuildCacheLayout_1.SourceBuildCacheLayout.markDefaultWorkspaceCacheRoot(defaultWorkspaceRoot);
+                output = node_path_1.default.join(physicalRoot, SourceBuildCacheLayout_1.SourceBuildCacheLayout.DESCRIPTOR_CACHE_DIRNAME, node_path_1.default.basename(file));
+            }
+            catch {
+                return;
+            }
+        }
+        const staging = `${output}.${process.pid}.${node_crypto_1.default.randomUUID()}.tmp`;
+        try {
+            node_fs_1.default.mkdirSync(node_path_1.default.dirname(output), { recursive: true });
+            // Written beside the entry and renamed, so a reader never sees a partial
+            // entry that happens to parse.
+            node_fs_1.default.writeFileSync(staging, JSON.stringify(entry), "utf8");
+            node_fs_1.default.renameSync(staging, output);
+        }
+        catch {
+            // The cache is an optimization over an evaluation that still works.
+        }
+        finally {
+            try {
+                node_fs_1.default.rmSync(staging, { force: true });
+            }
+            catch {
+                // Best-effort staging cleanup cannot replace descriptor evaluation.
+            }
+        }
+    }
+    PluginDescriptorEvaluationCache.write = write;
+    /**
+     * Entry format tag. Moves when the entry shape or its proof rule changes, so
+     * an entry written under another rule is evaluated again.
+     */
+    // Earlier generations could replace mapped-resolution pre-witnesses with
+    // later candidate state, so their apparently complete proofs are not reusable.
+    const FORMAT = "ttsc-descriptor-evaluation-v7";
+    /**
+     * The runtime executable as the key names it: its physical path with the
+     * content digest and bracketed lexical/physical metadata, so replaced bytes
+     * cannot reuse an evaluation by restoring size/timestamps. Null is unproved.
+     */
+    function runtimeIdentity(runtime) {
+        return (0, runtimeExecutableIdentity_1.runtimeExecutableIdentity)(runtime) ?? null;
+    }
+    /**
+     * The fingerprints a descriptor declared for the files it read itself
+     * (`hostInputHashes`), keyed by resolved path, or `null` when the declaration
+     * is not one a proof can use.
+     */
+    function declaredFingerprints(descriptor) {
+        const declared = descriptor
+            .hostInputHashes;
+        if (typeof declared !== "object" || declared === null)
+            return null;
+        const output = {};
+        for (const [file, hash] of Object.entries(declared)) {
+            if (!node_path_1.default.isAbsolute(file) || (hash !== null && typeof hash !== "string"))
+                return null;
+            output[node_path_1.default.resolve(file)] = hash;
+        }
+        return output;
+    }
+    function isEntry(value) {
+        if (typeof value !== "object" || value === null)
+            return false;
+        const entry = value;
+        const evaluation = entry.evaluation;
+        return (typeof entry.format === "string" &&
+            typeof entry.proof === "object" &&
+            entry.proof !== null &&
+            isStateMap(entry.proof.hashes) &&
+            isStateMap(entry.proof.realpaths) &&
+            typeof evaluation === "object" &&
+            evaluation !== null &&
+            evaluation.observationsComplete === true &&
+            isStateMap(evaluation.hostInputHashes) &&
+            isStateMap(evaluation.hostInputRealpaths) &&
+            Array.isArray(evaluation.inputs) &&
+            evaluation.inputs.every((input) => typeof input === "string"));
+    }
+    function isStateMap(value) {
+        return (typeof value === "object" &&
+            value !== null &&
+            !Array.isArray(value) &&
+            Object.values(value).every((state) => state === null || typeof state === "string"));
+    }
+    /**
+     * Whether two snapshots describe the same state, compared both ways: a key
+     * the fresh snapshot lacks means the two were taken over different sets.
+     */
+    function sameMap(recorded, current) {
+        const keys = Object.keys(recorded);
+        if (keys.length !== Object.keys(current).length)
+            return false;
+        return keys.every((key) => Object.prototype.hasOwnProperty.call(current, key) &&
+            recorded[key] === current[key]);
+    }
+})(PluginDescriptorEvaluationCache || (exports.PluginDescriptorEvaluationCache = PluginDescriptorEvaluationCache = {}));
+//# sourceMappingURL=PluginDescriptorEvaluationCache.js.map

package/lib/plugin/internal/load/PluginDescriptorEvaluationCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginDescriptorEvaluationCache.js","sourceRoot":"","sources":["../../../../src/plugin/internal/load/PluginDescriptorEvaluationCache.ts"],"names":[],"mappings":"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"}