@ttsc/metro 0.19.0 → 0.19.2

package/lib/core/fingerprint.mjs

@@ -0,0 +1,441 @@
+import { isProjectWalkPath, collectProjectInputHashes, collectExternalInputHashes } from '@ttsc/unplugin/api';
+import { randomBytes, createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Project fingerprint and reference-graph snapshot for `@ttsc/metro`.
+ *
+ * Metro's transform cache keys each file on its own content plus one static
+ * transformer key computed once per run (`getCacheKey`, called on the main
+ * process at `Transformer` construction). A ttsc transform's output can depend
+ * on inputs Metro never keys: other project sources reached through type-only
+ * edges, `node_modules` declarations, monorepo sibling sources, and the
+ * tsconfig `extends` ancestry. This module folds all of them into the static
+ * key so the cache key incorporates every input that can influence a
+ * transform's output:
+ *
+ * - **Project walk.** Every input file under the fingerprint roots (Metro's
+ *   `projectRoot` plus the resolved tsconfig's directory when it lies outside),
+ *   hashed with the exact walk universe the `@ttsc/unplugin` transform core
+ *   validates its own cache against.
+ * - **Recorded out-of-walk inputs.** The transform core cannot walk files outside
+ *   the roots or under ignored directories, but the host-owned reference graph
+ *   (samchon/ttsc#718) reports them per transform. Workers record them into a
+ *   snapshot under `node_modules/.cache/ttsc-metro`; the next run's
+ *   `getCacheKey` re-hashes the recorded set.
+ *
+ * Snapshot layout: one main file carrying a random epoch id plus per-worker
+ * files with unique names, so concurrent workers never race a shared write.
+ * `withTtsc` (the single config process, before workers exist) compacts worker
+ * files into the main file. Readers take the union of every file, reading the
+ * worker files strictly before the main file: the compactor renames the merged
+ * main into place strictly before deleting a worker file, so a worker file that
+ * disappears mid-read is always already merged into the main the reader loads
+ * afterwards.
+ *
+ * Sound degradations, by design:
+ *
+ * - No readable snapshot (first run, wiped cache dir, unwritable filesystem)
+ *   folds a random nonce: that run shares no cache entries with any other run.
+ * - A recreated snapshot carries a fresh epoch id, so it can never alias a key
+ *   from an older epoch whose recorded set is unknown.
+ * - A plugin-declared volatile output (non-file inputs; unrepresentable in any
+ *   file fingerprint) marks the snapshot volatile, which also folds a nonce
+ *   until a later run records the volatile declaration gone.
+ * - A recorded input that disappears hashes as a stable `missing` marker, so
+ *   deletion and reappearance both move the key.
+ */
+/** Bumped when the snapshot JSON shape changes; mismatches read as corrupt. */
+const SNAPSHOT_VERSION = 1;
+/** Snapshot directory segments under the fingerprint base directory. */
+const SNAPSHOT_DIRECTORY = ["node_modules", ".cache", "ttsc-metro"];
+/** Main snapshot file name (epoch id + compacted recorded inputs). */
+const MAIN_SNAPSHOT = "graph-inputs.json";
+/** Worker snapshot file prefix; each worker appends a unique suffix. */
+const WORKER_SNAPSHOT_PREFIX = "graph-inputs.worker-";
+/**
+ * Resolve the base directory both fingerprint sides agree on: Metro's
+ * `projectRoot` when known (`withTtsc` reads it from the config, `getCacheKey`
+ * from Metro's cache-key options, the transformer from each file's transform
+ * options — all the same value in a real Metro run), else the working directory
+ * Metro was launched from.
+ */
+function resolveFingerprintBase(projectRoot) {
+    return path.resolve(typeof projectRoot === "string" && projectRoot.length !== 0
+        ? projectRoot
+        : process.cwd());
+}
+/**
+ * The directories whose walk universes the fingerprint hashes: the base
+ * directory, plus the resolved tsconfig's directory when the tsconfig is not
+ * already inside the base walk (an explicit out-of-root `project`, or a
+ * monorepo-root tsconfig discovered above the app). Matching the transform
+ * core's own validation universe keeps the invariant simple: everything the
+ * core treats as an input is fingerprinted, either by a walk here or by the
+ * recorded out-of-walk snapshot.
+ */
+function fingerprintRoots(base, explicitProject) {
+    const tsconfig = resolveProjectTsconfig(base, explicitProject);
+    if (isProjectWalkPath(base, tsconfig)) {
+        return [base];
+    }
+    return [base, path.dirname(tsconfig)];
+}
+/**
+ * Locate the tsconfig governing the project, mirroring the transform core's
+ * discovery: an explicit `project` resolves against the working directory;
+ * otherwise ancestor directories starting at `base` are searched for a
+ * `tsconfig.json`, falling back to `<base>/tsconfig.json`.
+ */
+function resolveProjectTsconfig(base, explicitProject) {
+    if (explicitProject !== undefined && explicitProject.length !== 0) {
+        return path.isAbsolute(explicitProject)
+            ? explicitProject
+            : path.resolve(process.cwd(), explicitProject);
+    }
+    let current = base;
+    while (true) {
+        const candidate = path.join(current, "tsconfig.json");
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return path.resolve(base, "tsconfig.json");
+}
+/**
+ * Compute the fingerprint `getCacheKey` folds into Metro's static transformer
+ * key. Never throws: any failure degrades to a nonce, which soundly disables
+ * cross-run cache reuse for this run instead of serving stale output.
+ */
+function computeProjectFingerprint(props) {
+    try {
+        const base = resolveFingerprintBase(props.projectRoot);
+        const hash = createHash("sha256");
+        for (const root of fingerprintRoots(base, props.explicitProject)) {
+            hash.update(stableStringify(collectProjectInputHashes(root)));
+        }
+        const snapshot = readSnapshotState(base);
+        if (snapshot === undefined || snapshot.volatile) {
+            hash.update(nonce());
+        }
+        else {
+            hash.update(`snapshot:${snapshot.id}`);
+            hash.update(stableStringify(collectExternalInputHashes(snapshot.files)));
+        }
+        return hash.digest("hex");
+    }
+    catch {
+        return nonce();
+    }
+}
+/**
+ * A value no other run can reproduce. Folding it means this run's cache entries
+ * are written but never reused by later runs, and this run reuses nothing from
+ * earlier ones — the sound fallback whenever the recorded out-of-walk input set
+ * is unknown or unrepresentable.
+ */
+function nonce() {
+    return `nonce:${randomBytes(32).toString("hex")}`;
+}
+/**
+ * Prepare the snapshot for a new run. Called from `withTtsc` in the single
+ * Metro config process, before any worker exists: creates the main snapshot
+ * (fresh epoch id) when missing or corrupt, compacts leftover worker files into
+ * it, and sweeps unparseable worker files plus crash-leftover temp files. An
+ * unparseable worker file's recordings are unrecoverable, so its removal mints
+ * a fresh epoch id — every key that might have depended on the lost recordings
+ * is soundly orphaned, and later runs stabilize instead of degrading to a nonce
+ * forever. Never throws — an unwritable cache directory leaves the snapshot
+ * unreadable and `getCacheKey` degrades to a nonce.
+ */
+function prepareSnapshot(projectRoot) {
+    try {
+        const base = resolveFingerprintBase(projectRoot);
+        // A nonexistent base can never be a working Metro setup (Metro verifies
+        // the project root exists), so preparing a snapshot there would only
+        // materialize directory trees at arbitrary paths.
+        if (!fs.existsSync(base)) {
+            return;
+        }
+        const directory = snapshotDirectory(base);
+        fs.mkdirSync(directory, { recursive: true });
+        // Read the worker files strictly before the main file (see the module doc
+        // comment): a concurrent compactor deletes a worker file only after the
+        // merged main is renamed into place, so whatever this enumeration misses
+        // is already inside the main read below.
+        const workers = readWorkerFiles(directory);
+        const main = readMainDocument(directory);
+        const files = new Set(main?.files ?? []);
+        const volatile = workers.entries.length === 0
+            ? (main?.volatile ?? false)
+            : // Worker files carry the previous run's fresh observations, so they
+                // own the volatile verdict: a removed volatile declaration must be
+                // able to clear the sticky flag.
+                workers.entries.some((entry) => entry.volatile);
+        for (const entry of workers.entries) {
+            for (const file of entry.files) {
+                files.add(file);
+            }
+        }
+        writeSnapshotDocument(path.join(directory, MAIN_SNAPSHOT), {
+            files: [...files].sort(),
+            id: workers.corruptPaths.length === 0
+                ? (main?.id ?? randomBytes(16).toString("hex"))
+                : randomBytes(16).toString("hex"),
+            version: SNAPSHOT_VERSION,
+            volatile,
+        });
+        for (const file of [
+            ...workers.paths,
+            ...workers.corruptPaths,
+            ...listTemporaryFiles(directory),
+        ]) {
+            try {
+                fs.rmSync(file, { force: true });
+            }
+            catch {
+                // A locked worker file stays behind; readers union it, so nothing is
+                // lost, and the next compaction retries.
+            }
+        }
+    }
+    catch {
+        // Snapshot maintenance must never break the Metro config process.
+    }
+}
+/**
+ * Crash-leftover temp files from the atomic writer, swept at compaction. Only
+ * files older than a day qualify: a young temp file may belong to a live writer
+ * in a concurrently running Metro instance, and deleting it mid-write would
+ * silently drop that writer's recordings.
+ */
+function listTemporaryFiles(directory) {
+    const horizon = Date.now() - 24 * 60 * 60 * 1000;
+    try {
+        return fs
+            .readdirSync(directory)
+            .filter((name) => name.endsWith(".tmp"))
+            .map((name) => path.join(directory, name))
+            .filter((file) => {
+            try {
+                return fs.statSync(file).mtimeMs < horizon;
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Read the unioned snapshot state, or `undefined` when the main snapshot is
+ * missing or any snapshot file is corrupt (a torn or foreign write means the
+ * recorded set cannot be trusted, so the caller degrades to a nonce).
+ */
+function readSnapshotState(base) {
+    const directory = snapshotDirectory(base);
+    // Worker files strictly before the main file — see the module doc comment.
+    const workers = readWorkerFiles(directory);
+    if (workers.corruptPaths.length !== 0) {
+        return undefined;
+    }
+    const main = readMainDocument(directory);
+    if (main === undefined || typeof main.id !== "string") {
+        return undefined;
+    }
+    const files = new Set(main.files);
+    let volatile = main.volatile;
+    for (const entry of workers.entries) {
+        for (const file of entry.files) {
+            files.add(file);
+        }
+        volatile ||= entry.volatile;
+    }
+    return { files: [...files].sort(), id: main.id, volatile };
+}
+/**
+ * Recorder held by each Metro worker. Collects the out-of-walk inputs derived
+ * for every transformed file (the plugin-reported dependencies unioned with the
+ * reference graph's reach, globals, and configs — delivered through the
+ * transform core's `addWatchFile` hook) plus any volatile declaration, and
+ * persists them to this worker's uniquely named snapshot file whenever the
+ * observed state grows. The unique name makes worker writes race-free;
+ * `withTtsc` compacts the files on the next run.
+ */
+function createSnapshotRecorder() {
+    const suffix = `${process.pid.toString(36)}-${randomBytes(6).toString("hex")}`;
+    const states = new Map();
+    function stateFor(projectRoot, explicitProject) {
+        const base = resolveFingerprintBase(projectRoot);
+        let state = states.get(base);
+        if (state === undefined) {
+            state = {
+                dirty: false,
+                files: new Set(),
+                roots: fingerprintRoots(base, explicitProject),
+                volatile: false,
+            };
+            states.set(base, state);
+        }
+        return state;
+    }
+    function flush(base, state) {
+        if (!state.dirty) {
+            return;
+        }
+        try {
+            const directory = snapshotDirectory(base);
+            fs.mkdirSync(directory, { recursive: true });
+            writeSnapshotDocument(path.join(directory, `${WORKER_SNAPSHOT_PREFIX}${suffix}.json`), {
+                files: [...state.files].sort(),
+                version: SNAPSHOT_VERSION,
+                volatile: state.volatile,
+            });
+            // Cleared only on success so a transient write failure retries on the
+            // next recording instead of silently dropping the observed state.
+            state.dirty = false;
+        }
+        catch {
+            // An unwritable snapshot leaves the main snapshot unreadable or stale;
+            // getCacheKey degrades to a nonce rather than serving stale output.
+        }
+    }
+    return {
+        record(props) {
+            const base = resolveFingerprintBase(props.projectRoot);
+            const state = stateFor(props.projectRoot, props.explicitProject);
+            const input = path.resolve(props.input);
+            if (state.files.has(input) ||
+                state.roots.some((root) => isProjectWalkPath(root, input))) {
+                return;
+            }
+            state.files.add(input);
+            state.dirty = true;
+            flush(base, state);
+        },
+        recordVolatile(props) {
+            const base = resolveFingerprintBase(props.projectRoot);
+            const state = stateFor(props.projectRoot, props.explicitProject);
+            if (state.volatile) {
+                return;
+            }
+            state.volatile = true;
+            state.dirty = true;
+            flush(base, state);
+        },
+    };
+}
+function snapshotDirectory(base) {
+    return path.join(base, ...SNAPSHOT_DIRECTORY);
+}
+/**
+ * Read every worker snapshot file in `directory`. A file that disappears
+ * mid-read was compacted (merged into the main snapshot first) and is skipped;
+ * a file that exists but does not parse is reported in `corruptPaths` so
+ * readers can degrade to a nonce and the compactor can sweep it.
+ */
+function readWorkerFiles(directory) {
+    let names;
+    try {
+        names = fs.readdirSync(directory);
+    }
+    catch {
+        return { corruptPaths: [], entries: [], paths: [] };
+    }
+    const entries = [];
+    const paths = [];
+    const corruptPaths = [];
+    for (const name of names) {
+        if (!name.startsWith(WORKER_SNAPSHOT_PREFIX) || !name.endsWith(".json")) {
+            continue;
+        }
+        const file = path.join(directory, name);
+        let text;
+        try {
+            text = fs.readFileSync(file, "utf8");
+        }
+        catch {
+            continue;
+        }
+        const parsed = parseSnapshotDocument(text);
+        if (parsed === undefined) {
+            corruptPaths.push(file);
+            continue;
+        }
+        entries.push(parsed);
+        paths.push(file);
+    }
+    return { corruptPaths, entries, paths };
+}
+function readMainDocument(directory) {
+    let text;
+    try {
+        text = fs.readFileSync(path.join(directory, MAIN_SNAPSHOT), "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    return parseSnapshotDocument(text);
+}
+function parseSnapshotDocument(text) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    const document = value;
+    if (document.version !== SNAPSHOT_VERSION || !Array.isArray(document.files)) {
+        return undefined;
+    }
+    return {
+        files: document.files.filter((entry) => typeof entry === "string"),
+        ...(typeof document.id === "string" ? { id: document.id } : {}),
+        version: SNAPSHOT_VERSION,
+        volatile: document.volatile === true,
+    };
+}
+/** Write a snapshot document atomically (unique temp file, then rename). */
+function writeSnapshotDocument(file, document) {
+    const temp = `${file}.${randomBytes(6).toString("hex")}.tmp`;
+    fs.writeFileSync(temp, JSON.stringify(document), "utf8");
+    try {
+        fs.renameSync(temp, file);
+    }
+    catch (error) {
+        fs.rmSync(temp, { force: true });
+        throw error;
+    }
+}
+/**
+ * JSON-serialise with object keys sorted recursively, so two semantically equal
+ * records always hash to the same fingerprint regardless of property order.
+ * Shared with the transformer's option digest.
+ */
+function stableStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map(stableStringify).join(",")}]`;
+    }
+    if (value !== null && typeof value === "object") {
+        return `{${Object.entries(value)
+            .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+            .map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+
+export { computeProjectFingerprint, createSnapshotRecorder, fingerprintRoots, prepareSnapshot, readSnapshotState, resolveFingerprintBase, stableStringify };
+//# sourceMappingURL=fingerprint.mjs.map

package/lib/core/fingerprint.mjs.map

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

package/lib/index.js

@@ -2,6 +2,7 @@
 
 var path = require('node:path');
 var node_url = require('node:url');
+var fingerprint = require('./core/fingerprint.js');
 var options = require('./core/options.js');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
@@ -49,6 +50,11 @@ var _documentCurrentScript = typeof document !== 'undefined' ? document.currentS
  */
 function withTtsc(config, options$1 = {}) {
     process.env[options.ENV_KEY] = options.serializeOptions(options$1);
+    // Prepare the reference-graph snapshot backing the transformer's cache-key
+    // fingerprint (see `core/fingerprint.ts`). This runs in the single Metro
+    // config process before any worker exists, so it is the race-free moment to
+    // mint the snapshot epoch and compact the previous run's worker files.
+    fingerprint.prepareSnapshot(typeof config.projectRoot === "string" ? config.projectRoot : undefined);
     return {
         ...config,
         transformer: {

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/index.ts"],"sourcesContent":[null],"names":["options","ENV_KEY","serializeOptions","join","dirname","fileURLToPath"],"mappings":";;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AAyBH;;;;;;;;;;;;AAYG;SACa,QAAQ,CACtB,MAAS,EACTA,YAA4B,EAAE,EAAA;IAE9B,OAAO,CAAC,GAAG,CAACC,eAAO,CAAC,GAAGC,wBAAgB,CAACF,SAAO,CAAC;IAChD,OAAO;AACL,QAAA,GAAG,MAAM;AACT,QAAA,WAAW,EAAE;YACX,GAAG,MAAM,CAAC,WAAW;YACrB,oBAAoB,EAAE,qBAAqB,EAAE;AAC9C,SAAA;KACG;AACR;AAEA;;;;;;;;AAQG;AACH,SAAS,qBAAqB,GAAA;AAC5B,IAAA,OAAOG,SAAI,CAACC,YAAO,CAACC,sBAAa,CAAC,0PAAe,CAAC,CAAC,EAAE,gBAAgB,CAAC;AACxE;;;;"}
+{"version":3,"file":"index.js","sources":["../src/index.ts"],"sourcesContent":[null],"names":["options","ENV_KEY","serializeOptions","prepareSnapshot","join","dirname","fileURLToPath"],"mappings":";;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AA0BH;;;;;;;;;;;;AAYG;SACa,QAAQ,CACtB,MAAS,EACTA,YAA4B,EAAE,EAAA;IAE9B,OAAO,CAAC,GAAG,CAACC,eAAO,CAAC,GAAGC,wBAAgB,CAACF,SAAO,CAAC;;;;;AAKhD,IAAAG,2BAAe,CACb,OAAO,MAAM,CAAC,WAAW,KAAK,QAAQ,GAAG,MAAM,CAAC,WAAW,GAAG,SAAS,CACxE;IACD,OAAO;AACL,QAAA,GAAG,MAAM;AACT,QAAA,WAAW,EAAE;YACX,GAAG,MAAM,CAAC,WAAW;YACrB,oBAAoB,EAAE,qBAAqB,EAAE;AAC9C,SAAA;KACG;AACR;AAEA;;;;;;;;AAQG;AACH,SAAS,qBAAqB,GAAA;AAC5B,IAAA,OAAOC,SAAI,CAACC,YAAO,CAACC,sBAAa,CAAC,0PAAe,CAAC,CAAC,EAAE,gBAAgB,CAAC;AACxE;;;;"}

package/lib/index.mjs

@@ -1,5 +1,6 @@
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { prepareSnapshot } from './core/fingerprint.mjs';
 import { ENV_KEY, serializeOptions } from './core/options.mjs';
 
 /**
@@ -46,6 +47,11 @@ import { ENV_KEY, serializeOptions } from './core/options.mjs';
  */
 function withTtsc(config, options = {}) {
     process.env[ENV_KEY] = serializeOptions(options);
+    // Prepare the reference-graph snapshot backing the transformer's cache-key
+    // fingerprint (see `core/fingerprint.ts`). This runs in the single Metro
+    // config process before any worker exists, so it is the race-free moment to
+    // mint the snapshot epoch and compact the previous run's worker files.
+    prepareSnapshot(typeof config.projectRoot === "string" ? config.projectRoot : undefined);
     return {
         ...config,
         transformer: {

package/lib/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":["../src/index.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AAyBH;;;;;;;;;;;;AAYG;SACa,QAAQ,CACtB,MAAS,EACT,UAA4B,EAAE,EAAA;IAE9B,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,gBAAgB,CAAC,OAAO,CAAC;IAChD,OAAO;AACL,QAAA,GAAG,MAAM;AACT,QAAA,WAAW,EAAE;YACX,GAAG,MAAM,CAAC,WAAW;YACrB,oBAAoB,EAAE,qBAAqB,EAAE;AAC9C,SAAA;KACG;AACR;AAEA;;;;;;;;AAQG;AACH,SAAS,qBAAqB,GAAA;AAC5B,IAAA,OAAO,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,gBAAgB,CAAC;AACxE;;;;"}
+{"version":3,"file":"index.mjs","sources":["../src/index.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AA0BH;;;;;;;;;;;;AAYG;SACa,QAAQ,CACtB,MAAS,EACT,UAA4B,EAAE,EAAA;IAE9B,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,gBAAgB,CAAC,OAAO,CAAC;;;;;AAKhD,IAAA,eAAe,CACb,OAAO,MAAM,CAAC,WAAW,KAAK,QAAQ,GAAG,MAAM,CAAC,WAAW,GAAG,SAAS,CACxE;IACD,OAAO;AACL,QAAA,GAAG,MAAM;AACT,QAAA,WAAW,EAAE;YACX,GAAG,MAAM,CAAC,WAAW;YACrB,oBAAoB,EAAE,qBAAqB,EAAE;AAC9C,SAAA;KACG;AACR;AAEA;;;;;;;;AAQG;AACH,SAAS,qBAAqB,GAAA;AAC5B,IAAA,OAAO,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,gBAAgB,CAAC;AACxE;;;;"}

package/lib/transformer.d.ts

@@ -32,15 +32,25 @@ export declare function transform(params: {
 /**
  * Metro transform-cache key.
  *
- * Metro already content-hashes each file, so this only has to invalidate when
- * the transformer itself changes: package version + resolved options + the
- * upstream transformer's own key (forwarded Metro's args, e.g. `projectRoot`,
- * so a `babel.config.js` change still busts the cache). Resolving the upstream
- * is deliberately non-fatal here: a missing peer must not crash cache-key
- * computation. NOTE: this does not encode the tsconfig / plugin configuration
- * or cross-file type dependencies, so after editing those (or a depended-upon
- * type) run Metro with `--reset-cache`. See the README "Caveats" and
- * samchon/ttsc#255.
+ * Metro calls this once per run (dev-server start or cold `metro bundle`), on
+ * the main process, and folds the result into every file's per-content cache
+ * key. It must therefore incorporate every input that can influence a
+ * transform's output beyond the file's own content:
+ *
+ * - The transformer identity: package version + resolved options + the upstream
+ *   transformer's own key (forwarded Metro's args, e.g. `projectRoot`, so a
+ *   `babel.config.js` change still busts the cache);
+ * - The project fingerprint (see `core/fingerprint.ts`): every input file under
+ *   the project walk (tsconfig, plugin configs, type-only siblings) plus the
+ *   recorded out-of-walk reference-graph members from previous transforms
+ *   (`node_modules` declarations, monorepo sibling sources, out-of-root config
+ *   ancestry).
+ *
+ * A change to any fingerprinted input re-keys every transformed file —
+ * project-level granularity, forced by Metro's single static key — replacing
+ * the former manual `--reset-cache` step. Resolving the upstream is
+ * deliberately non-fatal here: a missing peer must not crash cache-key
+ * computation. See the README "Caveats" and samchon/ttsc#721.
  */
 export declare function getCacheKey(...args: unknown[]): string;
 /**