@ttsc/unplugin 0.30.4 → 0.31.0

package/lib/core/transform/session/openTtscTransformSession.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Open the shared compile store for the pooled host session this process
+ * configures, and return its path (samchon/ttsc#1390).
+ *
+ * Turbopack and Metro run transforms in a pool of worker processes, and each
+ * compiled the whole project before answering its first module. The process
+ * that configures the pool calls this before the workers exist, and puts the
+ * store's path into {@link TTSC_TRANSFORM_SESSION_ENV}, which the workers
+ * inherit. The first worker to need a generation compiles it and publishes it
+ * there, and the others prove it and adopt it.
+ *
+ * The store outlives the process (samchon/ttsc#1483). A dev server started
+ * again spawns fresh workers with no generation in memory, and Turbopack runs
+ * the loader for every module after a restart, so a store that died with its
+ * process left each restart compiling every project once. The store is one
+ * directory per user, kept across processes: a fresh worker adopts what the
+ * last process compiled after proving it against its own disk, as any adopter
+ * does, and a compile is named by what it is down to the compiler versions
+ * (`sharedCompileIdentity`). That key includes reported compiler and adapter
+ * versions; capture/adoption owners separately prove retained inputs.
+ * Publication pruning is best-effort (`claimSharedCompile`).
+ *
+ * A newly opened store lives below checked user-state storage under the system
+ * temporary directory (`userStateDirectory`). On uid-capable hosts that
+ * provider requires private user-owned directories; other hosts rely on native
+ * access policy. Its location is independent of project selection, not always
+ * outside a project placed in that root. Earlier versions kept one store per
+ * process in the same root, removed when it exited; one whose process is gone
+ * was left behind by a crash, and is removed here, as is the clock probe
+ * directory a crashed process kept there (`refreshProcessClockReference`). A
+ * process whose environment already names a live store, because a parent or an
+ * earlier call opened the session, keeps that store. The inherited reader
+ * checks an absolute current directory, not ownership or writability; the
+ * configuring host supplies that address.
+ *
+ * Sharing is an optimization, so any failure leaves the session closed and the
+ * workers compiling for themselves, never an error.
+ *
+ * @returns The store's absolute path, or `undefined` when none could be opened.
+ * @evidence contracts/common.md#principled-implementation An inherited absolute directory is preserved; otherwise checked user-state storage is declared before workers spawn. Publication keys and separate input proofs determine reuse, not store existence.
+ * @evidence contracts/common.md#clear-and-simple-design New directory ownership stays in userStateDirectory, claiming in claimSharedCompile and adoption proof in generation capture; this operation declares the address and reclaims recognized legacy children.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Optional store failure leaves real local compilation in place, rather than reusing unproven output or suppressing compiler failure.
+ * @evidence contracts/common.md#meaningful-documentation The prose explains worker inheritance, persistent versus obsolete process storage, and why sharing failures return undefined.
+ * @evidence contracts/portability.md#os-neutral-implementation Native joins and user-state capability checks provide new storage; inherited addresses receive only current directory checks. process.kill(pid, 0) treats success and EPERM as live, other failures as not live; this classification is not a general proof of death under every process-probe failure.
+ * @evidence contracts/performance.md#efficient-algorithms An inherited path performs native path/stat work and avoids the root scan. Cold opening materializes N child names, matches their text and probes recognized PIDs, with provider realpath/create/stat work and recursive deletion of selected subtrees. Cost depends on name bytes, removed descendants and native operations, not just N; persistent shared-store contents are not scanned here.
+ * @evidence contracts/performance.md#reuse-equivalent-work Parent and worker processes retain the inherited store capability, while compile identity, state proof and publication reuse remain with the claim/adoption owners.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Recognized clock and legacy children classified not live are recursively reclaimed. Inherited, live and unrecognized children bypass reclamation; a failed removal aborts opening, so no count or byte bound is enforced here. The environment retains the current address; claimSharedCompile owns best-effort publication pruning. Synchronous operations leave no open handle.
+ */
+export declare function openTtscTransformSession(): string | undefined;

package/lib/core/transform/session/openTtscTransformSession.js

@@ -0,0 +1,100 @@
+'use strict';
+
+var fs = require('node:fs');
+var path = require('node:path');
+var userStateDirectory = require('../filesystem/userStateDirectory.js');
+var TTSC_TRANSFORM_SESSION_ENV = require('./TTSC_TRANSFORM_SESSION_ENV.js');
+var readTtscTransformSession = require('./readTtscTransformSession.js');
+
+/**
+ * Open the shared compile store for the pooled host session this process
+ * configures, and return its path (samchon/ttsc#1390).
+ *
+ * Turbopack and Metro run transforms in a pool of worker processes, and each
+ * compiled the whole project before answering its first module. The process
+ * that configures the pool calls this before the workers exist, and puts the
+ * store's path into {@link TTSC_TRANSFORM_SESSION_ENV}, which the workers
+ * inherit. The first worker to need a generation compiles it and publishes it
+ * there, and the others prove it and adopt it.
+ *
+ * The store outlives the process (samchon/ttsc#1483). A dev server started
+ * again spawns fresh workers with no generation in memory, and Turbopack runs
+ * the loader for every module after a restart, so a store that died with its
+ * process left each restart compiling every project once. The store is one
+ * directory per user, kept across processes: a fresh worker adopts what the
+ * last process compiled after proving it against its own disk, as any adopter
+ * does, and a compile is named by what it is down to the compiler versions
+ * (`sharedCompileIdentity`). That key includes reported compiler and adapter
+ * versions; capture/adoption owners separately prove retained inputs.
+ * Publication pruning is best-effort (`claimSharedCompile`).
+ *
+ * A newly opened store lives below checked user-state storage under the system
+ * temporary directory (`userStateDirectory`). On uid-capable hosts that
+ * provider requires private user-owned directories; other hosts rely on native
+ * access policy. Its location is independent of project selection, not always
+ * outside a project placed in that root. Earlier versions kept one store per
+ * process in the same root, removed when it exited; one whose process is gone
+ * was left behind by a crash, and is removed here, as is the clock probe
+ * directory a crashed process kept there (`refreshProcessClockReference`). A
+ * process whose environment already names a live store, because a parent or an
+ * earlier call opened the session, keeps that store. The inherited reader
+ * checks an absolute current directory, not ownership or writability; the
+ * configuring host supplies that address.
+ *
+ * Sharing is an optimization, so any failure leaves the session closed and the
+ * workers compiling for themselves, never an error.
+ *
+ * @returns The store's absolute path, or `undefined` when none could be opened.
+ * @evidence contracts/common.md#principled-implementation An inherited absolute directory is preserved; otherwise checked user-state storage is declared before workers spawn. Publication keys and separate input proofs determine reuse, not store existence.
+ * @evidence contracts/common.md#clear-and-simple-design New directory ownership stays in userStateDirectory, claiming in claimSharedCompile and adoption proof in generation capture; this operation declares the address and reclaims recognized legacy children.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Optional store failure leaves real local compilation in place, rather than reusing unproven output or suppressing compiler failure.
+ * @evidence contracts/common.md#meaningful-documentation The prose explains worker inheritance, persistent versus obsolete process storage, and why sharing failures return undefined.
+ * @evidence contracts/portability.md#os-neutral-implementation Native joins and user-state capability checks provide new storage; inherited addresses receive only current directory checks. process.kill(pid, 0) treats success and EPERM as live, other failures as not live; this classification is not a general proof of death under every process-probe failure.
+ * @evidence contracts/performance.md#efficient-algorithms An inherited path performs native path/stat work and avoids the root scan. Cold opening materializes N child names, matches their text and probes recognized PIDs, with provider realpath/create/stat work and recursive deletion of selected subtrees. Cost depends on name bytes, removed descendants and native operations, not just N; persistent shared-store contents are not scanned here.
+ * @evidence contracts/performance.md#reuse-equivalent-work Parent and worker processes retain the inherited store capability, while compile identity, state proof and publication reuse remain with the claim/adoption owners.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Recognized clock and legacy children classified not live are recursively reclaimed. Inherited, live and unrecognized children bypass reclamation; a failed removal aborts opening, so no count or byte bound is enforced here. The environment retains the current address; claimSharedCompile owns best-effort publication pruning. Synchronous operations leave no open handle.
+ */
+function openTtscTransformSession() {
+    const inherited = readTtscTransformSession.readTtscTransformSession();
+    if (inherited !== undefined) {
+        return inherited;
+    }
+    try {
+        const root = userStateDirectory.userStateDirectory();
+        if (root === undefined)
+            return undefined;
+        for (const entry of fs.readdirSync(root)) {
+            const match = /^([1-9][0-9]*)-(?:clock|[A-Za-z0-9]{6})$/.exec(entry);
+            const owner = match === null ? undefined : Number(match[1]);
+            if (owner !== undefined &&
+                Number.isSafeInteger(owner) &&
+                !processAlive(owner)) {
+                fs.rmSync(path.join(root, entry), { force: true, recursive: true });
+            }
+        }
+        const store = userStateDirectory.userStateDirectory(SHARED_STORE);
+        if (store === undefined)
+            return undefined;
+        process.env[TTSC_TRANSFORM_SESSION_ENV.TTSC_TRANSFORM_SESSION_ENV] = store;
+        return store;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The store's name below the per-user root, which names no process. */
+const SHARED_STORE = "shared";
+/** Whether a process with this id exists, as far as this process can tell. */
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        // EPERM: it exists and belongs to another user.
+        return error.code === "EPERM";
+    }
+}
+
+exports.openTtscTransformSession = openTtscTransformSession;
+//# sourceMappingURL=openTtscTransformSession.js.map

package/lib/core/transform/session/openTtscTransformSession.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openTtscTransformSession.js","sources":["../../../../src/core/transform/session/openTtscTransformSession.ts"],"sourcesContent":[null],"names":["readTtscTransformSession","userStateDirectory","TTSC_TRANSFORM_SESSION_ENV"],"mappings":";;;;;;;;AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CG;SACa,wBAAwB,GAAA;AACtC,IAAA,MAAM,SAAS,GAAGA,iDAAwB,EAAE;AAC5C,IAAA,IAAI,SAAS,KAAK,SAAS,EAAE;AAC3B,QAAA,OAAO,SAAS;IAClB;AACA,IAAA,IAAI;AACF,QAAA,MAAM,IAAI,GAAGC,qCAAkB,EAAE;QACjC,IAAI,IAAI,KAAK,SAAS;AAAE,YAAA,OAAO,SAAS;QACxC,KAAK,MAAM,KAAK,IAAI,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE;YACxC,MAAM,KAAK,GAAG,0CAA0C,CAAC,IAAI,CAAC,KAAK,CAAC;AACpE,YAAA,MAAM,KAAK,GAAG,KAAK,KAAK,IAAI,GAAG,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAC3D,IACE,KAAK,KAAK,SAAS;AACnB,gBAAA,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC;AAC3B,gBAAA,CAAC,YAAY,CAAC,KAAK,CAAC,EACpB;gBACA,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;YACrE;QACF;AACA,QAAA,MAAM,KAAK,GAAGA,qCAAkB,CAAC,YAAY,CAAC;QAC9C,IAAI,KAAK,KAAK,SAAS;AAAE,YAAA,OAAO,SAAS;AACzC,QAAA,OAAO,CAAC,GAAG,CAACC,qDAA0B,CAAC,GAAG,KAAK;AAC/C,QAAA,OAAO,KAAK;IACd;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,SAAS;IAClB;AACF;AAEA;AACA,MAAM,YAAY,GAAG,QAAQ;AAE7B;AACA,SAAS,YAAY,CAAC,GAAW,EAAA;AAC/B,IAAA,IAAI;AACF,QAAA,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;AACpB,QAAA,OAAO,IAAI;IACb;IAAE,OAAO,KAAK,EAAE;;AAEd,QAAA,OAAQ,KAA+B,CAAC,IAAI,KAAK,OAAO;IAC1D;AACF;;;;"}

package/lib/core/transform/session/openTtscTransformSession.mjs

@@ -0,0 +1,98 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { userStateDirectory } from '../filesystem/userStateDirectory.mjs';
+import { TTSC_TRANSFORM_SESSION_ENV } from './TTSC_TRANSFORM_SESSION_ENV.mjs';
+import { readTtscTransformSession } from './readTtscTransformSession.mjs';
+
+/**
+ * Open the shared compile store for the pooled host session this process
+ * configures, and return its path (samchon/ttsc#1390).
+ *
+ * Turbopack and Metro run transforms in a pool of worker processes, and each
+ * compiled the whole project before answering its first module. The process
+ * that configures the pool calls this before the workers exist, and puts the
+ * store's path into {@link TTSC_TRANSFORM_SESSION_ENV}, which the workers
+ * inherit. The first worker to need a generation compiles it and publishes it
+ * there, and the others prove it and adopt it.
+ *
+ * The store outlives the process (samchon/ttsc#1483). A dev server started
+ * again spawns fresh workers with no generation in memory, and Turbopack runs
+ * the loader for every module after a restart, so a store that died with its
+ * process left each restart compiling every project once. The store is one
+ * directory per user, kept across processes: a fresh worker adopts what the
+ * last process compiled after proving it against its own disk, as any adopter
+ * does, and a compile is named by what it is down to the compiler versions
+ * (`sharedCompileIdentity`). That key includes reported compiler and adapter
+ * versions; capture/adoption owners separately prove retained inputs.
+ * Publication pruning is best-effort (`claimSharedCompile`).
+ *
+ * A newly opened store lives below checked user-state storage under the system
+ * temporary directory (`userStateDirectory`). On uid-capable hosts that
+ * provider requires private user-owned directories; other hosts rely on native
+ * access policy. Its location is independent of project selection, not always
+ * outside a project placed in that root. Earlier versions kept one store per
+ * process in the same root, removed when it exited; one whose process is gone
+ * was left behind by a crash, and is removed here, as is the clock probe
+ * directory a crashed process kept there (`refreshProcessClockReference`). A
+ * process whose environment already names a live store, because a parent or an
+ * earlier call opened the session, keeps that store. The inherited reader
+ * checks an absolute current directory, not ownership or writability; the
+ * configuring host supplies that address.
+ *
+ * Sharing is an optimization, so any failure leaves the session closed and the
+ * workers compiling for themselves, never an error.
+ *
+ * @returns The store's absolute path, or `undefined` when none could be opened.
+ * @evidence contracts/common.md#principled-implementation An inherited absolute directory is preserved; otherwise checked user-state storage is declared before workers spawn. Publication keys and separate input proofs determine reuse, not store existence.
+ * @evidence contracts/common.md#clear-and-simple-design New directory ownership stays in userStateDirectory, claiming in claimSharedCompile and adoption proof in generation capture; this operation declares the address and reclaims recognized legacy children.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Optional store failure leaves real local compilation in place, rather than reusing unproven output or suppressing compiler failure.
+ * @evidence contracts/common.md#meaningful-documentation The prose explains worker inheritance, persistent versus obsolete process storage, and why sharing failures return undefined.
+ * @evidence contracts/portability.md#os-neutral-implementation Native joins and user-state capability checks provide new storage; inherited addresses receive only current directory checks. process.kill(pid, 0) treats success and EPERM as live, other failures as not live; this classification is not a general proof of death under every process-probe failure.
+ * @evidence contracts/performance.md#efficient-algorithms An inherited path performs native path/stat work and avoids the root scan. Cold opening materializes N child names, matches their text and probes recognized PIDs, with provider realpath/create/stat work and recursive deletion of selected subtrees. Cost depends on name bytes, removed descendants and native operations, not just N; persistent shared-store contents are not scanned here.
+ * @evidence contracts/performance.md#reuse-equivalent-work Parent and worker processes retain the inherited store capability, while compile identity, state proof and publication reuse remain with the claim/adoption owners.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Recognized clock and legacy children classified not live are recursively reclaimed. Inherited, live and unrecognized children bypass reclamation; a failed removal aborts opening, so no count or byte bound is enforced here. The environment retains the current address; claimSharedCompile owns best-effort publication pruning. Synchronous operations leave no open handle.
+ */
+function openTtscTransformSession() {
+    const inherited = readTtscTransformSession();
+    if (inherited !== undefined) {
+        return inherited;
+    }
+    try {
+        const root = userStateDirectory();
+        if (root === undefined)
+            return undefined;
+        for (const entry of fs.readdirSync(root)) {
+            const match = /^([1-9][0-9]*)-(?:clock|[A-Za-z0-9]{6})$/.exec(entry);
+            const owner = match === null ? undefined : Number(match[1]);
+            if (owner !== undefined &&
+                Number.isSafeInteger(owner) &&
+                !processAlive(owner)) {
+                fs.rmSync(path.join(root, entry), { force: true, recursive: true });
+            }
+        }
+        const store = userStateDirectory(SHARED_STORE);
+        if (store === undefined)
+            return undefined;
+        process.env[TTSC_TRANSFORM_SESSION_ENV] = store;
+        return store;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The store's name below the per-user root, which names no process. */
+const SHARED_STORE = "shared";
+/** Whether a process with this id exists, as far as this process can tell. */
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        // EPERM: it exists and belongs to another user.
+        return error.code === "EPERM";
+    }
+}
+
+export { openTtscTransformSession };
+//# sourceMappingURL=openTtscTransformSession.mjs.map

package/lib/core/transform/session/openTtscTransformSession.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"openTtscTransformSession.mjs","sources":["../../../../src/core/transform/session/openTtscTransformSession.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CG;SACa,wBAAwB,GAAA;AACtC,IAAA,MAAM,SAAS,GAAG,wBAAwB,EAAE;AAC5C,IAAA,IAAI,SAAS,KAAK,SAAS,EAAE;AAC3B,QAAA,OAAO,SAAS;IAClB;AACA,IAAA,IAAI;AACF,QAAA,MAAM,IAAI,GAAG,kBAAkB,EAAE;QACjC,IAAI,IAAI,KAAK,SAAS;AAAE,YAAA,OAAO,SAAS;QACxC,KAAK,MAAM,KAAK,IAAI,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE;YACxC,MAAM,KAAK,GAAG,0CAA0C,CAAC,IAAI,CAAC,KAAK,CAAC;AACpE,YAAA,MAAM,KAAK,GAAG,KAAK,KAAK,IAAI,GAAG,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAC3D,IACE,KAAK,KAAK,SAAS;AACnB,gBAAA,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC;AAC3B,gBAAA,CAAC,YAAY,CAAC,KAAK,CAAC,EACpB;gBACA,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;YACrE;QACF;AACA,QAAA,MAAM,KAAK,GAAG,kBAAkB,CAAC,YAAY,CAAC;QAC9C,IAAI,KAAK,KAAK,SAAS;AAAE,YAAA,OAAO,SAAS;AACzC,QAAA,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC,GAAG,KAAK;AAC/C,QAAA,OAAO,KAAK;IACd;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,SAAS;IAClB;AACF;AAEA;AACA,MAAM,YAAY,GAAG,QAAQ;AAE7B;AACA,SAAS,YAAY,CAAC,GAAW,EAAA;AAC/B,IAAA,IAAI;AACF,QAAA,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;AACpB,QAAA,OAAO,IAAI;IACb;IAAE,OAAO,KAAK,EAAE;;AAEd,QAAA,OAAQ,KAA+B,CAAC,IAAI,KAAK,OAAO;IAC1D;AACF;;;;"}

package/lib/core/transform/session/readTtscTransformSession.d.cts

@@ -0,0 +1,20 @@
+/**
+ * The shared compile store of the pooled host session this process belongs to,
+ * or `undefined` when there is none (samchon/ttsc#1390).
+ *
+ * A worker reads {@link TTSC_TRANSFORM_SESSION_ENV}, inherited from the process
+ * that configured the pool. The value counts only as an absolute path to an
+ * stat-classified directory. Missing or failed metadata leaves the worker
+ * compiling for itself; acceptance here proves neither write permissions nor
+ * continued existence, capacity or valid publication contents.
+ *
+ * @evidence contracts/common.md#principled-implementation The reader accepts only an absolute address whose current native stat reports a directory. Absent/failed metadata withdraws optional sharing; store claiming separately handles publication access, and this observation does not certify future availability or writability.
+ * @evidence contracts/common.md#clear-and-simple-design The reader validates one environment value without opening stores, creating directories, or changing the caller's environment.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Failure withdraws only optional sharing and never fabricates a publication or compiler success.
+ * @evidence contracts/common.md#meaningful-documentation The comment identifies the inherited capability and precise absence behavior, including the reason failure is nonfatal.
+ * @evidence contracts/portability.md#os-neutral-implementation Node native isAbsolute and stat interpret the inherited store address, preserving drive and root forms; an unavailable directory withdraws optional sharing rather than assuming a fixed OS storage layout.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources statSync returns before the function does; no handle is retained.
+ * @evidence contracts/performance.md#efficient-algorithms One environment value is checked with native absolute-path grammar before at most one following stat. Native pathname resolution and filesystem access are part of that cost; syscall count does not bound their duration. No directory listing, record parse or output population is constructed.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Re-read per call because the environment can change; the shared store itself is the reuse.
+ */
+export declare function readTtscTransformSession(): string | undefined;

package/lib/core/transform/session/readTtscTransformSession.d.mts

@@ -0,0 +1,20 @@
+/**
+ * The shared compile store of the pooled host session this process belongs to,
+ * or `undefined` when there is none (samchon/ttsc#1390).
+ *
+ * A worker reads {@link TTSC_TRANSFORM_SESSION_ENV}, inherited from the process
+ * that configured the pool. The value counts only as an absolute path to an
+ * stat-classified directory. Missing or failed metadata leaves the worker
+ * compiling for itself; acceptance here proves neither write permissions nor
+ * continued existence, capacity or valid publication contents.
+ *
+ * @evidence contracts/common.md#principled-implementation The reader accepts only an absolute address whose current native stat reports a directory. Absent/failed metadata withdraws optional sharing; store claiming separately handles publication access, and this observation does not certify future availability or writability.
+ * @evidence contracts/common.md#clear-and-simple-design The reader validates one environment value without opening stores, creating directories, or changing the caller's environment.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Failure withdraws only optional sharing and never fabricates a publication or compiler success.
+ * @evidence contracts/common.md#meaningful-documentation The comment identifies the inherited capability and precise absence behavior, including the reason failure is nonfatal.
+ * @evidence contracts/portability.md#os-neutral-implementation Node native isAbsolute and stat interpret the inherited store address, preserving drive and root forms; an unavailable directory withdraws optional sharing rather than assuming a fixed OS storage layout.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources statSync returns before the function does; no handle is retained.
+ * @evidence contracts/performance.md#efficient-algorithms One environment value is checked with native absolute-path grammar before at most one following stat. Native pathname resolution and filesystem access are part of that cost; syscall count does not bound their duration. No directory listing, record parse or output population is constructed.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Re-read per call because the environment can change; the shared store itself is the reuse.
+ */
+export declare function readTtscTransformSession(): string | undefined;

package/lib/core/transform/session/readTtscTransformSession.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The shared compile store of the pooled host session this process belongs to,
+ * or `undefined` when there is none (samchon/ttsc#1390).
+ *
+ * A worker reads {@link TTSC_TRANSFORM_SESSION_ENV}, inherited from the process
+ * that configured the pool. The value counts only as an absolute path to an
+ * stat-classified directory. Missing or failed metadata leaves the worker
+ * compiling for itself; acceptance here proves neither write permissions nor
+ * continued existence, capacity or valid publication contents.
+ *
+ * @evidence contracts/common.md#principled-implementation The reader accepts only an absolute address whose current native stat reports a directory. Absent/failed metadata withdraws optional sharing; store claiming separately handles publication access, and this observation does not certify future availability or writability.
+ * @evidence contracts/common.md#clear-and-simple-design The reader validates one environment value without opening stores, creating directories, or changing the caller's environment.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Failure withdraws only optional sharing and never fabricates a publication or compiler success.
+ * @evidence contracts/common.md#meaningful-documentation The comment identifies the inherited capability and precise absence behavior, including the reason failure is nonfatal.
+ * @evidence contracts/portability.md#os-neutral-implementation Node native isAbsolute and stat interpret the inherited store address, preserving drive and root forms; an unavailable directory withdraws optional sharing rather than assuming a fixed OS storage layout.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources statSync returns before the function does; no handle is retained.
+ * @evidence contracts/performance.md#efficient-algorithms One environment value is checked with native absolute-path grammar before at most one following stat. Native pathname resolution and filesystem access are part of that cost; syscall count does not bound their duration. No directory listing, record parse or output population is constructed.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Re-read per call because the environment can change; the shared store itself is the reuse.
+ */
+export declare function readTtscTransformSession(): string | undefined;

package/lib/core/transform/session/readTtscTransformSession.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var fs = require('node:fs');
+var path = require('node:path');
+var TTSC_TRANSFORM_SESSION_ENV = require('./TTSC_TRANSFORM_SESSION_ENV.js');
+
+/**
+ * The shared compile store of the pooled host session this process belongs to,
+ * or `undefined` when there is none (samchon/ttsc#1390).
+ *
+ * A worker reads {@link TTSC_TRANSFORM_SESSION_ENV}, inherited from the process
+ * that configured the pool. The value counts only as an absolute path to an
+ * stat-classified directory. Missing or failed metadata leaves the worker
+ * compiling for itself; acceptance here proves neither write permissions nor
+ * continued existence, capacity or valid publication contents.
+ *
+ * @evidence contracts/common.md#principled-implementation The reader accepts only an absolute address whose current native stat reports a directory. Absent/failed metadata withdraws optional sharing; store claiming separately handles publication access, and this observation does not certify future availability or writability.
+ * @evidence contracts/common.md#clear-and-simple-design The reader validates one environment value without opening stores, creating directories, or changing the caller's environment.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Failure withdraws only optional sharing and never fabricates a publication or compiler success.
+ * @evidence contracts/common.md#meaningful-documentation The comment identifies the inherited capability and precise absence behavior, including the reason failure is nonfatal.
+ * @evidence contracts/portability.md#os-neutral-implementation Node native isAbsolute and stat interpret the inherited store address, preserving drive and root forms; an unavailable directory withdraws optional sharing rather than assuming a fixed OS storage layout.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources statSync returns before the function does; no handle is retained.
+ * @evidence contracts/performance.md#efficient-algorithms One environment value is checked with native absolute-path grammar before at most one following stat. Native pathname resolution and filesystem access are part of that cost; syscall count does not bound their duration. No directory listing, record parse or output population is constructed.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Re-read per call because the environment can change; the shared store itself is the reuse.
+ */
+function readTtscTransformSession() {
+    const directory = process.env[TTSC_TRANSFORM_SESSION_ENV.TTSC_TRANSFORM_SESSION_ENV];
+    if (directory === undefined || !path.isAbsolute(directory)) {
+        return undefined;
+    }
+    try {
+        return fs.statSync(directory).isDirectory() ? directory : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+
+exports.readTtscTransformSession = readTtscTransformSession;
+//# sourceMappingURL=readTtscTransformSession.js.map

package/lib/core/transform/session/readTtscTransformSession.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readTtscTransformSession.js","sources":["../../../../src/core/transform/session/readTtscTransformSession.ts"],"sourcesContent":[null],"names":["TTSC_TRANSFORM_SESSION_ENV"],"mappings":";;;;;;AAKA;;;;;;;;;;;;;;;;;;AAkBG;SACa,wBAAwB,GAAA;IACtC,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAACA,qDAA0B,CAAC;AACzD,IAAA,IAAI,SAAS,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE;AAC1D,QAAA,OAAO,SAAS;IAClB;AACA,IAAA,IAAI;AACF,QAAA,OAAO,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,GAAG,SAAS,GAAG,SAAS;IACrE;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,SAAS;IAClB;AACF;;;;"}

package/lib/core/transform/session/readTtscTransformSession.mjs

@@ -0,0 +1,38 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { TTSC_TRANSFORM_SESSION_ENV } from './TTSC_TRANSFORM_SESSION_ENV.mjs';
+
+/**
+ * The shared compile store of the pooled host session this process belongs to,
+ * or `undefined` when there is none (samchon/ttsc#1390).
+ *
+ * A worker reads {@link TTSC_TRANSFORM_SESSION_ENV}, inherited from the process
+ * that configured the pool. The value counts only as an absolute path to an
+ * stat-classified directory. Missing or failed metadata leaves the worker
+ * compiling for itself; acceptance here proves neither write permissions nor
+ * continued existence, capacity or valid publication contents.
+ *
+ * @evidence contracts/common.md#principled-implementation The reader accepts only an absolute address whose current native stat reports a directory. Absent/failed metadata withdraws optional sharing; store claiming separately handles publication access, and this observation does not certify future availability or writability.
+ * @evidence contracts/common.md#clear-and-simple-design The reader validates one environment value without opening stores, creating directories, or changing the caller's environment.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Failure withdraws only optional sharing and never fabricates a publication or compiler success.
+ * @evidence contracts/common.md#meaningful-documentation The comment identifies the inherited capability and precise absence behavior, including the reason failure is nonfatal.
+ * @evidence contracts/portability.md#os-neutral-implementation Node native isAbsolute and stat interpret the inherited store address, preserving drive and root forms; an unavailable directory withdraws optional sharing rather than assuming a fixed OS storage layout.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources statSync returns before the function does; no handle is retained.
+ * @evidence contracts/performance.md#efficient-algorithms One environment value is checked with native absolute-path grammar before at most one following stat. Native pathname resolution and filesystem access are part of that cost; syscall count does not bound their duration. No directory listing, record parse or output population is constructed.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Re-read per call because the environment can change; the shared store itself is the reuse.
+ */
+function readTtscTransformSession() {
+    const directory = process.env[TTSC_TRANSFORM_SESSION_ENV];
+    if (directory === undefined || !path.isAbsolute(directory)) {
+        return undefined;
+    }
+    try {
+        return fs.statSync(directory).isDirectory() ? directory : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+
+export { readTtscTransformSession };
+//# sourceMappingURL=readTtscTransformSession.mjs.map

package/lib/core/transform/session/readTtscTransformSession.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"readTtscTransformSession.mjs","sources":["../../../../src/core/transform/session/readTtscTransformSession.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAKA;;;;;;;;;;;;;;;;;;AAkBG;SACa,wBAAwB,GAAA;IACtC,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC;AACzD,IAAA,IAAI,SAAS,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE;AAC1D,QAAA,OAAO,SAAS;IAClB;AACA,IAAA,IAAI;AACF,QAAA,OAAO,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,GAAG,SAAS,GAAG,SAAS;IACrE;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,SAAS;IAClB;AACF;;;;"}

package/lib/core/transform/session/shareTtscTransformCache.d.cts

@@ -0,0 +1,23 @@
+import type { TtscTransformCache } from "../cache/TtscTransformCache.cjs";
+/**
+ * Let `cache` share whole-project compiles with the other processes of a pooled
+ * host session through `session` (samchon/ttsc#1390).
+ *
+ * A pooled adapter, such as the Turbopack loader or the Metro transformer,
+ * calls this once per worker with {@link readTtscTransformSession}'s answer. The
+ * cache then takes a generation that another worker of the session compiled
+ * from the same project state, once it has proven that state itself, instead of
+ * compiling the whole project again. `undefined` withdraws the declaration.
+ *
+ * @param cache The worker's transform cache.
+ * @param session The session's shared compile store, or `undefined`.
+ * @evidence contracts/common.md#principled-implementation Cache identity keys the session declaration, and undefined removes it, so sharing applies only to the declared worker cache.
+ * @evidence contracts/common.md#clear-and-simple-design One WeakMap update declares the capability; actual claiming and adoption proof remain in their owning operations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The declaration does not treat cached output as proven or patch the cache's methods.
+ * @evidence contracts/common.md#meaningful-documentation The native comment explains pooled-worker usage, later proof, and explicit withdrawal rather than suggesting immediate adoption.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The association retains one current store-address string per cache without keeping its object key alive. Set replaces the old value and undefined deletes it; address bytes have no cap. Withdrawal releases only this declaration, not native store files or another owner's session lifecycle.
+ * @evidence contracts/performance.md#efficient-algorithms One object-keyed WeakMap set or delete changes the association without scanning cache generations or store contents. The address string is retained unchanged rather than parsed or hashed here; this operation performs no native I/O.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This update declares which store a cache may consult. claimSharedCompile owns store claiming, while captureTransformGeneration owns publication adoption proof; storing the address supplies no completed compile or filesystem validity certificate.
+ * @evidence contracts/portability.md#os-neutral-implementation The caller supplies the session's native store address, commonly through readTtscTransformSession's absolute-directory check. This boundary preserves that address unchanged and withdraws undefined; actual interpretation, availability and process publication handling belong to the store owner. It guesses no platform path or directory capacity and does not validate a custom address here.
+ */
+export declare function shareTtscTransformCache(cache: TtscTransformCache, session: string | undefined): void;

package/lib/core/transform/session/shareTtscTransformCache.d.mts

@@ -0,0 +1,23 @@
+import type { TtscTransformCache } from "../cache/TtscTransformCache.mjs";
+/**
+ * Let `cache` share whole-project compiles with the other processes of a pooled
+ * host session through `session` (samchon/ttsc#1390).
+ *
+ * A pooled adapter, such as the Turbopack loader or the Metro transformer,
+ * calls this once per worker with {@link readTtscTransformSession}'s answer. The
+ * cache then takes a generation that another worker of the session compiled
+ * from the same project state, once it has proven that state itself, instead of
+ * compiling the whole project again. `undefined` withdraws the declaration.
+ *
+ * @param cache The worker's transform cache.
+ * @param session The session's shared compile store, or `undefined`.
+ * @evidence contracts/common.md#principled-implementation Cache identity keys the session declaration, and undefined removes it, so sharing applies only to the declared worker cache.
+ * @evidence contracts/common.md#clear-and-simple-design One WeakMap update declares the capability; actual claiming and adoption proof remain in their owning operations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The declaration does not treat cached output as proven or patch the cache's methods.
+ * @evidence contracts/common.md#meaningful-documentation The native comment explains pooled-worker usage, later proof, and explicit withdrawal rather than suggesting immediate adoption.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The association retains one current store-address string per cache without keeping its object key alive. Set replaces the old value and undefined deletes it; address bytes have no cap. Withdrawal releases only this declaration, not native store files or another owner's session lifecycle.
+ * @evidence contracts/performance.md#efficient-algorithms One object-keyed WeakMap set or delete changes the association without scanning cache generations or store contents. The address string is retained unchanged rather than parsed or hashed here; this operation performs no native I/O.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This update declares which store a cache may consult. claimSharedCompile owns store claiming, while captureTransformGeneration owns publication adoption proof; storing the address supplies no completed compile or filesystem validity certificate.
+ * @evidence contracts/portability.md#os-neutral-implementation The caller supplies the session's native store address, commonly through readTtscTransformSession's absolute-directory check. This boundary preserves that address unchanged and withdraws undefined; actual interpretation, availability and process publication handling belong to the store owner. It guesses no platform path or directory capacity and does not validate a custom address here.
+ */
+export declare function shareTtscTransformCache(cache: TtscTransformCache, session: string | undefined): void;

package/lib/core/transform/session/shareTtscTransformCache.d.ts

@@ -0,0 +1,23 @@
+import type { TtscTransformCache } from "../cache/TtscTransformCache";
+/**
+ * Let `cache` share whole-project compiles with the other processes of a pooled
+ * host session through `session` (samchon/ttsc#1390).
+ *
+ * A pooled adapter, such as the Turbopack loader or the Metro transformer,
+ * calls this once per worker with {@link readTtscTransformSession}'s answer. The
+ * cache then takes a generation that another worker of the session compiled
+ * from the same project state, once it has proven that state itself, instead of
+ * compiling the whole project again. `undefined` withdraws the declaration.
+ *
+ * @param cache The worker's transform cache.
+ * @param session The session's shared compile store, or `undefined`.
+ * @evidence contracts/common.md#principled-implementation Cache identity keys the session declaration, and undefined removes it, so sharing applies only to the declared worker cache.
+ * @evidence contracts/common.md#clear-and-simple-design One WeakMap update declares the capability; actual claiming and adoption proof remain in their owning operations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The declaration does not treat cached output as proven or patch the cache's methods.
+ * @evidence contracts/common.md#meaningful-documentation The native comment explains pooled-worker usage, later proof, and explicit withdrawal rather than suggesting immediate adoption.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The association retains one current store-address string per cache without keeping its object key alive. Set replaces the old value and undefined deletes it; address bytes have no cap. Withdrawal releases only this declaration, not native store files or another owner's session lifecycle.
+ * @evidence contracts/performance.md#efficient-algorithms One object-keyed WeakMap set or delete changes the association without scanning cache generations or store contents. The address string is retained unchanged rather than parsed or hashed here; this operation performs no native I/O.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This update declares which store a cache may consult. claimSharedCompile owns store claiming, while captureTransformGeneration owns publication adoption proof; storing the address supplies no completed compile or filesystem validity certificate.
+ * @evidence contracts/portability.md#os-neutral-implementation The caller supplies the session's native store address, commonly through readTtscTransformSession's absolute-directory check. This boundary preserves that address unchanged and withdraws undefined; actual interpretation, availability and process publication handling belong to the store owner. It guesses no platform path or directory capacity and does not validate a custom address here.
+ */
+export declare function shareTtscTransformCache(cache: TtscTransformCache, session: string | undefined): void;

package/lib/core/transform/session/shareTtscTransformCache.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var TRANSFORM_CACHE_SESSIONS = require('./TRANSFORM_CACHE_SESSIONS.js');
+
+/**
+ * Let `cache` share whole-project compiles with the other processes of a pooled
+ * host session through `session` (samchon/ttsc#1390).
+ *
+ * A pooled adapter, such as the Turbopack loader or the Metro transformer,
+ * calls this once per worker with {@link readTtscTransformSession}'s answer. The
+ * cache then takes a generation that another worker of the session compiled
+ * from the same project state, once it has proven that state itself, instead of
+ * compiling the whole project again. `undefined` withdraws the declaration.
+ *
+ * @param cache The worker's transform cache.
+ * @param session The session's shared compile store, or `undefined`.
+ * @evidence contracts/common.md#principled-implementation Cache identity keys the session declaration, and undefined removes it, so sharing applies only to the declared worker cache.
+ * @evidence contracts/common.md#clear-and-simple-design One WeakMap update declares the capability; actual claiming and adoption proof remain in their owning operations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The declaration does not treat cached output as proven or patch the cache's methods.
+ * @evidence contracts/common.md#meaningful-documentation The native comment explains pooled-worker usage, later proof, and explicit withdrawal rather than suggesting immediate adoption.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The association retains one current store-address string per cache without keeping its object key alive. Set replaces the old value and undefined deletes it; address bytes have no cap. Withdrawal releases only this declaration, not native store files or another owner's session lifecycle.
+ * @evidence contracts/performance.md#efficient-algorithms One object-keyed WeakMap set or delete changes the association without scanning cache generations or store contents. The address string is retained unchanged rather than parsed or hashed here; this operation performs no native I/O.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This update declares which store a cache may consult. claimSharedCompile owns store claiming, while captureTransformGeneration owns publication adoption proof; storing the address supplies no completed compile or filesystem validity certificate.
+ * @evidence contracts/portability.md#os-neutral-implementation The caller supplies the session's native store address, commonly through readTtscTransformSession's absolute-directory check. This boundary preserves that address unchanged and withdraws undefined; actual interpretation, availability and process publication handling belong to the store owner. It guesses no platform path or directory capacity and does not validate a custom address here.
+ */
+function shareTtscTransformCache(cache, session) {
+    if (session === undefined)
+        TRANSFORM_CACHE_SESSIONS.TRANSFORM_CACHE_SESSIONS.delete(cache);
+    else
+        TRANSFORM_CACHE_SESSIONS.TRANSFORM_CACHE_SESSIONS.set(cache, session);
+}
+
+exports.shareTtscTransformCache = shareTtscTransformCache;
+//# sourceMappingURL=shareTtscTransformCache.js.map

package/lib/core/transform/session/shareTtscTransformCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shareTtscTransformCache.js","sources":["../../../../src/core/transform/session/shareTtscTransformCache.ts"],"sourcesContent":[null],"names":["TRANSFORM_CACHE_SESSIONS"],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,uBAAuB,CACrC,KAAyB,EACzB,OAA2B,EAAA;IAE3B,IAAI,OAAO,KAAK,SAAS;AAAE,QAAAA,iDAAwB,CAAC,MAAM,CAAC,KAAK,CAAC;;AAC5D,QAAAA,iDAAwB,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC;AACnD;;;;"}

package/lib/core/transform/session/shareTtscTransformCache.mjs

@@ -0,0 +1,32 @@
+import { TRANSFORM_CACHE_SESSIONS } from './TRANSFORM_CACHE_SESSIONS.mjs';
+
+/**
+ * Let `cache` share whole-project compiles with the other processes of a pooled
+ * host session through `session` (samchon/ttsc#1390).
+ *
+ * A pooled adapter, such as the Turbopack loader or the Metro transformer,
+ * calls this once per worker with {@link readTtscTransformSession}'s answer. The
+ * cache then takes a generation that another worker of the session compiled
+ * from the same project state, once it has proven that state itself, instead of
+ * compiling the whole project again. `undefined` withdraws the declaration.
+ *
+ * @param cache The worker's transform cache.
+ * @param session The session's shared compile store, or `undefined`.
+ * @evidence contracts/common.md#principled-implementation Cache identity keys the session declaration, and undefined removes it, so sharing applies only to the declared worker cache.
+ * @evidence contracts/common.md#clear-and-simple-design One WeakMap update declares the capability; actual claiming and adoption proof remain in their owning operations.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The declaration does not treat cached output as proven or patch the cache's methods.
+ * @evidence contracts/common.md#meaningful-documentation The native comment explains pooled-worker usage, later proof, and explicit withdrawal rather than suggesting immediate adoption.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The association retains one current store-address string per cache without keeping its object key alive. Set replaces the old value and undefined deletes it; address bytes have no cap. Withdrawal releases only this declaration, not native store files or another owner's session lifecycle.
+ * @evidence contracts/performance.md#efficient-algorithms One object-keyed WeakMap set or delete changes the association without scanning cache generations or store contents. The address string is retained unchanged rather than parsed or hashed here; this operation performs no native I/O.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This update declares which store a cache may consult. claimSharedCompile owns store claiming, while captureTransformGeneration owns publication adoption proof; storing the address supplies no completed compile or filesystem validity certificate.
+ * @evidence contracts/portability.md#os-neutral-implementation The caller supplies the session's native store address, commonly through readTtscTransformSession's absolute-directory check. This boundary preserves that address unchanged and withdraws undefined; actual interpretation, availability and process publication handling belong to the store owner. It guesses no platform path or directory capacity and does not validate a custom address here.
+ */
+function shareTtscTransformCache(cache, session) {
+    if (session === undefined)
+        TRANSFORM_CACHE_SESSIONS.delete(cache);
+    else
+        TRANSFORM_CACHE_SESSIONS.set(cache, session);
+}
+
+export { shareTtscTransformCache };
+//# sourceMappingURL=shareTtscTransformCache.mjs.map

package/lib/core/transform/session/shareTtscTransformCache.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"shareTtscTransformCache.mjs","sources":["../../../../src/core/transform/session/shareTtscTransformCache.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,uBAAuB,CACrC,KAAyB,EACzB,OAA2B,EAAA;IAE3B,IAAI,OAAO,KAAK,SAAS;AAAE,QAAA,wBAAwB,CAAC,MAAM,CAAC,KAAK,CAAC;;AAC5D,QAAA,wBAAwB,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC;AACnD;;;;"}