@neat.is/types 0.6.4 → 0.7.1

package/dist/index.cjs

@@ -26,6 +26,7 @@ __export(index_exports, {
   BlastRadiusResultSchema: () => BlastRadiusResultSchema,
   BlastRadiusRuleSchema: () => BlastRadiusRuleSchema,
   CheckPoliciesScopeSchema: () => CheckPoliciesScopeSchema,
+  ColumnAttrSchema: () => ColumnAttrSchema,
   CompatRuleRefSchema: () => CompatRuleRefSchema,
   CompatViolationDivergenceSchema: () => CompatViolationDivergenceSchema,
   CompatibilityRuleSchema: () => CompatibilityRuleSchema,
@@ -106,6 +107,9 @@ __export(index_exports, {
   StaleEventSchema: () => StaleEventSchema,
   StaleEventsResponseSchema: () => StaleEventsResponseSchema,
   StructuralRuleSchema: () => StructuralRuleSchema,
+  SymbolKindSchema: () => SymbolKindSchema,
+  SymbolNodeSchema: () => SymbolNodeSchema,
+  SymbolSpanSchema: () => SymbolSpanSchema,
   TransitiveDependenciesResultSchema: () => TransitiveDependenciesResultSchema,
   TransitiveDependencySchema: () => TransitiveDependencySchema,
   VersionMismatchDivergenceSchema: () => VersionMismatchDivergenceSchema,
@@ -134,10 +138,12 @@ __export(index_exports, {
   parseInfraId: () => parseInfraId,
   parseRouteId: () => parseRouteId,
   parseServiceId: () => parseServiceId,
+  parseSymbolId: () => parseSymbolId,
   parseWebsocketChannelId: () => parseWebsocketChannelId,
   passesExtractedFloor: () => passesExtractedFloor,
   routeId: () => routeId,
   serviceId: () => serviceId,
+  symbolId: () => symbolId,
   websocketChannelId: () => websocketChannelId
 });
 module.exports = __toCommonJS(index_exports);
@@ -166,7 +172,16 @@ var EdgeType = {
   // Static module dependency between two FileNodes within a service (ADR-092,
   // file-awareness.md §10). Compile-time, not runtime — represents one file
   // importing another. Distinct from CALLS which records runtime invocations.
-  IMPORTS: "IMPORTS"
+  IMPORTS: "IMPORTS",
+  // Static heritage between two SymbolNodes (ADR-158 §3). `INHERITS` records a
+  // class's `extends` clause (`class ──INHERITS──▶ superclass`); `IMPLEMENTS`
+  // records an `implements` clause (`class ──IMPLEMENTS──▶ implemented`). Both
+  // are symbol→symbol, EXTRACTED, minted only when the parent name resolves to
+  // exactly one known SymbolNode — same-file or through the import graph — never
+  // fuzzy-matched. A parent that resolves to nothing (external package,
+  // re-export chain, an interface, which is not a SymbolNode) emits no edge.
+  INHERITS: "INHERITS",
+  IMPLEMENTS: "IMPLEMENTS"
 };
 var NodeType = {
   ServiceNode: "ServiceNode",
@@ -216,7 +231,18 @@ var NodeType = {
   // edge that carries `lastObserved` and decays OBSERVED → STALE on CONNECTS_TO's
   // own staleness threshold when the channel goes quiet. See
   // docs/contracts/otel-ingest.md.
-  WebSocketChannelNode: "WebSocketChannelNode"
+  WebSocketChannelNode: "WebSocketChannelNode",
+  // A symbol under a file — a function, method, constructor, or class
+  // definition — at definition-span granularity (ADR-158). Static-first: the
+  // extractor mints one per definition and the file owns it through a
+  // `file ──CONTAINS──▶ symbol` edge, one containment level below
+  // `service ──CONTAINS──▶ file`. It carries its `{ startLine, endLine }`
+  // definition span, which is the fusion key ingest joins a span's `code.line`
+  // against to land an OBSERVED edge on the calling symbol rather than only its
+  // file (observed-first edges, one grain finer than §4 file grain). The node is
+  // language-neutral; the per-language tree-sitter extractor is the adapter. See
+  // docs/contracts/static-extraction.md and docs/contracts/file-awareness.md §1.
+  SymbolNode: "SymbolNode"
 };
 var NodeTypeSchema = import_zod.z.enum([
   NodeType.ServiceNode,
@@ -228,145 +254,216 @@ var NodeTypeSchema = import_zod.z.enum([
   NodeType.RouteNode,
   NodeType.GraphQLOperationNode,
   NodeType.GrpcMethodNode,
-  NodeType.WebSocketChannelNode
+  NodeType.WebSocketChannelNode,
+  NodeType.SymbolNode
 ]);
 
 // src/nodes.ts
+var import_zod3 = require("zod");
+
+// src/edges.ts
 var import_zod2 = require("zod");
-var CompatibleDriverSchema = import_zod2.z.object({
-  name: import_zod2.z.string(),
-  minVersion: import_zod2.z.string()
+var ProvenanceSchema = import_zod2.z.enum([
+  Provenance.EXTRACTED,
+  Provenance.INFERRED,
+  Provenance.OBSERVED,
+  Provenance.STALE
+]);
+var EdgeTypeSchema = import_zod2.z.enum([
+  EdgeType.CALLS,
+  EdgeType.DEPENDS_ON,
+  EdgeType.CONNECTS_TO,
+  EdgeType.CONFIGURED_BY,
+  EdgeType.PUBLISHES_TO,
+  EdgeType.CONSUMES_FROM,
+  EdgeType.RUNS_ON,
+  EdgeType.CONTAINS,
+  EdgeType.IMPORTS,
+  EdgeType.INHERITS,
+  EdgeType.IMPLEMENTS
+]);
+var EdgeEvidenceSchema = import_zod2.z.object({
+  file: import_zod2.z.string(),
+  line: import_zod2.z.number().int().nonnegative().optional(),
+  snippet: import_zod2.z.string().optional(),
+  // HTTP shape of a recognised client call site (ADR-119). Present on a
+  // client↔route CALLS edge so the edge records the method + path-template the
+  // client named, alongside the file:line it named them at. Absent on every
+  // other edge — a config or infra edge has no HTTP method.
+  method: import_zod2.z.string().optional(),
+  pathTemplate: import_zod2.z.string().optional()
+});
+var EdgeSignalSchema = import_zod2.z.object({
+  spanCount: import_zod2.z.number().int().nonnegative(),
+  errorCount: import_zod2.z.number().int().nonnegative(),
+  lastObservedAgeMs: import_zod2.z.number().nonnegative().optional()
 });
-var DiscoveredViaSchema = import_zod2.z.enum(["static", "otel", "merged"]);
-var ServiceNodeSchema = import_zod2.z.object({
+var GraphEdgeSchema = import_zod2.z.object({
   id: import_zod2.z.string(),
-  type: import_zod2.z.literal(NodeType.ServiceNode),
-  name: import_zod2.z.string(),
-  language: import_zod2.z.string(),
+  source: import_zod2.z.string(),
+  target: import_zod2.z.string(),
+  type: EdgeTypeSchema,
+  provenance: ProvenanceSchema,
+  confidence: import_zod2.z.number().min(0).max(1).optional(),
+  lastObserved: import_zod2.z.string().datetime().optional(),
+  callCount: import_zod2.z.number().int().nonnegative().optional(),
+  evidence: EdgeEvidenceSchema.optional(),
+  signal: EdgeSignalSchema.optional(),
+  // OBSERVED grain (ADR-142): `file` when the edge originates from a source
+  // file's call site (a `file:` source + `evidence`), `service` for the coarse
+  // fallback where no call site was captured. Makes "service-grained only as a
+  // labeled fallback" (connector gate #803) a stored, machine-readable fact
+  // instead of a re-derivation from the source prefix. `.optional()` — EXTRACTED
+  // edges and legacy snapshots carry none; an OBSERVED edge is backfilled on its
+  // next observation.
+  grain: import_zod2.z.enum(["file", "service"]).optional()
+});
+
+// src/nodes.ts
+var CompatibleDriverSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  minVersion: import_zod3.z.string()
+});
+var DiscoveredViaSchema = import_zod3.z.enum(["static", "otel", "merged"]);
+var ServiceNodeSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  type: import_zod3.z.literal(NodeType.ServiceNode),
+  name: import_zod3.z.string(),
+  language: import_zod3.z.string(),
   // Deployment environment from the OTel `deployment.environment.name` attr
   // (with `deployment.environment` and resource-attr fallbacks). The literal
   // `'unknown'` is the honest sentinel when no env signal is present; static
   // extraction never sees env at extract time, so its ServiceNodes carry
   // `undefined` here and the id stays in the env-less wire format
   // `service:<name>`. See ADR-074 §2 and docs/contracts/env-dimension.md.
-  env: import_zod2.z.string().optional(),
+  env: import_zod3.z.string().optional(),
   // Framework recorded by the static extractor when the install plan
   // dispatches a framework-specific path (Next.js, Remix, SvelteKit, Nuxt,
   // Astro). Optional enrichment — `undefined` for lib-only packages and
   // ambiguous repos. See ADR-074 §3 / docs/contracts/framework-installers.md.
-  framework: import_zod2.z.string().optional(),
+  framework: import_zod3.z.string().optional(),
   // The hosting platform a static extractor recognized this service as
   // deployed to (`'cloudflare'` today) — a free string, same discipline as
   // `framework`, so a future platform needs no schema change. This is the
   // frontend's icon key at the service-rollup level (ADR-133,
   // docs/contracts/static-extraction.md).
-  platform: import_zod2.z.string().optional(),
+  platform: import_zod3.z.string().optional(),
   discoveredVia: DiscoveredViaSchema.optional(),
-  version: import_zod2.z.string().optional(),
-  dbConnectionTarget: import_zod2.z.string().optional(),
-  repoPath: import_zod2.z.string().optional(),
-  owner: import_zod2.z.string().optional(),
-  dependencies: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string()).optional(),
+  version: import_zod3.z.string().optional(),
+  dbConnectionTarget: import_zod3.z.string().optional(),
+  repoPath: import_zod3.z.string().optional(),
+  owner: import_zod3.z.string().optional(),
+  dependencies: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string()).optional(),
   // Hostnames OTel spans might mention for this service: compose service
   // names, k8s metadata.name (and the cluster-DNS variants), Dockerfile
   // labels, etc. resolveServiceId in ingest.ts checks these before falling
   // back to a FRONTIER placeholder.
-  aliases: import_zod2.z.array(import_zod2.z.string()).optional(),
+  aliases: import_zod3.z.array(import_zod3.z.string()).optional(),
   // Optional. If set, services declare their `engines.node` here so γ #74's
   // node-engine compat check has something to test against.
-  nodeEngine: import_zod2.z.string().optional(),
-  incompatibilities: import_zod2.z.array(
+  nodeEngine: import_zod3.z.string().optional(),
+  incompatibilities: import_zod3.z.array(
     // Discriminated by `kind`. `driver-engine` is the original shape and
     // stays default for backward compatibility — older snapshots without a
     // `kind` field still parse via the union's `.optional()` discriminator
     // fallback. New kinds came in with γ #74.
-    import_zod2.z.union([
-      import_zod2.z.object({
-        kind: import_zod2.z.literal("driver-engine").optional(),
-        driver: import_zod2.z.string(),
-        driverVersion: import_zod2.z.string(),
-        engine: import_zod2.z.string(),
-        engineVersion: import_zod2.z.string(),
-        reason: import_zod2.z.string()
+    import_zod3.z.union([
+      import_zod3.z.object({
+        kind: import_zod3.z.literal("driver-engine").optional(),
+        driver: import_zod3.z.string(),
+        driverVersion: import_zod3.z.string(),
+        engine: import_zod3.z.string(),
+        engineVersion: import_zod3.z.string(),
+        reason: import_zod3.z.string()
       }),
-      import_zod2.z.object({
-        kind: import_zod2.z.literal("node-engine"),
-        package: import_zod2.z.string(),
-        packageVersion: import_zod2.z.string().optional(),
-        requiredNodeVersion: import_zod2.z.string(),
-        declaredNodeEngine: import_zod2.z.string().optional(),
-        reason: import_zod2.z.string()
+      import_zod3.z.object({
+        kind: import_zod3.z.literal("node-engine"),
+        package: import_zod3.z.string(),
+        packageVersion: import_zod3.z.string().optional(),
+        requiredNodeVersion: import_zod3.z.string(),
+        declaredNodeEngine: import_zod3.z.string().optional(),
+        reason: import_zod3.z.string()
       }),
-      import_zod2.z.object({
-        kind: import_zod2.z.literal("package-conflict"),
-        package: import_zod2.z.string(),
-        packageVersion: import_zod2.z.string().optional(),
-        requires: import_zod2.z.object({
-          name: import_zod2.z.string(),
-          minVersion: import_zod2.z.string()
+      import_zod3.z.object({
+        kind: import_zod3.z.literal("package-conflict"),
+        package: import_zod3.z.string(),
+        packageVersion: import_zod3.z.string().optional(),
+        requires: import_zod3.z.object({
+          name: import_zod3.z.string(),
+          minVersion: import_zod3.z.string()
         }),
-        foundVersion: import_zod2.z.string().optional(),
-        reason: import_zod2.z.string()
+        foundVersion: import_zod3.z.string().optional(),
+        reason: import_zod3.z.string()
       }),
-      import_zod2.z.object({
-        kind: import_zod2.z.literal("deprecated-api"),
-        package: import_zod2.z.string(),
-        packageVersion: import_zod2.z.string().optional(),
-        reason: import_zod2.z.string()
+      import_zod3.z.object({
+        kind: import_zod3.z.literal("deprecated-api"),
+        package: import_zod3.z.string(),
+        packageVersion: import_zod3.z.string().optional(),
+        reason: import_zod3.z.string()
       })
     ])
   ).optional()
 });
-var DatabaseNodeSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  type: import_zod2.z.literal(NodeType.DatabaseNode),
-  name: import_zod2.z.string(),
-  engine: import_zod2.z.string(),
-  engineVersion: import_zod2.z.string(),
-  compatibleDrivers: import_zod2.z.array(CompatibleDriverSchema),
-  host: import_zod2.z.string().optional(),
-  port: import_zod2.z.number().optional(),
+var DatabaseNodeSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  type: import_zod3.z.literal(NodeType.DatabaseNode),
+  name: import_zod3.z.string(),
+  engine: import_zod3.z.string(),
+  engineVersion: import_zod3.z.string(),
+  compatibleDrivers: import_zod3.z.array(CompatibleDriverSchema),
+  host: import_zod3.z.string().optional(),
+  port: import_zod3.z.number().optional(),
   discoveredVia: DiscoveredViaSchema.optional()
 });
-var ConfigNodeSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  type: import_zod2.z.literal(NodeType.ConfigNode),
-  name: import_zod2.z.string(),
-  path: import_zod2.z.string(),
-  fileType: import_zod2.z.string()
+var ConfigNodeSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  type: import_zod3.z.literal(NodeType.ConfigNode),
+  name: import_zod3.z.string(),
+  path: import_zod3.z.string(),
+  fileType: import_zod3.z.string()
 });
-var InfraNodeSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  type: import_zod2.z.literal(NodeType.InfraNode),
-  name: import_zod2.z.string(),
-  provider: import_zod2.z.string(),
-  region: import_zod2.z.string().optional(),
-  kind: import_zod2.z.string().optional()
+var ColumnAttrSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  provenances: import_zod3.z.array(ProvenanceSchema),
+  confidence: import_zod3.z.number().min(0).max(1)
 });
-var FrontierNodeSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  type: import_zod2.z.literal(NodeType.FrontierNode),
-  name: import_zod2.z.string(),
-  host: import_zod2.z.string(),
-  firstObserved: import_zod2.z.string().datetime().optional(),
-  lastObserved: import_zod2.z.string().datetime().optional()
+var InfraNodeSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  type: import_zod3.z.literal(NodeType.InfraNode),
+  name: import_zod3.z.string(),
+  provider: import_zod3.z.string(),
+  region: import_zod3.z.string().optional(),
+  kind: import_zod3.z.string().optional(),
+  // Column-grain attributes on a table InfraNode (`sql-table`, `supabase-table`).
+  // Absent on a non-table InfraNode (a project node, a queue, a route). Optional
+  // schema growth (ADR-031); ADR-157 stamps the snapshot version because the field
+  // records a new grain the graph can now carry. See docs/contracts/schema.md.
+  columns: import_zod3.z.array(ColumnAttrSchema).optional()
 });
-var FileNodeSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  type: import_zod2.z.literal(NodeType.FileNode),
-  service: import_zod2.z.string(),
-  path: import_zod2.z.string(),
-  language: import_zod2.z.string().optional(),
+var FrontierNodeSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  type: import_zod3.z.literal(NodeType.FrontierNode),
+  name: import_zod3.z.string(),
+  host: import_zod3.z.string(),
+  firstObserved: import_zod3.z.string().datetime().optional(),
+  lastObserved: import_zod3.z.string().datetime().optional()
+});
+var FileNodeSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  type: import_zod3.z.literal(NodeType.FileNode),
+  service: import_zod3.z.string(),
+  path: import_zod3.z.string(),
+  language: import_zod3.z.string().optional(),
   discoveredVia: DiscoveredViaSchema.optional(),
   // The raw compiled `dist/...js` frame an OBSERVED call site was captured on,
   // preserved for diagnostic when ingest resolved it through a source map to
   // this original `src/...ts` (file-awareness.md §4 / `code.original_filepath`).
   // Absent when the call site was already source-grained.
-  originalPath: import_zod2.z.string().optional(),
+  originalPath: import_zod3.z.string().optional(),
   // The hosting platform this file is the entry point for (`'cloudflare'`
   // today) — set on a Worker/Pages-Function's entry file only, mirroring
   // ServiceNode's own `platform` field. See `platformName` below.
-  platform: import_zod2.z.string().optional(),
+  platform: import_zod3.z.string().optional(),
   // The platform's own name for this file's service, when the platform names
   // things differently than NEAT's manifest-derived serviceId (a Cloudflare
   // Worker's wrangler.toml/jsonc `name`, not `package.json#name`). This is the
@@ -374,52 +471,67 @@ var FileNodeSchema = import_zod2.z.object({
   // connector's resolveTarget looks up against to fuse an OBSERVED signal onto
   // this exact FileNode (ADR-133, docs/contracts/static-extraction.md /
   // docs/contracts/connectors.md).
-  platformName: import_zod2.z.string().optional()
+  platformName: import_zod3.z.string().optional()
 });
-var RouteNodeSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  type: import_zod2.z.literal(NodeType.RouteNode),
-  name: import_zod2.z.string(),
-  service: import_zod2.z.string(),
-  method: import_zod2.z.string(),
-  pathTemplate: import_zod2.z.string(),
-  path: import_zod2.z.string(),
-  line: import_zod2.z.number().int().nonnegative().optional(),
-  framework: import_zod2.z.string().optional(),
+var RouteNodeSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  type: import_zod3.z.literal(NodeType.RouteNode),
+  name: import_zod3.z.string(),
+  service: import_zod3.z.string(),
+  method: import_zod3.z.string(),
+  pathTemplate: import_zod3.z.string(),
+  path: import_zod3.z.string(),
+  line: import_zod3.z.number().int().nonnegative().optional(),
+  framework: import_zod3.z.string().optional(),
   discoveredVia: DiscoveredViaSchema.optional()
 });
-var GraphQLOperationNodeSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  type: import_zod2.z.literal(NodeType.GraphQLOperationNode),
-  name: import_zod2.z.string(),
-  service: import_zod2.z.string(),
-  operationType: import_zod2.z.string(),
-  operationName: import_zod2.z.string(),
-  path: import_zod2.z.string().optional(),
-  line: import_zod2.z.number().int().nonnegative().optional(),
+var GraphQLOperationNodeSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  type: import_zod3.z.literal(NodeType.GraphQLOperationNode),
+  name: import_zod3.z.string(),
+  service: import_zod3.z.string(),
+  operationType: import_zod3.z.string(),
+  operationName: import_zod3.z.string(),
+  path: import_zod3.z.string().optional(),
+  line: import_zod3.z.number().int().nonnegative().optional(),
   discoveredVia: DiscoveredViaSchema.optional()
 });
-var GrpcMethodNodeSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  type: import_zod2.z.literal(NodeType.GrpcMethodNode),
-  name: import_zod2.z.string(),
-  rpcService: import_zod2.z.string(),
-  rpcMethod: import_zod2.z.string(),
-  path: import_zod2.z.string().optional(),
-  line: import_zod2.z.number().int().nonnegative().optional(),
+var GrpcMethodNodeSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  type: import_zod3.z.literal(NodeType.GrpcMethodNode),
+  name: import_zod3.z.string(),
+  rpcService: import_zod3.z.string(),
+  rpcMethod: import_zod3.z.string(),
+  path: import_zod3.z.string().optional(),
+  line: import_zod3.z.number().int().nonnegative().optional(),
   discoveredVia: DiscoveredViaSchema.optional()
 });
-var WebSocketChannelNodeSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  type: import_zod2.z.literal(NodeType.WebSocketChannelNode),
-  name: import_zod2.z.string(),
-  service: import_zod2.z.string(),
-  channel: import_zod2.z.string(),
-  path: import_zod2.z.string().optional(),
-  line: import_zod2.z.number().int().nonnegative().optional(),
+var WebSocketChannelNodeSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  type: import_zod3.z.literal(NodeType.WebSocketChannelNode),
+  name: import_zod3.z.string(),
+  service: import_zod3.z.string(),
+  channel: import_zod3.z.string(),
+  path: import_zod3.z.string().optional(),
+  line: import_zod3.z.number().int().nonnegative().optional(),
   discoveredVia: DiscoveredViaSchema.optional()
 });
-var GraphNodeSchema = import_zod2.z.discriminatedUnion("type", [
+var SymbolKindSchema = import_zod3.z.enum(["function", "method", "constructor", "class"]);
+var SymbolSpanSchema = import_zod3.z.object({
+  startLine: import_zod3.z.number().int().nonnegative(),
+  endLine: import_zod3.z.number().int().nonnegative()
+});
+var SymbolNodeSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  type: import_zod3.z.literal(NodeType.SymbolNode),
+  kind: SymbolKindSchema,
+  qualname: import_zod3.z.string(),
+  span: SymbolSpanSchema,
+  service: import_zod3.z.string(),
+  relPath: import_zod3.z.string(),
+  discoveredVia: DiscoveredViaSchema.optional()
+});
+var GraphNodeSchema = import_zod3.z.discriminatedUnion("type", [
   ServiceNodeSchema,
   DatabaseNodeSchema,
   ConfigNodeSchema,
@@ -429,65 +541,10 @@ var GraphNodeSchema = import_zod2.z.discriminatedUnion("type", [
   RouteNodeSchema,
   GraphQLOperationNodeSchema,
   GrpcMethodNodeSchema,
-  WebSocketChannelNodeSchema
+  WebSocketChannelNodeSchema,
+  SymbolNodeSchema
 ]);
 
-// src/edges.ts
-var import_zod3 = require("zod");
-var ProvenanceSchema = import_zod3.z.enum([
-  Provenance.EXTRACTED,
-  Provenance.INFERRED,
-  Provenance.OBSERVED,
-  Provenance.STALE
-]);
-var EdgeTypeSchema = import_zod3.z.enum([
-  EdgeType.CALLS,
-  EdgeType.DEPENDS_ON,
-  EdgeType.CONNECTS_TO,
-  EdgeType.CONFIGURED_BY,
-  EdgeType.PUBLISHES_TO,
-  EdgeType.CONSUMES_FROM,
-  EdgeType.RUNS_ON,
-  EdgeType.CONTAINS,
-  EdgeType.IMPORTS
-]);
-var EdgeEvidenceSchema = import_zod3.z.object({
-  file: import_zod3.z.string(),
-  line: import_zod3.z.number().int().nonnegative().optional(),
-  snippet: import_zod3.z.string().optional(),
-  // HTTP shape of a recognised client call site (ADR-119). Present on a
-  // client↔route CALLS edge so the edge records the method + path-template the
-  // client named, alongside the file:line it named them at. Absent on every
-  // other edge — a config or infra edge has no HTTP method.
-  method: import_zod3.z.string().optional(),
-  pathTemplate: import_zod3.z.string().optional()
-});
-var EdgeSignalSchema = import_zod3.z.object({
-  spanCount: import_zod3.z.number().int().nonnegative(),
-  errorCount: import_zod3.z.number().int().nonnegative(),
-  lastObservedAgeMs: import_zod3.z.number().nonnegative().optional()
-});
-var GraphEdgeSchema = import_zod3.z.object({
-  id: import_zod3.z.string(),
-  source: import_zod3.z.string(),
-  target: import_zod3.z.string(),
-  type: EdgeTypeSchema,
-  provenance: ProvenanceSchema,
-  confidence: import_zod3.z.number().min(0).max(1).optional(),
-  lastObserved: import_zod3.z.string().datetime().optional(),
-  callCount: import_zod3.z.number().int().nonnegative().optional(),
-  evidence: EdgeEvidenceSchema.optional(),
-  signal: EdgeSignalSchema.optional(),
-  // OBSERVED grain (ADR-142): `file` when the edge originates from a source
-  // file's call site (a `file:` source + `evidence`), `service` for the coarse
-  // fallback where no call site was captured. Makes "service-grained only as a
-  // labeled fallback" (connector gate #803) a stored, machine-readable fact
-  // instead of a re-derivation from the source prefix. `.optional()` — EXTRACTED
-  // edges and legacy snapshots carry none; an OBSERVED edge is backfilled on its
-  // next observation.
-  grain: import_zod3.z.enum(["file", "service"]).optional()
-});
-
 // src/events.ts
 var import_zod4 = require("zod");
 var SpanAttributesSchema = import_zod4.z.record(
@@ -637,6 +694,7 @@ var ROUTE_PREFIX = "route:";
 var GRAPHQL_OP_PREFIX = "graphql:";
 var GRPC_METHOD_PREFIX = "grpc:";
 var WEBSOCKET_CHANNEL_PREFIX = "ws:";
+var SYMBOL_PREFIX = "symbol:";
 var ENV_UNKNOWN = "unknown";
 function serviceId(name, env) {
   if (env === void 0 || env === ENV_UNKNOWN) return `${SERVICE_PREFIX}${name}`;
@@ -756,6 +814,34 @@ function parseWebsocketChannelId(id) {
   if (service.length === 0 || channel.length === 0) return null;
   return { service, channel };
 }
+function symbolId(service, relPath, qualname, disambiguator) {
+  const base = `${SYMBOL_PREFIX}${service}:${relPath}#${qualname}`;
+  return disambiguator === void 0 ? base : `${base}~${disambiguator}`;
+}
+function parseSymbolId(id) {
+  if (!id.startsWith(SYMBOL_PREFIX)) return null;
+  const rest = id.slice(SYMBOL_PREFIX.length);
+  const colon = rest.indexOf(":");
+  if (colon === -1) return null;
+  const service = rest.slice(0, colon);
+  const tail = rest.slice(colon + 1);
+  const hash = tail.lastIndexOf("#");
+  if (hash === -1) return null;
+  const relPath = tail.slice(0, hash);
+  let qualname = tail.slice(hash + 1);
+  if (service.length === 0 || relPath.length === 0 || qualname.length === 0) return null;
+  let disambiguator;
+  const tilde = qualname.lastIndexOf("~");
+  if (tilde !== -1) {
+    const suffix = qualname.slice(tilde + 1);
+    if (suffix.length > 0 && /^\d+$/.test(suffix)) {
+      disambiguator = Number(suffix);
+      qualname = qualname.slice(0, tilde);
+    }
+  }
+  if (qualname.length === 0) return null;
+  return { service, relPath, qualname, ...disambiguator !== void 0 ? { disambiguator } : {} };
+}
 var EDGE_ARROW = "->";
 function extractedEdgeId(source, target, type) {
   return `${type}:${source}${EDGE_ARROW}${target}`;
@@ -978,14 +1064,20 @@ var commonFields = {
 var MissingObservedDivergenceSchema = import_zod8.z.object({
   type: import_zod8.z.literal("missing-observed"),
   ...commonFields,
-  edgeType: EdgeTypeSchema,
-  extracted: GraphEdgeSchema
+  edgeType: EdgeTypeSchema.optional(),
+  extracted: GraphEdgeSchema.optional(),
+  // Column locus (ADR-157 §4): the `sql-table` node id and the declared-only column.
+  table: import_zod8.z.string().optional(),
+  column: import_zod8.z.string().optional()
 });
 var MissingExtractedDivergenceSchema = import_zod8.z.object({
   type: import_zod8.z.literal("missing-extracted"),
   ...commonFields,
-  edgeType: EdgeTypeSchema,
-  observed: GraphEdgeSchema
+  edgeType: EdgeTypeSchema.optional(),
+  observed: GraphEdgeSchema.optional(),
+  // Column locus (ADR-157 §4): the `sql-table` node id and the observed-only column.
+  table: import_zod8.z.string().optional(),
+  column: import_zod8.z.string().optional()
 });
 var CompatibilityVerdictSchema = import_zod8.z.enum(["incompatible", "deprecated", "unknown"]);
 var VersionMismatchDivergenceSchema = import_zod8.z.object({
@@ -1239,6 +1331,7 @@ function passesExtractedFloor(confidence) {
   BlastRadiusResultSchema,
   BlastRadiusRuleSchema,
   CheckPoliciesScopeSchema,
+  ColumnAttrSchema,
   CompatRuleRefSchema,
   CompatViolationDivergenceSchema,
   CompatibilityRuleSchema,
@@ -1319,6 +1412,9 @@ function passesExtractedFloor(confidence) {
   StaleEventSchema,
   StaleEventsResponseSchema,
   StructuralRuleSchema,
+  SymbolKindSchema,
+  SymbolNodeSchema,
+  SymbolSpanSchema,
   TransitiveDependenciesResultSchema,
   TransitiveDependencySchema,
   VersionMismatchDivergenceSchema,
@@ -1347,10 +1443,12 @@ function passesExtractedFloor(confidence) {
   parseInfraId,
   parseRouteId,
   parseServiceId,
+  parseSymbolId,
   parseWebsocketChannelId,
   passesExtractedFloor,
   routeId,
   serviceId,
+  symbolId,
   websocketChannelId
 });
 //# sourceMappingURL=index.cjs.map