ttsc 0.24.0 → 0.25.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Jeongho Nam
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 Jeongho Nam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -8,8 +8,9 @@ A `typescript-go` toolchain for compiler-powered plugins and type-safe execution
 
 - **`ttsc`**: build, check, and transform.
 - **`ttsx`**: execute TypeScript with type checking.
-- [**`@ttsc/graph`**](https://github.com/samchon/ttsc/tree/master/packages/graph): MCP code graph that reduces agent token usage.
 - [**`@ttsc/lint`**](https://github.com/samchon/ttsc/tree/master/packages/lint): lint violations as compiler errors.
+- [**`@ttsc/evidence`**](https://github.com/samchon/ttsc/tree/master/packages/evidence): 100% requirement coverage, or the build fails.
+- [**`@ttsc/graph`**](https://github.com/samchon/ttsc/tree/master/packages/graph): compiler knowledge graph that cuts agent tokens by 92%.
 - **plugin support**: compiler-powered libraries, such as `typia`.
 
 ## Setup
@@ -35,94 +36,95 @@ That covers the CLI. The integrations each have a short guide:
 - [`@ttsc/metro`](https://ttsc.dev/docs/setup/metro): React Native and Expo.
 - [`@ttsc/vscode`](https://ttsc.dev/docs/setup/vscode): live editor diagnostics.
 
-## Graph
-
-Your coding agent answers from the compiler, spending roughly 90% fewer tokens.
+## Lint
 
-`@ttsc/graph` is an MCP server that gives the agent a compiler-resolved graph of your project: what calls what, what a change would touch, and where to start reading. The agent asks the type checker instead of grepping and re-reading files.
+Lint and format inside the type-check you already run. 720+ rules across 21 families, plus a formatter that reproduces Prettier's output.
 
-Register it with your MCP client. For Claude Code, a `.mcp.json` in the project root:
+```ts
+// src/index.ts
+var x: number = 3;
+let y: number = 4;
+const z: string = 5;
+```
 
 ```bash
-npm install -D ttsc @ttsc/graph typescript
-```
+$ npx ttsc --noEmit
+src/index.ts:3:7 - error TS2322: Type 'number' is not assignable to type 'string'.
 
-```json
-{
-  "mcpServers": {
-    "ttsc-graph": {
-      "command": "npx",
-      "args": ["-y", "@ttsc/graph"]
-    }
-  }
-}
-```
+3 const z: string = 5;
+        ~
 
-On the agent-cost benchmark, Claude agents answer reading zero files, cutting tokens by roughly 90% and tool calls by 93% to 96%. The design and per-repository numbers are in the [Code Graph guide](https://ttsc.dev/docs/graph) and the [benchmark](https://ttsc.dev/docs/benchmark/graph).
+src/index.ts:2:5 - error TS17397: [prefer-const] Use const instead of let.
 
-![Median tokens on the shared onboarding question, lower is better](https://ttsc.dev/benchmark/svg/graph-common-codex-gpt-5.6-sol.svg)
+2 let y: number = 4;
+      ~~~~~~~~~~~~~
 
-## Lint
+src/index.ts:1:1 - error TS11966: [no-var] Unexpected var, use let or const instead.
 
-Lint and format at compiler speed: up to 800x faster than ESLint.
+1 var x: number = 3;
+  ~~~~~~~~~~~~~~~~~~
 
-`@ttsc/lint` replaces ESLint and Prettier with rules that run inside the type-check. It shares one AST pass with the compiler, so linting and formatting add almost nothing to the build you already run.
+Found 3 errors in the same file, starting at: src/index.ts:3
+```
 
-Configuration is a single file. Each rule takes `"error"`, `"warning"`, or `"off"`, and the `format` block mirrors `.prettierrc`.
+Type errors and lint violations arrive in one stream, so the CI step that already runs `ttsc --noEmit` gates lint with no second job and no second parse. On vscode's 6,093 files the rules take 73 ms inside that check, where ESLint spends 66.7 s as its own command.
 
-```bash
-npm install -D @ttsc/lint
-```
+`npx ttsc fix` applies autofixes and formatting; `npx ttsc format` only formats. Rules and every `format` key are in the [Lint and Format guide](https://ttsc.dev/docs/lint).
 
-```ts
-// lint.config.ts
-import type { ITtscLintConfig } from "@ttsc/lint";
-
-export default {
-  rules: {
-    "no-var": "error",
-    "prefer-const": "error",
-    "typescript/no-explicit-any": "warning",
-  },
-  format: {
-    printWidth: 100,
-    singleQuote: true,
-    trailingComma: "all",
-  },
-} satisfies ITtscLintConfig;
+## Evidence Graph
+
+Your spec becomes a compile error, so requirement coverage is 100% or the build does not pass. An agent can still lie, but it cannot lie by omission.
+
+```tsx
+/**
+ * @evidence docs/discount.md#coupon-stacking
+ *           States the per-issuer stacking limit
+ *           this section defines, in the buyer's words.
+ * @evidence POST:/orders/{orderId}/coupons
+ *           Explains the rejection this endpoint returns
+ *           for an over-stacked coupon set.
+ * @evidence {@link hooks.useCouponStacking} Renders the limit this hook resolves.
+ */
+export function CouponStackingNotice(props: IProps): JSX.Element;
 ```
 
-Violations surface as compiler diagnostics, in the same stream as type errors, so the CI step that already runs `ttsc --noEmit` gates lint without a second job:
+`@evidence <target> <reason>` names one unit of the spec and why this declaration answers for it. A target is a document section, an API operation, a database schema model, or a TypeScript symbol as an inline link.
 
-```ts
-// src/index.ts
-var count = 3;
-let total = count;
+```bash
+$ npx ttsc
+error TS16411: [evidence/graph] Missing acknowledgement for 'docs/discount.md#coupon-stacking'
+  (Markdown H2 'Coupon Stacking' at docs/discount.md:3)
+  in Claim 1 reference 1 (markdown, symbols: h2, h3).
+
+  Use @evidence on a selected typescript host or @evidenceExclude on an eligible carrier.
+
+Found 3 errors.
 ```
 
-```text
-$ npx ttsc --noEmit
-src/index.ts:1:1 - error TS11966: [no-var] Unexpected var, use let or const instead.
+Without those tags, the build fails once per obligation, because one reference never covers another. An AI coding agent has to clear them to finish, and clearing them means citing each target and writing down why its code answers for it.
 
-1 var count = 3;
-  ~~~
+![Coverage and token spend, Plain against Evidence](https://raw.githubusercontent.com/samchon/ttsc/gh-pages/benchmark/png/evidence-summary.png)
 
-src/index.ts:2:5 - error TS17397: [prefer-const] Use const instead of let.
+## Compiler Knowledge Graph
 
-2 let total = count;
-    ~~~~~
+Your coding agent answers from the compiler instead of grepping and re-reading files.
 
-Found 2 errors in the same file, starting at: src/index.ts:1
+```json
+{
+  "mcpServers": {
+    "ttsc-graph": {
+      "command": "npx",
+      "args": ["-y", "@ttsc/graph"]
+    }
+  }
+}
 ```
 
-Clean the project in place:
+One typed MCP tool over a graph the type checker resolved: what calls what, what a change would touch, where to start reading. Answers carry names, signatures, edges, and spans, never file bodies, so a large repository cannot inflate the response.
 
-```bash
-npx ttsc fix      # lint autofixes + format edits
-npx ttsc format   # format edits only, never changes behavior
-```
+Across 64 measured question and model pairs, the median answer costs 92% fewer tokens and 95% fewer tool calls than the same agent with no MCP. The design and the comparators are in [`@ttsc/graph`](https://github.com/samchon/ttsc/tree/master/packages/graph).
 
-The rule catalog and every `format` key are in the [Lint & Format guide](https://ttsc.dev/docs/lint).
+![Median tokens on the shared onboarding question, lower is better](https://raw.githubusercontent.com/samchon/ttsc/gh-pages/benchmark/png/graph-common-codex-gpt-5.6-sol.png)
 
 ## Plugins
 
@@ -148,6 +150,7 @@ export const isStringArray = (() => {
 Utility plugins shipped in this repository:
 
 - [`@ttsc/banner`](https://github.com/samchon/ttsc/tree/master/packages/banner): adds `@packageDocumentation` JSDoc banners.
+- [`@ttsc/evidence`](https://github.com/samchon/ttsc/tree/master/packages/evidence): turns a requirement into a compile error until code, tests, or docs acknowledge it by name.
 - [`@ttsc/graph`](https://github.com/samchon/ttsc/tree/master/packages/graph): MCP server exposing a checker-resolved code graph to coding agents.
 - [`@ttsc/lint`](https://github.com/samchon/ttsc/tree/master/packages/lint): lints and formats TypeScript source.
 - [`@ttsc/paths`](https://github.com/samchon/ttsc/tree/master/packages/paths): rewrites source path aliases so JS and declaration emit receive relative imports.

package/cmd/ttscgraph/serve_answers_a_project_that_implements_its_own_ambient_declaration_test.go

@@ -0,0 +1,69 @@
+package main
+
+import (
+  "bytes"
+  "encoding/json"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestServeAnswersAProjectThatImplementsItsOwnAmbientDeclaration verifies shard
+// assembly succeeds for a project that declares an ambient global in its own
+// `.d.ts` and assigns the implementation elsewhere.
+//
+// Shard partition indexes edge sources by non-external node, and external nodes
+// live in a non-source shard that may own no edges. An edge leaving one is
+// therefore not a wrong fact but an unassemblable snapshot: the session refused
+// the whole transaction with "edge source node is absent from shard facts", so
+// every request failed before it ran while `dump`, which applies no such check,
+// still emitted the graph.
+//
+//  1. Serve a project whose `src/globals.d.ts` declares `var patched` and whose
+//     `src/index.ts` assigns an arrow function to it.
+//  2. Request one negotiated shard snapshot.
+//  3. Assert the response carries a complete transaction and no error.
+func TestServeAnswersAProjectThatImplementsItsOwnAmbientDeclaration(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "target": "ES2022", "module": "commonjs", "strict": true },
+  "include": ["src"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "globals.d.ts"), `declare global {
+  var patched: (message: string) => void;
+}
+export {};
+`)
+  writeGraphFile(t, filepath.Join(root, "src", "index.ts"), `export function helper(): void {}
+patched = (message: string): void => {
+  helper();
+};
+`)
+
+  input := strings.NewReader("{\"id\":1,\"graphSnapshotVersion\":1}\n")
+  var output bytes.Buffer
+  if code := serveSnapshots(input, &output, root, "tsconfig.json"); code != 0 {
+    t.Fatalf("serveSnapshots exited %d: %s", code, output.String())
+  }
+
+  var initial serveResponse
+  if err := json.NewDecoder(&output).Decode(&initial); err != nil {
+    t.Fatal(err)
+  }
+  if initial.Error != "" {
+    t.Fatalf("shard assembly refused a project that implements its own ambient declaration: %s", initial.Error)
+  }
+  if initial.Mode != serveModeInitial || !initial.Changed || initial.Dump != nil || initial.Snapshot == nil {
+    t.Fatalf("negotiated initial response: %#v", initial)
+  }
+  if len(initial.Snapshot.Manifest) == 0 ||
+    len(initial.Snapshot.Upserts) != len(initial.Snapshot.Manifest) ||
+    len(initial.Snapshot.Deletes) != 0 {
+    t.Fatalf(
+      "initial transaction is not complete: manifest=%d upserts=%d deletes=%d",
+      len(initial.Snapshot.Manifest),
+      len(initial.Snapshot.Upserts),
+      len(initial.Snapshot.Deletes),
+    )
+  }
+}

package/go.sum

@@ -1,22 +1,22 @@
-github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 h1:vymEbVwYFP/L05h5TKQxvkXoKxNvTpjxYKdF1Nlwuao=
-github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433/go.mod h1:tphK2c80bpPhMOI4v6bIc2xWywPfbqi1Z06+RcrMkDg=
-github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
-github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
-github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
-github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
-github.com/microsoft/typescript-go v0.0.0-20260429010842-56ab4af42157 h1:llOMPhKDiQ+UEJiAaQuuWaJOTg5V7tNNTEf9JPWoYSY=
-github.com/microsoft/typescript-go v0.0.0-20260429010842-56ab4af42157/go.mod h1:m8YA0PMC7ti0GW0RI05D6fEcjQeu98XVS+FWF+VDW2k=
-github.com/peter-evans/patience v0.3.0 h1:rX0JdJeepqdQl1Sk9c9uvorjYYzL2TfgLX1adqYm9cA=
-github.com/peter-evans/patience v0.3.0/go.mod h1:Kmxu5sY1NmBLFSStvXjX1wS9mIv7wMcP/ubucyMOAu0=
-github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
-github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
-github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
-github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
-golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
-golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
-golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI=
-golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/text v0.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg=
-golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164=
-gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=
-gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA=
+github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 h1:vymEbVwYFP/L05h5TKQxvkXoKxNvTpjxYKdF1Nlwuao=
+github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433/go.mod h1:tphK2c80bpPhMOI4v6bIc2xWywPfbqi1Z06+RcrMkDg=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
+github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/microsoft/typescript-go v0.0.0-20260429010842-56ab4af42157 h1:llOMPhKDiQ+UEJiAaQuuWaJOTg5V7tNNTEf9JPWoYSY=
+github.com/microsoft/typescript-go v0.0.0-20260429010842-56ab4af42157/go.mod h1:m8YA0PMC7ti0GW0RI05D6fEcjQeu98XVS+FWF+VDW2k=
+github.com/peter-evans/patience v0.3.0 h1:rX0JdJeepqdQl1Sk9c9uvorjYYzL2TfgLX1adqYm9cA=
+github.com/peter-evans/patience v0.3.0/go.mod h1:Kmxu5sY1NmBLFSStvXjX1wS9mIv7wMcP/ubucyMOAu0=
+github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
+github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
+github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
+github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
+golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
+golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI=
+golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/text v0.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg=
+golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164=
+gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=
+gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA=

package/internal/graph/assigned_implementations_of_declaration_file_symbols_leave_no_edge_source_test.go

@@ -0,0 +1,84 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// ambientGlobalFixtureTSConfig compiles a project that declares an ambient
+// global in its own `.d.ts` and assigns the implementation in a sibling source.
+// Both files are named because a global augmentation only reaches the program
+// when its declaration file is an input.
+const ambientGlobalFixtureTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "strict": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "files": ["src/globals.d.ts", "src/main.ts"]
+}
+`
+
+// TestAssignedImplementationsOfDeclarationFileSymbolsLeaveNoEdgeSource verifies
+// that assigning a function to a symbol declared in a declaration file records
+// no edge leaving the external boundary leaf that symbol enters the graph as.
+//
+// An external leaf has no outgoing side: the graph never walks a dependency's
+// internals, and no shard may hold an edge whose source is one — an external
+// node is owned by the non-source external shard, which is forbidden to own
+// edges. Attributing the assigned body to it therefore did not merely misplace
+// facts (with evidence offsets from the implementation read against the
+// declaration file); it produced a snapshot `ttscgraph serve` could not
+// assemble, so every request against such a project failed. The calls the body
+// makes are not lost by refusing it: the module that runs the assignment owns
+// them.
+//
+//  1. Compile a fixture whose `src/globals.d.ts` declares `var patched` in a
+//     global augmentation and whose `src/main.ts` assigns an arrow function to
+//     it that calls a local `helper`.
+//  2. Build the graph.
+//  3. Assert no edge leaves an external node, and that `main.ts`'s module node
+//     still owns the value-call edge to `helper`.
+func TestAssignedImplementationsOfDeclarationFileSymbolsLeaveNoEdgeSource(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), ambientGlobalFixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "globals.d.ts"), `declare global {
+  var patched: (message: string) => void;
+}
+export {};
+`)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export function helper(): void {}
+patched = (message: string): void => {
+  helper();
+};
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  graph := Build(prog)
+  mainPath := sourceFile(t, prog, "main.ts").FileName()
+
+  for _, edge := range graph.Edges {
+    node, ok := graph.Nodes[edge.From]
+    if ok && node.External {
+      t.Fatalf("edge leaves the external boundary: %s -> %s (%s), source declared in %s", edge.From, edge.To, edge.Kind, node.File)
+    }
+  }
+
+  module := moduleID(mainPath)
+  helper := nodeID(mainPath, "helper", NodeFunction)
+  if !hasEdge(graph, module, helper, EdgeValueCall) {
+    t.Fatalf("the assigned body's call to helper is not owned by the running module; edges: %v", graph.Edges)
+  }
+}

package/internal/graph/assigned_implementations_of_node_modules_symbols_leave_no_edge_source_test.go

@@ -0,0 +1,85 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// nodeModulesGlobalFixtureTSConfig compiles a project whose ambient global is
+// declared by a dependency's raw `.ts` source. Both inputs are named because
+// the declaring file is reached by neither an import nor a glob, and no
+// `rootDir` or `outDir` is set because a `node_modules` input under one would
+// be an input outside the root.
+const nodeModulesGlobalFixtureTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "strict": true
+  },
+  "files": ["node_modules/dep/globals.ts", "src/main.ts"]
+}
+`
+
+// TestAssignedImplementationsOfNodeModulesSymbolsLeaveNoEdgeSource verifies the
+// other half of the external boundary: a symbol declared under `node_modules`
+// gains no outgoing edge from an assignment either.
+//
+// `IsWorkspaceSourceFile` refuses a file for two disjoint reasons, and only one
+// of them is being a declaration file. A dependency that ships raw TypeScript
+// is not a declaration file and still owns no facts in this graph, so an
+// assignment to something it declares must be refused by the same rule. Without
+// this case the fix is pinned on one branch of the classifier and a change to
+// the other would pass.
+//
+//  1. Compile a fixture whose `node_modules/dep/globals.ts` declares `var
+//     patched` in a global augmentation and whose `src/main.ts` assigns an arrow
+//     function to it that calls a local `helper`.
+//  2. Build the graph.
+//  3. Assert no edge leaves an external node, and that `main.ts`'s module node
+//     still owns the value-call edge to `helper`.
+func TestAssignedImplementationsOfNodeModulesSymbolsLeaveNoEdgeSource(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), nodeModulesGlobalFixtureTSConfig)
+  writeFile(t, filepath.Join(root, "node_modules", "dep", "package.json"), `{
+  "name": "dep",
+  "version": "1.0.0"
+}
+`)
+  writeFile(t, filepath.Join(root, "node_modules", "dep", "globals.ts"), `declare global {
+  var patched: (message: string) => void;
+}
+export {};
+`)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export function helper(): void {}
+patched = (message: string): void => {
+  helper();
+};
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  graph := Build(prog)
+  mainPath := sourceFile(t, prog, "main.ts").FileName()
+
+  for _, edge := range graph.Edges {
+    node, ok := graph.Nodes[edge.From]
+    if ok && node.External {
+      t.Fatalf("edge leaves the external boundary: %s -> %s (%s), source declared in %s", edge.From, edge.To, edge.Kind, node.File)
+    }
+  }
+
+  module := moduleID(mainPath)
+  helper := nodeID(mainPath, "helper", NodeFunction)
+  if !hasEdge(graph, module, helper, EdgeValueCall) {
+    t.Fatalf("the assigned body's call to helper is not owned by the running module; edges: %v", graph.Edges)
+  }
+}

package/internal/graph/edges.go

@@ -604,6 +604,20 @@ func (g *Graph) callsWithin(checker *shimchecker.Checker, from string, node *shi
   })
 }
 
+// assignedFunctionTarget returns the graph node an `x.y = function` assignment
+// implements, or "" when the assignment implements no node this graph owns.
+//
+// A declaration outside the workspace is not such a node. `globalThis.assert =
+// …` against a `declare global { function assert(…) }`, or a patched member of
+// a dependency's `@types`, resolves to a symbol whose only declaration is in a
+// declaration file — which has no body, holds no facts, and enters the graph as
+// an external boundary leaf. Re-attributing the assigned body to it moved the
+// implementation's calls and type references onto a node that never ran them,
+// under offsets read against the wrong file: `recordImplementation` already
+// refuses an external node, so the evidence file stayed unset and the spans
+// pointed at neither the declaration nor the implementation. And the edge
+// itself was unassemblable, so every request against such a project failed at
+// shard partition.
 func (g *Graph) assignedFunctionTarget(checker *shimchecker.Checker, from string, node *shimast.Node) string {
   binary := node.AsBinaryExpression()
   if binary == nil ||
@@ -614,7 +628,7 @@ func (g *Graph) assignedFunctionTarget(checker *shimchecker.Checker, from string
     return ""
   }
   target := g.resolve(checker, binary.Left)
-  if target == nil || target.Symbol == nil {
+  if target == nil || target.Symbol == nil || target.External {
     return ""
   }
   to := g.ensureTargetNode(target)

package/internal/lspserver/lsp_native_plugin_source.go

@@ -11,10 +11,8 @@ import (
   "strings"
   "sync"
   "sync/atomic"
-  "time"
 )
 
-const nativePluginCommandTimeout = 30 * time.Second
 const nativePluginCommandStdoutLimit = 4 * 1024 * 1024
 const nativePluginCommandStderrLimit = 1024 * 1024
 
@@ -825,7 +823,11 @@ func (s *NativePluginSource) runWithStdin(plugin NativeLSPPluginEntry, command s
   if strings.TrimSpace(plugin.Binary) == "" {
     return nil, fmt.Errorf("ttscserver: %s has no binary", pluginLabel(plugin))
   }
-  ctx, cancel := context.WithTimeout(context.Background(), nativePluginCommandTimeout)
+  // No deadline: the command is running the user's own rules, and how long
+  // that takes is not this process's call. The context stays so that a future
+  // early return cannot leave the child running — cancelling it kills the
+  // process rather than abandoning it.
+  ctx, cancel := context.WithCancel(context.Background())
   defer cancel()
   allArgs := []string{
     command,
@@ -848,9 +850,6 @@ func (s *NativePluginSource) runWithStdin(plugin NativeLSPPluginEntry, command s
   cmd.Stdout = &stdout
   cmd.Stderr = &stderr
   err := cmd.Run()
-  if ctx.Err() != nil {
-    return nil, fmt.Errorf("ttscserver: %s %s timed out", pluginLabel(plugin), command)
-  }
   if err != nil {
     msg := strings.TrimSpace(stderr.String())
     if msg == "" {

package/internal/lspserver/lsp_native_resident.go

@@ -9,15 +9,8 @@ import (
   "os/exec"
   "strings"
   "sync"
-  "time"
 )
 
-// residentRequestTimeout bounds one resident verb round trip, mirroring the
-// spawn-per-verb path's nativePluginCommandTimeout. A rule that hangs must not
-// wedge the daemon's request mutex forever; on timeout the sidecar is killed and
-// the caller falls back to a fresh spawn.
-const residentRequestTimeout = nativePluginCommandTimeout
-
 // The serve verbs below are routed to the resident daemon because they load a
 // Program.
 // lsp-command-ids / lsp-code-action-kinds run once at startup and never load one
@@ -121,8 +114,10 @@ func (s *NativePluginSource) serveRun(plugin NativeLSPPluginEntry, verb string,
 }
 
 // call sends one request to the daemon and reads its reply, serializing access
-// to the single pipe. It spawns the child on first use or after a death, and
-// enforces a per-request timeout so a hung rule cannot wedge the mutex.
+// to the single pipe. It spawns the child on first use or after a death. The
+// read is unbounded — the rule is the user's own code — and the mutex is held
+// only as long as the sidecar is alive, because its death closes stdout and
+// ends the read.
 func (sc *residentSidecar) call(s *NativePluginSource, plugin NativeLSPPluginEntry, req serveClientRequest) ([]byte, int, error) {
   sc.mu.Lock()
   defer sc.mu.Unlock()
@@ -162,23 +157,21 @@ func (sc *residentSidecar) call(s *NativePluginSource, plugin NativeLSPPluginEnt
     raw, err := sc.stdout.ReadBytes('\n')
     done <- readResult{line: raw, err: err}
   }()
-  select {
-  case <-time.After(residentRequestTimeout):
+  // No deadline: a rule that takes a long time is the user's own code running,
+  // and the read still ends the moment the sidecar dies, because closing its
+  // stdout surfaces here as a read error.
+  res := <-done
+  if res.err != nil {
     sc.kill()
-    return nil, 0, fmt.Errorf("ttscserver: %s %s (resident) timed out", pluginLabel(plugin), req.Verb)
-  case res := <-done:
-    if res.err != nil {
-      sc.kill()
-      return nil, 0, res.err
-    }
-    var resp serveClientResponse
-    if err := json.Unmarshal(res.line, &resp); err != nil {
-      sc.kill()
-      return nil, 0, err
-    }
-    sc.everServed = true
-    return resp.Result, resp.Code, nil
+    return nil, 0, res.err
+  }
+  var resp serveClientResponse
+  if err := json.Unmarshal(res.line, &resp); err != nil {
+    sc.kill()
+    return nil, 0, err
   }
+  sc.everServed = true
+  return resp.Result, resp.Code, nil
 }
 
 // spawn starts the resident child with the base project args and the lsp-serve