@ttsc/unplugin 0.30.4 → 0.31.0

package/lib/core/transform/filesystem/relativeToProject.mjs

@@ -0,0 +1,43 @@
+import path from 'node:path';
+import { pathIsWithin } from './pathIsWithin.mjs';
+
+/**
+ * The path of a file below the project, under whichever of the project root's
+ * two spellings contains it, or `undefined` when neither does.
+ *
+ * An empty string names the root itself. A file spelled under the physical root
+ * and one spelled under the named root are both the project's, so a containment
+ * decided against one spelling alone refused every input the compiler reported
+ * for a project reached through a link.
+ *
+ * @param file The absolute path to place.
+ * @param project The project root's two spellings.
+ * @param platform The observed path grammar; the host platform by default.
+ * @evidence contracts/common.md#principled-implementation Both named and physical roots can place an input inside the same project; an empty relative path explicitly identifies the root itself.
+ * @evidence contracts/common.md#clear-and-simple-design At most two existing lexical-containment checks produce the relative spelling, without resolving every input again.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Link-root aliases are not repaired with prefix substitution or a platform-specific temporary-directory exception.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain two-root containment, undefined, and the root's empty-string representation.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral containment uses native resolve/relative and root boundaries under both observed spellings, preserving cross-drive rejection without a fixed platform path policy.
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Resolves the input once, then tries at most two captured roots using
+ *   lexical containment. Cost scales with input and root spelling lengths;
+ *   no native metadata or recursive directory observation is repeated.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   Keeps no cache of its own and computes each value once.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   Acquires no handle, timer or retained state of its own.
+ */
+function relativeToProject(file, project, platform = process.platform) {
+    const pathApi = platform === "win32" ? path.win32 : path.posix;
+    const absolute = pathApi.resolve(file);
+    for (const root of project.physical === project.spelling
+        ? [project.spelling]
+        : [project.spelling, project.physical]) {
+        if (pathIsWithin(absolute, root, platform))
+            return pathApi.relative(root, absolute);
+    }
+    return undefined;
+}
+
+export { relativeToProject };
+//# sourceMappingURL=relativeToProject.mjs.map

package/lib/core/transform/filesystem/relativeToProject.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"relativeToProject.mjs","sources":["../../../../src/core/transform/filesystem/relativeToProject.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACG,SAAU,iBAAiB,CAC/B,IAAY,EACZ,OAA6B,EAC7B,QAAA,GAA4B,OAAO,CAAC,QAAQ,EAAA;AAE5C,IAAA,MAAM,OAAO,GAAG,QAAQ,KAAK,OAAO,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK;IAC9D,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC;IACtC,KAAK,MAAM,IAAI,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC;AAC9C,UAAE,CAAC,OAAO,CAAC,QAAQ;UACjB,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE;AACxC,QAAA,IAAI,YAAY,CAAC,QAAQ,EAAE,IAAI,EAAE,QAAQ,CAAC;YACxC,OAAO,OAAO,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAC3C;AACA,IAAA,OAAO,SAAS;AAClB;;;;"}

package/lib/core/transform/filesystem/userStateDirectory.d.cts

@@ -0,0 +1,35 @@
+/**
+ * A directory below this user's own root under the system temporary directory,
+ * created when absent, spelled in its long form, or `undefined` when the root
+ * or any requested directory is not a real directory. On uid-capable hosts,
+ * each must also belong to this user with no group or other permission bits;
+ * other hosts rely on the native access policy of their temporary directory.
+ *
+ * The adapter keeps there what outlives a process and belongs to no project:
+ * the pooled hosts' shared compile store (`openTtscTransformSession`) and the
+ * project records of a host whose own tool directory cannot be written
+ * (`fallbackToolDirectory`). It also keeps one probe directory per process for
+ * the clock references of proofs that hold no generation
+ * (`refreshProcessClockReference`), named by the process id so the next session
+ * removes one a crashed process left. What the store holds becomes build
+ * output, and a record tells a host whether its cache still holds, so only this
+ * user may write either: the root is checked where the temporary directory is
+ * shared, as `/tmp` is, and so is every directory below it. A platform without
+ * user ids checks directory kind but leaves access control to its native
+ * temporary-directory policy. The long spelling (`fs.realpathSync.native`)
+ * keeps a Windows host watching a record from meeting the short name the
+ * temporary directory routinely has (`C:\Users\RUNNER~1\...`), on which libuv's
+ * backend aborts.
+ *
+ * @param segments Trusted single child names below the root, each created and
+ *   checked; internal callers supply no traversal or embedded path separators.
+ * @evidence contracts/common.md#principled-implementation Internal callers use the shared-store literal or process clock name below the native temporary root; lstat rejects linked entries and POSIX uid/mode checks require user-owned private directories.
+ * @evidence contracts/common.md#clear-and-simple-design One provider creates and checks the state root and requested owned directories, leaving store contents, pruning, and probe lifetime to consumers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Native temporary-root discovery and realpath replace guessed user-directory paths; failures decline optional storage rather than fabricating a usable store.
+ * @evidence contracts/common.md#meaningful-documentation The prose explains retained output ownership, per-process probes, uid-capable checks, and the long Windows spelling required by native watchers.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral directory selection uses os.tmpdir, native realpath, native joins, and available uid capability; hosts without uid checks rely on their user temporary directory's native access policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources This provider leaves no open handles; process probes own exit cleanup, while the persistent store's owner best-effort prunes publication counts, bytes and abandoned-process files.
+ * @evidence contracts/performance.md#efficient-algorithms Creation visits only the root and requested segments, with one ownership stat per directory rather than scanning the temporary tree.
+ * @evidence contracts/performance.md#reuse-equivalent-work Existing directories are reused by shared compile stores and process probes; consumers independently prove retained content instead of recompiling solely because a process restarted.
+ */
+export declare function userStateDirectory(...segments: string[]): string | undefined;

package/lib/core/transform/filesystem/userStateDirectory.d.mts

@@ -0,0 +1,35 @@
+/**
+ * A directory below this user's own root under the system temporary directory,
+ * created when absent, spelled in its long form, or `undefined` when the root
+ * or any requested directory is not a real directory. On uid-capable hosts,
+ * each must also belong to this user with no group or other permission bits;
+ * other hosts rely on the native access policy of their temporary directory.
+ *
+ * The adapter keeps there what outlives a process and belongs to no project:
+ * the pooled hosts' shared compile store (`openTtscTransformSession`) and the
+ * project records of a host whose own tool directory cannot be written
+ * (`fallbackToolDirectory`). It also keeps one probe directory per process for
+ * the clock references of proofs that hold no generation
+ * (`refreshProcessClockReference`), named by the process id so the next session
+ * removes one a crashed process left. What the store holds becomes build
+ * output, and a record tells a host whether its cache still holds, so only this
+ * user may write either: the root is checked where the temporary directory is
+ * shared, as `/tmp` is, and so is every directory below it. A platform without
+ * user ids checks directory kind but leaves access control to its native
+ * temporary-directory policy. The long spelling (`fs.realpathSync.native`)
+ * keeps a Windows host watching a record from meeting the short name the
+ * temporary directory routinely has (`C:\Users\RUNNER~1\...`), on which libuv's
+ * backend aborts.
+ *
+ * @param segments Trusted single child names below the root, each created and
+ *   checked; internal callers supply no traversal or embedded path separators.
+ * @evidence contracts/common.md#principled-implementation Internal callers use the shared-store literal or process clock name below the native temporary root; lstat rejects linked entries and POSIX uid/mode checks require user-owned private directories.
+ * @evidence contracts/common.md#clear-and-simple-design One provider creates and checks the state root and requested owned directories, leaving store contents, pruning, and probe lifetime to consumers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Native temporary-root discovery and realpath replace guessed user-directory paths; failures decline optional storage rather than fabricating a usable store.
+ * @evidence contracts/common.md#meaningful-documentation The prose explains retained output ownership, per-process probes, uid-capable checks, and the long Windows spelling required by native watchers.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral directory selection uses os.tmpdir, native realpath, native joins, and available uid capability; hosts without uid checks rely on their user temporary directory's native access policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources This provider leaves no open handles; process probes own exit cleanup, while the persistent store's owner best-effort prunes publication counts, bytes and abandoned-process files.
+ * @evidence contracts/performance.md#efficient-algorithms Creation visits only the root and requested segments, with one ownership stat per directory rather than scanning the temporary tree.
+ * @evidence contracts/performance.md#reuse-equivalent-work Existing directories are reused by shared compile stores and process probes; consumers independently prove retained content instead of recompiling solely because a process restarted.
+ */
+export declare function userStateDirectory(...segments: string[]): string | undefined;

package/lib/core/transform/filesystem/userStateDirectory.d.ts

@@ -0,0 +1,35 @@
+/**
+ * A directory below this user's own root under the system temporary directory,
+ * created when absent, spelled in its long form, or `undefined` when the root
+ * or any requested directory is not a real directory. On uid-capable hosts,
+ * each must also belong to this user with no group or other permission bits;
+ * other hosts rely on the native access policy of their temporary directory.
+ *
+ * The adapter keeps there what outlives a process and belongs to no project:
+ * the pooled hosts' shared compile store (`openTtscTransformSession`) and the
+ * project records of a host whose own tool directory cannot be written
+ * (`fallbackToolDirectory`). It also keeps one probe directory per process for
+ * the clock references of proofs that hold no generation
+ * (`refreshProcessClockReference`), named by the process id so the next session
+ * removes one a crashed process left. What the store holds becomes build
+ * output, and a record tells a host whether its cache still holds, so only this
+ * user may write either: the root is checked where the temporary directory is
+ * shared, as `/tmp` is, and so is every directory below it. A platform without
+ * user ids checks directory kind but leaves access control to its native
+ * temporary-directory policy. The long spelling (`fs.realpathSync.native`)
+ * keeps a Windows host watching a record from meeting the short name the
+ * temporary directory routinely has (`C:\Users\RUNNER~1\...`), on which libuv's
+ * backend aborts.
+ *
+ * @param segments Trusted single child names below the root, each created and
+ *   checked; internal callers supply no traversal or embedded path separators.
+ * @evidence contracts/common.md#principled-implementation Internal callers use the shared-store literal or process clock name below the native temporary root; lstat rejects linked entries and POSIX uid/mode checks require user-owned private directories.
+ * @evidence contracts/common.md#clear-and-simple-design One provider creates and checks the state root and requested owned directories, leaving store contents, pruning, and probe lifetime to consumers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Native temporary-root discovery and realpath replace guessed user-directory paths; failures decline optional storage rather than fabricating a usable store.
+ * @evidence contracts/common.md#meaningful-documentation The prose explains retained output ownership, per-process probes, uid-capable checks, and the long Windows spelling required by native watchers.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral directory selection uses os.tmpdir, native realpath, native joins, and available uid capability; hosts without uid checks rely on their user temporary directory's native access policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources This provider leaves no open handles; process probes own exit cleanup, while the persistent store's owner best-effort prunes publication counts, bytes and abandoned-process files.
+ * @evidence contracts/performance.md#efficient-algorithms Creation visits only the root and requested segments, with one ownership stat per directory rather than scanning the temporary tree.
+ * @evidence contracts/performance.md#reuse-equivalent-work Existing directories are reused by shared compile stores and process probes; consumers independently prove retained content instead of recompiling solely because a process restarted.
+ */
+export declare function userStateDirectory(...segments: string[]): string | undefined;

package/lib/core/transform/filesystem/userStateDirectory.js

@@ -0,0 +1,71 @@
+'use strict';
+
+var fs = require('node:fs');
+var os = require('node:os');
+var path = require('node:path');
+
+/**
+ * A directory below this user's own root under the system temporary directory,
+ * created when absent, spelled in its long form, or `undefined` when the root
+ * or any requested directory is not a real directory. On uid-capable hosts,
+ * each must also belong to this user with no group or other permission bits;
+ * other hosts rely on the native access policy of their temporary directory.
+ *
+ * The adapter keeps there what outlives a process and belongs to no project:
+ * the pooled hosts' shared compile store (`openTtscTransformSession`) and the
+ * project records of a host whose own tool directory cannot be written
+ * (`fallbackToolDirectory`). It also keeps one probe directory per process for
+ * the clock references of proofs that hold no generation
+ * (`refreshProcessClockReference`), named by the process id so the next session
+ * removes one a crashed process left. What the store holds becomes build
+ * output, and a record tells a host whether its cache still holds, so only this
+ * user may write either: the root is checked where the temporary directory is
+ * shared, as `/tmp` is, and so is every directory below it. A platform without
+ * user ids checks directory kind but leaves access control to its native
+ * temporary-directory policy. The long spelling (`fs.realpathSync.native`)
+ * keeps a Windows host watching a record from meeting the short name the
+ * temporary directory routinely has (`C:\Users\RUNNER~1\...`), on which libuv's
+ * backend aborts.
+ *
+ * @param segments Trusted single child names below the root, each created and
+ *   checked; internal callers supply no traversal or embedded path separators.
+ * @evidence contracts/common.md#principled-implementation Internal callers use the shared-store literal or process clock name below the native temporary root; lstat rejects linked entries and POSIX uid/mode checks require user-owned private directories.
+ * @evidence contracts/common.md#clear-and-simple-design One provider creates and checks the state root and requested owned directories, leaving store contents, pruning, and probe lifetime to consumers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Native temporary-root discovery and realpath replace guessed user-directory paths; failures decline optional storage rather than fabricating a usable store.
+ * @evidence contracts/common.md#meaningful-documentation The prose explains retained output ownership, per-process probes, uid-capable checks, and the long Windows spelling required by native watchers.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral directory selection uses os.tmpdir, native realpath, native joins, and available uid capability; hosts without uid checks rely on their user temporary directory's native access policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources This provider leaves no open handles; process probes own exit cleanup, while the persistent store's owner best-effort prunes publication counts, bytes and abandoned-process files.
+ * @evidence contracts/performance.md#efficient-algorithms Creation visits only the root and requested segments, with one ownership stat per directory rather than scanning the temporary tree.
+ * @evidence contracts/performance.md#reuse-equivalent-work Existing directories are reused by shared compile stores and process probes; consumers independently prove retained content instead of recompiling solely because a process restarted.
+ */
+function userStateDirectory(...segments) {
+    try {
+        const user = process.getuid?.();
+        let directory = path.join(fs.realpathSync.native(os.tmpdir()), `ttsc-unplugin-sessions${user === undefined ? "" : `-${user}`}`);
+        if (!ownedDirectory(directory, user))
+            return undefined;
+        for (const segment of segments) {
+            directory = path.join(directory, segment);
+            if (!ownedDirectory(directory, user))
+                return undefined;
+        }
+        return directory;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Create `directory` when absent and check its nonlinked directory kind. When a
+ * uid is available, also require that owner and private mode bits; otherwise
+ * access control remains with the native temporary-directory policy.
+ */
+function ownedDirectory(directory, user) {
+    fs.mkdirSync(directory, { mode: 0o700, recursive: true });
+    const stat = fs.lstatSync(directory);
+    return (stat.isDirectory() &&
+        (user === undefined || (stat.uid === user && (stat.mode & 0o077) === 0)));
+}
+
+exports.userStateDirectory = userStateDirectory;
+//# sourceMappingURL=userStateDirectory.js.map

package/lib/core/transform/filesystem/userStateDirectory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"userStateDirectory.js","sources":["../../../../src/core/transform/filesystem/userStateDirectory.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;AACG,SAAU,kBAAkB,CAAC,GAAG,QAAkB,EAAA;AACtD,IAAA,IAAI;AACF,QAAA,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,IAAI;AAC/B,QAAA,IAAI,SAAS,GAAG,IAAI,CAAC,IAAI,CACvB,EAAE,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,EACnC,CAAA,sBAAA,EAAyB,IAAI,KAAK,SAAS,GAAG,EAAE,GAAG,CAAA,CAAA,EAAI,IAAI,CAAA,CAAE,CAAA,CAAE,CAChE;AACD,QAAA,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,IAAI,CAAC;AAAE,YAAA,OAAO,SAAS;AACtD,QAAA,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;YAC9B,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC;AACzC,YAAA,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,IAAI,CAAC;AAAE,gBAAA,OAAO,SAAS;QACxD;AACA,QAAA,OAAO,SAAS;IAClB;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,SAAS;IAClB;AACF;AAEA;;;;AAIG;AACH,SAAS,cAAc,CAAC,SAAiB,EAAE,IAAwB,EAAA;AACjE,IAAA,EAAE,CAAC,SAAS,CAAC,SAAS,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;IACzD,MAAM,IAAI,GAAG,EAAE,CAAC,SAAS,CAAC,SAAS,CAAC;AACpC,IAAA,QACE,IAAI,CAAC,WAAW,EAAE;SACjB,IAAI,KAAK,SAAS,KAAK,IAAI,CAAC,GAAG,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,GAAG,KAAK,MAAM,CAAC,CAAC,CAAC;AAE5E;;;;"}

package/lib/core/transform/filesystem/userStateDirectory.mjs

@@ -0,0 +1,69 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+/**
+ * A directory below this user's own root under the system temporary directory,
+ * created when absent, spelled in its long form, or `undefined` when the root
+ * or any requested directory is not a real directory. On uid-capable hosts,
+ * each must also belong to this user with no group or other permission bits;
+ * other hosts rely on the native access policy of their temporary directory.
+ *
+ * The adapter keeps there what outlives a process and belongs to no project:
+ * the pooled hosts' shared compile store (`openTtscTransformSession`) and the
+ * project records of a host whose own tool directory cannot be written
+ * (`fallbackToolDirectory`). It also keeps one probe directory per process for
+ * the clock references of proofs that hold no generation
+ * (`refreshProcessClockReference`), named by the process id so the next session
+ * removes one a crashed process left. What the store holds becomes build
+ * output, and a record tells a host whether its cache still holds, so only this
+ * user may write either: the root is checked where the temporary directory is
+ * shared, as `/tmp` is, and so is every directory below it. A platform without
+ * user ids checks directory kind but leaves access control to its native
+ * temporary-directory policy. The long spelling (`fs.realpathSync.native`)
+ * keeps a Windows host watching a record from meeting the short name the
+ * temporary directory routinely has (`C:\Users\RUNNER~1\...`), on which libuv's
+ * backend aborts.
+ *
+ * @param segments Trusted single child names below the root, each created and
+ *   checked; internal callers supply no traversal or embedded path separators.
+ * @evidence contracts/common.md#principled-implementation Internal callers use the shared-store literal or process clock name below the native temporary root; lstat rejects linked entries and POSIX uid/mode checks require user-owned private directories.
+ * @evidence contracts/common.md#clear-and-simple-design One provider creates and checks the state root and requested owned directories, leaving store contents, pruning, and probe lifetime to consumers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Native temporary-root discovery and realpath replace guessed user-directory paths; failures decline optional storage rather than fabricating a usable store.
+ * @evidence contracts/common.md#meaningful-documentation The prose explains retained output ownership, per-process probes, uid-capable checks, and the long Windows spelling required by native watchers.
+ * @evidence contracts/portability.md#os-neutral-implementation OS-neutral directory selection uses os.tmpdir, native realpath, native joins, and available uid capability; hosts without uid checks rely on their user temporary directory's native access policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources This provider leaves no open handles; process probes own exit cleanup, while the persistent store's owner best-effort prunes publication counts, bytes and abandoned-process files.
+ * @evidence contracts/performance.md#efficient-algorithms Creation visits only the root and requested segments, with one ownership stat per directory rather than scanning the temporary tree.
+ * @evidence contracts/performance.md#reuse-equivalent-work Existing directories are reused by shared compile stores and process probes; consumers independently prove retained content instead of recompiling solely because a process restarted.
+ */
+function userStateDirectory(...segments) {
+    try {
+        const user = process.getuid?.();
+        let directory = path.join(fs.realpathSync.native(os.tmpdir()), `ttsc-unplugin-sessions${user === undefined ? "" : `-${user}`}`);
+        if (!ownedDirectory(directory, user))
+            return undefined;
+        for (const segment of segments) {
+            directory = path.join(directory, segment);
+            if (!ownedDirectory(directory, user))
+                return undefined;
+        }
+        return directory;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Create `directory` when absent and check its nonlinked directory kind. When a
+ * uid is available, also require that owner and private mode bits; otherwise
+ * access control remains with the native temporary-directory policy.
+ */
+function ownedDirectory(directory, user) {
+    fs.mkdirSync(directory, { mode: 0o700, recursive: true });
+    const stat = fs.lstatSync(directory);
+    return (stat.isDirectory() &&
+        (user === undefined || (stat.uid === user && (stat.mode & 0o077) === 0)));
+}
+
+export { userStateDirectory };
+//# sourceMappingURL=userStateDirectory.mjs.map

package/lib/core/transform/filesystem/userStateDirectory.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"userStateDirectory.mjs","sources":["../../../../src/core/transform/filesystem/userStateDirectory.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;AACG,SAAU,kBAAkB,CAAC,GAAG,QAAkB,EAAA;AACtD,IAAA,IAAI;AACF,QAAA,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,IAAI;AAC/B,QAAA,IAAI,SAAS,GAAG,IAAI,CAAC,IAAI,CACvB,EAAE,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,EACnC,CAAA,sBAAA,EAAyB,IAAI,KAAK,SAAS,GAAG,EAAE,GAAG,CAAA,CAAA,EAAI,IAAI,CAAA,CAAE,CAAA,CAAE,CAChE;AACD,QAAA,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,IAAI,CAAC;AAAE,YAAA,OAAO,SAAS;AACtD,QAAA,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;YAC9B,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC;AACzC,YAAA,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,IAAI,CAAC;AAAE,gBAAA,OAAO,SAAS;QACxD;AACA,QAAA,OAAO,SAAS;IAClB;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,SAAS;IAClB;AACF;AAEA;;;;AAIG;AACH,SAAS,cAAc,CAAC,SAAiB,EAAE,IAAwB,EAAA;AACjE,IAAA,EAAE,CAAC,SAAS,CAAC,SAAS,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;IACzD,MAAM,IAAI,GAAG,EAAE,CAAC,SAAS,CAAC,SAAS,CAAC;AACpC,IAAA,QACE,IAAI,CAAC,WAAW,EAAE;SACjB,IAAI,KAAK,SAAS,KAAK,IAAI,CAAC,GAAG,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,GAAG,KAAK,MAAM,CAAC,CAAC,CAAC;AAE5E;;;;"}

package/lib/core/transform/generation/TERMINAL_ENVIRONMENT_VERDICTS.d.cts

@@ -0,0 +1,12 @@
+import type { TtscFailedGenerationValidation } from "./TtscFailedGenerationValidation.cjs";
+/**
+ * The environment verdict each terminal failed generation reached in the
+ * current event-loop turn (samchon/ttsc#1398).
+ *
+ * A page load delivers hundreds of modules while a terminal verdict is
+ * replayed, and each delivery asked whether the environment had changed by
+ * walking the project and re-reading every recorded input. One answer per turn
+ * is shared by every delivery of that turn, and it is dropped on the next turn
+ * so a later change is still seen.
+ */
+export declare const TERMINAL_ENVIRONMENT_VERDICTS: WeakMap<TtscFailedGenerationValidation, boolean>;

package/lib/core/transform/generation/TERMINAL_ENVIRONMENT_VERDICTS.d.mts

@@ -0,0 +1,12 @@
+import type { TtscFailedGenerationValidation } from "./TtscFailedGenerationValidation.mjs";
+/**
+ * The environment verdict each terminal failed generation reached in the
+ * current event-loop turn (samchon/ttsc#1398).
+ *
+ * A page load delivers hundreds of modules while a terminal verdict is
+ * replayed, and each delivery asked whether the environment had changed by
+ * walking the project and re-reading every recorded input. One answer per turn
+ * is shared by every delivery of that turn, and it is dropped on the next turn
+ * so a later change is still seen.
+ */
+export declare const TERMINAL_ENVIRONMENT_VERDICTS: WeakMap<TtscFailedGenerationValidation, boolean>;

package/lib/core/transform/generation/TERMINAL_ENVIRONMENT_VERDICTS.d.ts

@@ -0,0 +1,12 @@
+import type { TtscFailedGenerationValidation } from "./TtscFailedGenerationValidation";
+/**
+ * The environment verdict each terminal failed generation reached in the
+ * current event-loop turn (samchon/ttsc#1398).
+ *
+ * A page load delivers hundreds of modules while a terminal verdict is
+ * replayed, and each delivery asked whether the environment had changed by
+ * walking the project and re-reading every recorded input. One answer per turn
+ * is shared by every delivery of that turn, and it is dropped on the next turn
+ * so a later change is still seen.
+ */
+export declare const TERMINAL_ENVIRONMENT_VERDICTS: WeakMap<TtscFailedGenerationValidation, boolean>;

package/lib/core/transform/generation/TERMINAL_ENVIRONMENT_VERDICTS.js

@@ -0,0 +1,16 @@
+'use strict';
+
+/**
+ * The environment verdict each terminal failed generation reached in the
+ * current event-loop turn (samchon/ttsc#1398).
+ *
+ * A page load delivers hundreds of modules while a terminal verdict is
+ * replayed, and each delivery asked whether the environment had changed by
+ * walking the project and re-reading every recorded input. One answer per turn
+ * is shared by every delivery of that turn, and it is dropped on the next turn
+ * so a later change is still seen.
+ */
+const TERMINAL_ENVIRONMENT_VERDICTS = new WeakMap();
+
+exports.TERMINAL_ENVIRONMENT_VERDICTS = TERMINAL_ENVIRONMENT_VERDICTS;
+//# sourceMappingURL=TERMINAL_ENVIRONMENT_VERDICTS.js.map

package/lib/core/transform/generation/TERMINAL_ENVIRONMENT_VERDICTS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TERMINAL_ENVIRONMENT_VERDICTS.js","sources":["../../../../src/core/transform/generation/TERMINAL_ENVIRONMENT_VERDICTS.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;AASG;AACI,MAAM,6BAA6B,GAAG,IAAI,OAAO;;;;"}

package/lib/core/transform/generation/TERMINAL_ENVIRONMENT_VERDICTS.mjs

@@ -0,0 +1,14 @@
+/**
+ * The environment verdict each terminal failed generation reached in the
+ * current event-loop turn (samchon/ttsc#1398).
+ *
+ * A page load delivers hundreds of modules while a terminal verdict is
+ * replayed, and each delivery asked whether the environment had changed by
+ * walking the project and re-reading every recorded input. One answer per turn
+ * is shared by every delivery of that turn, and it is dropped on the next turn
+ * so a later change is still seen.
+ */
+const TERMINAL_ENVIRONMENT_VERDICTS = new WeakMap();
+
+export { TERMINAL_ENVIRONMENT_VERDICTS };
+//# sourceMappingURL=TERMINAL_ENVIRONMENT_VERDICTS.mjs.map

package/lib/core/transform/generation/TERMINAL_ENVIRONMENT_VERDICTS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TERMINAL_ENVIRONMENT_VERDICTS.mjs","sources":["../../../../src/core/transform/generation/TERMINAL_ENVIRONMENT_VERDICTS.ts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;;;;;;;;AASG;AACI,MAAM,6BAA6B,GAAG,IAAI,OAAO;;;;"}

package/lib/core/transform/generation/TRANSFORM_FAILED_GENERATION_VALIDATIONS.d.cts

@@ -0,0 +1,4 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscFailedGenerationValidation } from "./TtscFailedGenerationValidation.cjs";
+/** Retry baselines retained only for attempts that could not be published. */
+export declare const TRANSFORM_FAILED_GENERATION_VALIDATIONS: WeakMap<ITtscCompilerTransformation, TtscFailedGenerationValidation>;

package/lib/core/transform/generation/TRANSFORM_FAILED_GENERATION_VALIDATIONS.d.mts

@@ -0,0 +1,4 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscFailedGenerationValidation } from "./TtscFailedGenerationValidation.mjs";
+/** Retry baselines retained only for attempts that could not be published. */
+export declare const TRANSFORM_FAILED_GENERATION_VALIDATIONS: WeakMap<ITtscCompilerTransformation, TtscFailedGenerationValidation>;

package/lib/core/transform/generation/TRANSFORM_FAILED_GENERATION_VALIDATIONS.d.ts

@@ -0,0 +1,4 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscFailedGenerationValidation } from "./TtscFailedGenerationValidation";
+/** Retry baselines retained only for attempts that could not be published. */
+export declare const TRANSFORM_FAILED_GENERATION_VALIDATIONS: WeakMap<ITtscCompilerTransformation, TtscFailedGenerationValidation>;

package/lib/core/transform/generation/TRANSFORM_FAILED_GENERATION_VALIDATIONS.js

@@ -0,0 +1,7 @@
+'use strict';
+
+/** Retry baselines retained only for attempts that could not be published. */
+const TRANSFORM_FAILED_GENERATION_VALIDATIONS = new WeakMap();
+
+exports.TRANSFORM_FAILED_GENERATION_VALIDATIONS = TRANSFORM_FAILED_GENERATION_VALIDATIONS;
+//# sourceMappingURL=TRANSFORM_FAILED_GENERATION_VALIDATIONS.js.map

package/lib/core/transform/generation/TRANSFORM_FAILED_GENERATION_VALIDATIONS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TRANSFORM_FAILED_GENERATION_VALIDATIONS.js","sources":["../../../../src/core/transform/generation/TRANSFORM_FAILED_GENERATION_VALIDATIONS.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;AACO,MAAM,uCAAuC,GAAG,IAAI,OAAO;;;;"}

package/lib/core/transform/generation/TRANSFORM_FAILED_GENERATION_VALIDATIONS.mjs

@@ -0,0 +1,5 @@
+/** Retry baselines retained only for attempts that could not be published. */
+const TRANSFORM_FAILED_GENERATION_VALIDATIONS = new WeakMap();
+
+export { TRANSFORM_FAILED_GENERATION_VALIDATIONS };
+//# sourceMappingURL=TRANSFORM_FAILED_GENERATION_VALIDATIONS.mjs.map

package/lib/core/transform/generation/TRANSFORM_FAILED_GENERATION_VALIDATIONS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TRANSFORM_FAILED_GENERATION_VALIDATIONS.mjs","sources":["../../../../src/core/transform/generation/TRANSFORM_FAILED_GENERATION_VALIDATIONS.ts"],"sourcesContent":[null],"names":[],"mappings":"AAIA;AACO,MAAM,uCAAuC,GAAG,IAAI,OAAO;;;;"}

package/lib/core/transform/generation/TRANSFORM_GENERATION_FAILURES.d.cts

@@ -0,0 +1,4 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscGenerationProofFailures } from "./TtscGenerationProofFailures.cjs";
+/** Proof witnesses retained beside a compiler result without extending its API. */
+export declare const TRANSFORM_GENERATION_FAILURES: WeakMap<ITtscCompilerTransformation, TtscGenerationProofFailures>;

package/lib/core/transform/generation/TRANSFORM_GENERATION_FAILURES.d.mts

@@ -0,0 +1,4 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscGenerationProofFailures } from "./TtscGenerationProofFailures.mjs";
+/** Proof witnesses retained beside a compiler result without extending its API. */
+export declare const TRANSFORM_GENERATION_FAILURES: WeakMap<ITtscCompilerTransformation, TtscGenerationProofFailures>;

package/lib/core/transform/generation/TRANSFORM_GENERATION_FAILURES.d.ts

@@ -0,0 +1,4 @@
+import type { ITtscCompilerTransformation } from "ttsc";
+import type { TtscGenerationProofFailures } from "./TtscGenerationProofFailures";
+/** Proof witnesses retained beside a compiler result without extending its API. */
+export declare const TRANSFORM_GENERATION_FAILURES: WeakMap<ITtscCompilerTransformation, TtscGenerationProofFailures>;

package/lib/core/transform/generation/TRANSFORM_GENERATION_FAILURES.js

@@ -0,0 +1,7 @@
+'use strict';
+
+/** Proof witnesses retained beside a compiler result without extending its API. */
+const TRANSFORM_GENERATION_FAILURES = new WeakMap();
+
+exports.TRANSFORM_GENERATION_FAILURES = TRANSFORM_GENERATION_FAILURES;
+//# sourceMappingURL=TRANSFORM_GENERATION_FAILURES.js.map

package/lib/core/transform/generation/TRANSFORM_GENERATION_FAILURES.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TRANSFORM_GENERATION_FAILURES.js","sources":["../../../../src/core/transform/generation/TRANSFORM_GENERATION_FAILURES.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;AACO,MAAM,6BAA6B,GAAG,IAAI,OAAO;;;;"}

package/lib/core/transform/generation/TRANSFORM_GENERATION_FAILURES.mjs

@@ -0,0 +1,5 @@
+/** Proof witnesses retained beside a compiler result without extending its API. */
+const TRANSFORM_GENERATION_FAILURES = new WeakMap();
+
+export { TRANSFORM_GENERATION_FAILURES };
+//# sourceMappingURL=TRANSFORM_GENERATION_FAILURES.mjs.map

package/lib/core/transform/generation/TRANSFORM_GENERATION_FAILURES.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TRANSFORM_GENERATION_FAILURES.mjs","sources":["../../../../src/core/transform/generation/TRANSFORM_GENERATION_FAILURES.ts"],"sourcesContent":[null],"names":[],"mappings":"AAIA;AACO,MAAM,6BAA6B,GAAG,IAAI,OAAO;;;;"}

package/lib/core/transform/generation/TtscFailedGenerationInputState.d.cts

@@ -0,0 +1,39 @@
+/**
+ * What a failed generation recorded about one input outside the project walk.
+ *
+ * @evidence contracts/common.md#principled-implementation The state is always present, and the discriminated alternatives forbid a single-path metadata signature on a plugin tree because that signature cannot establish its descendants' state.
+ * @evidence contracts/common.md#clear-and-simple-design One small observation carrier distinguishes ordinary exact-path validation from whole-plugin-tree validation without owning either algorithm.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing metadata cannot masquerade as a valid signature, and a tree retains its source/build-environment state instead of an invented unchanged marker.
+ * @evidence contracts/common.md#meaningful-documentation Separated property paragraphs explain signature timing, complete state composition and why tree observations carry no single-path signature; no property has acknowledgment tags.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation The carrier holds opaque state and signature strings plus a tree discriminator; native addresses belong to the containing map, and filesystem observation semantics belong to the capture and comparison owners.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscFailedGenerationInputState only declares a shape; it has no
+ *   computation at runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscFailedGenerationInputState only declares a shape; it has no work to
+ *   reuse at runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscFailedGenerationInputState only declares a shape; it has no handle or
+ *   retained state at runtime.
+ */
+export type TtscFailedGenerationInputState = {
+    /**
+     * The input's full state: metadata, content, realpath, and listing; or, for a
+     * plugin source directory, the state its sources and build environment hold
+     * (`pluginSourceState`).
+     */
+    state: string;
+} & ({
+    /**
+     * Exact-path metadata observed before its state, retained only when the
+     * clock proves separation. A matching separable signature permits reuse.
+     */
+    signature?: string;
+    /** Ordinary exact-path observation rather than a plugin subtree. */
+    tree?: never;
+} | {
+    /** Plugin source/build-environment state requiring whole-tree validation. */
+    tree: true;
+    /** No one path's metadata can authorize reuse of descendant state. */
+    signature?: never;
+});

package/lib/core/transform/generation/TtscFailedGenerationInputState.d.mts

@@ -0,0 +1,39 @@
+/**
+ * What a failed generation recorded about one input outside the project walk.
+ *
+ * @evidence contracts/common.md#principled-implementation The state is always present, and the discriminated alternatives forbid a single-path metadata signature on a plugin tree because that signature cannot establish its descendants' state.
+ * @evidence contracts/common.md#clear-and-simple-design One small observation carrier distinguishes ordinary exact-path validation from whole-plugin-tree validation without owning either algorithm.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing metadata cannot masquerade as a valid signature, and a tree retains its source/build-environment state instead of an invented unchanged marker.
+ * @evidence contracts/common.md#meaningful-documentation Separated property paragraphs explain signature timing, complete state composition and why tree observations carry no single-path signature; no property has acknowledgment tags.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation The carrier holds opaque state and signature strings plus a tree discriminator; native addresses belong to the containing map, and filesystem observation semantics belong to the capture and comparison owners.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscFailedGenerationInputState only declares a shape; it has no
+ *   computation at runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscFailedGenerationInputState only declares a shape; it has no work to
+ *   reuse at runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscFailedGenerationInputState only declares a shape; it has no handle or
+ *   retained state at runtime.
+ */
+export type TtscFailedGenerationInputState = {
+    /**
+     * The input's full state: metadata, content, realpath, and listing; or, for a
+     * plugin source directory, the state its sources and build environment hold
+     * (`pluginSourceState`).
+     */
+    state: string;
+} & ({
+    /**
+     * Exact-path metadata observed before its state, retained only when the
+     * clock proves separation. A matching separable signature permits reuse.
+     */
+    signature?: string;
+    /** Ordinary exact-path observation rather than a plugin subtree. */
+    tree?: never;
+} | {
+    /** Plugin source/build-environment state requiring whole-tree validation. */
+    tree: true;
+    /** No one path's metadata can authorize reuse of descendant state. */
+    signature?: never;
+});

package/lib/core/transform/generation/TtscFailedGenerationInputState.d.ts

@@ -0,0 +1,39 @@
+/**
+ * What a failed generation recorded about one input outside the project walk.
+ *
+ * @evidence contracts/common.md#principled-implementation The state is always present, and the discriminated alternatives forbid a single-path metadata signature on a plugin tree because that signature cannot establish its descendants' state.
+ * @evidence contracts/common.md#clear-and-simple-design One small observation carrier distinguishes ordinary exact-path validation from whole-plugin-tree validation without owning either algorithm.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing metadata cannot masquerade as a valid signature, and a tree retains its source/build-environment state instead of an invented unchanged marker.
+ * @evidence contracts/common.md#meaningful-documentation Separated property paragraphs explain signature timing, complete state composition and why tree observations carry no single-path signature; no property has acknowledgment tags.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation The carrier holds opaque state and signature strings plus a tree discriminator; native addresses belong to the containing map, and filesystem observation semantics belong to the capture and comparison owners.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms
+ *   TtscFailedGenerationInputState only declares a shape; it has no
+ *   computation at runtime.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work
+ *   TtscFailedGenerationInputState only declares a shape; it has no work to
+ *   reuse at runtime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources
+ *   TtscFailedGenerationInputState only declares a shape; it has no handle or
+ *   retained state at runtime.
+ */
+export type TtscFailedGenerationInputState = {
+    /**
+     * The input's full state: metadata, content, realpath, and listing; or, for a
+     * plugin source directory, the state its sources and build environment hold
+     * (`pluginSourceState`).
+     */
+    state: string;
+} & ({
+    /**
+     * Exact-path metadata observed before its state, retained only when the
+     * clock proves separation. A matching separable signature permits reuse.
+     */
+    signature?: string;
+    /** Ordinary exact-path observation rather than a plugin subtree. */
+    tree?: never;
+} | {
+    /** Plugin source/build-environment state requiring whole-tree validation. */
+    tree: true;
+    /** No one path's metadata can authorize reuse of descendant state. */
+    signature?: never;
+});