@nicia-ai/typegraph 0.34.0 → 0.36.0

package/dist/chunk-T2DWPQNE.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/interchange/types.ts","../src/interchange/export.ts","../src/interchange/import.ts"],"names":["result"],"mappings":"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","file":"chunk-T2DWPQNE.js","sourcesContent":["/**\n * Graph interchange format types.\n *\n * Defines Zod schemas for importing and exporting graph data.\n * The format is designed to be:\n * - JSON-serializable for API transport\n * - Validated via Zod at runtime\n * - Exportable as JSON Schema for LLM/API documentation\n */\nimport { z } from \"zod\";\n\nimport { isCanonicalIsoDate } from \"../utils/date\";\n\n// ============================================================\n// Format Version\n// ============================================================\n\n/**\n * Current interchange format version.\n * Increment for breaking changes to the format.\n */\nexport const FORMAT_VERSION = \"1.0\" as const;\n\n/**\n * A stored validity-window timestamp (`validFrom` / `validTo`). Must be a\n * canonical fixed-width UTC ISO-8601 string (`YYYY-MM-DDTHH:mm:ss.sssZ`) — the\n * same contract `create` / `update` enforce — because temporal filters compare\n * it as text against the `asOf` read coordinate, and a variable-width value\n * (date-only, offset, missing/variable milliseconds) would mis-sort and\n * silently include or exclude the wrong rows. Convert non-canonical inputs with\n * `new Date(value).toISOString()`.\n */\nconst ValidityTimestampSchema = z.iso\n  .datetime()\n  .refine((value) => isCanonicalIsoDate(value), {\n    message:\n      \"Expected canonical UTC ISO 8601 (YYYY-MM-DDTHH:mm:ss.sssZ); convert with new Date(value).toISOString().\",\n  });\n\n// ============================================================\n// Node Interchange\n// ============================================================\n\n/**\n * Interchange format for a node.\n *\n * Properties are stored as a record to allow schema-agnostic transport.\n * Validation against the actual schema happens during import.\n */\nexport const InterchangeNodeSchema = z.object({\n  kind: z.string().min(1),\n  id: z.string().min(1),\n  properties: z.record(z.string(), z.unknown()),\n  validFrom: ValidityTimestampSchema.optional(),\n  validTo: ValidityTimestampSchema.optional(),\n  meta: z\n    .object({\n      version: z.number().int().positive().optional(),\n      createdAt: z.iso.datetime().optional(),\n      updatedAt: z.iso.datetime().optional(),\n    })\n    .optional(),\n});\n\nexport type InterchangeNode = z.infer<typeof InterchangeNodeSchema>;\n\n// ============================================================\n// Edge Interchange\n// ============================================================\n\n/**\n * Interchange format for an edge.\n *\n * Endpoint references are objects with kind and id, rather than\n * composite strings, for clarity and type safety.\n */\nexport const InterchangeEdgeSchema = z.object({\n  kind: z.string().min(1),\n  id: z.string().min(1),\n  from: z.object({\n    kind: z.string().min(1),\n    id: z.string().min(1),\n  }),\n  to: z.object({\n    kind: z.string().min(1),\n    id: z.string().min(1),\n  }),\n  properties: z.record(z.string(), z.unknown()).default({}),\n  validFrom: ValidityTimestampSchema.optional(),\n  validTo: ValidityTimestampSchema.optional(),\n  meta: z\n    .object({\n      createdAt: z.iso.datetime().optional(),\n      updatedAt: z.iso.datetime().optional(),\n    })\n    .optional(),\n});\n\nexport type InterchangeEdge = z.infer<typeof InterchangeEdgeSchema>;\n\n// ============================================================\n// Import Configuration\n// ============================================================\n\n/**\n * Strategy for handling conflicts when a node/edge ID already exists.\n *\n * - `skip`: Keep existing, ignore incoming\n * - `update`: Merge incoming properties into existing\n * - `error`: Throw an error on conflict\n */\nexport const ConflictStrategySchema = z.enum([\"skip\", \"update\", \"error\"]);\nexport type ConflictStrategy = z.infer<typeof ConflictStrategySchema>;\n\n/**\n * Strategy for handling properties not defined in the schema.\n *\n * - `error`: Throw a validation error\n * - `strip`: Remove unknown properties silently\n * - `allow`: Pass through to storage (relies on backend behavior)\n */\nexport const UnknownPropertyStrategySchema = z.enum([\n  \"error\",\n  \"strip\",\n  \"allow\",\n]);\nexport type UnknownPropertyStrategy = z.infer<\n  typeof UnknownPropertyStrategySchema\n>;\n\n/**\n * Options for importing graph data.\n */\nexport const ImportOptionsSchema = z.object({\n  /** How to handle existing nodes/edges with the same ID */\n  onConflict: ConflictStrategySchema,\n  /** How to handle properties not in the schema */\n  onUnknownProperty: UnknownPropertyStrategySchema.default(\"error\"),\n  /** Whether to validate that edge endpoints exist */\n  validateReferences: z.boolean().default(true),\n  /** Number of items to process in each batch */\n  batchSize: z.number().int().positive().default(100),\n});\n\nexport type ImportOptions = z.infer<typeof ImportOptionsSchema>;\n\n// ============================================================\n// Graph Data Source\n// ============================================================\n\n/**\n * Source metadata for graph data.\n *\n * Uses discriminated union to capture different origin types:\n * - `typegraph-export`: Exported from a TypeGraph store\n * - `external`: From a third-party system\n */\nexport const GraphDataSourceSchema = z.discriminatedUnion(\"type\", [\n  z.object({\n    type: z.literal(\"typegraph-export\"),\n    graphId: z.string(),\n    schemaVersion: z.number().int().positive(),\n  }),\n  z.object({\n    type: z.literal(\"external\"),\n    description: z.string().optional(),\n  }),\n]);\n\nexport type GraphDataSource = z.infer<typeof GraphDataSourceSchema>;\n\n// ============================================================\n// Graph Data Envelope\n// ============================================================\n\n/**\n * Complete graph data interchange format.\n *\n * The envelope contains metadata about the data source and format version,\n * plus arrays of nodes and edges to import.\n */\nexport const GraphDataSchema = z.object({\n  formatVersion: z.literal(FORMAT_VERSION),\n  exportedAt: z.iso.datetime(),\n  source: GraphDataSourceSchema,\n  nodes: z.array(InterchangeNodeSchema),\n  edges: z.array(InterchangeEdgeSchema),\n});\n\nexport type GraphData = z.infer<typeof GraphDataSchema>;\n\n// ============================================================\n// Import Result\n// ============================================================\n\n/**\n * An error that occurred during import.\n */\nexport const ImportErrorSchema = z.object({\n  entityType: z.enum([\"node\", \"edge\"]),\n  kind: z.string(),\n  id: z.string(),\n  error: z.string(),\n});\n\nexport type ImportError = z.infer<typeof ImportErrorSchema>;\n\n/**\n * Result of an import operation.\n *\n * Contains counts of created/updated/skipped entities and any errors.\n */\nexport const ImportResultSchema = z.object({\n  success: z.boolean(),\n  nodes: z.object({\n    created: z.number().int().nonnegative(),\n    updated: z.number().int().nonnegative(),\n    skipped: z.number().int().nonnegative(),\n  }),\n  edges: z.object({\n    created: z.number().int().nonnegative(),\n    updated: z.number().int().nonnegative(),\n    skipped: z.number().int().nonnegative(),\n  }),\n  errors: z.array(ImportErrorSchema),\n});\n\nexport type ImportResult = z.infer<typeof ImportResultSchema>;\n\n// ============================================================\n// Export Options\n// ============================================================\n\n/**\n * Options for exporting graph data.\n */\nexport const ExportOptionsSchema = z.object({\n  /** Filter to specific node kinds (undefined = all) */\n  nodeKinds: z.array(z.string()).optional(),\n  /** Filter to specific edge kinds (undefined = all) */\n  edgeKinds: z.array(z.string()).optional(),\n  /** Include temporal fields (validFrom, validTo) */\n  includeTemporal: z.boolean().default(false),\n  /** Include metadata (version, timestamps) */\n  includeMeta: z.boolean().default(false),\n  /** Include soft-deleted records */\n  includeDeleted: z.boolean().default(false),\n});\n\n/** Export options with defaults applied (output type) */\nexport type ExportOptions = z.infer<typeof ExportOptionsSchema>;\n\n/** Export options as accepted by exportGraph (input type with optional defaults) */\nexport type ExportOptionsInput = z.input<typeof ExportOptionsSchema>;\n","/**\n * Graph data export functionality.\n *\n * Exports nodes and edges from a store to the interchange format.\n */\nimport { type GraphBackend } from \"../backend/types\";\nimport {\n  getEdgeKinds,\n  getNodeKinds,\n  type GraphDef,\n} from \"../core/define-graph\";\nimport { type Store } from \"../store/store\";\nimport { nowIso } from \"../utils/date\";\nimport {\n  type ExportOptionsInput,\n  FORMAT_VERSION,\n  type GraphData,\n  type InterchangeEdge,\n  type InterchangeNode,\n} from \"./types\";\n\n// ============================================================\n// Export Function\n// ============================================================\n\n/**\n * Export graph data from a store.\n *\n * @param store - The graph store to export from\n * @param options - Export configuration\n * @returns Graph data in interchange format\n *\n * @example\n * ```typescript\n * const data = await exportGraph(store, {\n *   nodeKinds: [\"Person\", \"Organization\"],\n *   includeMeta: true,\n * });\n *\n * // Write to file\n * await fs.writeFile(\"backup.json\", JSON.stringify(data, null, 2));\n * ```\n */\nexport async function exportGraph<G extends GraphDef>(\n  store: Store<G>,\n  options?: ExportOptionsInput,\n): Promise<GraphData> {\n  const options_ = {\n    nodeKinds: options?.nodeKinds,\n    edgeKinds: options?.edgeKinds,\n    includeTemporal: options?.includeTemporal ?? false,\n    includeMeta: options?.includeMeta ?? false,\n    includeDeleted: options?.includeDeleted ?? false,\n  };\n\n  const graph = store.graph;\n  const graphId = store.graphId;\n  const backend = store.backend;\n\n  // Determine which kinds to export\n  const nodeKindsToExport = options_.nodeKinds ?? getNodeKinds(graph);\n  const edgeKindsToExport = options_.edgeKinds ?? getEdgeKinds(graph);\n\n  // Export nodes\n  const nodes: InterchangeNode[] = [];\n  for (const kind of nodeKindsToExport) {\n    const kindNodes = await exportNodesOfKind(backend, graphId, kind, options_);\n    nodes.push(...kindNodes);\n  }\n\n  // Export edges\n  const edges: InterchangeEdge[] = [];\n  for (const kind of edgeKindsToExport) {\n    const kindEdges = await exportEdgesOfKind(backend, graphId, kind, options_);\n    edges.push(...kindEdges);\n  }\n\n  // Get current schema version\n  const schemaVersion = await backend.getActiveSchema(graphId);\n\n  return {\n    formatVersion: FORMAT_VERSION,\n    exportedAt: nowIso(),\n    source: {\n      type: \"typegraph-export\",\n      graphId,\n      schemaVersion: schemaVersion?.version ?? 1,\n    },\n    nodes,\n    edges,\n  };\n}\n\n// ============================================================\n// Node Export\n// ============================================================\n\ntype ExportOptions_ = Readonly<{\n  includeTemporal: boolean;\n  includeMeta: boolean;\n  includeDeleted: boolean;\n}>;\n\nasync function exportNodesOfKind(\n  backend: GraphBackend,\n  graphId: string,\n  kind: string,\n  options: ExportOptions_,\n): Promise<InterchangeNode[]> {\n  const rows = await backend.findNodesByKind({\n    graphId,\n    kind,\n    excludeDeleted: !options.includeDeleted,\n  });\n\n  return rows.map((row) => {\n    const node: InterchangeNode = {\n      kind: row.kind,\n      id: row.id,\n      properties: JSON.parse(row.props) as Record<string, unknown>,\n    };\n\n    if (options.includeTemporal) {\n      if (row.valid_from) {\n        (node as { validFrom?: string }).validFrom = row.valid_from;\n      }\n      if (row.valid_to) {\n        (node as { validTo?: string }).validTo = row.valid_to;\n      }\n    }\n\n    if (options.includeMeta) {\n      (node as { meta?: InterchangeNode[\"meta\"] }).meta = {\n        version: row.version,\n        createdAt: row.created_at,\n        updatedAt: row.updated_at,\n      };\n    }\n\n    return node;\n  });\n}\n\n// ============================================================\n// Edge Export\n// ============================================================\n\nasync function exportEdgesOfKind(\n  backend: GraphBackend,\n  graphId: string,\n  kind: string,\n  options: ExportOptions_,\n): Promise<InterchangeEdge[]> {\n  const rows = await backend.findEdgesByKind({\n    graphId,\n    kind,\n    excludeDeleted: !options.includeDeleted,\n  });\n\n  return rows.map((row) => {\n    const edge: InterchangeEdge = {\n      kind: row.kind,\n      id: row.id,\n      from: {\n        kind: row.from_kind,\n        id: row.from_id,\n      },\n      to: {\n        kind: row.to_kind,\n        id: row.to_id,\n      },\n      properties: JSON.parse(row.props) as Record<string, unknown>,\n    };\n\n    if (options.includeTemporal) {\n      if (row.valid_from) {\n        (edge as { validFrom?: string }).validFrom = row.valid_from;\n      }\n      if (row.valid_to) {\n        (edge as { validTo?: string }).validTo = row.valid_to;\n      }\n    }\n\n    if (options.includeMeta) {\n      (edge as { meta?: InterchangeEdge[\"meta\"] }).meta = {\n        createdAt: row.created_at,\n        updatedAt: row.updated_at,\n      };\n    }\n\n    return edge;\n  });\n}\n","/**\n * Graph data import functionality.\n *\n * Imports nodes and edges from the interchange format into a store,\n * with configurable conflict resolution and validation.\n */\nimport type { z } from \"zod\";\n\nimport {\n  type GraphBackend,\n  isLiveNodeRow,\n  type TransactionBackend,\n} from \"../backend/types\";\nimport { validateEdgeEndpoints } from \"../constraints\";\nimport {\n  getEdgeKinds,\n  getNodeKinds,\n  type GraphDef,\n} from \"../core/define-graph\";\nimport { type EdgeRegistration, type NodeRegistration } from \"../core/types\";\nimport { UniquenessError } from \"../errors\";\nimport { type KindRegistry } from \"../registry/kind-registry\";\nimport {\n  applyNodeInsertSideEffects,\n  applyNodeUpdate,\n} from \"../store/operations/node-write-pipeline\";\nimport { runInWriteTransaction } from \"../store/operations/write-transaction\";\nimport { type GraphWriteLock } from \"../store/recorded-capture/clock\";\nimport { type Store } from \"../store/store\";\nimport { checkUniquenessConstraints } from \"../store/uniqueness\";\nimport { validateOptionalCanonicalIsoDate } from \"../utils/date\";\nimport {\n  type GraphData,\n  type ImportError,\n  type ImportOptions,\n  type ImportResult,\n  type InterchangeEdge,\n  type InterchangeNode,\n  type UnknownPropertyStrategy,\n} from \"./types\";\n\n// ============================================================\n// Import Function\n// ============================================================\n\n/**\n * Import graph data into a store.\n *\n * Nodes are imported first to satisfy edge reference validation.\n * The import runs within a transaction for atomicity when supported.\n *\n * @param store - The graph store to import into\n * @param data - Graph data in interchange format\n * @param options - Import configuration\n * @returns Import statistics and any errors\n *\n * @example\n * ```typescript\n * const result = await importGraph(store, data, {\n *   onConflict: \"update\",\n *   onUnknownProperty: \"strip\",\n * });\n *\n * console.log(`Created ${result.nodes.created} nodes`);\n * ```\n */\nexport async function importGraph<G extends GraphDef>(\n  store: Store<G>,\n  data: GraphData,\n  options: ImportOptions,\n): Promise<ImportResult> {\n  const result: ImportResult = {\n    success: true,\n    nodes: { created: 0, updated: 0, skipped: 0 },\n    edges: { created: 0, updated: 0, skipped: 0 },\n    errors: [],\n  };\n\n  const errors: ImportError[] = [];\n  const graph = store.graph;\n  const graphId = store.graphId;\n  const backend = store.backend;\n  const registry = store.registry;\n\n  // Build lookup maps for schema validation\n  const nodeSchemas = buildNodeSchemaMap(graph);\n  const edgeSchemas = buildEdgeSchemaMap(graph);\n\n  // Track imported node IDs for reference validation\n  const importedNodeIds = new Set<string>();\n\n  // One transaction on a transactional backend; runs directly otherwise, with\n  // the per-graph write lock taken before any row work — see\n  // runInWriteTransaction for the shared lock-before-rows contract every\n  // writer follows.\n  await runInWriteTransaction(store, backend, async (target, lock) => {\n    await processNodes(\n      target,\n      graphId,\n      registry,\n      data.nodes,\n      nodeSchemas,\n      options,\n      result,\n      errors,\n      importedNodeIds,\n      lock,\n    );\n    await processEdges(\n      target,\n      graphId,\n      registry,\n      data.edges,\n      edgeSchemas,\n      nodeSchemas,\n      options,\n      result,\n      errors,\n      importedNodeIds,\n    );\n  });\n\n  return {\n    ...result,\n    success: errors.length === 0,\n    errors,\n  };\n}\n\n// ============================================================\n// Schema Maps\n// ============================================================\n\ntype NodeSchemaEntry = Readonly<{\n  registration: NodeRegistration;\n  schema: z.ZodObject<z.ZodRawShape>;\n}>;\n\ntype EdgeSchemaEntry = Readonly<{\n  registration: EdgeRegistration;\n  schema: z.ZodObject<z.ZodRawShape>;\n}>;\n\nfunction buildNodeSchemaMap(\n  graph: GraphDef,\n): ReadonlyMap<string, NodeSchemaEntry> {\n  const map = new Map<string, NodeSchemaEntry>();\n\n  for (const kindName of getNodeKinds(graph)) {\n    const registration = graph.nodes[kindName] as NodeRegistration;\n    map.set(kindName, {\n      registration,\n      schema: registration.type.schema,\n    });\n  }\n\n  return map;\n}\n\nfunction buildEdgeSchemaMap(\n  graph: GraphDef,\n): ReadonlyMap<string, EdgeSchemaEntry> {\n  const map = new Map<string, EdgeSchemaEntry>();\n\n  for (const kindName of getEdgeKinds(graph)) {\n    const registration = graph.edges[kindName] as EdgeRegistration;\n    map.set(kindName, {\n      registration,\n      schema: registration.type.schema,\n    });\n  }\n\n  return map;\n}\n\n// ============================================================\n// Node Processing\n// ============================================================\n\nasync function processNodes(\n  backend: GraphBackend | TransactionBackend,\n  graphId: string,\n  registry: KindRegistry,\n  nodes: readonly InterchangeNode[],\n  schemas: ReadonlyMap<string, NodeSchemaEntry>,\n  options: ImportOptions,\n  result: ImportResult,\n  errors: ImportError[],\n  importedNodeIds: Set<string>,\n  lock: GraphWriteLock,\n): Promise<void> {\n  const batchSize = options.batchSize;\n\n  for (let index = 0; index < nodes.length; index += batchSize) {\n    const batch = nodes.slice(index, index + batchSize);\n\n    for (const node of batch) {\n      const importResult = await processNode(\n        backend,\n        graphId,\n        registry,\n        node,\n        schemas,\n        options,\n        lock,\n      );\n\n      switch (importResult.status) {\n        case \"created\": {\n          result.nodes.created++;\n          importedNodeIds.add(makeNodeKey(node.kind, node.id));\n          break;\n        }\n        case \"updated\": {\n          result.nodes.updated++;\n          importedNodeIds.add(makeNodeKey(node.kind, node.id));\n          break;\n        }\n        case \"skipped\": {\n          result.nodes.skipped++;\n          // A live skipped row is still a valid edge endpoint; a tombstone\n          // is not.\n          if (importResult.liveTarget) {\n            importedNodeIds.add(makeNodeKey(node.kind, node.id));\n          }\n          break;\n        }\n        case \"error\": {\n          errors.push({\n            entityType: \"node\",\n            kind: node.kind,\n            id: node.id,\n            error: importResult.error,\n          });\n          break;\n        }\n      }\n    }\n  }\n}\n\ntype ProcessResult =\n  | { status: \"created\" }\n  | { status: \"updated\" }\n  /**\n   * `liveTarget` distinguishes \"skipped because a LIVE row already exists\"\n   * (a valid edge endpoint) from \"skipped because the row is a tombstone\"\n   * (which must NOT be recorded as available — a live edge pointing at a\n   * soft-deleted node violates the endpoint-liveness invariant the\n   * collection API enforces).\n   */\n  | { status: \"skipped\"; liveTarget: boolean }\n  | { status: \"error\"; error: string };\n\ntype UniquenessGuardResult<T> =\n  | Readonly<{ ok: true; value: T }>\n  | Readonly<{ ok: false; error: string }>;\n\n/**\n * Runs `fn` and reports a `UniquenessError` as a per-row result instead of\n * letting it abort the whole import — the same recovery both the node\n * uniqueness pre-check and the update path need. Any other error still\n * propagates.\n */\nasync function catchUniquenessError<T>(\n  fn: () => Promise<T>,\n): Promise<UniquenessGuardResult<T>> {\n  try {\n    return { ok: true, value: await fn() };\n  } catch (error) {\n    if (error instanceof UniquenessError) {\n      return { ok: false, error: error.message };\n    }\n    throw error;\n  }\n}\n\n/**\n * Validates an entity's validity-window timestamps against the canonical\n * fixed-width UTC ISO-8601 contract that `create` / `update` enforce, so no\n * import write path can persist a non-canonical `valid_from` / `valid_to` that\n * later mis-sorts as text against an `asOf` read coordinate. The interchange\n * schema enforces the same contract at the parse boundary, but `importGraph`\n * accepts a pre-typed `GraphData` and does not re-parse it, so this is the\n * guarantee for callers that bypass the schema. Returns a per-row error message\n * (recorded in the import result) instead of throwing, so one malformed row\n * does not abort the whole import.\n */\nfunction validateValidityWindow(\n  entity: Readonly<{\n    validFrom?: string | undefined;\n    validTo?: string | undefined;\n  }>,\n): string | undefined {\n  try {\n    validateOptionalCanonicalIsoDate(entity.validFrom, \"validFrom\");\n    validateOptionalCanonicalIsoDate(entity.validTo, \"validTo\");\n    return undefined;\n  } catch (error) {\n    return error instanceof Error ? error.message : String(error);\n  }\n}\n\nasync function processNode(\n  backend: GraphBackend | TransactionBackend,\n  graphId: string,\n  registry: KindRegistry,\n  node: InterchangeNode,\n  schemas: ReadonlyMap<string, NodeSchemaEntry>,\n  options: ImportOptions,\n  lock: GraphWriteLock,\n): Promise<ProcessResult> {\n  // Validate kind exists\n  const schemaEntry = schemas.get(node.kind);\n  if (!schemaEntry) {\n    return { status: \"error\", error: `Unknown node kind: ${node.kind}` };\n  }\n\n  // Validate and transform properties\n  const propsResult = validateProperties(\n    node.properties,\n    schemaEntry.schema,\n    options.onUnknownProperty,\n  );\n\n  if (!propsResult.success) {\n    return { status: \"error\", error: propsResult.error };\n  }\n\n  const validityError = validateValidityWindow(node);\n  if (validityError !== undefined) {\n    return { status: \"error\", error: validityError };\n  }\n\n  const { registration } = schemaEntry;\n  const uniqueConstraints = registration.unique ?? [];\n  const writeContext = { graphId, registry, lock };\n\n  // Check if node already exists\n  const existing = await backend.getNode(graphId, node.kind, node.id);\n\n  if (existing) {\n    switch (options.onConflict) {\n      case \"skip\": {\n        return { status: \"skipped\", liveTarget: isLiveNodeRow(existing) };\n      }\n      case \"error\": {\n        return {\n          status: \"error\",\n          error: `Node already exists: ${node.kind}:${node.id}`,\n        };\n      }\n      case \"update\": {\n        if (!isLiveNodeRow(existing)) {\n          // A soft-deleted node is not updatable: import never resurrects a\n          // tombstone, and running the live-row update pipeline here would\n          // recreate uniqueness/embedding/fulltext rows for a node that\n          // stays invisible — a uniqueness reservation held by a tombstoned\n          // node would block live creates of the same value.\n          return { status: \"skipped\", liveTarget: false };\n        }\n        // Route through the shared write step so the update maintains\n        // uniqueness entries, embeddings, and fulltext — the collection API's\n        // integrity, which a raw backend.updateNode would skip. A uniqueness\n        // conflict is reported per-row (updateUniquenessEntries throws before\n        // the row is written, so no partial write escapes).\n        const updateResult = await catchUniquenessError(() =>\n          applyNodeUpdate(\n            writeContext,\n            {\n              existing,\n              schema: registration.type.schema,\n              validatedProps: propsResult.data,\n              uniqueConstraints,\n              ...(node.validTo !== undefined && { validTo: node.validTo }),\n            },\n            backend,\n          ),\n        );\n        if (!updateResult.ok) {\n          return { status: \"error\", error: updateResult.error };\n        }\n        return { status: \"updated\" };\n      }\n    }\n  }\n\n  // Create new node. Pre-check uniqueness (as the collection create does) so a\n  // conflict is a per-row error rather than an orphaned node row, then apply the\n  // integrity side effects the raw backend.insertNode would otherwise bypass.\n  const uniquenessResult = await catchUniquenessError(() =>\n    checkUniquenessConstraints(\n      { graphId, registry, backend },\n      node.kind,\n      node.id,\n      propsResult.data,\n      uniqueConstraints,\n    ),\n  );\n  if (!uniquenessResult.ok) {\n    return { status: \"error\", error: uniquenessResult.error };\n  }\n\n  await backend.insertNode({\n    graphId,\n    kind: node.kind,\n    id: node.id,\n    props: propsResult.data,\n    ...(node.validFrom !== undefined && { validFrom: node.validFrom }),\n    ...(node.validTo !== undefined && { validTo: node.validTo }),\n  });\n  await applyNodeInsertSideEffects(\n    writeContext,\n    {\n      kind: node.kind,\n      id: node.id,\n      schema: registration.type.schema,\n      props: propsResult.data,\n      uniqueConstraints,\n    },\n    backend,\n  );\n\n  return { status: \"created\" };\n}\n\n// ============================================================\n// Edge Processing\n// ============================================================\n\nasync function processEdges(\n  backend: GraphBackend | TransactionBackend,\n  graphId: string,\n  registry: KindRegistry,\n  edges: readonly InterchangeEdge[],\n  edgeSchemas: ReadonlyMap<string, EdgeSchemaEntry>,\n  nodeSchemas: ReadonlyMap<string, NodeSchemaEntry>,\n  options: ImportOptions,\n  result: ImportResult,\n  errors: ImportError[],\n  importedNodeIds: Set<string>,\n): Promise<void> {\n  const batchSize = options.batchSize;\n\n  for (let index = 0; index < edges.length; index += batchSize) {\n    const batch = edges.slice(index, index + batchSize);\n\n    for (const edge of batch) {\n      const importResult = await processEdge(\n        backend,\n        graphId,\n        registry,\n        edge,\n        edgeSchemas,\n        nodeSchemas,\n        options,\n        importedNodeIds,\n      );\n\n      switch (importResult.status) {\n        case \"created\": {\n          result.edges.created++;\n          break;\n        }\n        case \"updated\": {\n          result.edges.updated++;\n          break;\n        }\n        case \"skipped\": {\n          result.edges.skipped++;\n          break;\n        }\n        case \"error\": {\n          errors.push({\n            entityType: \"edge\",\n            kind: edge.kind,\n            id: edge.id,\n            error: importResult.error,\n          });\n          break;\n        }\n      }\n    }\n  }\n}\n\nasync function processEdge(\n  backend: GraphBackend | TransactionBackend,\n  graphId: string,\n  registry: KindRegistry,\n  edge: InterchangeEdge,\n  edgeSchemas: ReadonlyMap<string, EdgeSchemaEntry>,\n  nodeSchemas: ReadonlyMap<string, NodeSchemaEntry>,\n  options: ImportOptions,\n  importedNodeIds: Set<string>,\n): Promise<ProcessResult> {\n  // Validate edge kind exists\n  const schemaEntry = edgeSchemas.get(edge.kind);\n  if (!schemaEntry) {\n    return { status: \"error\", error: `Unknown edge kind: ${edge.kind}` };\n  }\n\n  // Validate endpoint kinds exist\n  if (!nodeSchemas.has(edge.from.kind)) {\n    return {\n      status: \"error\",\n      error: `Unknown from node kind: ${edge.from.kind}`,\n    };\n  }\n  if (!nodeSchemas.has(edge.to.kind)) {\n    return { status: \"error\", error: `Unknown to node kind: ${edge.to.kind}` };\n  }\n\n  // Validate endpoint kinds are allowed for this edge type. Uses the shared,\n  // subclass-aware check (registry.isAssignableTo) that the collection API uses,\n  // so an edge whose endpoint is a subclass of a declared kind — legal in the\n  // store and emitted verbatim by export — imports cleanly instead of being\n  // rejected by an exact-kind comparison.\n  const endpointError = validateEdgeEndpoints(\n    edge.kind,\n    edge.from.kind,\n    edge.to.kind,\n    schemaEntry.registration,\n    registry,\n  );\n  if (endpointError !== undefined) {\n    return { status: \"error\", error: endpointError.message };\n  }\n\n  // Validate references exist (in DB or in import batch)\n  if (options.validateReferences) {\n    const fromKey = makeNodeKey(edge.from.kind, edge.from.id);\n    const toKey = makeNodeKey(edge.to.kind, edge.to.id);\n\n    // Check import batch first, then DB. The DB row must be LIVE: getNode\n    // returns tombstones, and inserting an edge whose endpoint is\n    // soft-deleted would bypass the endpoint-liveness invariant the\n    // collection API enforces.\n    if (!importedNodeIds.has(fromKey)) {\n      const fromExists = await backend.getNode(\n        graphId,\n        edge.from.kind,\n        edge.from.id,\n      );\n      if (fromExists === undefined || !isLiveNodeRow(fromExists)) {\n        return {\n          status: \"error\",\n          error: `From node not found: ${edge.from.kind}:${edge.from.id}`,\n        };\n      }\n    }\n\n    if (!importedNodeIds.has(toKey)) {\n      const toExists = await backend.getNode(graphId, edge.to.kind, edge.to.id);\n      if (toExists === undefined || !isLiveNodeRow(toExists)) {\n        return {\n          status: \"error\",\n          error: `To node not found: ${edge.to.kind}:${edge.to.id}`,\n        };\n      }\n    }\n  }\n\n  // Validate and transform properties\n  const propsResult = validateProperties(\n    edge.properties,\n    schemaEntry.schema,\n    options.onUnknownProperty,\n  );\n\n  if (!propsResult.success) {\n    return { status: \"error\", error: propsResult.error };\n  }\n\n  const validityError = validateValidityWindow(edge);\n  if (validityError !== undefined) {\n    return { status: \"error\", error: validityError };\n  }\n\n  // Check if edge already exists\n  const existing = await backend.getEdge(graphId, edge.id);\n\n  if (existing) {\n    switch (options.onConflict) {\n      case \"skip\": {\n        return {\n          status: \"skipped\",\n          liveTarget: existing.deleted_at === undefined,\n        };\n      }\n      case \"error\": {\n        return { status: \"error\", error: `Edge already exists: ${edge.id}` };\n      }\n      case \"update\": {\n        // Same contract as nodes: import never resurrects a tombstone, and\n        // the backend's update targets live rows only.\n        if (existing.deleted_at !== undefined) {\n          return { status: \"skipped\", liveTarget: false };\n        }\n        await backend.updateEdge({\n          graphId,\n          id: edge.id,\n          props: propsResult.data,\n          ...(edge.validTo !== undefined && { validTo: edge.validTo }),\n        });\n        return { status: \"updated\" };\n      }\n    }\n  }\n\n  // Create new edge\n  await backend.insertEdge({\n    graphId,\n    id: edge.id,\n    kind: edge.kind,\n    fromKind: edge.from.kind,\n    fromId: edge.from.id,\n    toKind: edge.to.kind,\n    toId: edge.to.id,\n    props: propsResult.data,\n    ...(edge.validFrom !== undefined && { validFrom: edge.validFrom }),\n    ...(edge.validTo !== undefined && { validTo: edge.validTo }),\n  });\n\n  return { status: \"created\" };\n}\n\n// ============================================================\n// Property Validation\n// ============================================================\n\ntype ValidationResult =\n  | { success: true; data: Record<string, unknown> }\n  | { success: false; error: string };\n\nfunction validateProperties(\n  properties: Record<string, unknown>,\n  schema: z.ZodObject<z.ZodRawShape>,\n  unknownStrategy: UnknownPropertyStrategy,\n): ValidationResult {\n  try {\n    // Get the schema's known keys\n    const knownKeys = new Set(Object.keys(schema.shape));\n\n    // Check for unknown properties\n    const unknownKeys = Object.keys(properties).filter(\n      (key) => !knownKeys.has(key),\n    );\n\n    if (unknownKeys.length > 0) {\n      switch (unknownStrategy) {\n        case \"error\": {\n          return {\n            success: false,\n            error: `Unknown properties: ${unknownKeys.join(\", \")}`,\n          };\n        }\n        case \"strip\": {\n          // Remove unknown properties\n          const stripped: Record<string, unknown> = {};\n          for (const key of knownKeys) {\n            if (key in properties) {\n              stripped[key] = properties[key];\n            }\n          }\n          // Validate stripped properties\n          const result = schema.safeParse(stripped);\n          if (!result.success) {\n            return {\n              success: false,\n              error: formatZodError(result.error),\n            };\n          }\n          return {\n            success: true,\n            data: result.data,\n          };\n        }\n        case \"allow\": {\n          // Validate the known fields, then return the ORIGINAL properties\n          // verbatim — unknown keys preserved, known values byte-for-byte.\n          // Exported data already carries post-transform values, so\n          // re-applying schema transforms here would corrupt every\n          // export→import round trip whose transforms are not idempotent.\n          // \"allow\" is the fidelity-preserving strategy; \"strip\" (and the\n          // create path) remain the normalizing ones.\n          const result = schema.safeParse(properties);\n          if (!result.success) {\n            return {\n              success: false,\n              error: formatZodError(result.error),\n            };\n          }\n          return { success: true, data: properties };\n        }\n      }\n    }\n\n    // No unknown properties - standard validation\n    const result = schema.safeParse(properties);\n    if (!result.success) {\n      return { success: false, error: formatZodError(result.error) };\n    }\n\n    return { success: true, data: result.data };\n  } catch (error) {\n    const message = error instanceof Error ? error.message : String(error);\n    return { success: false, error: `Validation error: ${message}` };\n  }\n}\n\nfunction formatZodError(error: z.ZodError): string {\n  return error.issues\n    .map((issue) => {\n      const path = issue.path.join(\".\");\n      return path ? `${path}: ${issue.message}` : issue.message;\n    })\n    .join(\"; \");\n}\n\n// ============================================================\n// Helpers\n// ============================================================\n\nfunction makeNodeKey(kind: string, id: string): string {\n  return `${kind}:${id}`;\n}\n"]}

package/dist/chunk-T6SPUYLX.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/core/types.ts","../src/indexes/auto-derive.ts","../src/core/define-graph.ts"],"names":["getEmbeddingIndex","isEmbeddingSchema","ConfigurationError"],"mappings":"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","file":"chunk-T6SPUYLX.cjs","sourcesContent":["import { type z } from \"zod\";\n\n// ============================================================\n// Cross-cutting Discriminators\n// ============================================================\n\n/**\n * Which side of the bipartite graph a kind lives on. Used everywhere a\n * function takes \"the entity that owns a kind\" — error metadata,\n * extension classifiers, removal queues, schema diffs.\n */\nexport type KindEntity = \"node\" | \"edge\";\n\n/**\n * Which physical surface an index targets. Vector indexes don't own a\n * kind directly (they back a per-`(kind, field)` typed embedding table\n * owned by the active `VectorStrategy`), but they participate in the same\n * materialization and diff pipelines, so they share this discriminator.\n */\nexport type IndexEntity = \"node\" | \"edge\" | \"vector\";\n\n/**\n * Field-level null-check operations that round-trip through persisted\n * documents (unique-constraint where clauses, index where clauses,\n * graph-extension where clauses, IsNullPredicate). Consolidated so a\n * single rename or extension touches one site.\n */\nexport type NullCheckOp = \"isNull\" | \"isNotNull\";\n\n// ============================================================\n// Brand Keys for Nominal Typing\n// ============================================================\n\n/** Brand key for NodeType */\nexport const NODE_TYPE_BRAND = \"__nodeType\" as const;\n\n/** Brand key for EdgeType */\nexport const EDGE_TYPE_BRAND = \"__edgeType\" as const;\n\n/** Brand symbol for NodeId */\ndeclare const __nodeId: unique symbol;\n\n/** Brand symbol for EdgeId */\ndeclare const __edgeId: unique symbol;\n\n// ============================================================\n// Node Type\n// ============================================================\n\n/**\n * Any JSON-serializable value.\n *\n * Mirrors the JSON wire format: primitives, arrays, and string-keyed objects.\n * `null` is included because the JSON spec requires it for \"no value here\";\n * this is the one place in the public API that uses `null` over `undefined`.\n */\nexport type JsonValue =\n  | null\n  | string\n  | number\n  | boolean\n  | readonly JsonValue[]\n  | Readonly<{ [key: string]: JsonValue }>;\n\n/**\n * Consumer-owned per-kind annotations.\n *\n * Stable labels attached to a node or edge kind at definition time — UI hints,\n * audit policy, provenance pointers, tooling annotations.\n *\n * **Consumer-owned, fully.** TypeGraph never reads, validates, or interprets\n * values in this field. Consumers own the entire namespace; there are no\n * reserved keys or extension prefixes. Future library-owned per-kind state,\n * if needed, will use a separate sibling field rather than carving out keys\n * here.\n *\n * **Annotations participate in schema hashing.** Any change to an annotation\n * value (or adding/removing an annotation key) bumps the canonical schema\n * hash and is reported as a `safe`-severity diff by `getSchemaChanges`. If\n * you don't want versioning for a piece of state, do not put it here.\n *\n * Values must be JSON-serializable — `bigint`, `function`, `symbol`, `undefined`,\n * `Date`, and other class instances are rejected at definition time so they can\n * never silently break schema hashing or storage round-trips.\n */\nexport type KindAnnotations = Readonly<Record<string, JsonValue>>;\n\n/**\n * A node type definition.\n *\n * Created via `defineNode()`. Represents a type of node in the graph\n * with an associated Zod schema for properties.\n */\nexport type NodeType<\n  K extends string = string,\n  S extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>,\n> = Readonly<{\n  [NODE_TYPE_BRAND]: true;\n  kind: K;\n  schema: S;\n  description: string | undefined;\n  annotations: KindAnnotations | undefined;\n}>;\n\n/**\n * Branded node ID type.\n *\n * Prevents mixing IDs from different node types at compile time.\n */\nexport type NodeId<N extends NodeType> = string &\n  Readonly<{\n    [__nodeId]: N;\n  }>;\n\n/**\n * Infer the props type from a NodeType.\n */\nexport type NodeProps<N extends NodeType> = z.infer<N[\"schema\"]>;\n\n// ============================================================\n// Edge Type\n// ============================================================\n\n/**\n * An edge type definition.\n *\n * Created via `defineEdge()`. Represents a type of edge in the graph\n * with an optional Zod schema for properties.\n *\n * Optionally includes `from` and `to` arrays that define the allowed\n * source and target node types (domain and range constraints).\n */\nexport type EdgeType<\n  K extends string = string,\n  S extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>,\n  From extends readonly NodeType[] | undefined = undefined,\n  To extends readonly NodeType[] | undefined = undefined,\n> = Readonly<{\n  [EDGE_TYPE_BRAND]: true;\n  kind: K;\n  schema: S;\n  description: string | undefined;\n  annotations: KindAnnotations | undefined;\n  from: From;\n  to: To;\n}>;\n\n/**\n * Base edge type for use in constraints - accepts any from/to configuration.\n */\nexport type AnyEdgeType = EdgeType<\n  string,\n  z.ZodObject<z.ZodRawShape>,\n  readonly NodeType[] | undefined,\n  readonly NodeType[] | undefined\n>;\n\n/**\n * An edge type that has both from and to constraints defined.\n * Can be used directly in defineGraph without an EdgeRegistration wrapper.\n */\nexport type EdgeTypeWithEndpoints = EdgeType<\n  string,\n  z.ZodObject<z.ZodRawShape>,\n  readonly NodeType[],\n  readonly NodeType[]\n>;\n\n/**\n * Branded edge ID type.\n *\n * Prevents mixing IDs from different edge types at compile time.\n */\nexport type EdgeId<E extends AnyEdgeType = AnyEdgeType> = string &\n  Readonly<{\n    [__edgeId]: E;\n  }>;\n\n/**\n * Infer the props type from an EdgeType.\n */\nexport type EdgeProps<E extends AnyEdgeType> = z.infer<E[\"schema\"]>;\n\n// ============================================================\n// Configuration Types\n// ============================================================\n\n/**\n * Delete behaviors for nodes.\n */\nexport type DeleteBehavior = \"restrict\" | \"cascade\" | \"disconnect\";\n\n/**\n * Edge cardinality constraints.\n */\nexport type Cardinality =\n  | \"many\" // No constraint (default)\n  | \"one\" // At most one edge of this kind from any source node\n  | \"unique\" // At most one edge of this kind between any (source, target) pair\n  | \"oneActive\"; // At most one edge with valid_to IS NULL from any source\n\n/**\n * Endpoint existence modes for edge validation.\n */\nexport type EndpointExistence =\n  | \"notDeleted\" // Endpoint deleted_at IS NULL (default)\n  | \"currentlyValid\" // Endpoint not deleted AND temporally valid\n  | \"ever\"; // Endpoint exists in any state\n\n/**\n * Temporal query modes.\n */\nexport type TemporalMode =\n  | \"current\" // Valid now AND not deleted\n  | \"asOf\" // Valid at specific date AND not deleted\n  | \"includeEnded\" // All validity periods AND not deleted\n  | \"includeTombstones\"; // Everything including soft-deleted\n\n/**\n * Uniqueness constraint scope.\n */\nexport type UniquenessScope =\n  | \"kind\" // Unique within this exact kind only\n  | \"kindWithSubClasses\"; // Unique across this kind and all subclasses\n\n/**\n * Collation for uniqueness constraints.\n */\nexport type Collation = \"binary\" | \"caseInsensitive\";\n\n// ============================================================\n// Uniqueness Constraint\n// ============================================================\n\n/**\n * Uniqueness constraint definition.\n */\nexport type UniqueConstraint<\n  S extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>,\n> = Readonly<{\n  name: string;\n  fields: readonly (keyof z.infer<S> & string)[];\n  where?: (\n    props: UniqueConstraintPredicateBuilder<S>,\n  ) => UniqueConstraintPredicate;\n  scope: UniquenessScope;\n  collation: Collation;\n}>;\n\n/**\n * Predicate builder for uniqueness constraint where clause.\n * Uses -? to make all fields required in the builder, even if optional in the schema.\n */\ntype UniqueConstraintPredicateBuilder<S extends z.ZodObject<z.ZodRawShape>> =\n  Readonly<{\n    [K in keyof z.infer<S>]-?: UniqueConstraintField;\n  }>;\n\n/**\n * Field operations for uniqueness constraint predicates.\n */\ntype UniqueConstraintField = Readonly<{\n  isNull: () => UniqueConstraintPredicate;\n  isNotNull: () => UniqueConstraintPredicate;\n}>;\n\n/**\n * A uniqueness constraint predicate (internal representation).\n */\ntype UniqueConstraintPredicate = Readonly<{\n  __type: \"unique_predicate\";\n  field: string;\n  op: NullCheckOp;\n}>;\n\n// ============================================================\n// Node Registration\n// ============================================================\n\n/**\n * Node registration in a graph definition.\n */\nexport type NodeRegistration<N extends NodeType = NodeType> = Readonly<{\n  type: N;\n  unique?: readonly UniqueConstraint<N[\"schema\"]>[];\n  onDelete?: DeleteBehavior;\n}>;\n\n// ============================================================\n// Edge Registration\n// ============================================================\n\n/**\n * Edge registration in a graph definition.\n */\nexport type EdgeRegistration<\n  E extends AnyEdgeType = AnyEdgeType,\n  FromTypes extends NodeType = NodeType,\n  ToTypes extends NodeType = NodeType,\n> = Readonly<{\n  type: E;\n  from: readonly FromTypes[];\n  to: readonly ToTypes[];\n  cardinality?: Cardinality;\n  endpointExistence?: EndpointExistence;\n}>;\n\n// ============================================================\n// Graph Defaults\n// ============================================================\n\n/**\n * Default settings for a graph.\n */\nexport type GraphDefaults = Readonly<{\n  onNodeDelete?: DeleteBehavior;\n  temporalMode?: TemporalMode;\n}>;\n\n// ============================================================\n// Type Helpers\n// ============================================================\n\n/**\n * Checks if a value is a NodeType.\n */\nexport function isNodeType(value: unknown): value is NodeType {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    NODE_TYPE_BRAND in value &&\n    (value as Record<string, unknown>)[NODE_TYPE_BRAND] === true\n  );\n}\n\n/**\n * Checks if a value is an EdgeType.\n */\nexport function isEdgeType(value: unknown): value is AnyEdgeType {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    EDGE_TYPE_BRAND in value &&\n    (value as Record<string, unknown>)[EDGE_TYPE_BRAND] === true\n  );\n}\n\n/**\n * Checks if a value is an EdgeType with both from and to constraints defined.\n * Such edges can be used directly in defineGraph without an EdgeRegistration wrapper.\n */\nexport function isEdgeTypeWithEndpoints(\n  value: unknown,\n): value is EdgeTypeWithEndpoints {\n  return (\n    isEdgeType(value) &&\n    Array.isArray(value.from) &&\n    value.from.length > 0 &&\n    Array.isArray(value.to) &&\n    value.to.length > 0\n  );\n}\n","/**\n * Auto-derive vector index declarations from `embedding()` brands on\n * node schemas.\n *\n * Walks each node's top-level Zod shape, finds fields wrapped in\n * `embedding(dimensions, opts)` (including `.optional()` /\n * `.nullable()` wrappers), and emits one `VectorIndexDeclaration` per\n * (kind, field) pair. The declaration carries the resolved index\n * configuration from the embedding brand — metric, indexType, HNSW /\n * IVFFlat params — so the materializer doesn't need to reach back into\n * the Zod schema.\n *\n * Auto-derivation is intentionally limited to TOP-LEVEL embedding\n * fields. Embeddings nested inside object properties are out of scope\n * for v1 — vector slots are materialized as flat `(kind, fieldPath)`\n * storage units, and top-level fields keep that contract explicit.\n *\n * Explicit `defineVectorIndex(node, fieldPath, opts)` declarations\n * passed via `defineGraph({ indexes })` take precedence — when an\n * explicit declaration matches the same (kind, fieldPath) as an\n * auto-derived one, the explicit version wins. This lets consumers\n * override defaults without losing auto-derivation for other fields.\n */\n\nimport { type z } from \"zod\";\n\nimport {\n  getEmbeddingIndex,\n  isEmbeddingSchema,\n  type ResolvedEmbeddingIndex,\n} from \"../core/embedding\";\nimport { type NodeRegistration } from \"../core/types\";\nimport { type IndexDeclaration, type VectorIndexDeclaration } from \"./types\";\n\n/**\n * Auto-derive vector index declarations from embedding brands on a\n * map of node registrations. Returns one declaration per\n * (kind, top-level field) pair. Empty array when no embeddings found.\n *\n * Cross-graph status-table disambiguation does NOT happen here — the\n * declaration name stays clean (`tg_vec_{kind}_{field}_{metric}`) so\n * `pg_indexes` and result-entry inspection are readable. The\n * materializer composes a graph-scoped key (`${graphId}::${name}`)\n * for status-table identity, applied uniformly to both auto-derived\n * and explicit `VectorIndexDeclaration` entries — see\n * `vectorStatusKey` in `store/materialize-indexes.ts`. This keeps\n * the disambiguation rule in one place that BOTH paths go through,\n * rather than depending on the auto-derive caller to produce a\n * graph-scoped name.\n */\nexport function autoDeriveVectorIndexes(\n  nodes: Record<string, NodeRegistration>,\n): readonly VectorIndexDeclaration[] {\n  const out: VectorIndexDeclaration[] = [];\n  for (const registration of Object.values(nodes)) {\n    const node = registration.type;\n    const shape = readObjectShape(node.schema);\n    if (shape === undefined) continue;\n    for (const [fieldName, fieldSchema] of Object.entries(shape)) {\n      const config = readEmbeddingIndex(fieldSchema);\n      if (config === undefined) continue;\n      const dimensions = readEmbeddingDimensions(fieldSchema);\n      if (dimensions === undefined) continue;\n      out.push(buildAutoDerived(node.kind, fieldName, dimensions, config));\n    }\n  }\n  return out;\n}\n\n/**\n * Merge auto-derived declarations with explicit ones, preferring\n * explicit on (kind, fieldPath) collisions. Returns a flat list of all\n * indexes; non-vector entries from `explicit` pass through unchanged.\n */\nexport function mergeVectorIndexes(\n  explicit: readonly IndexDeclaration[],\n  autoDerived: readonly VectorIndexDeclaration[],\n): readonly IndexDeclaration[] {\n  if (autoDerived.length === 0) return explicit;\n  const explicitVectorKeys = new Set<string>();\n  for (const declaration of explicit) {\n    if (declaration.entity === \"vector\") {\n      explicitVectorKeys.add(`${declaration.kind}|${declaration.fieldPath}`);\n    }\n  }\n  const filteredAuto = autoDerived.filter(\n    (entry) => !explicitVectorKeys.has(`${entry.kind}|${entry.fieldPath}`),\n  );\n  return [...explicit, ...filteredAuto];\n}\n\n/**\n * Generate the deterministic vector index name. The visible prefix\n * `tg_vec_<kind>_<field>_<metric>` keeps it scannable in result-entry\n * inspection and the `typegraph_index_materializations` table.\n *\n * Cross-graph disambiguation is handled separately at the\n * materialization boundary (see `vectorStatusKey`) so the declaration\n * name doesn't need to carry `graphId` — the same auto-derived name\n * is reusable across graphs and the materializer composes a\n * graph-scoped status key for both auto-derived and explicit entries\n * uniformly.\n */\nfunction buildAutoDerived(\n  kind: string,\n  fieldName: string,\n  dimensions: number,\n  config: ResolvedEmbeddingIndex,\n): VectorIndexDeclaration {\n  const fieldPath = fieldName;\n  return Object.freeze({\n    entity: \"vector\" as const,\n    name: `tg_vec_${sanitize(kind)}_${sanitize(fieldName)}_${config.metric}`,\n    kind,\n    fieldPath,\n    dimensions,\n    metric: config.metric,\n    indexType: config.indexType,\n    indexParams: Object.freeze({\n      m: config.m,\n      efConstruction: config.efConstruction,\n      lists: config.lists,\n    }),\n  });\n}\n\nfunction sanitize(value: string): string {\n  return value.replaceAll(/[^a-zA-Z0-9]/g, \"_\").toLowerCase();\n}\n\nfunction readObjectShape(\n  schema: z.ZodType,\n): Record<string, z.ZodType> | undefined {\n  if ((schema as { type?: string }).type !== \"object\") return undefined;\n  const shape = (schema.def as { shape?: Record<string, z.ZodType> }).shape;\n  return shape;\n}\n\nfunction readEmbeddingIndex(\n  schema: z.ZodType,\n): ResolvedEmbeddingIndex | undefined {\n  for (const candidate of unwrapChain(schema)) {\n    const config = getEmbeddingIndex(candidate);\n    if (config !== undefined) return config;\n  }\n  return undefined;\n}\n\nfunction readEmbeddingDimensions(schema: z.ZodType): number | undefined {\n  for (const candidate of unwrapChain(schema)) {\n    if (isEmbeddingSchema(candidate)) {\n      return (candidate as unknown as Record<string, number>)\n        ._embeddingDimensions;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Yield the schema and every reachable inner schema by repeatedly\n * applying `.unwrap()` (Zod 4 optional/nullable/default) and\n * `.def.innerType` (some wrappers). Cycle-guarded by depth and\n * reference identity. Generators stop at the first non-unwrappable\n * schema OR after 8 levels — deeper wrapping is pathological and not\n * worth supporting.\n */\nfunction* unwrapChain(schema: z.ZodType): Generator<z.ZodType, void, void> {\n  const seen = new Set<z.ZodType>();\n  let current: z.ZodType | undefined = schema;\n  let depth = 0;\n  while (current !== undefined && !seen.has(current) && depth < 8) {\n    seen.add(current);\n    yield current;\n    current = unwrapOnce(current);\n    depth++;\n  }\n}\n\nfunction unwrapOnce(schema: z.ZodType): z.ZodType | undefined {\n  // Zod 4 wrappers expose `.unwrap()` on optional/nullable/default.\n  const candidate = schema as unknown as { unwrap?: () => z.ZodType };\n  if (typeof candidate.unwrap === \"function\") return candidate.unwrap();\n  // Some wrappers expose the inner schema via `.def.innerType`.\n  return (schema as unknown as { def?: { innerType?: z.ZodType } }).def\n    ?.innerType;\n}\n","import { ConfigurationError } from \"../errors/index\";\nimport { type GraphExtension } from \"../graph-extension/extension-types\";\nimport {\n  autoDeriveVectorIndexes,\n  mergeVectorIndexes,\n} from \"../indexes/auto-derive\";\nimport { type IndexDeclaration } from \"../indexes/types\";\nimport { type OntologyRelation } from \"../ontology/types\";\nimport {\n  type AnyEdgeType,\n  type DeleteBehavior,\n  type EdgeRegistration,\n  type EdgeTypeWithEndpoints,\n  type GraphDefaults,\n  isEdgeType,\n  isEdgeTypeWithEndpoints,\n  type KindEntity,\n  type NodeRegistration,\n  type NodeType,\n  type TemporalMode,\n} from \"./types\";\n\n// ============================================================\n// Graph Definition Brand Symbol\n// ============================================================\n\n/** Brand key for GraphDef */\nconst GRAPH_DEF_BRAND = \"__graphDef\" as const;\n\n// ============================================================\n// Edge Entry Types\n// ============================================================\n\n/**\n * An edge entry in the graph definition.\n * Can be:\n * - EdgeType directly (constrained or unconstrained)\n * - EdgeRegistration object (always works, can override/narrow defaults)\n */\ntype EdgeEntry = EdgeRegistration | AnyEdgeType;\n\n/**\n * Normalized edge map type - all entries become EdgeRegistration.\n * For bare EdgeTypes, constrained endpoints are extracted from the type;\n * unconstrained edges fall back to all node types in the graph.\n */\ntype NormalizedEdges<\n  TNodes extends Record<string, NodeRegistration>,\n  TEdges extends Record<string, EdgeEntry>,\n> = {\n  [K in keyof TEdges]: TEdges[K] extends EdgeRegistration ? TEdges[K]\n  : TEdges[K] extends AnyEdgeType ?\n    EdgeRegistration<\n      TEdges[K],\n      TEdges[K][\"from\"] extends readonly (infer N extends NodeType)[] ? N\n      : TNodes[keyof TNodes][\"type\"],\n      TEdges[K][\"to\"] extends readonly (infer N extends NodeType)[] ? N\n      : TNodes[keyof TNodes][\"type\"]\n    >\n  : never;\n};\n\n// ============================================================\n// Edge Normalization Functions\n// ============================================================\n\n/**\n * Validates that an EdgeRegistration's constraints don't widen beyond\n * the edge type's built-in domain/range constraints.\n */\nfunction validateConstraintNarrowing(\n  name: string,\n  edgeType: EdgeTypeWithEndpoints,\n  registration: EdgeRegistration,\n): void {\n  const builtInFromNames = new Set(edgeType.from.map((node) => node.kind));\n  for (const fromNode of registration.from) {\n    if (!builtInFromNames.has(fromNode.kind)) {\n      throw new ConfigurationError(\n        `Edge \"${name}\" registration has 'from' kind \"${fromNode.kind}\" ` +\n          `not in edge's built-in domain: [${[...builtInFromNames].join(\", \")}]`,\n        {\n          edgeName: name,\n          invalidFrom: fromNode.kind,\n          allowedFrom: [...builtInFromNames],\n        },\n        {\n          suggestion: `Edge registration can only narrow, not widen, the edge type's built-in constraints.`,\n        },\n      );\n    }\n  }\n\n  const builtInToNames = new Set(edgeType.to.map((node) => node.kind));\n  for (const toNode of registration.to) {\n    if (!builtInToNames.has(toNode.kind)) {\n      throw new ConfigurationError(\n        `Edge \"${name}\" registration has 'to' kind \"${toNode.kind}\" ` +\n          `not in edge's built-in range: [${[...builtInToNames].join(\", \")}]`,\n        {\n          edgeName: name,\n          invalidTo: toNode.kind,\n          allowedTo: [...builtInToNames],\n        },\n        {\n          suggestion: `Edge registration can only narrow, not widen, the edge type's built-in constraints.`,\n        },\n      );\n    }\n  }\n}\n\n/**\n * Normalizes a single edge entry to EdgeRegistration.\n */\nfunction normalizeEdgeEntry(\n  name: string,\n  entry: EdgeEntry,\n  allNodeTypes: readonly NodeType[],\n): EdgeRegistration {\n  if (isEdgeType(entry)) {\n    if (isEdgeTypeWithEndpoints(entry)) {\n      // EdgeType with from/to — convert to EdgeRegistration\n      return { type: entry, from: entry.from, to: entry.to };\n    }\n    // Unconstrained EdgeType — allow any→any\n    return { type: entry, from: allNodeTypes, to: allNodeTypes };\n  }\n\n  // Already EdgeRegistration — validate narrowing if edge has built-in constraints\n  if (isEdgeTypeWithEndpoints(entry.type)) {\n    validateConstraintNarrowing(name, entry.type, entry);\n  }\n\n  return entry;\n}\n\n/**\n * Normalizes all edge entries to EdgeRegistration.\n */\nfunction normalizeEdges(\n  edges: Record<string, EdgeEntry>,\n  allNodeTypes: readonly NodeType[],\n): Record<string, EdgeRegistration> {\n  const result: Record<string, EdgeRegistration> = {};\n  for (const [name, entry] of Object.entries(edges)) {\n    result[name] = normalizeEdgeEntry(name, entry, allNodeTypes);\n  }\n  return result;\n}\n\n// ============================================================\n// Graph Definition Configuration\n// ============================================================\n\n/**\n * Configuration for defineGraph.\n */\ntype GraphDefConfig<\n  TNodes extends Record<string, NodeRegistration>,\n  TEdges extends Record<string, EdgeEntry>,\n  TOntology extends readonly OntologyRelation[],\n> = Readonly<{\n  /** Unique identifier for this graph */\n  id: string;\n  /** Node registrations */\n  nodes: TNodes;\n  /** Edge registrations or EdgeTypes with built-in domain/range */\n  edges: TEdges;\n  /** Ontology relations */\n  ontology?: TOntology;\n  /** Graph-wide defaults */\n  defaults?: GraphDefaults;\n  /**\n   * Index declarations attached to this graph.\n   *\n   * Accepts the outputs of `defineNodeIndex` / `defineEdgeIndex` (which\n   * already return `IndexDeclaration` values) or pre-built declarations\n   * reconstructed from a stored schema or graph extension.\n   *\n   * Validated at definition time: every index must reference a `kind`\n   * that exists in `nodes` / `edges`, and index `name`s must be unique\n   * within the graph.\n   *\n   * Index DDL is **not** generated by `defineGraph`. Indexes flow into\n   * `SerializedSchema.indexes` so they can later be materialized via\n   * `store.materializeIndexes()` — lifting the storage concern out of\n   * the schema-version commit path.\n   */\n  indexes?: readonly IndexDeclaration[];\n}>;\n\n// ============================================================\n// Graph Definition Type\n// ============================================================\n\n/**\n * A graph definition.\n *\n * This is a compile-time artifact that describes the structure of a graph.\n * Use `createStore()` to create a runtime store from this definition.\n */\nexport type GraphDef<\n  TNodes extends Record<string, NodeRegistration> = Record<\n    string,\n    NodeRegistration\n  >,\n  TEdges extends Record<string, EdgeRegistration> = Record<\n    string,\n    EdgeRegistration\n  >,\n  TOntology extends readonly OntologyRelation[] = readonly OntologyRelation[],\n> = Readonly<{\n  [GRAPH_DEF_BRAND]: true;\n  id: string;\n  nodes: TNodes;\n  edges: TEdges;\n  ontology: TOntology;\n  defaults: Readonly<{\n    onNodeDelete: DeleteBehavior;\n    temporalMode: TemporalMode;\n  }>;\n  /**\n   * Index declarations attached to this graph. Preserves whatever the\n   * caller passed to `defineGraph` (including an explicit empty array)\n   * for introspection purposes.\n   *\n   * The serialized canonical form is order-canonicalized (sorted by\n   * `name`) and treats `undefined` and `[]` as the same \"no slice\" form\n   * — an empty array does not bump the schema hash, since indexes are\n   * an unordered set keyed by name and `[]` carries no semantic meaning\n   * that an absent slice doesn't.\n   */\n  indexes: readonly IndexDeclaration[] | undefined;\n  /**\n   * Graph extension this graph was merged with, if any. Set by\n   * `mergeGraphExtension`; never set by `defineGraph` directly.\n   * Exists solely so re-serialization is stable — the rest of the\n   * system reads the merged kinds through `nodes` / `edges` /\n   * `ontology` and never inspects this field. Absent on graphs that\n   * have never been extended; legacy graphs hash byte-identically.\n   */\n  extension: GraphExtension | undefined;\n  /**\n   * Soft-deprecated kind names attached to this graph. Set by the\n   * loader from the persisted schema and by `store.deprecateKinds(...)`\n   * / `store.undeprecateKinds(...)`. A purely informational signal\n   * surfaced for introspection — does not gate reads, writes, or\n   * queries. Defaults to the empty set on freshly-defined graphs.\n   */\n  deprecatedKinds: ReadonlySet<string>;\n}>;\n\n// ============================================================\n// Type Helpers\n// ============================================================\n\n/**\n * Extract node kind names from a GraphDef.\n */\nexport type NodeKinds<G extends GraphDef> = keyof G[\"nodes\"] & string;\n\n/**\n * Extract edge kind names from a GraphDef.\n */\nexport type EdgeKinds<G extends GraphDef> = keyof G[\"edges\"] & string;\n\n/**\n * Get a NodeType from a GraphDef by kind name.\n */\nexport type GetNodeType<\n  G extends GraphDef,\n  K extends NodeKinds<G>,\n> = G[\"nodes\"][K][\"type\"];\n\n/**\n * Get an EdgeType from a GraphDef by kind name.\n */\nexport type GetEdgeType<\n  G extends GraphDef,\n  K extends EdgeKinds<G>,\n> = G[\"edges\"][K][\"type\"];\n\n/**\n * Get all NodeTypes from a GraphDef.\n */\nexport type AllNodeTypes<G extends GraphDef> = {\n  [K in NodeKinds<G>]: G[\"nodes\"][K][\"type\"];\n}[NodeKinds<G>];\n\n/**\n * Get all EdgeTypes from a GraphDef.\n */\nexport type AllEdgeTypes<G extends GraphDef> = {\n  [K in EdgeKinds<G>]: G[\"edges\"][K][\"type\"];\n}[EdgeKinds<G>];\n\n// ============================================================\n// Define Graph Function\n// ============================================================\n\n/**\n * Creates a graph definition.\n *\n * @example\n * ```typescript\n * const graph = defineGraph({\n *   id: \"my_graph\",\n *   nodes: {\n *     Person: { type: Person },\n *     Company: { type: Company },\n *   },\n *   edges: {\n *     // Traditional EdgeRegistration syntax\n *     worksAt: {\n *       type: worksAt,\n *       from: [Person],\n *       to: [Company],\n *       cardinality: \"many\",\n *     },\n *     // Or use EdgeType directly if it has from/to defined\n *     knows,  // EdgeType with built-in domain/range\n *   },\n *   ontology: [\n *     subClassOf(Company, Organization),\n *     disjointWith(Person, Organization),\n *   ],\n *   defaults: {\n *     onNodeDelete: \"restrict\",\n *     temporalMode: \"current\",\n *   },\n * });\n * ```\n */\nexport function defineGraph<\n  const TNodes extends Record<string, NodeRegistration<NodeType>>,\n  const TEdges extends Record<string, EdgeEntry>,\n  const TOntology extends readonly OntologyRelation[],\n>(\n  config: GraphDefConfig<TNodes, TEdges, TOntology>,\n): GraphDef<TNodes, NormalizedEdges<TNodes, TEdges>, TOntology> {\n  const defaults = {\n    onNodeDelete: config.defaults?.onNodeDelete ?? \"restrict\",\n    temporalMode: config.defaults?.temporalMode ?? \"current\",\n  } as const;\n\n  const allNodeTypes = Object.values(config.nodes).map((reg) => reg.type);\n  const normalizedEdges = normalizeEdges(config.edges, allNodeTypes);\n  // Vector indexes are auto-derived from `embedding()` brands on node\n  // schemas (see `autoDeriveVectorIndexes`). Explicit declarations\n  // passed via `defineGraph({ indexes })` win on (kind, fieldPath)\n  // collisions so consumers can override defaults — see\n  // `mergeVectorIndexes`. The merged list flows through\n  // `normalizeIndexes` for the standard kind-registered + unique-name\n  // checks.\n  //\n  // Preservation rule: if the consumer never passed `indexes` at all\n  // AND no embedding brands exist, leave `graph.indexes` undefined to\n  // keep the introspection surface stable for legacy graphs. If the\n  // consumer passed an explicit `[]`, surface it as `[]` (not\n  // `undefined`) to match the contract pinned by the\n  // \"preserves an explicit empty indexes array\" test.\n  const autoVectorIndexes = autoDeriveVectorIndexes(config.nodes);\n  const explicitProvided = config.indexes !== undefined;\n  const mergedIndexes = mergeVectorIndexes(\n    config.indexes ?? [],\n    autoVectorIndexes,\n  );\n  const indexes =\n    !explicitProvided && mergedIndexes.length === 0 ?\n      undefined\n    : normalizeIndexes(mergedIndexes, config.nodes, normalizedEdges);\n\n  return Object.freeze({\n    [GRAPH_DEF_BRAND]: true as const,\n    id: config.id,\n    nodes: config.nodes,\n    edges: normalizedEdges,\n    ontology: config.ontology ?? ([] as unknown as TOntology),\n    defaults,\n    indexes,\n    extension: undefined,\n    deprecatedKinds: EMPTY_DEPRECATED_KINDS,\n  }) as GraphDef<TNodes, NormalizedEdges<TNodes, TEdges>, TOntology>;\n}\n\n// Sharing one frozen empty Set keeps the canonical-form hash stable\n// across graphs that never deprecate any kinds.\nconst EMPTY_DEPRECATED_KINDS: ReadonlySet<string> = Object.freeze(\n  new Set<string>(),\n);\n\n// ============================================================\n// Index Normalization\n// ============================================================\n\n/**\n * Validates the `indexes` config slice:\n *\n * - Every index references a kind that exists in the graph's `nodes`\n *   (for node indexes) or `edges` (for edge indexes).\n * - Index `name`s are unique within the graph.\n */\nfunction normalizeIndexes(\n  inputs: readonly IndexDeclaration[],\n  nodes: Record<string, NodeRegistration>,\n  edges: Record<string, EdgeRegistration>,\n): readonly IndexDeclaration[] {\n  if (inputs.length === 0) {\n    return [];\n  }\n\n  const nodeKinds = collectKinds(nodes);\n  const edgeKinds = collectKinds(edges);\n  const seenNames = new Set<string>();\n\n  for (const declaration of inputs) {\n    if (declaration.entity === \"node\" || declaration.entity === \"vector\") {\n      // Vector indexes attach to node kinds (the embedding lives on a\n      // node field). Validation reuses the node-kind check.\n      assertKindRegistered(declaration, nodeKinds, \"node\");\n    } else {\n      assertKindRegistered(declaration, edgeKinds, \"edge\");\n    }\n\n    if (seenNames.has(declaration.name)) {\n      throw new ConfigurationError(\n        `Duplicate index name \"${declaration.name}\" in defineGraph({ indexes }). ` +\n          `Index names must be unique within a graph.`,\n        { indexName: declaration.name },\n        {\n          suggestion: `Pass an explicit { name: \"...\" } to disambiguate.`,\n        },\n      );\n    }\n    seenNames.add(declaration.name);\n  }\n\n  return inputs;\n}\n\nfunction collectKinds(\n  registrations: Record<string, { type: { kind: string } }>,\n): ReadonlySet<string> {\n  const kinds = new Set<string>();\n  for (const registration of Object.values(registrations)) {\n    kinds.add(registration.type.kind);\n  }\n  return kinds;\n}\n\nfunction assertKindRegistered(\n  declaration: IndexDeclaration,\n  registeredKinds: ReadonlySet<string>,\n  entity: KindEntity,\n): void {\n  if (registeredKinds.has(declaration.kind)) return;\n\n  const slot = entity === \"node\" ? \"nodes\" : \"edges\";\n  const suggestion =\n    entity === \"node\" ?\n      `Add { ${declaration.kind}: { type: ${declaration.kind} } } to defineGraph({ nodes }) ` +\n      `or remove the index from \"indexes\".`\n    : `Register the edge in defineGraph({ edges }) or remove the index from \"indexes\".`;\n\n  throw new ConfigurationError(\n    `Index \"${declaration.name}\" references ${entity} kind \"${declaration.kind}\" ` +\n      `which is not registered in this graph's \"${slot}\".`,\n    {\n      indexName: declaration.name,\n      referencedKind: declaration.kind,\n      availableKinds: [...registeredKinds],\n    },\n    { suggestion },\n  );\n}\n\n// ============================================================\n// Graph Definition Utilities\n// ============================================================\n\n/**\n * Checks if a value is a GraphDef.\n */\nexport function isGraphDef(value: unknown): value is GraphDef {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    GRAPH_DEF_BRAND in value &&\n    (value as Record<string, unknown>)[GRAPH_DEF_BRAND] === true\n  );\n}\n\n/**\n * Gets all node kind names from a GraphDef.\n */\nexport function getNodeKinds<G extends GraphDef>(\n  graph: G,\n): readonly (keyof G[\"nodes\"] & string)[] {\n  return Object.keys(graph.nodes);\n}\n\n/**\n * Gets all edge kind names from a GraphDef.\n */\nexport function getEdgeKinds<G extends GraphDef>(\n  graph: G,\n): readonly (keyof G[\"edges\"] & string)[] {\n  return Object.keys(graph.edges);\n}\n\n/**\n * Returns true when `name` is registered as either a node or edge kind\n * on the given graph.\n */\nexport function isKnownKind(graph: GraphDef, name: string): boolean {\n  return Object.hasOwn(graph.nodes, name) || Object.hasOwn(graph.edges, name);\n}\n"]}

package/dist/chunk-TGJE22RM.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/indexes/ddl.ts"],"names":["sql","compileNodeIndexKeys","compileEdgeIndexKeys","compileIndexWhere","CasingCache","getDialect"],"mappings":"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","file":"chunk-TGJE22RM.cjs","sourcesContent":["import { type SQL, sql } from \"drizzle-orm\";\nimport { CasingCache } from \"drizzle-orm/casing\";\n\nimport { getDialect } from \"../query/dialect\";\nimport { type SqlDialect } from \"../query/dialect/types\";\nimport {\n  compileEdgeIndexKeys,\n  compileIndexWhere,\n  compileNodeIndexKeys,\n  type IndexCompilationContext,\n} from \"./compiler\";\nimport {\n  type EdgeIndexDeclaration,\n  type NodeIndexDeclaration,\n  type RelationalIndexDeclaration,\n  type SystemColumnName,\n} from \"./types\";\n\nexport type GenerateIndexDdlOptions = Readonly<{\n  nodesTableName?: string | undefined;\n  edgesTableName?: string | undefined;\n  ifNotExists?: boolean | undefined;\n  /**\n   * Emit `CREATE INDEX CONCURRENTLY` (Postgres only). Required for\n   * `store.materializeIndexes()` so live tables don't take an\n   * `AccessExclusiveLock`. Ignored on SQLite (no equivalent; SQLite is\n   * single-writer regardless). When true on Postgres, the resulting\n   * statement cannot be executed inside a transaction.\n   */\n  concurrent?: boolean | undefined;\n}>;\n\n/**\n * Generate `CREATE INDEX` DDL for a single relational index declaration.\n *\n * Vector index declarations (`entity: \"vector\"`) are NOT handled here —\n * they go through `backend.createVectorIndex` instead because the DDL\n * is dialect-specific (`USING hnsw (...) WITH (m=..., ef_construction=...)`\n * on Postgres) and operates on the strategy's per-`(kind, field)` embedding\n * tables, not `typegraph_nodes` / `typegraph_edges`. Callers narrow to the\n * relational subset before calling this function.\n */\nexport function generateIndexDDL(\n  index: RelationalIndexDeclaration,\n  dialect: SqlDialect,\n  options: GenerateIndexDdlOptions = {},\n): string {\n  if (index.entity === \"node\") {\n    return generateNodeIndexDDL(index, dialect, options);\n  }\n  return generateEdgeIndexDDL(index, dialect, options);\n}\n\nexport function generateNodeIndexDDL(\n  index: NodeIndexDeclaration,\n  dialect: SqlDialect,\n  options: GenerateIndexDdlOptions = {},\n): string {\n  const tableName = options.nodesTableName ?? \"typegraph_nodes\";\n  return generateTableIndexDDL(index, dialect, tableName, options);\n}\n\nexport function generateEdgeIndexDDL(\n  index: EdgeIndexDeclaration,\n  dialect: SqlDialect,\n  options: GenerateIndexDdlOptions = {},\n): string {\n  const tableName = options.edgesTableName ?? \"typegraph_edges\";\n  return generateTableIndexDDL(index, dialect, tableName, options);\n}\n\nfunction generateTableIndexDDL(\n  index: RelationalIndexDeclaration,\n  dialect: SqlDialect,\n  tableName: string,\n  options: GenerateIndexDdlOptions,\n): string {\n  const ifNotExists = options.ifNotExists ?? true;\n  const propsColumn = sql.raw('\"props\"');\n  const systemColumn = (column: SystemColumnName): SQL =>\n    sql.raw(quoteIdentifier(column));\n\n  const keys =\n    index.entity === \"node\" ?\n      compileNodeIndexKeys(index, dialect, propsColumn, systemColumn).keys\n    : compileEdgeIndexKeys(index, dialect, propsColumn, systemColumn).keys;\n\n  const whereSql =\n    index.where ?\n      sqlToInlineString(\n        compileIndexWhere(\n          {\n            dialect,\n            propsColumn,\n            systemColumn,\n          } satisfies IndexCompilationContext,\n          index.where,\n        ),\n        dialect,\n      )\n    : undefined;\n\n  const keySql = keys.map((k) => sqlToInlineString(k, dialect)).join(\", \");\n  const unique = index.unique ? \"UNIQUE \" : \"\";\n  const concurrent =\n    options.concurrent === true && dialect === \"postgres\" ?\n      \"CONCURRENTLY \"\n    : \"\";\n  const ifNotExistsSql = ifNotExists ? \"IF NOT EXISTS \" : \"\";\n\n  const whereClause = whereSql ? ` WHERE ${whereSql}` : \"\";\n\n  return `CREATE ${unique}INDEX ${concurrent}${ifNotExistsSql}${quoteIdentifier(index.name)} ON ${quoteIdentifier(tableName)} (${keySql})${whereClause};`;\n}\n\nfunction quoteIdentifier(identifier: string): string {\n  return `\"${identifier.replaceAll('\"', '\"\"')}\"`;\n}\n\nfunction sqlToInlineString(object: SQL, dialect: SqlDialect): string {\n  const query = object.toQuery({\n    casing: new CasingCache(),\n    escapeName: (name) => name,\n    escapeParam: (_number, value) => inlineParam(value, dialect),\n    escapeString: (value) => escapeStringLiteral(value),\n    inlineParams: true,\n    invokeSource: \"indexes\",\n  });\n\n  if (query.params.length > 0) {\n    throw new Error(\n      \"Index DDL generation produced parameters; expected fully inlined SQL\",\n    );\n  }\n\n  return query.sql;\n}\n\nfunction inlineParam(value: unknown, dialect: SqlDialect): string {\n  if (value === null || value === undefined) {\n    return \"NULL\";\n  }\n  if (value instanceof Date) {\n    return escapeStringLiteral(value.toISOString());\n  }\n\n  if (typeof value === \"string\") {\n    return escapeStringLiteral(value);\n  }\n  if (typeof value === \"number\") {\n    return value.toString();\n  }\n  if (typeof value === \"boolean\") {\n    return getDialect(dialect).booleanLiteralString(value);\n  }\n  if (typeof value === \"bigint\") {\n    return value.toString();\n  }\n\n  throw new TypeError(\n    \"Index DDL generation received an unsupported SQL parameter value\",\n  );\n}\n\nfunction escapeStringLiteral(value: string): string {\n  return `'${value.replaceAll(\"'\", \"''\")}'`;\n}\n"]}