@ttsc/unplugin 0.30.4 → 0.31.1

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

@@ -0,0 +1,522 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+
+/** How often a lock holder proves it is still working. */
+const HEARTBEAT_MS = 1_000;
+/**
+ * How long a lock may go without a heartbeat before a waiter takes it over. A
+ * holder whose process died is detected at once through its pid. This bound
+ * covers a pid that was reused, and a holder that cannot run at all.
+ */
+const ABANDONED_MS = 15_000;
+/** Longest pause between two looks at the store while another worker holds it. */
+const MAX_WAIT_MS = 250;
+/** Publications kept per compile identity, most recently used first. */
+const KEPT_PUBLICATIONS = 4;
+/**
+ * Publications kept in the whole store, most recently used first. The store
+ * outlives every process (samchon/ttsc#1483), so without a bound it would keep
+ * every identity a project ever had, those of an older ttsc among them, which
+ * can never be adopted again.
+ */
+const KEPT_STORE_PUBLICATIONS = 32;
+/** Maximum publication bytes retained by the shared store after pruning. */
+const KEPT_STORE_BYTES = 256 * 1024 * 1024;
+/**
+ * Ask the session store for the compile named `identity` and `state`: another
+ * worker's publication, or the lock to compile it here (samchon/ttsc#1390).
+ *
+ * `identity` encodes reported compile configuration and `state` a supplied
+ * project-input projection. Neither key alone certifies a publication. The
+ * first worker to need a pair takes its lock by creating a directory, which the
+ * filesystem makes atomic. The others wait without blocking the event loop, and
+ * adopt the publication the holder leaves behind. When the holder releases the
+ * lock without publishing, the next waiter takes the lock instead. A holder
+ * whose process has died, or whose heartbeat stopped, can lose the lock to a
+ * waiter. Waiting has no total deadline or cancellation; progress still depends
+ * on native operations and successful reclamation.
+ *
+ * The store outlives the processes that use it (samchon/ttsc#1483), so it
+ * best-effort prunes itself: an adoption marks its publication used, and each
+ * publication keeps the most recently used ones of its identity within the
+ * store's count and byte budgets, and removes locks and partial writes whose
+ * writer is gone. A publication larger than the byte budget stays in the
+ * compiling worker; it cannot be shared without making persistent storage
+ * unbounded.
+ *
+ * Sharing is only an optimization. An unreadable or unusable publication is
+ * ignored and a worker may claim its own compile. An escaping claim error
+ * answers `undefined`; publishing and cleanup failures are suppressed without
+ * certifying persistence. The caller retains local compilation. With `adopt:
+ * false` the caller has already found a publication wanting and compiles
+ * regardless, but still under the lock, so its compile replaces the publication
+ * for the waiters. A rejectedPublication excludes only that serialized payload:
+ * another worker's replacement under the same projected state remains eligible
+ * for independent adoption proof. The digest is computed from the already read
+ * UTF-8 publication, without another filesystem query.
+ *
+ * Its place in the adapter's invalidation model, and the units beside it, are
+ * mapped in the maintainer page
+ * `website/src/content/docs/development/reference/unplugin-invalidation.mdx`.
+ *
+ * @param store The session's shared compile store.
+ * @param identity Caller-provided hex configuration digest used in store names.
+ * @param state Caller-provided hex project-state digest used in store names.
+ * @param options.adopt Whether an existing publication may be adopted.
+ * @param options.rejectedPublication Digest of the exact previously refuted
+ *   payload; a replacement still requires the caller's full proof.
+ * @evidence contracts/common.md#principled-implementation
+ *   Filesystem directory creation coordinates independent workers, and owned
+ *   tokens distinguish a claim from another holder at the same pathname.
+ *
+ * @evidence contracts/common.md#clear-and-simple-design
+ *   One identity/state claim selects adoption or compile ownership. Private
+ *   helpers separate lock coordination, publication, and bounded retention;
+ *   filesystem failure leaves the caller's local compile path available.
+ *
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts
+ *   The optional store preserves a local compile path when sharing is
+ *   unavailable rather than changing compile semantics; it uses native APIs
+ *   without replacing foreign methods.
+ *
+ * @evidence contracts/common.md#meaningful-documentation
+ *   JSDoc explains why the store is optional, what identity and state name,
+ *   how waiting and abandonment differ, and why retained publications need
+ *   bounds. Purpose and reasons use separate native paragraphs under the
+ *   documentation skill; claim and publication interfaces retain their value
+ *   documentation.
+ *
+ * @evidence contracts/portability.md#os-neutral-implementation
+ *   Node native paths and filesystem operations own store publication. The
+ *   implementation has a Windows replacement path because an open destination
+ *   may refuse rename; this does not make its ownership checks atomic. The
+ *   remaining pathname-check and replacement windows are recorded for
+ *   investigation rather than asserted OS-safe.
+ *
+ * @evidence contracts/performance.md#efficient-algorithms
+ *   Each waiting iteration may reread and parse all publication bytes, inspect
+ *   envelope fields, probe lock metadata/token/process state and reclaim a
+ *   subtree. Backoff intervals are capped, not iteration count or total time.
+ *   Each valid read additionally hashes its serialized UTF-8 payload in O(bytes)
+ *   time for attempt-local refutation identity. This is not an input proof.
+ *   Publishing serializes the full payload before its UTF8 byte-budget check.
+ *   Pruning materializes all N store names, launches concurrent stats for J
+ *   JSON entries, sorts J last-use observations and scans names again for
+ *   abandoned state. Text comparisons, encoded bytes, native IO and removed
+ *   descendants contribute beyond entry counts; transient state includes full
+ *   publication text/value and O(N+J) lists/promises. Independent processes
+ *   share the inventory, so a process-local index cannot establish its contents.
+ *
+ * @evidence contracts/performance.md#reuse-equivalent-work
+ *   The supplied identity/state pair coordinates in-flight ownership and
+ *   retained publication lookup. Shape checks reject unusable envelopes but
+ *   do not prove inputs; the producer and adopter supply separate stability,
+ *   completeness and current-state proofs. Caller adopt=false bypasses lookup
+ *   while retaining locking. Repeated claims still reread publication/lock
+ *   state; failed or oversized persistence leaves later workers compiling.
+ *
+ * @evidence contracts/performance.md#bound-retention-and-release-resources
+ *   A publication over 256 MiB is not persisted. Each successful publication
+ *   best-effort prunes to four files per identity, 32 store-wide and 256 MiB of
+ *   publication bytes. Concurrent writes, failed removals or failed pruning
+ *   can leave limits exceeded until a later successful prune. Limits do not
+ *   bound live locks, partial-write bytes, waiting claims or concurrent IO.
+ *   A compile claim transfers its unref'd heartbeat and lock to the caller,
+ *   whose release clears the timer and best-effort removes an owned lock;
+ *   publishing alone does not release it. Later prunes reclaim abandoned locks
+ *   and departed-writer partial files. Owner checks followed by pathname IO
+ *   remain non-atomic, including asynchronous heartbeat touches.
+ */
+async function claimSharedCompile(store, identity, state, options) {
+    const name = `${identity}-${state}`;
+    const publication = path.join(store, `${name}.json`);
+    const lock = path.join(store, `${name}.lock`);
+    let wait = 20;
+    try {
+        for (;;) {
+            if (options.adopt) {
+                const published = await readPublication(publication);
+                if (published !== undefined &&
+                    published.fingerprint !== options.rejectedPublication) {
+                    await markUsed(publication);
+                    return {
+                        kind: "adopt",
+                        publication: published.value,
+                        fingerprint: published.fingerprint,
+                    };
+                }
+            }
+            const token = await acquire(lock);
+            if (token !== undefined) {
+                const claim = holdLock(store, identity, publication, lock, token);
+                if (options.adopt) {
+                    // A holder may have published and released between the read above
+                    // and the lock.
+                    const published = await readPublication(publication);
+                    if (published !== undefined &&
+                        published.fingerprint !== options.rejectedPublication) {
+                        claim.release();
+                        await markUsed(publication);
+                        return {
+                            kind: "adopt",
+                            publication: published.value,
+                            fingerprint: published.fingerprint,
+                        };
+                    }
+                }
+                return claim;
+            }
+            const stale = await abandoned(lock);
+            if (stale !== undefined) {
+                await reclaim(lock, stale);
+                continue;
+            }
+            await new Promise((resolve) => setTimeout(resolve, wait));
+            wait = Math.min(wait * 2, MAX_WAIT_MS);
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Take the lock and return this claim's owner token, or `undefined` when
+ * another worker holds it. The token lets a release tell its own lock from one
+ * a waiter took over after this holder's heartbeat went stale.
+ */
+async function acquire(lock) {
+    try {
+        await fs.promises.mkdir(lock);
+    }
+    catch (error) {
+        if (error.code === "EEXIST")
+            return undefined;
+        throw error;
+    }
+    const token = `${process.pid}:${crypto.randomUUID()}`;
+    try {
+        await fs.promises.writeFile(path.join(lock, "owner"), token);
+    }
+    catch (error) {
+        fs.rmSync(lock, { force: true, recursive: true });
+        throw error;
+    }
+    return token;
+}
+/**
+ * The owner token of `lock` when its holder is gone or has stopped working, or
+ * `undefined` when the lock is live or released. A stale lock whose holder
+ * never named itself answers the empty token.
+ */
+async function abandoned(lock) {
+    let modified;
+    try {
+        modified = (await fs.promises.stat(lock)).mtimeMs;
+    }
+    catch {
+        // Released meanwhile: not abandoned, and the next loop takes it.
+        return undefined;
+    }
+    let token;
+    try {
+        token = await fs.promises.readFile(path.join(lock, "owner"), "utf8");
+    }
+    catch {
+        // The holder is between creating the lock and naming itself, unless it
+        // stopped there.
+        return Date.now() - modified > ABANDONED_MS ? "" : undefined;
+    }
+    if (Date.now() - modified > ABANDONED_MS)
+        return token;
+    return processGone(Number.parseInt(token, 10)) ? token : undefined;
+}
+/**
+ * Take an abandoned lock away from its holder, and only that holder's.
+ *
+ * Removing the path would remove whatever lock is there by then, and two
+ * reclaimers that saw the same abandoned holder would each remove the other's
+ * fresh lock. The lock is instead moved aside, which one reclaimer alone can
+ * do, and the moved lock's owner is compared with the one judged abandoned.
+ * When another reclaimer's fresh lock was moved instead, it is put back; if a
+ * third worker already locked the path, the moved holder has lost its lock,
+ * which its own ownership checks then find, so it neither publishes nor removes
+ * the lock that replaced it.
+ */
+async function reclaim(lock, stale) {
+    const aside = `${lock}.${process.pid}.${crypto.randomUUID()}.retired`;
+    try {
+        await fs.promises.rename(lock, aside);
+    }
+    catch {
+        // Released, or reclaimed by another waiter meanwhile.
+        return;
+    }
+    let owner;
+    try {
+        owner = await fs.promises.readFile(path.join(aside, "owner"), "utf8");
+    }
+    catch {
+        owner = "";
+    }
+    if (owner !== stale) {
+        try {
+            await fs.promises.rename(aside, lock);
+            return;
+        }
+        catch {
+            // The path was locked again meanwhile; the moved lock is lost.
+        }
+    }
+    await fs.promises
+        .rm(aside, { force: true, recursive: true })
+        .catch(() => undefined);
+}
+/** Whether this claim's token still names the holder of `lock`. */
+function owns(lock, token) {
+    try {
+        return fs.readFileSync(path.join(lock, "owner"), "utf8") === token;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Whether no process with this id exists on this machine, which the store's
+ * locks and partial writes name their writer by. An id that is not a positive
+ * integer names nothing this can tell, and counts as alive.
+ */
+function processGone(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return false;
+    }
+    catch (error) {
+        return error.code === "ESRCH";
+    }
+}
+/** The claim of a worker that holds the lock. */
+function holdLock(store, identity, publication, lock, token) {
+    // Only while this claim still owns the lock: touching the path after a
+    // waiter took it over would keep the successor's lock alive in this holder's
+    // name.
+    const heartbeat = setInterval(() => {
+        if (!owns(lock, token))
+            return;
+        const now = new Date();
+        fs.promises.utimes(lock, now, now).catch(() => undefined);
+    }, HEARTBEAT_MS);
+    heartbeat.unref();
+    let released = false;
+    return {
+        kind: "compile",
+        publish: async (value) => {
+            const temporary = `${publication}.${process.pid}.${crypto.randomUUID()}.tmp`;
+            try {
+                const serialized = JSON.stringify(value);
+                if (Buffer.byteLength(serialized, "utf8") > KEPT_STORE_BYTES) {
+                    await prunePublications(store, identity);
+                    return;
+                }
+                await fs.promises.writeFile(temporary, serialized, "utf8");
+                // A holder that lost the lock while it compiled no longer speaks for
+                // the store: its successor may already have published a newer answer,
+                // which this one must not replace. Checked after the write, right
+                // before the rename, so the window a takeover can still slip into is
+                // the rename itself; an adopter proves whatever it adopts regardless.
+                if (!owns(lock, token)) {
+                    await fs.promises.rm(temporary, { force: true });
+                    return;
+                }
+                try {
+                    await fs.promises.rename(temporary, publication);
+                }
+                catch {
+                    // Windows refuses to replace a file another worker has open.
+                    await fs.promises.rm(publication, { force: true });
+                    await fs.promises.rename(temporary, publication);
+                }
+                await prunePublications(store, identity);
+            }
+            catch {
+                await fs.promises.rm(temporary, { force: true }).catch(() => undefined);
+            }
+        },
+        release: () => {
+            if (released)
+                return;
+            released = true;
+            clearInterval(heartbeat);
+            if (owns(lock, token)) {
+                try {
+                    fs.rmSync(lock, { force: true, recursive: true });
+                }
+                catch {
+                    // Cleanup is best effort: a failed removal must not prevent the
+                    // caller's independent generation resources from being released.
+                }
+            }
+        },
+    };
+}
+/**
+ * Keep the most recently used publications of `identity` within the store's
+ * count and byte budgets, and remove abandoned locks and partial writes.
+ */
+async function prunePublications(store, identity) {
+    const entries = await fs.promises.readdir(store);
+    const dated = await Promise.all(entries
+        .filter((entry) => entry.endsWith(".json"))
+        .map(async (entry) => {
+        const file = path.join(store, entry);
+        try {
+            const stat = await fs.promises.stat(file);
+            return { entry, file, size: stat.size, used: stat.mtimeMs };
+        }
+        catch {
+            return { entry, file, size: 0, used: -1 };
+        }
+    }));
+    dated.sort((left, right) => right.used - left.used);
+    const own = dated.filter(({ entry }) => entry.startsWith(`${identity}-`));
+    const removed = new Set([
+        ...own.slice(KEPT_PUBLICATIONS).map(({ file }) => file),
+        ...dated.slice(KEPT_STORE_PUBLICATIONS).map(({ file }) => file),
+    ]);
+    let keptBytes = 0;
+    for (const { file, size } of dated) {
+        if (removed.has(file))
+            continue;
+        if (size > KEPT_STORE_BYTES - keptBytes)
+            removed.add(file);
+        else
+            keptBytes += size;
+    }
+    for (const file of removed) {
+        await fs.promises.rm(file, { force: true }).catch(() => undefined);
+    }
+    for (const entry of entries) {
+        const file = path.join(store, entry);
+        const stale = entry.endsWith(".lock") ? await abandoned(file) : undefined;
+        if (stale !== undefined) {
+            await reclaim(file, stale);
+        }
+        else if (entry.endsWith(".tmp") &&
+            // A partial write outlives only a writer that died before renaming it,
+            // and its name carries the writer's process id, before the random part
+            // (`<publication>.<pid>.<uuid>.tmp`). A live writer's is left to it,
+            // however long it takes to write.
+            processGone(Number(entry.split(".").at(-3)))) {
+            await fs.promises.rm(file, { force: true }).catch(() => undefined);
+        }
+        else if (entry.endsWith(".retired") &&
+            // A lock moved aside by a reclaimer that died before removing it; the
+            // name carries that reclaimer's process id the same way.
+            processGone(Number(entry.split(".").at(-3)))) {
+            await fs.promises
+                .rm(file, { force: true, recursive: true })
+                .catch(() => undefined);
+        }
+    }
+}
+/**
+ * Mark a publication used, so the store keeps the ones its processes still
+ * adopt. Best effort: an unmarked publication is only pruned sooner.
+ */
+async function markUsed(file) {
+    const now = new Date();
+    await fs.promises.utimes(file, now, now).catch(() => undefined);
+}
+/** Read a publication, or `undefined` when it is absent or unusable. */
+async function readPublication(file) {
+    let bytes;
+    try {
+        bytes = await fs.promises.readFile(file);
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const value = JSON.parse(bytes.toString("utf8"));
+        // A compile that ended in diagnostics is published like one that
+        // succeeded (samchon/ttsc#1458); an exception never is.
+        if (!isPublicationRecord(value) ||
+            !isPublicationResult(value.result) ||
+            !isPublicationRecord(value.externalInputHashes) ||
+            !Object.values(value.externalInputHashes).every((hash) => typeof hash === "string") ||
+            !isPublicationRecord(value.externalInputRealpaths) ||
+            !Object.values(value.externalInputRealpaths).every((realpath) => realpath === null || typeof realpath === "string") ||
+            typeof value.scratchDirectory !== "string" ||
+            (value.temporaryTsconfig !== undefined &&
+                typeof value.temporaryTsconfig !== "string")) {
+            return undefined;
+        }
+        return {
+            value: value,
+            fingerprint: crypto.createHash("sha256").update(bytes).digest("hex"),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Persisted dictionary values must not be arrays or null. */
+function isPublicationRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Check the envelope fields read directly before advisory index validation. */
+function isPublicationResult(value) {
+    if (!isPublicationRecord(value) ||
+        (value.type !== "success" && value.type !== "failure") ||
+        !isPublicationRecord(value.typescript) ||
+        !Object.values(value.typescript).every((source) => typeof source === "string"))
+        return false;
+    // Neither an explicit incomplete observer nor failed per-input authority can
+    // certify cross-worker reuse. Unsupported marker shapes are not ignored.
+    if (value.observationsComplete !== undefined ||
+        (value.hostInputProofFailures !== undefined &&
+            (!isPublicationRecord(value.hostInputProofFailures) ||
+                Object.keys(value.hostInputProofFailures).length !== 0)))
+        return false;
+    if (value.diagnostics !== undefined) {
+        if (!Array.isArray(value.diagnostics) ||
+            !value.diagnostics.every((diagnostic) => isPublicationRecord(diagnostic) &&
+                typeof diagnostic.messageText === "string" &&
+                (diagnostic.file === undefined ||
+                    typeof diagnostic.file === "string") &&
+                (diagnostic.line === undefined ||
+                    typeof diagnostic.line === "number") &&
+                (diagnostic.character === undefined ||
+                    typeof diagnostic.character === "number")))
+            return false;
+    }
+    else if (value.type === "failure")
+        return false;
+    if (value.graph !== undefined && !isPublicationRecord(value.graph))
+        return false;
+    if (value.sourceMaps !== undefined &&
+        (!isPublicationRecord(value.sourceMaps) ||
+            !Object.values(value.sourceMaps).every(isPublicationSourceMap)))
+        return false;
+    return true;
+}
+/** Source maps must support the native source/provenance projection safely. */
+function isPublicationSourceMap(value) {
+    if (!isPublicationRecord(value) ||
+        value.version !== 3 ||
+        typeof value.mappings !== "string" ||
+        !Array.isArray(value.sources) ||
+        !value.sources.every((source) => typeof source === "string") ||
+        !Array.isArray(value.names) ||
+        !value.names.every((name) => typeof name === "string") ||
+        (value.sourceRoot !== undefined && typeof value.sourceRoot !== "string"))
+        return false;
+    return (value.sourcesContent === undefined ||
+        (Array.isArray(value.sourcesContent) &&
+            value.sourcesContent.every((source) => source === null || typeof source === "string")));
+}
+
+export { claimSharedCompile };
+//# sourceMappingURL=claimSharedCompile.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"claimSharedCompile.mjs","sources":["../../../../src/core/transform/session/claimSharedCompile.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

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

@@ -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.d.mts

@@ -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;