ttsc 0.30.4 → 0.31.0

package/lib/launcher/internal/ttscserver/LSPProjectInputDigest.d.ts

@@ -0,0 +1,95 @@
+import type { ITtscProjectInputSnapshot } from "../../../structures/internal/ITtscProjectInputSnapshot";
+/**
+ * Content fingerprints of the files and directories whose change forces the
+ * language server to reselect plugins.
+ *
+ * `ttscserver` resolves its plugin selection before the Go LSP host starts and
+ * hands both the selection and these fingerprints to the host, which recomputes
+ * them to notice a change that landed in between. The two sides must therefore
+ * use compatible byte framing. The Windows parity test in `internal/lspserver`
+ * checks one existing directory and one missing descendant; it does not
+ * establish agreement for every native entry or failure state.
+ *
+ * @evidence contracts/common.md#principled-implementation Domain-framed content, link and topology records encode the same selection distinctions as the Go validator; physical directory identity is distinct from leaf-link identity and ordinary child content.
+ * @evidence contracts/common.md#clear-and-simple-design JavaScript capture and validation share these digest helpers; the Go peer independently implements the startup framing and must remain compatible.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unavailable reads and non-file entries use declared protocol markers; a missing marker can also represent a read failure and is not proof of absence. Native readers remain supported APIs without foreign replacement.
+ * @evidence contracts/common.md#meaningful-documentation Namespace and helper comments explain cross-host framing, raw-byte preservation and leaf identity, with separated public tags and member paragraphs following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Windows native paths use the shared identity resolver; POSIX reads preserve raw path and link-target bytes, and neither branch infers filesystem case from an OS label.
+ *
+ * @evidenceExclude contracts/performance.md#efficient-algorithms This namespace groups digest operations but chooses no computation itself; its functions acknowledge their own traversal and allocation costs.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The namespace retains no digest or validity state; each function supplies the current observation its caller needs.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The namespace owns no stored baseline, handle or running task; capture and session owners control returned observations.
+ */
+export declare namespace LSPProjectInputDigest {
+    /**
+     * A project-input snapshot plus the fingerprints taken when it was read.
+     *
+     * @evidence contracts/common.md#principled-implementation The intersection retains dependency declarations and attaches separate read-time file/content and directory/topology observations keyed by those declarations.
+     * @evidence contracts/common.md#clear-and-simple-design Two readonly maps add baseline evidence without copying the base dependency schema or merging distinct reload semantics.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The representation stores actual captured digests rather than a precomputed compliance boolean that could conceal changed inputs.
+     * @evidence contracts/common.md#meaningful-documentation Native type and member comments identify read-time provenance and topology versus content, using blank member lines and prose/tag separation following the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Map keys preserve declared native spellings while the digest producer separately handles physical identity and link state across supported platforms.
+     *
+     * @evidenceExclude contracts/performance.md#efficient-algorithms This baseline type represents observations without choosing a traversal or hashing algorithm.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work The representation does not coordinate equivalent requests; capture and validation functions own whether a selection remains reusable.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Session callers own the baseline lifetime; declaring its maps does not allocate or retain historical snapshots independently.
+     */
+    type InitialLSPProjectInputSnapshot = ITtscProjectInputSnapshot & {
+        /** Topology digest of each reload directory, keyed by its declared path. */
+        reloadDirectoryDigests: Readonly<Record<string, string>>;
+        /** Content digest of each reload file, keyed by its declared path. */
+        reloadFileDigests: Readonly<Record<string, string>>;
+    };
+    /**
+     * Digest of a directory's immediate topology: each child's name, kind, and
+     * link target, resolved through the directory's physical identity. Content of
+     * the children is not part of it.
+     *
+     * @evidence contracts/common.md#principled-implementation The frame combines the available directory identity and sorted immediate name/kind/link-target observations; ordinary child content is excluded. These sequential native reads are not an atomic topology snapshot.
+     * @evidence contracts/common.md#clear-and-simple-design Physical identity and immediate topology have separate private readers and combine at one documented protocol boundary.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Any failed directory listing uses the missing topology marker, without certifying absence or distinguishing permission failure; unreadable link targets have a separate marker and supported filesystem APIs remain unchanged.
+     * @evidence contracts/common.md#meaningful-documentation The native paragraph states exactly which entry facts count and excludes child contents, with separated tags following the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Windows uses native resolved spelling; POSIX passes raw physical bytes through topology enumeration, preserving backslashes and non-UTF-8 names rather than converting them into protocol separators.
+     * @evidence contracts/performance.md#efficient-algorithms Native identity setup includes path probes, ancestor spelling work and a possible Windows capability query. For E immediate entries, sorting makes O(E log E) byte comparisons whose cost depends on compared name/target lengths; record buffers, sorting references and concatenated framing coexist, with hashing proportional to framed bytes. Child trees are not recursively scanned.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each reading is a freshness observation; sharing prior topology would need an independent change witness which this digest boundary does not own.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Supported synchronous APIs own their native handles; this helper retains no cross-call state or running task. Its identity context and entry/framing buffers live through the call without an independent byte ceiling.
+     */
+    function lspProjectInputReloadDirectoryDigest(location: string): string;
+    /**
+     * Digest of the available observations of one entry. A symlink frame combines
+     * its raw target and reached content; failed target/content reads use
+     * markers. Regular files hash their bytes, while classification or
+     * regular-file read failure hashes the stable `missing` marker. Other entry
+     * kinds hash as `other`. The reads are sequential and do not pin the entry
+     * against change.
+     *
+     * @evidence contracts/common.md#principled-implementation File, symlink and other frames distinguish available entry observations; a symlink includes the observed target and reached bytes. Unavailable observations collapse into markers, so unchanged digests do not prove native state was unchanged.
+     * @evidence contracts/common.md#clear-and-simple-design One lstat-driven dispatch owns entry-kind framing and keeps dangling or unreadable symlink content distinct from a missing link itself.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Fixed markers encode the native wire contract's unavailable states; the function reads actual entries rather than replacing content with expected diagnostics or test values.
+     * @evidence contracts/common.md#meaningful-documentation Native prose documents each entry kind and the two symlink inputs, with tags separated according to the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Native lstat, readlink and readFile preserve host link semantics; Buffer target reads retain POSIX raw bytes while Windows supplies the native target representation consumed by the Go peer.
+     * @evidence contracts/performance.md#efficient-algorithms One native classification and at most one target/content read produce the digest. Native path work, hashing and copied framing scale with path, target and reached content bytes; whole-file buffers and concatenated frames coexist without a separate input byte ceiling. No unrelated files are enumerated.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This produces a current observation, not a cached selection; a prior digest cannot be reused without separately proving the file and link remained unchanged.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Supported synchronous APIs own their handles; this helper retains only local content/framing buffers during the call and returns digest text. It owns no cross-call history, persistent handle or running task.
+     */
+    function lspProjectInputFileDigest(location: string): string;
+    /**
+     * Best-effort resolved spelling of an entry's parent joined with its own
+     * basename, preserving the leaf link rather than resolving its target. Failed
+     * parent probes retain unresolved suffixes; if every probe fails, the
+     * normalized lexical spelling is returned. This does not pin identity.
+     *
+     * @evidence contracts/common.md#principled-implementation Resolving available parent ancestors and reattaching the basename preserves the leaf coordinate used by exact reload-file fingerprints. Failed resolution falls back to lexical spelling rather than certifying a physical identity.
+     * @evidence contracts/common.md#clear-and-simple-design Parent canonicalization stays with one private resolver; this public adapter expresses the leaf-preserving operation in one native join.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts All failed realpath probes are treated as unresolved, including failures other than absence. Suffixes remain beneath a resolved ancestor, or the normalized original path is returned when no ancestor resolves.
+     * @evidence contracts/common.md#meaningful-documentation The native paragraph explains why the leaf differs from its ancestors, and separated tags follow the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Shared native spelling normalization handles extended Windows paths while native dirname/basename/join preserve POSIX names; no unconditional case folding is used.
+     * @evidence contracts/performance.md#efficient-algorithms The ancestor walk makes one native realpath probe per visited parent until success or root. Repeated dirname/basename/path normalization and the final join depend on path text lengths; retained suffix strings and joined spelling are local, with no directory traversal.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Ancestor aliases may retarget between captures, so this current resolver owns no reusable validity proof or persistent canonicalization cache.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only local path components are retained through the synchronous walk; no handle or cross-call path history survives.
+     */
+    function realLSPProjectInputEntryPath(location: string): string;
+}

package/lib/launcher/internal/ttscserver/LSPProjectInputDigest.js

@@ -0,0 +1,270 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LSPProjectInputDigest = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const createProjectInputPathIdentityContext_1 = require("../../../internal/pathIdentity/createProjectInputPathIdentityContext");
+const resolveProjectInputPath_1 = require("../../../internal/pathIdentity/resolveProjectInputPath");
+/**
+ * Content fingerprints of the files and directories whose change forces the
+ * language server to reselect plugins.
+ *
+ * `ttscserver` resolves its plugin selection before the Go LSP host starts and
+ * hands both the selection and these fingerprints to the host, which recomputes
+ * them to notice a change that landed in between. The two sides must therefore
+ * use compatible byte framing. The Windows parity test in `internal/lspserver`
+ * checks one existing directory and one missing descendant; it does not
+ * establish agreement for every native entry or failure state.
+ *
+ * @evidence contracts/common.md#principled-implementation Domain-framed content, link and topology records encode the same selection distinctions as the Go validator; physical directory identity is distinct from leaf-link identity and ordinary child content.
+ * @evidence contracts/common.md#clear-and-simple-design JavaScript capture and validation share these digest helpers; the Go peer independently implements the startup framing and must remain compatible.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unavailable reads and non-file entries use declared protocol markers; a missing marker can also represent a read failure and is not proof of absence. Native readers remain supported APIs without foreign replacement.
+ * @evidence contracts/common.md#meaningful-documentation Namespace and helper comments explain cross-host framing, raw-byte preservation and leaf identity, with separated public tags and member paragraphs following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Windows native paths use the shared identity resolver; POSIX reads preserve raw path and link-target bytes, and neither branch infers filesystem case from an OS label.
+ *
+ * @evidenceExclude contracts/performance.md#efficient-algorithms This namespace groups digest operations but chooses no computation itself; its functions acknowledge their own traversal and allocation costs.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The namespace retains no digest or validity state; each function supplies the current observation its caller needs.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The namespace owns no stored baseline, handle or running task; capture and session owners control returned observations.
+ */
+var LSPProjectInputDigest;
+(function (LSPProjectInputDigest) {
+    /**
+     * Digest of a directory's immediate topology: each child's name, kind, and
+     * link target, resolved through the directory's physical identity. Content of
+     * the children is not part of it.
+     *
+     * @evidence contracts/common.md#principled-implementation The frame combines the available directory identity and sorted immediate name/kind/link-target observations; ordinary child content is excluded. These sequential native reads are not an atomic topology snapshot.
+     * @evidence contracts/common.md#clear-and-simple-design Physical identity and immediate topology have separate private readers and combine at one documented protocol boundary.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Any failed directory listing uses the missing topology marker, without certifying absence or distinguishing permission failure; unreadable link targets have a separate marker and supported filesystem APIs remain unchanged.
+     * @evidence contracts/common.md#meaningful-documentation The native paragraph states exactly which entry facts count and excludes child contents, with separated tags following the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Windows uses native resolved spelling; POSIX passes raw physical bytes through topology enumeration, preserving backslashes and non-UTF-8 names rather than converting them into protocol separators.
+     * @evidence contracts/performance.md#efficient-algorithms Native identity setup includes path probes, ancestor spelling work and a possible Windows capability query. For E immediate entries, sorting makes O(E log E) byte comparisons whose cost depends on compared name/target lengths; record buffers, sorting references and concatenated framing coexist, with hashing proportional to framed bytes. Child trees are not recursively scanned.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each reading is a freshness observation; sharing prior topology would need an independent change witness which this digest boundary does not own.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Supported synchronous APIs own their native handles; this helper retains no cross-call state or running task. Its identity context and entry/framing buffers live through the call without an independent byte ceiling.
+     */
+    function lspProjectInputReloadDirectoryDigest(location) {
+        const identities = (0, createProjectInputPathIdentityContext_1.createProjectInputPathIdentityContext)();
+        const identity = lspProjectInputPhysicalPathIdentity(location, identities);
+        return (0, node_crypto_1.createHash)("sha256")
+            .update(Buffer.concat([
+            Buffer.from("directory\0"),
+            identity,
+            Buffer.from([0]),
+            Buffer.from(lspProjectInputDirectoryTopologyDigest(process.platform === "win32"
+                ? identities.resolve(location).path
+                : identity)),
+        ]))
+            .digest("hex");
+    }
+    LSPProjectInputDigest.lspProjectInputReloadDirectoryDigest = lspProjectInputReloadDirectoryDigest;
+    function lspProjectInputPhysicalPathIdentity(location, identities) {
+        if (process.platform === "win32") {
+            return Buffer.from(identities.resolve(location).path.replaceAll("\\", "/"), "utf8");
+        }
+        let existing = node_path_1.default.resolve(location);
+        const missing = [];
+        while (true) {
+            try {
+                const realpath = node_fs_1.default.realpathSync.native ?? node_fs_1.default.realpathSync;
+                const physical = realpath(Buffer.from(existing), {
+                    encoding: "buffer",
+                });
+                const segments = [physical];
+                for (let index = missing.length - 1; index >= 0; index--) {
+                    if (index !== missing.length - 1 || physical.at(-1) !== 0x2f)
+                        segments.push(Buffer.from("/"));
+                    segments.push(missing[index]);
+                }
+                return Buffer.concat(segments);
+            }
+            catch (error) {
+                if (error instanceof Error &&
+                    "code" in error &&
+                    error.code !== "ENOENT" &&
+                    error.code !== "ENOTDIR") {
+                    throw error;
+                }
+                const parent = node_path_1.default.dirname(existing);
+                if (parent === existing)
+                    return Buffer.from(existing);
+                missing.push(Buffer.from(node_path_1.default.basename(existing)));
+                existing = parent;
+            }
+        }
+    }
+    function lspProjectInputDirectoryTopologyDigest(location) {
+        const entries = [];
+        try {
+            if (process.platform === "win32") {
+                const directory = typeof location === "string" ? location : location.toString("utf8");
+                for (const entry of node_fs_1.default.readdirSync(directory, {
+                    withFileTypes: true,
+                })) {
+                    let target = Buffer.alloc(0);
+                    if (entry.isSymbolicLink()) {
+                        try {
+                            target = Buffer.from(node_fs_1.default.readlinkSync(node_path_1.default.join(directory, entry.name)), "utf8");
+                        }
+                        catch {
+                            target = Buffer.from("<unreadable>");
+                        }
+                    }
+                    entries.push(lspProjectInputDirectoryRecord(Buffer.from(entry.name), entry, target));
+                }
+            }
+            else {
+                for (const entry of node_fs_1.default.readdirSync(location, {
+                    encoding: "buffer",
+                    withFileTypes: true,
+                })) {
+                    let target = Buffer.alloc(0);
+                    if (entry.isSymbolicLink()) {
+                        try {
+                            target = node_fs_1.default.readlinkSync(Buffer.concat([
+                                Buffer.isBuffer(location) ? location : Buffer.from(location),
+                                Buffer.from(node_path_1.default.sep),
+                                entry.name,
+                            ]), { encoding: "buffer" });
+                        }
+                        catch {
+                            target = Buffer.from("<unreadable>");
+                        }
+                    }
+                    entries.push(lspProjectInputDirectoryRecord(entry.name, entry, target));
+                }
+            }
+        }
+        catch {
+            return (0, node_crypto_1.createHash)("sha256").update("missing\0").digest("hex");
+        }
+        entries.sort(Buffer.compare);
+        const serialized = Buffer.concat(entries.flatMap((entry, index) => index === 0 ? [entry] : [Buffer.from([0]), entry]));
+        return (0, node_crypto_1.createHash)("sha256").update(serialized).digest("hex");
+    }
+    function lspProjectInputDirectoryRecord(name, entry, target) {
+        const kind = entry.isDirectory()
+            ? "directory"
+            : entry.isFile()
+                ? "file"
+                : entry.isSymbolicLink()
+                    ? "symlink"
+                    : "other";
+        return Buffer.concat([name, Buffer.from("\0" + kind + "\0"), target]);
+    }
+    /**
+     * Digest of the available observations of one entry. A symlink frame combines
+     * its raw target and reached content; failed target/content reads use
+     * markers. Regular files hash their bytes, while classification or
+     * regular-file read failure hashes the stable `missing` marker. Other entry
+     * kinds hash as `other`. The reads are sequential and do not pin the entry
+     * against change.
+     *
+     * @evidence contracts/common.md#principled-implementation File, symlink and other frames distinguish available entry observations; a symlink includes the observed target and reached bytes. Unavailable observations collapse into markers, so unchanged digests do not prove native state was unchanged.
+     * @evidence contracts/common.md#clear-and-simple-design One lstat-driven dispatch owns entry-kind framing and keeps dangling or unreadable symlink content distinct from a missing link itself.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Fixed markers encode the native wire contract's unavailable states; the function reads actual entries rather than replacing content with expected diagnostics or test values.
+     * @evidence contracts/common.md#meaningful-documentation Native prose documents each entry kind and the two symlink inputs, with tags separated according to the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Native lstat, readlink and readFile preserve host link semantics; Buffer target reads retain POSIX raw bytes while Windows supplies the native target representation consumed by the Go peer.
+     * @evidence contracts/performance.md#efficient-algorithms One native classification and at most one target/content read produce the digest. Native path work, hashing and copied framing scale with path, target and reached content bytes; whole-file buffers and concatenated frames coexist without a separate input byte ceiling. No unrelated files are enumerated.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This produces a current observation, not a cached selection; a prior digest cannot be reused without separately proving the file and link remained unchanged.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Supported synchronous APIs own their handles; this helper retains only local content/framing buffers during the call and returns digest text. It owns no cross-call history, persistent handle or running task.
+     */
+    function lspProjectInputFileDigest(location) {
+        try {
+            const info = node_fs_1.default.lstatSync(location);
+            if (info.isSymbolicLink()) {
+                let target = Buffer.from("<unreadable>");
+                try {
+                    target = node_fs_1.default.readlinkSync(Buffer.from(location), {
+                        encoding: "buffer",
+                    });
+                }
+                catch {
+                    // Preserve the same explicit unreadable state as the Go validator.
+                }
+                let content = Buffer.from("missing\0");
+                try {
+                    content = Buffer.concat([
+                        Buffer.from("file\0"),
+                        node_fs_1.default.readFileSync(location),
+                    ]);
+                }
+                catch {
+                    // A dangling or unreadable target remains part of the symlink state.
+                }
+                return (0, node_crypto_1.createHash)("sha256")
+                    .update(Buffer.concat([
+                    Buffer.from("symlink\0"),
+                    target,
+                    Buffer.from([0]),
+                    content,
+                ]))
+                    .digest("hex");
+            }
+            if (info.isFile()) {
+                return (0, node_crypto_1.createHash)("sha256")
+                    .update(Buffer.concat([Buffer.from("file\0"), node_fs_1.default.readFileSync(location)]))
+                    .digest("hex");
+            }
+            return (0, node_crypto_1.createHash)("sha256").update("other\0").digest("hex");
+        }
+        catch {
+            return (0, node_crypto_1.createHash)("sha256").update("missing\0").digest("hex");
+        }
+    }
+    LSPProjectInputDigest.lspProjectInputFileDigest = lspProjectInputFileDigest;
+    /**
+     * Physical path of a location whose leaf may not exist yet.
+     *
+     * Both ends go through the shared spelling rule rather than `path.resolve`
+     * alone. Windows hands back extended-length paths from a native realpath, and
+     * a record written as `\?\C:\project` never matches a lookup for `C:\project`
+     * even though one file is meant — the split identity every other consumer on
+     * this branch was taught to avoid.
+     */
+    function realLSPProjectInputPath(location) {
+        const absolute = (0, resolveProjectInputPath_1.resolveProjectInputPath)(location);
+        let probe = absolute;
+        const suffix = [];
+        for (;;) {
+            try {
+                const resolved = (0, resolveProjectInputPath_1.resolveProjectInputPath)(node_fs_1.default.realpathSync.native(probe));
+                return node_path_1.default.join(resolved, ...suffix.reverse());
+            }
+            catch {
+                const parent = node_path_1.default.dirname(probe);
+                if (parent === probe)
+                    return node_path_1.default.normalize(absolute);
+                suffix.push(node_path_1.default.basename(probe));
+                probe = parent;
+            }
+        }
+    }
+    /**
+     * Best-effort resolved spelling of an entry's parent joined with its own
+     * basename, preserving the leaf link rather than resolving its target. Failed
+     * parent probes retain unresolved suffixes; if every probe fails, the
+     * normalized lexical spelling is returned. This does not pin identity.
+     *
+     * @evidence contracts/common.md#principled-implementation Resolving available parent ancestors and reattaching the basename preserves the leaf coordinate used by exact reload-file fingerprints. Failed resolution falls back to lexical spelling rather than certifying a physical identity.
+     * @evidence contracts/common.md#clear-and-simple-design Parent canonicalization stays with one private resolver; this public adapter expresses the leaf-preserving operation in one native join.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts All failed realpath probes are treated as unresolved, including failures other than absence. Suffixes remain beneath a resolved ancestor, or the normalized original path is returned when no ancestor resolves.
+     * @evidence contracts/common.md#meaningful-documentation The native paragraph explains why the leaf differs from its ancestors, and separated tags follow the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Shared native spelling normalization handles extended Windows paths while native dirname/basename/join preserve POSIX names; no unconditional case folding is used.
+     * @evidence contracts/performance.md#efficient-algorithms The ancestor walk makes one native realpath probe per visited parent until success or root. Repeated dirname/basename/path normalization and the final join depend on path text lengths; retained suffix strings and joined spelling are local, with no directory traversal.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Ancestor aliases may retarget between captures, so this current resolver owns no reusable validity proof or persistent canonicalization cache.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only local path components are retained through the synchronous walk; no handle or cross-call path history survives.
+     */
+    function realLSPProjectInputEntryPath(location) {
+        const absolute = (0, resolveProjectInputPath_1.resolveProjectInputPath)(location);
+        return node_path_1.default.join(realLSPProjectInputPath(node_path_1.default.dirname(absolute)), node_path_1.default.basename(absolute));
+    }
+    LSPProjectInputDigest.realLSPProjectInputEntryPath = realLSPProjectInputEntryPath;
+})(LSPProjectInputDigest || (exports.LSPProjectInputDigest = LSPProjectInputDigest = {}));
+//# sourceMappingURL=LSPProjectInputDigest.js.map

package/lib/launcher/internal/ttscserver/LSPProjectInputDigest.js.map

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

package/lib/launcher/internal/ttscserver/captureLSPPluginSelectionInputs.d.ts

@@ -0,0 +1,46 @@
+import type { ILSPPluginSelectionInputs } from "./ILSPPluginSelectionInputs";
+/**
+ * The inputs a `ttscserver` session's plugin selection was loaded from, which
+ * the native host watches for the life of the session, or `undefined` when one
+ * of them no longer holds the state the load proved.
+ *
+ * A session runs the sidecar binaries and the capabilities one plugin load
+ * resolved at startup. The load read the descriptors and the files they
+ * resolved (`hostInputs`), and it built each binary from the Go sources of its
+ * `pluginSources`; a change to any of them selects other plugins, or builds
+ * another binary, which only a new session loads. The host ends the session
+ * through its reload path when one changes, and the editor starts the next. The
+ * shape each travels in is `ILSPPluginSelectionInputs`.
+ *
+ * What selects the plugins is among them: the project's config chain, whose
+ * `compilerOptions.plugins` names them, and the manifests plugin discovery
+ * reads. A change there is a selection change, as `ttsc --watch` treats it,
+ * rather than only a Program refresh. Left out is a plugin's `configFile` that
+ * no descriptor read, which its plugin declares among its own project inputs.
+ *
+ * Non-deferred inputs are fingerprinted, then recorded content/target proofs
+ * and plugin-source states are checked again. Only paths with a recorded proof
+ * participate in that proof comparison. These sequential observations reject
+ * detected drift; unavailable markers or changes between reads are not a proof
+ * that the complete filesystem stayed fixed throughout capture.
+ *
+ * @param loaded The plugin load of the session.
+ * @returns The inputs, or `undefined` when the load no longer describes the
+ *   filesystem and the selection has to be loaded again.
+ * @evidence contracts/common.md#principled-implementation The manifest groups candidate/source-file digests by directory. Recorded content and physical-target proofs and all plugin-source states are compared again before return; a detected mismatch rejects capture, while sequential reads and unproven paths do not certify every post-load change.
+ * @evidence contracts/common.md#clear-and-simple-design Candidate filtering, source enumeration and proof comparison remain separate; the private recorder owns basename insertion into prototype-free maps, including names such as __proto__.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Source omission rules come from the binary builder's shared constants; stale proofs return undefined instead of replacing a loaded selection with guessed current evidence.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain selection versus program refresh, deferred config inputs and the startup race; parameter/result documentation and separated tags follow the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path operations retain declared spellings and actual realpath observations detect symlink or junction retargeting independently of content equality; no OS name supplies filesystem case policy.
+ * @evidence contracts/performance.md#efficient-algorithms Path normalization/filtering allocates candidate arrays and an excluded set. Each source is walked for directories and again for files; file framing is followed by separate recorded content/realpath proof reads and plugin-source state validation, including its native/toolchain costs. Maps retain path keys and digests while temporary walk/read buffers coexist; directory grouping avoids repeating directory keys per file.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This capture validates a particular completed load against current filesystem state; retained plugin/binary reuse belongs to that load's owner, and cached post-load readings would miss drift.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Returned maps transfer to the session builder. Supported readers and source-state helpers own their native acquisition/release boundaries; this mapper stores no cross-call capture or running task, and local output has no independent population or byte ceiling.
+ */
+export declare function captureLSPPluginSelectionInputs(loaded: {
+    deferredHostInputs: readonly string[];
+    hostInputHashes: Readonly<Record<string, string | null>>;
+    hostInputRealpaths: Readonly<Record<string, string | null>>;
+    hostInputs: readonly string[];
+    pluginSources: Readonly<Record<string, string>>;
+}): ILSPPluginSelectionInputs | undefined;

package/lib/launcher/internal/ttscserver/captureLSPPluginSelectionInputs.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureLSPPluginSelectionInputs = captureLSPPluginSelectionInputs;
+const node_path_1 = __importDefault(require("node:path"));
+const hashHostInputPaths_1 = require("../../../plugin/internal/load/hashHostInputPaths");
+const realpathHostInputPaths_1 = require("../../../plugin/internal/load/realpathHostInputPaths");
+const GoSourceInputs_1 = require("../../../plugin/internal/source/GoSourceInputs");
+const collectPluginSourceDirectories_1 = require("../../../plugin/internal/source/collectPluginSourceDirectories");
+const collectPluginSourceFiles_1 = require("../../../plugin/internal/source/collectPluginSourceFiles");
+const pluginSourceStateHolds_1 = require("../../../plugin/internal/source/pluginSourceStateHolds");
+const LSPProjectInputDigest_1 = require("./LSPProjectInputDigest");
+/**
+ * The inputs a `ttscserver` session's plugin selection was loaded from, which
+ * the native host watches for the life of the session, or `undefined` when one
+ * of them no longer holds the state the load proved.
+ *
+ * A session runs the sidecar binaries and the capabilities one plugin load
+ * resolved at startup. The load read the descriptors and the files they
+ * resolved (`hostInputs`), and it built each binary from the Go sources of its
+ * `pluginSources`; a change to any of them selects other plugins, or builds
+ * another binary, which only a new session loads. The host ends the session
+ * through its reload path when one changes, and the editor starts the next. The
+ * shape each travels in is `ILSPPluginSelectionInputs`.
+ *
+ * What selects the plugins is among them: the project's config chain, whose
+ * `compilerOptions.plugins` names them, and the manifests plugin discovery
+ * reads. A change there is a selection change, as `ttsc --watch` treats it,
+ * rather than only a Program refresh. Left out is a plugin's `configFile` that
+ * no descriptor read, which its plugin declares among its own project inputs.
+ *
+ * Non-deferred inputs are fingerprinted, then recorded content/target proofs
+ * and plugin-source states are checked again. Only paths with a recorded proof
+ * participate in that proof comparison. These sequential observations reject
+ * detected drift; unavailable markers or changes between reads are not a proof
+ * that the complete filesystem stayed fixed throughout capture.
+ *
+ * @param loaded The plugin load of the session.
+ * @returns The inputs, or `undefined` when the load no longer describes the
+ *   filesystem and the selection has to be loaded again.
+ * @evidence contracts/common.md#principled-implementation The manifest groups candidate/source-file digests by directory. Recorded content and physical-target proofs and all plugin-source states are compared again before return; a detected mismatch rejects capture, while sequential reads and unproven paths do not certify every post-load change.
+ * @evidence contracts/common.md#clear-and-simple-design Candidate filtering, source enumeration and proof comparison remain separate; the private recorder owns basename insertion into prototype-free maps, including names such as __proto__.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Source omission rules come from the binary builder's shared constants; stale proofs return undefined instead of replacing a loaded selection with guessed current evidence.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain selection versus program refresh, deferred config inputs and the startup race; parameter/result documentation and separated tags follow the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path operations retain declared spellings and actual realpath observations detect symlink or junction retargeting independently of content equality; no OS name supplies filesystem case policy.
+ * @evidence contracts/performance.md#efficient-algorithms Path normalization/filtering allocates candidate arrays and an excluded set. Each source is walked for directories and again for files; file framing is followed by separate recorded content/realpath proof reads and plugin-source state validation, including its native/toolchain costs. Maps retain path keys and digests while temporary walk/read buffers coexist; directory grouping avoids repeating directory keys per file.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This capture validates a particular completed load against current filesystem state; retained plugin/binary reuse belongs to that load's owner, and cached post-load readings would miss drift.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Returned maps transfer to the session builder. Supported readers and source-state helpers own their native acquisition/release boundaries; this mapper stores no cross-call capture or running task, and local output has no independent population or byte ceiling.
+ */
+function captureLSPPluginSelectionInputs(loaded) {
+    const excluded = new Set(loaded.deferredHostInputs.map((file) => node_path_1.default.resolve(file)));
+    const descriptorInputs = loaded.hostInputs
+        .map((file) => node_path_1.default.resolve(file))
+        .filter((file) => !excluded.has(file));
+    const descriptorFiles = {};
+    for (const file of descriptorInputs)
+        record(descriptorFiles, file);
+    const sourceFiles = {};
+    for (const source of Object.keys(loaded.pluginSources)) {
+        for (const directory of (0, collectPluginSourceDirectories_1.collectPluginSourceDirectories)(source))
+            sourceFiles[node_path_1.default.resolve(directory)] ??= Object.create(null);
+        for (const file of (0, collectPluginSourceFiles_1.collectPluginSourceFiles)(source))
+            record(sourceFiles, node_path_1.default.resolve(file));
+    }
+    const proven = descriptorInputs.filter((file) => Object.prototype.hasOwnProperty.call(loaded.hostInputHashes, file));
+    const current = (0, hashHostInputPaths_1.hashHostInputPaths)(proven);
+    if (proven.some((file) => current[file] !== loaded.hostInputHashes[file]))
+        return undefined;
+    const physicalInputs = descriptorInputs.filter((file) => Object.prototype.hasOwnProperty.call(loaded.hostInputRealpaths, file));
+    const currentRealpaths = (0, realpathHostInputPaths_1.realpathHostInputPaths)(physicalInputs);
+    if (physicalInputs.some((file) => currentRealpaths[file] !== loaded.hostInputRealpaths[file]))
+        return undefined;
+    for (const [directory, state] of Object.entries(loaded.pluginSources))
+        if (!(0, pluginSourceStateHolds_1.pluginSourceStateHolds)(directory, state))
+            return undefined;
+    return {
+        omittedNames: GoSourceInputs_1.GoSourceInputs.OMITTED_SOURCE_FILE_NAMES,
+        omittedSuffixes: GoSourceInputs_1.GoSourceInputs.OMITTED_SOURCE_FILE_SUFFIXES,
+        prunedDirectoryNames: GoSourceInputs_1.GoSourceInputs.PRUNED_SOURCE_DIRECTORY_NAMES,
+        descriptorFiles,
+        sourceFiles,
+    };
+}
+/** Record `file`'s digest under its directory. */
+function record(directories, file) {
+    (directories[node_path_1.default.dirname(file)] ??= Object.create(null))[node_path_1.default.basename(file)] = LSPProjectInputDigest_1.LSPProjectInputDigest.lspProjectInputFileDigest(file);
+}
+//# sourceMappingURL=captureLSPPluginSelectionInputs.js.map

package/lib/launcher/internal/ttscserver/captureLSPPluginSelectionInputs.js.map

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

package/lib/launcher/internal/ttscserver/fingerprintInitialLSPProjectInputSnapshot.d.ts

@@ -0,0 +1,21 @@
+import type { ITtscProjectInputSnapshot } from "../../../structures/internal/ITtscProjectInputSnapshot";
+import { LSPProjectInputDigest } from "./LSPProjectInputDigest";
+/**
+ * Capture reload-directory and reload-file fingerprints sequentially for the
+ * startup baseline. These reads do not define one atomic selection instant.
+ *
+ * Reload directory digests describe immediate topology and physical identity;
+ * reload file digests keep the leaf link while resolving its parent. The native
+ * host can validate this startup baseline before accepting watcher coverage.
+ *
+ * @evidence contracts/common.md#principled-implementation Attaching each reload input's framed digest to the unchanged declaration preserves the selection-time baseline; later validators compare against those observations instead of blessing a newly sampled state.
+ * @evidence contracts/common.md#clear-and-simple-design Two explicit lanes delegate file and directory semantics to the shared digest namespace and retain the original snapshot's other dependency fields.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Production startup uses these observations before native watcher registration; the exported helper serves that protocol rather than existing solely for parity tests.
+ * @evidence contracts/common.md#meaningful-documentation Native documentation distinguishes topology from content and identifies the startup handoff, with separated tags following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation File leaves retain their entry coordinate and directory digests use available native identity observations with documented lexical/unavailable fallbacks; declared map keys are not blanket case-folded.
+ * @evidence contracts/performance.md#efficient-algorithms Both lanes process every supplied entry, including duplicates, and delegate ancestor/path probes, possible Windows capability queries, immediate topology byte comparisons/framing or whole-file reads. Returned key/digest maps grow with distinct declared paths; current digest buffers coexist with maps already built, without unrelated dependency-file traversal.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This captures a fresh baseline for a selected session; reuse without observing current reload inputs could certify an older selection and belongs to neither this mapper nor its contract.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Digest maps transfer to the returned snapshot and hold no open handle or process-wide history.
+ */
+export declare function fingerprintInitialLSPProjectInputSnapshot(snapshot: ITtscProjectInputSnapshot): LSPProjectInputDigest.InitialLSPProjectInputSnapshot;

package/lib/launcher/internal/ttscserver/fingerprintInitialLSPProjectInputSnapshot.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fingerprintInitialLSPProjectInputSnapshot = fingerprintInitialLSPProjectInputSnapshot;
+const LSPProjectInputDigest_1 = require("./LSPProjectInputDigest");
+/**
+ * Capture reload-directory and reload-file fingerprints sequentially for the
+ * startup baseline. These reads do not define one atomic selection instant.
+ *
+ * Reload directory digests describe immediate topology and physical identity;
+ * reload file digests keep the leaf link while resolving its parent. The native
+ * host can validate this startup baseline before accepting watcher coverage.
+ *
+ * @evidence contracts/common.md#principled-implementation Attaching each reload input's framed digest to the unchanged declaration preserves the selection-time baseline; later validators compare against those observations instead of blessing a newly sampled state.
+ * @evidence contracts/common.md#clear-and-simple-design Two explicit lanes delegate file and directory semantics to the shared digest namespace and retain the original snapshot's other dependency fields.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Production startup uses these observations before native watcher registration; the exported helper serves that protocol rather than existing solely for parity tests.
+ * @evidence contracts/common.md#meaningful-documentation Native documentation distinguishes topology from content and identifies the startup handoff, with separated tags following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation File leaves retain their entry coordinate and directory digests use available native identity observations with documented lexical/unavailable fallbacks; declared map keys are not blanket case-folded.
+ * @evidence contracts/performance.md#efficient-algorithms Both lanes process every supplied entry, including duplicates, and delegate ancestor/path probes, possible Windows capability queries, immediate topology byte comparisons/framing or whole-file reads. Returned key/digest maps grow with distinct declared paths; current digest buffers coexist with maps already built, without unrelated dependency-file traversal.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This captures a fresh baseline for a selected session; reuse without observing current reload inputs could certify an older selection and belongs to neither this mapper nor its contract.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Digest maps transfer to the returned snapshot and hold no open handle or process-wide history.
+ */
+function fingerprintInitialLSPProjectInputSnapshot(snapshot) {
+    const reloadDirectoryDigests = {};
+    const reloadFileDigests = {};
+    for (const directory of snapshot.reloadDirectories ?? []) {
+        reloadDirectoryDigests[directory] =
+            LSPProjectInputDigest_1.LSPProjectInputDigest.lspProjectInputReloadDirectoryDigest(directory);
+    }
+    for (const file of snapshot.reloadFiles ?? []) {
+        reloadFileDigests[file] = LSPProjectInputDigest_1.LSPProjectInputDigest.lspProjectInputFileDigest(LSPProjectInputDigest_1.LSPProjectInputDigest.realLSPProjectInputEntryPath(file));
+    }
+    return {
+        ...snapshot,
+        reloadDirectoryDigests,
+        reloadFileDigests,
+    };
+}
+//# sourceMappingURL=fingerprintInitialLSPProjectInputSnapshot.js.map

package/lib/launcher/internal/ttscserver/fingerprintInitialLSPProjectInputSnapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fingerprintInitialLSPProjectInputSnapshot.js","sourceRoot":"","sources":["../../../../src/launcher/internal/ttscserver/fingerprintInitialLSPProjectInputSnapshot.ts"],"names":[],"mappings":";;;AACA,mEAAgE;AAEhE;;;;;;;;;;;;;;;;;GAiBG;AACH,mDACE,QAAmC;IAEnC,MAAM,sBAAsB,GAA2B,EAAE,CAAC;IAC1D,MAAM,iBAAiB,GAA2B,EAAE,CAAC;IACrD,KAAK,MAAM,SAAS,IAAI,QAAQ,CAAC,iBAAiB,IAAI,EAAE,EAAE,CAAC;QACzD,sBAAsB,CAAC,SAAS,CAAC;YAC/B,6CAAqB,CAAC,oCAAoC,CAAC,SAAS,CAAC,CAAC;IAC1E,CAAC;IACD,KAAK,MAAM,IAAI,IAAI,QAAQ,CAAC,WAAW,IAAI,EAAE,EAAE,CAAC;QAC9C,iBAAiB,CAAC,IAAI,CAAC,GAAG,6CAAqB,CAAC,yBAAyB,CACvE,6CAAqB,CAAC,4BAA4B,CAAC,IAAI,CAAC,CACzD,CAAC;IACJ,CAAC;IACD,OAAO;QACL,GAAG,QAAQ;QACX,sBAAsB;QACtB,iBAAiB;KAClB,CAAC;AACJ,CAAC"}