@neat.is/types 0.7.0 → 0.7.2

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,
@@ -258,141 +259,211 @@ var NodeTypeSchema = import_zod.z.enum([
 ]);
 
 // 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
@@ -400,67 +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 SymbolKindSchema = import_zod2.z.enum(["function", "method", "constructor", "class"]);
-var SymbolSpanSchema = import_zod2.z.object({
-  startLine: import_zod2.z.number().int().nonnegative(),
-  endLine: import_zod2.z.number().int().nonnegative()
+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_zod2.z.object({
-  id: import_zod2.z.string(),
-  type: import_zod2.z.literal(NodeType.SymbolNode),
+var SymbolNodeSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  type: import_zod3.z.literal(NodeType.SymbolNode),
   kind: SymbolKindSchema,
-  qualname: import_zod2.z.string(),
+  qualname: import_zod3.z.string(),
   span: SymbolSpanSchema,
-  service: import_zod2.z.string(),
-  relPath: import_zod2.z.string(),
+  service: import_zod3.z.string(),
+  relPath: import_zod3.z.string(),
   discoveredVia: DiscoveredViaSchema.optional()
 });
-var GraphNodeSchema = import_zod2.z.discriminatedUnion("type", [
+var GraphNodeSchema = import_zod3.z.discriminatedUnion("type", [
   ServiceNodeSchema,
   DatabaseNodeSchema,
   ConfigNodeSchema,
@@ -474,64 +545,6 @@ var GraphNodeSchema = import_zod2.z.discriminatedUnion("type", [
   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,
-  EdgeType.INHERITS,
-  EdgeType.IMPLEMENTS
-]);
-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(
@@ -1051,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({
@@ -1312,6 +1331,7 @@ function passesExtractedFloor(confidence) {
   BlastRadiusResultSchema,
   BlastRadiusRuleSchema,
   CheckPoliciesScopeSchema,
+  ColumnAttrSchema,
   CompatRuleRefSchema,
   CompatViolationDivergenceSchema,
   CompatibilityRuleSchema,