@ttsc/graph 0.23.0 → 0.24.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/graph",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "description": "Checker-resolved architecture graph over MCP for coding agents, backed by ttsc's in-process TypeScript-Go compiler.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -20,7 +20,7 @@
     "typia": "13.2.0"
   },
   "peerDependencies": {
-    "ttsc": "^0.23.0"
+    "ttsc": "^0.24.0"
   },
   "keywords": [
     "ttsc",
@@ -42,7 +42,7 @@
     "three": "^0.184.0",
     "three-forcegraph": "^1.43.4",
     "typescript": "^7.0.2",
-    "ttsc": "0.23.0"
+    "ttsc": "0.24.0"
   },
   "repository": {
     "type": "git",

package/src/index.ts

@@ -83,6 +83,37 @@ export function runGraph(
   );
 }
 
+/** The help spellings `ttscgraph` itself accepts, mirrored for the fallback. */
+const DUMP_HELP_FLAGS = new Set(["--help", "-help", "-h"]);
+
+/**
+ * Print a `dump` usage summary when the native binary cannot be resolved.
+ *
+ * This is a fallback, not a second contract: `cmd/ttscgraph/main.go` owns these
+ * flags and answers whenever it is installed. Keep this short and point at that
+ * authority, so a drift degrades to a stale summary rather than a wrong
+ * answer.
+ */
+function printDumpHelp(): void {
+  process.stdout.write(
+    [
+      "Usage: ttsc-graph dump [options]",
+      "",
+      "Write the whole compiler graph as JSON to stdout: every node and edge,",
+      "none of the MCP response caps.",
+      "",
+      "Options:",
+      "  --cwd <dir>        Project root (default: current directory).",
+      "  --tsconfig <path>  Project tsconfig path (default: tsconfig.json).",
+      "  --pretty           Indent the JSON output.",
+      "",
+      "The native `ttscgraph` binary owns these flags and is not installed here,",
+      "so this summary may lag it. Install `ttsc` and rerun for the exact list.",
+      "",
+    ].join("\n"),
+  );
+}
+
 /**
  * Pass `dump` through to the native binary, inheriting stdio so the JSON lands
  * on this process's stdout. Returns the child's exit code.
@@ -93,6 +124,15 @@ function runDump(argv: readonly string[]): number {
   const { cwd } = projectOptions(parseLauncherOptions(argv, DUMP_OPTIONS));
   const binary = resolveGraphBinary(process.env, cwd);
   if (binary === null) {
+    // `ttscgraph` owns the flag contract, so a resolvable binary always answers
+    // `--help` itself and stays the single source of truth. It cannot answer
+    // when it is absent, and that is exactly when a caller is most likely to be
+    // asking what the command needs — so fall back to a summary that names the
+    // authority rather than making usage unreachable behind an install error.
+    if (argv.some((argument) => DUMP_HELP_FLAGS.has(argument))) {
+      printDumpHelp();
+      return 0;
+    }
     process.stderr.write(
       "@ttsc/graph: could not resolve the ttscgraph binary. " +
         "Install `ttsc` so its platform package is present, " +

package/src/model/TtscGraphMemory.ts

@@ -27,7 +27,7 @@ export class TtscGraphMemory {
 
   /** The absolute project root the dump was built for. */
   readonly project: string;
-  /** Every node, raw plus synthesized (file containers). */
+  /** Every post-fold node, including refined properties and file containers. */
   readonly nodes: readonly ITtscGraphNode[];
   /** Every edge, raw plus synthesized containment. */
   readonly edges: readonly ITtscGraphEdge[];
@@ -190,20 +190,22 @@ function synthesize(dump: ITtscGraphDump): {
   // small — the two copies are 17% of the document, 55 MB of VS Code's 323 MB,
   // paid again in the encode, the pipe, the parse and the validation. Nothing
   // downstream of this line sees a span without its file.
-  const nodes: ITtscGraphNode[] = dump.nodes
-    .filter((n) => n.kind !== "module")
-    .map((n) => {
-      const { evidence, implementation, ...rest } = n;
-      return {
+  const nodes: ITtscGraphNode[] = dump.nodes.flatMap((n): ITtscGraphNode[] => {
+    if (n.kind === "module") return [];
+    const { evidence, implementation, ...rest } = n;
+    return [
+      {
         ...rest,
+        kind: n.kind,
         ...(evidence !== undefined
           ? { evidence: spanIn(evidence, n.file) }
           : {}),
         ...(implementation !== undefined
           ? { implementation: spanIn(implementation, n.file) }
           : {}),
-      };
-    });
+      },
+    ];
+  });
   const edges: ITtscGraphEdge[] = dump.edges.map((edge) => {
     const { evidence, ...rest } = edge;
     const from = moduleIds.get(edge.from);

package/src/model/TtscGraphSession.ts

@@ -6,6 +6,7 @@ import { ensureExecutable } from "../nativeExecutable";
 import { resolveGraphBinary } from "../resolveGraphBinary";
 import { ITtscGraphSnapshot } from "../structures/ITtscGraphSnapshot";
 import { TtscGraphMemory } from "./TtscGraphMemory";
+import { TtscGraphShardStore } from "./TtscGraphShardStore";
 import { DUMP_SCHEMA_VERSION } from "./loadGraph";
 
 /**
@@ -17,6 +18,7 @@ import { DUMP_SCHEMA_VERSION } from "./loadGraph";
  * constant out of this file and fails if the pair drifts.
  */
 const PROTOCOL_VERSION = 1;
+const GRAPH_SNAPSHOT_PROTOCOL_VERSION = 1;
 const DEFAULT_REQUEST_TIMEOUT_MS = 300_000;
 const MAX_TIMER_MS = 2_147_483_647;
 const TERMINATION_GRACE_MS = 1_000;
@@ -75,6 +77,7 @@ export class TtscGraphSession {
   private readonly pending = new Map<number, Pending>();
   private queue: Promise<void> = Promise.resolve();
   private current: TtscGraphMemory | undefined;
+  private shardStore = new TtscGraphShardStore();
   private closed = false;
 
   public constructor(options: TtscGraphSessionOptions) {
@@ -167,16 +170,30 @@ export class TtscGraphSession {
     // The protocol version and the envelope shape were both settled in onLine,
     // before this frame was ever routed here.
     const response = await this.request(signal);
+    this.assertResponseSemantics(response);
     if (response.error !== undefined) {
       throw new Error(`@ttsc/graph: ${response.error}`);
     }
     if (response.changed) {
-      if (response.dump === undefined) {
+      if (response.snapshot !== undefined) {
+        try {
+          this.current = TtscGraphMemory.from(
+            this.shardStore.apply(response.snapshot),
+          );
+        } catch (error) {
+          const failure = asError(error);
+          if (this.child !== undefined) this.failChild(this.child, failure);
+          throw failure;
+        }
+      } else if (response.dump !== undefined) {
+        // A serve-protocol-v1 binary predating graph shard negotiation ignores
+        // the optional request field and retains the complete-dump response.
+        this.current = TtscGraphMemory.from(response.dump);
+      } else {
         throw new Error(
-          `@ttsc/graph: native ${response.mode} response omitted its dump`,
+          `@ttsc/graph: native ${response.mode} response omitted both graph snapshot protocol v${String(GRAPH_SNAPSHOT_PROTOCOL_VERSION)} data and a compatible dump`,
         );
       }
-      this.current = TtscGraphMemory.from(response.dump);
     }
     if (this.current === undefined) {
       throw new Error(
@@ -186,6 +203,30 @@ export class TtscGraphSession {
     return this.current;
   }
 
+  private assertResponseSemantics(response: ITtscGraphSnapshot): void {
+    const bodies =
+      Number(response.dump !== undefined) +
+      Number(response.snapshot !== undefined);
+    let problem: string | undefined;
+    if (response.error !== undefined) {
+      if (response.mode !== "error" || response.changed || bodies !== 0) {
+        problem = "an error response carried snapshot state";
+      }
+    } else if (response.mode === "error") {
+      problem = "an error-mode response omitted its error";
+    } else if (response.changed) {
+      if (response.mode === "unchanged" || bodies !== 1) {
+        problem = "a changed response did not carry exactly one snapshot body";
+      }
+    } else if (response.mode !== "unchanged" || bodies !== 0) {
+      problem = "an unchanged response carried changed mode or snapshot state";
+    }
+    if (problem === undefined) return;
+    const error = new Error(`@ttsc/graph: native session returned ${problem}`);
+    if (this.child !== undefined) this.failChild(this.child, error);
+    throw error;
+  }
+
   private request(signal?: AbortSignal): Promise<ITtscGraphSnapshot> {
     if (signal?.aborted) throw cancelledError(signal);
     const child = this.ensureChild();
@@ -216,16 +257,19 @@ export class TtscGraphSession {
         pending.abort!();
         return;
       }
-      child.process.stdin.write(`${JSON.stringify({ id })}\n`, (error) => {
-        if (error === null || error === undefined) return;
-        if (this.pending.get(id) !== pending) return;
-        this.failChild(
-          child,
-          new Error(
-            `@ttsc/graph: could not request native snapshot: ${error.message}`,
-          ),
-        );
-      });
+      child.process.stdin.write(
+        `${JSON.stringify({ id, graphSnapshotVersion: GRAPH_SNAPSHOT_PROTOCOL_VERSION })}\n`,
+        (error) => {
+          if (error === null || error === undefined) return;
+          if (this.pending.get(id) !== pending) return;
+          this.failChild(
+            child,
+            new Error(
+              `@ttsc/graph: could not request native snapshot: ${error.message}`,
+            ),
+          );
+        },
+      );
     });
   }
 
@@ -344,8 +388,10 @@ export class TtscGraphSession {
     // looking like a type with no members. Hold the body to its own number too,
     // once the frame is understood.
     if (
-      response.dump !== undefined &&
-      response.dump.provenance.schemaVersion !== DUMP_SCHEMA_VERSION
+      (response.dump !== undefined &&
+        response.dump.provenance.schemaVersion !== DUMP_SCHEMA_VERSION) ||
+      (response.snapshot !== undefined &&
+        response.snapshot.schemaVersion !== DUMP_SCHEMA_VERSION)
     ) {
       // Session-wide, for the same reason the protocol mismatch above is: it is
       // the wrong binary, not one bad frame.
@@ -353,7 +399,8 @@ export class TtscGraphSession {
         child,
         new Error(
           `@ttsc/graph: ttscgraph sends dump schema v${String(
-            response.dump.provenance.schemaVersion,
+            response.dump?.provenance.schemaVersion ??
+              response.snapshot?.schemaVersion,
           )}, this client reads v${String(DUMP_SCHEMA_VERSION)}. ` +
             "Install a matching `ttsc` (the binary resolves from the target " +
             "project, or from TTSC_GRAPH_BINARY).",
@@ -371,6 +418,7 @@ export class TtscGraphSession {
     if (this.child !== child) return;
     this.child = undefined;
     this.current = undefined;
+    this.shardStore = new TtscGraphShardStore();
     child.lines.close();
     this.failPending(error, child);
     if (terminate) terminateChild(child.process);

package/src/model/TtscGraphShardStore.ts

@@ -0,0 +1,371 @@
+import { Buffer } from "node:buffer";
+import { createHash } from "node:crypto";
+
+import { ITtscGraphDump } from "../structures/ITtscGraphDump";
+import { ITtscGraphSnapshot } from "../structures/ITtscGraphSnapshot";
+import { DUMP_SCHEMA_VERSION } from "./loadGraph";
+
+/** Atomic validator and assembler for native `ttscgraph` shard transactions. */
+export class TtscGraphShardStore {
+  static readonly PROTOCOL_VERSION = 1;
+
+  private sequence: number | undefined;
+  private generation: string | undefined;
+  private project: string | undefined;
+  private tsconfig: string | undefined;
+  private shards = new Map<
+    string,
+    { digest: string; shard: ITtscGraphSnapshot.IShard }
+  >();
+
+  /** Validate and atomically commit one complete or base-generation delta. */
+  apply(transaction: ITtscGraphSnapshot.ITransaction): ITtscGraphDump {
+    this.assertCoordinates(transaction);
+    const next = new Map(this.shards);
+    const touched = new Set<string>();
+    for (const key of transaction.deletes) {
+      assertShardKey(key);
+      if (touched.has(key)) {
+        throw new Error(`@ttsc/graph: native transaction repeats shard ${key}`);
+      }
+      touched.add(key);
+      if (!next.delete(key)) {
+        throw new Error(
+          `@ttsc/graph: native transaction deletes unknown shard ${key}`,
+        );
+      }
+    }
+    for (const upsert of transaction.upserts) {
+      assertShardKey(upsert.shard.key);
+      if (touched.has(upsert.shard.key)) {
+        throw new Error(
+          `@ttsc/graph: native transaction touches shard ${upsert.shard.key} more than once`,
+        );
+      }
+      touched.add(upsert.shard.key);
+      const digest = TtscGraphShardStore.shardDigest(upsert.shard);
+      if (digest !== upsert.digest) {
+        throw new Error(
+          `@ttsc/graph: native shard ${upsert.shard.key} digest ${upsert.digest} does not match ${digest}`,
+        );
+      }
+      next.set(upsert.shard.key, { digest, shard: upsert.shard });
+    }
+
+    const manifest = [...transaction.manifest];
+    for (let index = 0; index < manifest.length; index++) {
+      const reference = manifest[index]!;
+      if (
+        index !== 0 &&
+        compareText(manifest[index - 1]!.key, reference.key) >= 0
+      ) {
+        throw new Error(
+          "@ttsc/graph: native shard manifest must be strictly key-sorted",
+        );
+      }
+    }
+    if (manifest.length !== next.size) {
+      throw new Error(
+        "@ttsc/graph: native shard manifest does not describe the reconstructed generation",
+      );
+    }
+    for (const reference of manifest) {
+      assertShardKey(reference.key);
+      const committed = next.get(reference.key);
+      if (committed === undefined || committed.digest !== reference.digest) {
+        throw new Error(
+          `@ttsc/graph: native shard manifest disagrees at ${reference.key}`,
+        );
+      }
+    }
+    const generation = digest({
+      tsconfig: transaction.tsconfig,
+      producer: transaction.producer,
+      capabilities: transaction.capabilities,
+      universe: transaction.universe,
+      manifest,
+    });
+    if (generation !== transaction.generation) {
+      throw new Error(
+        `@ttsc/graph: native generation ${transaction.generation} does not match ${generation}`,
+      );
+    }
+
+    const dump = assemble(transaction, next);
+    this.sequence = transaction.sequence;
+    this.generation = transaction.generation;
+    this.project = transaction.project;
+    this.tsconfig = transaction.tsconfig;
+    this.shards = next;
+    return dump;
+  }
+
+  /** SHA-256 over the producer's deterministic Go JSON encoding. */
+  static shardDigest(shard: ITtscGraphSnapshot.IShard): string {
+    return digest(shard);
+  }
+
+  private assertCoordinates(
+    transaction: ITtscGraphSnapshot.ITransaction,
+  ): void {
+    if (transaction.protocolVersion !== TtscGraphShardStore.PROTOCOL_VERSION) {
+      throw new Error(
+        `@ttsc/graph: ttscgraph sends graph snapshot protocol v${String(transaction.protocolVersion)}, this client reads v${String(TtscGraphShardStore.PROTOCOL_VERSION)}`,
+      );
+    }
+    if (transaction.schemaVersion !== DUMP_SCHEMA_VERSION) {
+      throw new Error(
+        `@ttsc/graph: ttscgraph sends dump schema v${String(transaction.schemaVersion)}, this client reads v${String(DUMP_SCHEMA_VERSION)}`,
+      );
+    }
+    if (
+      !Number.isSafeInteger(transaction.sequence) ||
+      transaction.sequence < 1
+    ) {
+      throw new Error("@ttsc/graph: native transaction sequence is invalid");
+    }
+    if (transaction.generation === "") {
+      throw new Error("@ttsc/graph: native transaction generation is empty");
+    }
+    if (this.sequence === undefined || this.generation === undefined) {
+      if (
+        transaction.sequence !== 1 ||
+        transaction.baseSequence !== undefined ||
+        transaction.baseGeneration !== undefined ||
+        transaction.deletes.length !== 0
+      ) {
+        throw new Error(
+          "@ttsc/graph: initial native transaction is not a complete generation",
+        );
+      }
+      return;
+    }
+    if (
+      transaction.sequence !== this.sequence + 1 ||
+      transaction.baseSequence !== this.sequence ||
+      transaction.baseGeneration !== this.generation
+    ) {
+      throw new Error(
+        `@ttsc/graph: native transaction has stale base ${String(transaction.baseSequence)}/${String(transaction.baseGeneration)}`,
+      );
+    }
+    if (
+      transaction.project !== this.project ||
+      transaction.tsconfig !== this.tsconfig
+    ) {
+      throw new Error(
+        "@ttsc/graph: native transaction changed its resident project coordinates",
+      );
+    }
+  }
+}
+
+function assemble(
+  transaction: ITtscGraphSnapshot.ITransaction,
+  committed: ReadonlyMap<
+    string,
+    { digest: string; shard: ITtscGraphSnapshot.IShard }
+  >,
+): ITtscGraphDump {
+  const nodes: ITtscGraphDump.INode[] = [];
+  const edges: ITtscGraphDump.IEdge[] = [];
+  const diagnostics: ITtscGraphDump.IDiagnostic[] = [];
+  const sources: ITtscGraphDump.ISourceDigest[] = [];
+  const nodeOwners = new Map<string, string>();
+  const sourceFiles = new Set<string>();
+  const configInputs = new Map<string, string>();
+  for (const [key, value] of committed) {
+    const shard = value.shard;
+    if (shard.key !== key) {
+      throw new Error(`@ttsc/graph: native shard key disagrees at ${key}`);
+    }
+    if (shard.source !== undefined && shard.config !== undefined) {
+      throw new Error(
+        `@ttsc/graph: native shard ${key} claims both source and config input`,
+      );
+    }
+    if (
+      shard.config !== undefined &&
+      (shard.nodes.length !== 0 || shard.edges.length !== 0)
+    ) {
+      throw new Error(
+        `@ttsc/graph: native config shard ${key} unexpectedly owns facts`,
+      );
+    }
+    if (shard.config !== undefined) {
+      if (configInputs.has(shard.config.file)) {
+        throw new Error(
+          `@ttsc/graph: native config ${shard.config.file} has more than one shard`,
+        );
+      }
+      configInputs.set(shard.config.file, shard.config.digest);
+    }
+    if (shard.source !== undefined) {
+      if (sourceFiles.has(shard.source.file)) {
+        throw new Error(
+          `@ttsc/graph: native source ${shard.source.file} has more than one shard`,
+        );
+      }
+      sourceFiles.add(shard.source.file);
+      sources.push({ ...shard.source });
+    }
+    assertShardContents(key, shard);
+    for (const node of shard.nodes) {
+      const owner = nodeOwners.get(node.id);
+      if (owner !== undefined) {
+        throw new Error(
+          `@ttsc/graph: native node ${node.id} is owned by both ${owner} and ${key}`,
+        );
+      }
+      nodeOwners.set(node.id, key);
+      nodes.push(node);
+    }
+    edges.push(...shard.edges);
+    diagnostics.push(...shard.diagnostics);
+  }
+  for (const [key, value] of committed) {
+    for (const edge of value.shard.edges) {
+      if (nodeOwners.get(edge.from) !== key) {
+        throw new Error(
+          `@ttsc/graph: native shard ${key} does not own edge source ${edge.from}`,
+        );
+      }
+      if (!nodeOwners.has(edge.to)) {
+        throw new Error(
+          `@ttsc/graph: native edge target is absent from the generation: ${edge.to}`,
+        );
+      }
+    }
+  }
+  const unmatchedConfigs = new Map(configInputs);
+  for (const config of transaction.universe.configs) {
+    if (
+      unmatchedConfigs.get(config.file) !== config.digest ||
+      !unmatchedConfigs.delete(config.file)
+    ) {
+      throw new Error(
+        `@ttsc/graph: native config shard disagrees with universe input ${config.file}`,
+      );
+    }
+  }
+  if (unmatchedConfigs.size !== 0) {
+    throw new Error(
+      "@ttsc/graph: native config shards do not cover the build universe",
+    );
+  }
+  nodes.sort((left, right) => compareText(left.id, right.id));
+  edges.sort(
+    (left, right) =>
+      compareText(left.from, right.from) ||
+      compareText(left.to, right.to) ||
+      compareText(left.kind, right.kind),
+  );
+  diagnostics.sort(
+    (left, right) =>
+      compareText(left.file, right.file) ||
+      left.line - right.line ||
+      left.column - right.column ||
+      left.code - right.code,
+  );
+  sources.sort((left, right) => compareText(left.file, right.file));
+  return {
+    project: transaction.project,
+    tsconfig: transaction.tsconfig,
+    provenance: {
+      schemaVersion: transaction.schemaVersion,
+      capabilities: [...transaction.capabilities],
+      producer: { ...transaction.producer },
+      universe: {
+        configs: transaction.universe.configs.map((config) => ({ ...config })),
+        roots: transaction.universe.roots.map((root) => ({ ...root })),
+      },
+      sources,
+    },
+    diagnostics,
+    nodes,
+    edges,
+  };
+}
+
+function assertShardContents(
+  key: string,
+  shard: ITtscGraphSnapshot.IShard,
+): void {
+  if (shard.source !== undefined) {
+    for (const node of shard.nodes) {
+      if (node.external || node.file !== shard.source.file) {
+        throw new Error(
+          `@ttsc/graph: native source shard ${key} owns node ${node.id} from ${node.file}`,
+        );
+      }
+    }
+    for (const diagnostic of shard.diagnostics) {
+      if (diagnostic.file !== shard.source.file) {
+        throw new Error(
+          `@ttsc/graph: native source shard ${key} owns diagnostic from ${diagnostic.file}`,
+        );
+      }
+    }
+    return;
+  }
+  if (shard.edges.length !== 0) {
+    throw new Error(
+      `@ttsc/graph: native non-source shard ${key} unexpectedly owns edges`,
+    );
+  }
+  if (shard.config !== undefined) {
+    for (const diagnostic of shard.diagnostics) {
+      if (diagnostic.file !== shard.config.file) {
+        throw new Error(
+          `@ttsc/graph: native config shard ${key} owns diagnostic from ${diagnostic.file}`,
+        );
+      }
+    }
+    return;
+  }
+  for (const node of shard.nodes) {
+    if (!node.external) {
+      throw new Error(
+        `@ttsc/graph: native metadata shard ${key} owns authored node ${node.id}`,
+      );
+    }
+  }
+  for (const diagnostic of shard.diagnostics) {
+    if (diagnostic.file !== "") {
+      throw new Error(
+        `@ttsc/graph: native metadata shard ${key} owns diagnostic from ${diagnostic.file}`,
+      );
+    }
+  }
+}
+
+function assertShardKey(key: string): void {
+  if (key === "" || key.includes("\0")) {
+    throw new Error(`@ttsc/graph: native shard key is invalid: ${key}`);
+  }
+}
+
+function compareText(left: string, right: string): number {
+  return Buffer.compare(Buffer.from(left, "utf8"), Buffer.from(right, "utf8"));
+}
+
+function goJSON(value: unknown): string {
+  return JSON.stringify(value).replace(/[<>&\u2028\u2029]/gu, (character) => {
+    switch (character) {
+      case "<":
+        return "\\u003c";
+      case ">":
+        return "\\u003e";
+      case "&":
+        return "\\u0026";
+      case "\u2028":
+        return "\\u2028";
+      default:
+        return "\\u2029";
+    }
+  });
+}
+
+function digest(value: unknown): string {
+  return createHash("sha256").update(goJSON(value)).digest("hex");
+}

package/src/server/runDetails.ts

@@ -24,13 +24,11 @@ const MAX_NEIGHBORS = 3;
 const DEFAULT_DEPENDENCIES = 2;
 const MAX_DEPENDENCIES = 4;
 // Structural relationships are navigation, not the dependency picture details is for.
-const STRUCTURAL_KINDS = new Set<string>(["contains", "exports", "imports"]);
+const STRUCTURAL_KINDS = new Set<string>(["contains", "exports"]);
 // Kinds whose value is their member outline, not implementation text.
-const CONTAINER_KINDS = new Set<string>([
+const CONTAINER_KINDS = new Set<ITtscGraphNode["kind"]>([
   "class",
   "interface",
-  "namespace",
-  "module",
   "enum",
   "file",
 ]);
@@ -464,16 +462,13 @@ function edgeKindRank(kind: string): number {
     case "accesses":
     case "renders":
       return 2;
-    case "tests":
-      return 3;
     case "overrides":
-    case "decorates":
-      return 4;
+      return 3;
     case "extends":
     case "implements":
-      return 5;
+      return 4;
     case "type_ref":
-      return 6;
+      return 5;
     default:
       return 10;
   }