@nicia-ai/typegraph 0.50.0 → 0.51.0

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/identity/rebuild.ts","../src/identity/types.ts","../src/backend/migrate-vectors.ts"],"names":["embedding"],"mappings":"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","file":"index.js","sourcesContent":["import { type GraphDef, type GraphIdentityConfig } from \"../core/define-graph\";\nimport { storeRuntime } from \"../store/runtime-port\";\nimport { type Store } from \"../store/store\";\n\n/**\n * Rebuilds the derived current identity closure for an identity-enabled store.\n * This is a repair operation: it does not change graph revision or assertions.\n */\nexport async function rebuildIdentityClosure<\n  G extends GraphDef & Readonly<{ identity: GraphIdentityConfig }>,\n>(store: Store<G>): Promise<void> {\n  await storeRuntime(store).rebuildIdentityClosure();\n}\n","import {\n  type AllNodeTypes,\n  type GraphDef,\n  type NodeKinds,\n} from \"../core/define-graph\";\nimport { ValidationError } from \"../errors\";\nimport {\n  type DynamicNode,\n  type DynamicNodeReference,\n  type GraphNodeReference,\n  type Node,\n  type NodeRef,\n} from \"../store/types\";\n\n/**\n * The accepted *input* form for every identity facade method: a whole node or\n * a `{ kind, id }` pair for any compile-time graph kind, plus a proof-bearing\n * node or reference produced through the runtime collection lane. Runtime\n * values stay nominal so accepting them does not make an arbitrary\n * `{ kind: string, id: string }` object type-safe.\n *\n * Identity results use {@link IdentityNodeReference}, which honestly includes\n * runtime kinds because an evolved kind can belong to a class reached from a\n * compile-time node.\n */\nexport type IdentityNodeRefInput<G extends GraphDef> =\n  NodeRef<AllNodeTypes<G>> | DynamicNode | DynamicNodeReference;\n\n/**\n * A node reference returned by Operational Identity.\n *\n * Identity classes can contain runtime-evolved kinds even when a read starts\n * from a compile-time node, so results honestly include both lanes.\n */\nexport type IdentityNodeReference<G extends GraphDef> =\n  GraphNodeReference<G> | DynamicNodeReference;\n\n/** A hydrated compile-time or runtime identity member. */\nexport type IdentityNode<G extends GraphDef> =\n  | {\n      [K in NodeKinds<G>]: Node<G[\"nodes\"][K][\"type\"]>;\n    }[NodeKinds<G>]\n  | DynamicNode;\n\ndeclare const __identityAssertionId: unique symbol;\n\nexport type IdentityAssertionId = string &\n  Readonly<{ [__identityAssertionId]: true }>;\n\n/**\n * Brands a non-empty string as an {@link IdentityAssertionId}.\n *\n * Use this when a persisted identity assertion id has round-tripped through\n * untyped storage or an external boundary and must be passed back to a\n * retraction surface such as `retractAssertion` or `bulkRetractAssertions`.\n * Mirrors the `asNodeId` / `asEdgeId` precedent.\n *\n * @throws {ValidationError} when `value` is empty.\n */\nexport function asIdentityAssertionId(value: string): IdentityAssertionId {\n  if (value.length === 0) {\n    throw new ValidationError(\n      \"asIdentityAssertionId must be a non-empty string.\",\n      {\n        issues: [\n          {\n            path: \"asIdentityAssertionId\",\n            message: \"Expected a non-empty string.\",\n          },\n        ],\n      },\n      {\n        suggestion: \"Use a persisted identity assertion id value.\",\n      },\n    );\n  }\n  return value as IdentityAssertionId;\n}\n\n/**\n * What one assertion claims about a pair of nodes: `\"same\"` merges them into\n * one equivalence set, `\"different\"` records a disjointness that a later\n * `\"same\"` claim must not contradict.\n */\nexport type IdentityRelation = \"same\" | \"different\";\n\n/**\n * One persisted identity claim about an ordered pair of nodes. Returned by the\n * assertion writers and by `identity.assertionsOf(...)`; `validTo` is set when\n * the assertion has been retracted, so a historical read can still see it.\n */\nexport type IdentityAssertion<G extends GraphDef> = Readonly<{\n  id: IdentityAssertionId;\n  relation: IdentityRelation;\n  a: IdentityNodeReference<G>;\n  b: IdentityNodeReference<G>;\n  validFrom: string;\n  validTo?: string;\n}>;\n\n/** Result of an idempotent assertion write. */\nexport type IdentityAssertionResult<G extends GraphDef> = Readonly<{\n  assertion: IdentityAssertion<G>;\n  action: \"created\" | \"existing\";\n}>;\n\n/** The half-open effective-time window of an identity assertion. */\nexport type IdentityValidityWindow = Readonly<{\n  validFrom?: string;\n  validTo?: string;\n}>;\n\n/** One ordered node pair handed to `bulkAssertSame` / `bulkAssertDifferent`. */\nexport type IdentityPair<G extends GraphDef> = Readonly<{\n  a: IdentityNodeRefInput<G>;\n  b: IdentityNodeRefInput<G>;\n}> &\n  IdentityValidityWindow;\n\n/**\n * The read half of the identity surface: equivalence-set membership,\n * representative selection, and the assertions behind them.\n *\n * Obtained from a read-only lens — `store.asOf(...).identity`,\n * `store.snapshot().identity` — where it answers at that view's coordinate.\n * The full read+write surface is {@link IdentityFacade}.\n */\nexport type IdentityReadFacade<G extends GraphDef> = Readonly<{\n  representativeOf: (\n    ref: IdentityNodeRefInput<G>,\n  ) => Promise<IdentityNodeReference<G> | undefined>;\n  membersOf: (\n    ref: IdentityNodeRefInput<G>,\n  ) => Promise<readonly IdentityNodeReference<G>[]>;\n  nodesOf: (\n    ref: IdentityNodeRefInput<G>,\n  ) => Promise<readonly IdentityNode<G>[]>;\n  areSame: (\n    a: IdentityNodeRefInput<G>,\n    b: IdentityNodeRefInput<G>,\n  ) => Promise<boolean>;\n  areDifferent: (\n    a: IdentityNodeRefInput<G>,\n    b: IdentityNodeRefInput<G>,\n  ) => Promise<boolean>;\n  assertionsOf: (\n    ref: IdentityNodeRefInput<G>,\n  ) => Promise<readonly IdentityAssertion<G>[]>;\n}>;\n\n/**\n * The full TypeGraph Identity Profile surface: {@link IdentityReadFacade} plus\n * the assertion writers and retractions.\n *\n * Obtained from `store.identity` or `tx.identity`, and present only on graphs\n * that declared `identity: { ... }` in `defineGraph`. Every writer is\n * idempotent — re-asserting an existing claim returns it with\n * `action: \"existing\"` rather than duplicating it.\n */\nexport type IdentityFacade<G extends GraphDef> = IdentityReadFacade<G> &\n  Readonly<{\n    assertSame: (\n      a: IdentityNodeRefInput<G>,\n      b: IdentityNodeRefInput<G>,\n      window?: IdentityValidityWindow,\n    ) => Promise<IdentityAssertionResult<G>>;\n    assertDifferent: (\n      a: IdentityNodeRefInput<G>,\n      b: IdentityNodeRefInput<G>,\n      window?: IdentityValidityWindow,\n    ) => Promise<IdentityAssertionResult<G>>;\n    bulkAssertSame: (\n      pairs: readonly IdentityPair<G>[],\n    ) => Promise<readonly IdentityAssertionResult<G>[]>;\n    bulkAssertDifferent: (\n      pairs: readonly IdentityPair<G>[],\n    ) => Promise<readonly IdentityAssertionResult<G>[]>;\n    retractAssertion: (\n      id: IdentityAssertionId,\n    ) => Promise<IdentityAssertion<G> | undefined>;\n    retractSameAssertion: (\n      a: IdentityNodeRefInput<G>,\n      b: IdentityNodeRefInput<G>,\n    ) => Promise<IdentityAssertion<G> | undefined>;\n    retractDifferentAssertion: (\n      a: IdentityNodeRefInput<G>,\n      b: IdentityNodeRefInput<G>,\n    ) => Promise<IdentityAssertion<G> | undefined>;\n    bulkRetractAssertions: (\n      ids: readonly IdentityAssertionId[],\n    ) => Promise<readonly IdentityAssertion<G>[]>;\n  }>;\n\n/**\n * The assertion-only write surface of the TypeGraph Identity Profile.\n *\n * This deliberately excludes reads and retractions so constrained staging\n * handles can accept incoming identity claims without exposing the broader\n * operational identity surface.\n */\nexport type IdentityAssertionWriteFacade<G extends GraphDef> = Pick<\n  IdentityFacade<G>,\n  \"assertSame\" | \"assertDifferent\" | \"bulkAssertSame\" | \"bulkAssertDifferent\"\n>;\n\n/**\n * Per-transaction identity write counts carried by a transaction receipt.\n * `total` is the sum of the three preceding counters.\n */\nexport type IdentityWriteSummary = Readonly<{\n  sameAssertions: number;\n  differentAssertions: number;\n  retractions: number;\n  total: number;\n}>;\n","/**\n * One-time offline migration: legacy shared embeddings table → per-field\n * strategy storage.\n *\n * ## What this is for\n *\n * The cross-backend vector cutover (#157) dropped the single shared\n * `typegraph_node_embeddings` table. Each\n * `VectorStrategy` now OWNS one typed, fixed-dimension structure per\n * `(nodeKind, fieldPath)` — the only layout that can be ANN-indexed on\n * libSQL and sqlite-vec, not just pgvector.\n *\n * Deployments that wrote embeddings under the old shared table before\n * upgrading still hold those rows. This utility drains them into the new\n * per-field storage **once**, during the upgrade, so existing embedded\n * data survives the cutover without re-embedding from source.\n *\n * It is an explicitly-run, offline step — not wired into `materializeIndexes`\n * or any boot path. Run it once after deploying the new version and before\n * (or alongside) the first `materializeIndexes()`, then drop the legacy\n * table at your leisure.\n *\n * ## How it works\n *\n * - Skips cleanly (returns a zero summary) when the legacy table is absent —\n *   a fresh install, or a re-run after the table was dropped.\n * - Reads rows in keyset-paginated batches (never the whole table at once),\n *   decoding the engine-native embedding column to a numeric array at the SQL\n *   level: sqlite-vec stored a `vec_f32` blob (`vec_to_json` decodes it);\n *   pgvector stored a native `vector` (`::text` yields a `[…]` literal).\n * - Re-inserts each row through `backend.upsertEmbedding`, which routes the\n *   active strategy's `buildUpsert` and idempotently provisions the per-field\n *   storage (the same `(nodeKind, fieldPath)` slot a fresh store write uses).\n *   The migration stays graph-agnostic and execution-correct on both the\n *   sync (better-sqlite3) and async (libsql / Postgres) backends — it does\n *   not re-implement the backend's statement-execution glue.\n *\n * Idempotent and resumable: a partial run followed by a full run converges\n * to the same per-field tables, because every write is an upsert keyed by\n * `(graph_id, node_id)` in the strategy's owned storage.\n */\nimport {\n  DEFAULT_EMBEDDING_INDEX_TYPE,\n  DEFAULT_EMBEDDING_METRIC,\n  type EmbeddingIndexType,\n  type EmbeddingMetric,\n} from \"../core/embedding\";\nimport { EmbeddingDimensionChangedError } from \"../errors\";\nimport { sql, type SqlFragment } from \"../query/sql-fragment\";\nimport { asCompiledRowsSql } from \"../query/sql-intent\";\nimport { createDataKeyedBag } from \"../utils/object\";\nimport { requireDefined } from \"../utils/presence\";\nimport { isMissingTableError } from \"../utils/sql-errors\";\nimport { LEGACY_EMBEDDINGS_TABLE_NAME } from \"./drizzle/schema/sqlite\";\nimport { type GraphBackend } from \"./types\";\n\n/**\n * Default rows read per round-trip. Large enough to amortize round-trip\n * latency, small enough to bound peak memory regardless of table size.\n */\nconst DEFAULT_BATCH_SIZE = 500;\n\n/**\n * Metric / index type applied to a migrated field when no\n * {@link MigrateLegacyEmbeddingsOptions.resolveSlotConfig} is supplied (or\n * it returns `undefined`). Matches the defaults `embedding()` and\n * `resolveEmbeddingFields` apply, so a migrated field lands in storage shaped\n * identically to one written fresh through the store. Migrated data is only\n * ever brute-forceable until `materializeIndexes()` builds the ANN index, so\n * the index-type default governs only which ANN structure the per-field\n * storage DDL provisions, not the migration's correctness.\n */\nconst DEFAULT_SLOT_METRIC: EmbeddingMetric = DEFAULT_EMBEDDING_METRIC;\nconst DEFAULT_SLOT_INDEX_TYPE: EmbeddingIndexType =\n  DEFAULT_EMBEDDING_INDEX_TYPE;\n\n/**\n * The resolved storage config for one `(nodeKind, fieldPath)` slot that the\n * legacy table did not record. The legacy shared table stored only the\n * vector and its dimension count — not the metric or index type — so a\n * caller that wants migrated fields to match a specific graph's `embedding()`\n * declarations supplies this resolver.\n */\nexport type LegacyEmbeddingSlotConfig = Readonly<{\n  metric: EmbeddingMetric;\n  indexType: EmbeddingIndexType;\n}>;\n\n/**\n * Options for {@link migrateLegacyEmbeddings}.\n */\nexport type MigrateLegacyEmbeddingsOptions = Readonly<{\n  /**\n   * The backend to migrate, wired with the destination `VectorStrategy`\n   * (i.e. the post-cutover backend). Its `vectorStrategy` owns the per-field\n   * storage rows are written into and its `upsertEmbedding` performs the\n   * writes.\n   */\n  backend: GraphBackend;\n\n  /**\n   * Restrict the migration to a single graph. When omitted, every graph's\n   * rows in the legacy table are migrated (the table is graph-scoped by its\n   * `graph_id` column).\n   */\n  graphId?: string;\n\n  /**\n   * Resolves the metric / index type for a `(nodeKind, fieldPath)` slot the\n   * legacy table didn't persist. Return `undefined` to fall back to the\n   * cosine / hnsw defaults. Supply this (typically reading the graph's\n   * `embedding()` declarations) when migrated fields must match a specific\n   * metric — e.g. an `l2` field, which scores incorrectly under the cosine\n   * default.\n   */\n  resolveSlotConfig?: (\n    nodeKind: string,\n    fieldPath: string,\n  ) => LegacyEmbeddingSlotConfig | undefined;\n\n  /** Rows read per round-trip. Defaults to {@link DEFAULT_BATCH_SIZE}. */\n  batchSize?: number;\n\n  /**\n   * Physical name of the legacy table to drain. Defaults to\n   * {@link LEGACY_EMBEDDINGS_TABLE_NAME}. Override only for a non-default\n   * deployment that renamed the embeddings table.\n   */\n  legacyTableName?: string;\n}>;\n\n/**\n * Summary of a {@link migrateLegacyEmbeddings} run.\n */\nexport type MigrateLegacyEmbeddingsResult = Readonly<{\n  /** Total embedding rows re-inserted into per-field storage. */\n  migrated: number;\n  /**\n   * Per-`(nodeKind, fieldPath)` counts, keyed `\"<nodeKind>.<fieldPath>\"`\n   * (the strategy's logical-slot key form). Empty when the legacy table was\n   * absent or held no rows for the requested scope.\n   */\n  perField: Readonly<Record<string, number>>;\n  /**\n   * Rows skipped because their vector length didn't match the per-field\n   * table's fixed dimension. The legacy shared column allowed mixed\n   * dimensions for one `(nodeKind, fieldPath)` (e.g. an unmigrated model\n   * change); the first migrated row fixes the typed table's dimension and\n   * any differently-sized rows for that slot are skipped rather than aborting\n   * the whole migration. Keyed `\"<nodeKind>.<fieldPath>\"`. Non-empty here\n   * means those fields need a deliberate re-embed at a single dimension.\n   */\n  skippedDimensionMismatch: Readonly<Record<string, number>>;\n  /**\n   * Rows skipped because their legacy embedding could not be decoded into a\n   * finite-number array — a corrupt value (e.g. a pgvector `vector` column\n   * permits `NaN`/`Infinity`, which is not valid JSON). Keyed\n   * `\"<nodeKind>.<fieldPath>\"`. Skipping + reporting keeps one bad row from\n   * aborting the whole migration; non-empty here means those rows need manual\n   * repair.\n   */\n  skippedDecodeError: Readonly<Record<string, number>>;\n  /**\n   * Whether the legacy table existed. `false` means the run was a clean\n   * no-op (fresh install, or already-dropped table on a re-run).\n   */\n  legacyTablePresent: boolean;\n}>;\n\n/**\n * A single legacy embedding row, with the engine-native vector already\n * decoded to a JSON array string by the dialect-specific SELECT. The\n * legacy `dimensions` column is intentionally not read: the decoded array's\n * length is the authoritative fixed dimension for the destination slot, and\n * relying on it sidesteps the per-driver string/number coercion the legacy\n * integer column would otherwise need.\n */\ntype LegacyEmbeddingRow = Readonly<{\n  graph_id: string;\n  node_kind: string;\n  node_id: string;\n  field_path: string;\n  /** JSON array text, e.g. `\"[0.1,0.2,0.3]\"` — decoded per dialect. */\n  embedding_json: string;\n}>;\n\n/**\n * Re-inserts every embedding from the legacy shared\n * `typegraph_node_embeddings` table into the active\n * `backend.vectorStrategy`'s per-`(nodeKind, fieldPath)` storage.\n *\n * One-time, explicitly-run upgrade step for the shared-table → per-field\n * cutover (#157). Idempotent, batched, and a clean no-op when the legacy\n * table is absent. See the module doc comment for the full contract.\n *\n * @throws Error when the backend exposes no `vectorStrategy` /\n *         `upsertEmbedding` (nothing to migrate *into*) — a configuration\n *         error the caller must fix by wiring the destination strategy\n *         before migrating.\n */\nexport async function migrateLegacyEmbeddings(\n  options: MigrateLegacyEmbeddingsOptions,\n): Promise<MigrateLegacyEmbeddingsResult> {\n  const {\n    backend,\n    graphId,\n    resolveSlotConfig,\n    batchSize = DEFAULT_BATCH_SIZE,\n    legacyTableName = LEGACY_EMBEDDINGS_TABLE_NAME,\n  } = options;\n\n  if (\n    backend.vectorStrategy === undefined ||\n    backend.upsertEmbedding === undefined\n  ) {\n    throw new Error(\n      \"migrateLegacyEmbeddings requires a backend wired with a vectorStrategy \" +\n        \"(the destination per-field storage). Pass the post-cutover backend.\",\n    );\n  }\n  if (!Number.isInteger(batchSize) || batchSize <= 0) {\n    throw new RangeError(\n      `batchSize must be a positive integer, got: ${batchSize}`,\n    );\n  }\n  const upsertEmbedding = backend.upsertEmbedding;\n  const ensureVectorSlotContribution = backend.ensureVectorSlotContribution;\n\n  // Data-keyed: slot keys are built from a row's `node_kind` / `field_path`.\n  const perField = createDataKeyedBag<number>();\n  const skippedDimensionMismatch = createDataKeyedBag<number>();\n  const skippedDecodeError = createDataKeyedBag<number>();\n  // (kind, field) slots whose per-field table + durable marker this run has\n  // already provisioned, mapped to the dimension the table was fixed at.\n  // `upsertEmbedding` asserts the marker (#135) and no longer self-creates\n  // the table, so this offline migration (privileged) provisions each slot\n  // once — at the first row's dimension, which fixes the typed table just as\n  // the original lazy write did. Differently-sized later rows for the same\n  // slot are detected against this map and skipped BEFORE the upsert: the\n  // marker assert would otherwise read the differently-dimensioned slot as\n  // stale and abort the whole migration, and the ensure is deliberately not\n  // re-run per row (that would trip the marker drift-guard).\n  const ensuredSlots = new Map<string, number>();\n  let migrated = 0;\n\n  let cursor: LegacyRowCursor | undefined;\n  for (;;) {\n    let batch: readonly LegacyEmbeddingRow[];\n    try {\n      batch = await readLegacyBatch(backend, {\n        legacyTableName,\n        graphId,\n        batchSize,\n        after: cursor,\n      });\n    } catch (error) {\n      // A missing legacy table is the expected \"nothing to migrate\" path on\n      // the first read — surface it as a clean no-op, not a failure.\n      if (cursor === undefined && isMissingTableError(error)) {\n        return {\n          migrated: 0,\n          perField: {},\n          skippedDimensionMismatch: {},\n          skippedDecodeError: {},\n          legacyTablePresent: false,\n        };\n      }\n      throw error;\n    }\n\n    if (batch.length === 0) break;\n\n    for (const row of batch) {\n      const slotKey = `${row.node_kind}.${row.field_path}`;\n\n      let embedding: readonly number[];\n      try {\n        embedding = decodeEmbeddingJson(row);\n      } catch {\n        // A corrupt legacy value (e.g. a pgvector `vector` column permits\n        // NaN/Infinity, which is not valid JSON) is skipped + reported rather\n        // than aborting the whole migration on one bad row.\n        skippedDecodeError[slotKey] = (skippedDecodeError[slotKey] ?? 0) + 1;\n        continue;\n      }\n      const config = resolveSlotConfig?.(row.node_kind, row.field_path);\n      // The decoded length is the authoritative fixed dimension — the\n      // strategy provisions its column type (e.g. `F32_BLOB(N)`) from it.\n      const slot = {\n        graphId: row.graph_id,\n        nodeKind: row.node_kind,\n        fieldPath: row.field_path,\n        dimensions: embedding.length,\n        metric: config?.metric ?? DEFAULT_SLOT_METRIC,\n        indexType: config?.indexType ?? DEFAULT_SLOT_INDEX_TYPE,\n      };\n\n      // Provision the per-field table + durable marker before the first\n      // write into this slot. Once per (graph, kind, field): the first row's\n      // dimension fixes the table. Keyed by graph id too — the legacy table\n      // is graph-scoped, so the same `kind.field` can recur across graphs.\n      const ensuredKey = JSON.stringify([\n        row.graph_id,\n        row.node_kind,\n        row.field_path,\n      ]);\n      if (\n        ensureVectorSlotContribution !== undefined &&\n        !ensuredSlots.has(ensuredKey)\n      ) {\n        await ensureVectorSlotContribution(slot);\n        ensuredSlots.set(ensuredKey, slot.dimensions);\n      }\n\n      // The legacy shared column allowed mixed dimensions for one\n      // (nodeKind, fieldPath); the per-field table is fixed at the first\n      // migrated row's dimension. Skip a differently-sized row up front —\n      // its slot would fail the marker assert as stale (different\n      // signature), aborting the migration instead of skipping the row.\n      const provisionedDimensions = ensuredSlots.get(ensuredKey);\n      if (\n        provisionedDimensions !== undefined &&\n        provisionedDimensions !== embedding.length\n      ) {\n        skippedDimensionMismatch[slotKey] =\n          (skippedDimensionMismatch[slotKey] ?? 0) + 1;\n        continue;\n      }\n\n      try {\n        await upsertEmbedding({ ...slot, nodeId: row.node_id, embedding });\n      } catch (error) {\n        // The legacy shared column allowed mixed dimensions for one\n        // (nodeKind, fieldPath); the per-field table is fixed at the first\n        // migrated row's dimension, so a differently-sized row is skipped and\n        // reported rather than aborting the whole migration.\n        if (error instanceof EmbeddingDimensionChangedError) {\n          skippedDimensionMismatch[slotKey] =\n            (skippedDimensionMismatch[slotKey] ?? 0) + 1;\n          continue;\n        }\n        throw error;\n      }\n\n      migrated += 1;\n      perField[slotKey] = (perField[slotKey] ?? 0) + 1;\n    }\n\n    if (batch.length < batchSize) break;\n    const last = requireDefined(batch.at(-1));\n    cursor = {\n      graphId: last.graph_id,\n      nodeKind: last.node_kind,\n      nodeId: last.node_id,\n      fieldPath: last.field_path,\n    };\n  }\n\n  // SPREAD at the boundary. The three maps are null-prototype accumulators\n  // because their keys are slot names built from row data; that protection is\n  // internal, and returning the bags as-is handed a caller three maps with no\n  // `toString` and `instanceof Object === false` — while the early\n  // \"nothing to migrate\" return above hands back `{}` literals, so the same\n  // exported function answered with two different kinds of object depending on\n  // whether the legacy table existed. Spread copies own properties with\n  // CreateDataProperty, so a `__proto__` slot key survives as an own key.\n  return {\n    migrated,\n    perField: { ...perField },\n    skippedDimensionMismatch: { ...skippedDimensionMismatch },\n    skippedDecodeError: { ...skippedDecodeError },\n    legacyTablePresent: true,\n  };\n}\n\n/**\n * Composite keyset cursor over the legacy table's primary key\n * `(graph_id, node_kind, node_id, field_path)`. Stable under concurrent\n * writes and immune to OFFSET drift, so a batched walk reads every row once.\n */\ntype LegacyRowCursor = Readonly<{\n  graphId: string;\n  nodeKind: string;\n  nodeId: string;\n  fieldPath: string;\n}>;\n\ntype ReadLegacyBatchParams = Readonly<{\n  legacyTableName: string;\n  graphId: string | undefined;\n  batchSize: number;\n  after: LegacyRowCursor | undefined;\n}>;\n\n/**\n * Reads one keyset-paginated batch of legacy rows, ordered by the primary\n * key, with the engine-native embedding column decoded to a JSON array\n * string by the dialect.\n */\nasync function readLegacyBatch(\n  backend: GraphBackend,\n  params: ReadLegacyBatchParams,\n): Promise<readonly LegacyEmbeddingRow[]> {\n  const table = sql.identifier(params.legacyTableName);\n  const embeddingJson = legacyEmbeddingDecodeExpression(backend);\n\n  const conditions: SqlFragment[] = [];\n  if (params.graphId !== undefined) {\n    conditions.push(sql`\"graph_id\" = ${params.graphId}`);\n  }\n  if (params.after !== undefined) {\n    conditions.push(keysetAfterCondition(params.after));\n  }\n\n  const whereClause =\n    conditions.length === 0 ?\n      sql``\n    : sql` WHERE ${sql.join(conditions, sql` AND `)}`;\n\n  const query = sql`\n    SELECT\n      \"graph_id\" AS graph_id,\n      \"node_kind\" AS node_kind,\n      \"node_id\" AS node_id,\n      \"field_path\" AS field_path,\n      ${embeddingJson} AS embedding_json\n    FROM ${table}${whereClause}\n    ORDER BY \"graph_id\" ASC, \"node_kind\" ASC, \"node_id\" ASC, \"field_path\" ASC\n    LIMIT ${params.batchSize}\n  `;\n\n  return backend.execute<LegacyEmbeddingRow>(asCompiledRowsSql(query));\n}\n\n/**\n * The strict `>` comparison over the composite primary key, expressed as\n * the standard lexicographic OR-chain so it works on every dialect (SQLite\n * supports row-value comparison, but Postgres + SQLite both accept this\n * portable form).\n */\nfunction keysetAfterCondition(after: LegacyRowCursor): SqlFragment {\n  return sql`\n    (\n        \"graph_id\" > ${after.graphId}\n        OR (\"graph_id\" = ${after.graphId} AND \"node_kind\" > ${after.nodeKind})\n        OR (\"graph_id\" = ${after.graphId} AND \"node_kind\" = ${after.nodeKind} AND \"node_id\" > ${after.nodeId})\n        OR (\n          \"graph_id\" = ${after.graphId}\n          AND \"node_kind\" = ${after.nodeKind}\n          AND \"node_id\" = ${after.nodeId}\n          AND \"field_path\" > ${after.fieldPath}\n        )\n      )\n  `;\n}\n\n/**\n * The SQL expression that decodes the legacy engine-native embedding column\n * into a JSON array string `embedding_json`. The single dialect branch in\n * this whole module: the legacy storage formats are genuinely engine-\n * specific, and there is no longer a strategy abstraction over the *legacy*\n * table to delegate to.\n */\nfunction legacyEmbeddingDecodeExpression(backend: GraphBackend): SqlFragment {\n  switch (backend.dialect) {\n    case \"sqlite\": {\n      // Legacy SQLite embeddings were written via `vec_f32('[…]')`\n      // (sqlite-vec binary). `vec_to_json` is its inverse, yielding the\n      // JSON array text. Requires sqlite-vec on the connection — which the\n      // legacy write path also required, so any deployment with legacy rows\n      // has it loaded.\n      return sql`vec_to_json(\"embedding\")`;\n    }\n    case \"postgres\": {\n      // pgvector's native `vector` casts to its `[…]` text literal, which is\n      // valid JSON for `JSON.parse`.\n      return sql`\"embedding\"::text`;\n    }\n    default: {\n      const _exhaustive: never = backend.dialect;\n      throw new Error(\n        `migrateLegacyEmbeddings does not support dialect: ${String(_exhaustive)}`,\n      );\n    }\n  }\n}\n\n/**\n * Parses a decoded `embedding_json` array, asserting it is a non-empty array\n * of finite numbers. A bad decode (wrong type, NaN) names the offending row\n * loudly instead of writing a corrupt vector into per-field storage.\n */\nfunction decodeEmbeddingJson(row: LegacyEmbeddingRow): readonly number[] {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(row.embedding_json) as unknown;\n  } catch (error) {\n    throw new Error(\n      `Failed to decode legacy embedding for ${row.node_kind}.${row.field_path} ` +\n        `(graph ${row.graph_id}, node ${row.node_id}): not valid JSON.`,\n      { cause: error },\n    );\n  }\n  if (!Array.isArray(parsed) || parsed.length === 0) {\n    throw new Error(\n      `Legacy embedding for ${row.node_kind}.${row.field_path} ` +\n        `(graph ${row.graph_id}, node ${row.node_id}) decoded to a non-array ` +\n        `or empty value.`,\n    );\n  }\n  for (const [index, value] of parsed.entries()) {\n    if (typeof value !== \"number\" || !Number.isFinite(value)) {\n      throw new TypeError(\n        `Legacy embedding for ${row.node_kind}.${row.field_path} ` +\n          `(graph ${row.graph_id}, node ${row.node_id}) has a non-finite ` +\n          `value at index ${index}: ${String(value)}.`,\n      );\n    }\n  }\n  return parsed as readonly number[];\n}\n"]}
+{"version":3,"sources":["../src/identity/rebuild.ts","../src/identity/types.ts","../src/backend/migrate-vectors.ts"],"names":["embedding"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA,eAAsB,uBAEpB,KAAA,EAAgC;AAChC,EAAA,MAAM,YAAA,CAAa,KAAK,CAAA,CAAE,sBAAA,EAAuB;AACnD;;;AC+CO,SAAS,sBAAsB,KAAA,EAAoC;AACxE,EAAA,IAAI,KAAA,CAAM,WAAW,CAAA,EAAG;AACtB,IAAA,MAAM,IAAI,eAAA;AAAA,MACR,mDAAA;AAAA,MACA;AAAA,QACE,MAAA,EAAQ;AAAA,UACN;AAAA,YACE,IAAA,EAAM,uBAAA;AAAA,YACN,OAAA,EAAS;AAAA;AACX;AACF,OACF;AAAA,MACA;AAAA,QACE,UAAA,EAAY;AAAA;AACd,KACF;AAAA,EACF;AACA,EAAA,OAAO,KAAA;AACT;;;ACjBA,IAAM,kBAAA,GAAqB,GAAA;AAY3B,IAAM,mBAAA,GAAuC,wBAAA;AAC7C,IAAM,uBAAA,GACJ,4BAAA;AA8HF,eAAsB,wBACpB,OAAA,EACwC;AACxC,EAAA,MAAM;AAAA,IACJ,OAAA;AAAA,IACA,OAAA;AAAA,IACA,iBAAA;AAAA,IACA,SAAA,GAAY,kBAAA;AAAA,IACZ,eAAA,GAAkB;AAAA,GACpB,GAAI,OAAA;AAEJ,EAAA,IACE,OAAA,CAAQ,cAAA,KAAmB,MAAA,IAC3B,OAAA,CAAQ,oBAAoB,MAAA,EAC5B;AACA,IAAA,MAAM,IAAI,KAAA;AAAA,MACR;AAAA,KAEF;AAAA,EACF;AACA,EAAA,IAAI,CAAC,MAAA,CAAO,SAAA,CAAU,SAAS,CAAA,IAAK,aAAa,CAAA,EAAG;AAClD,IAAA,MAAM,IAAI,UAAA;AAAA,MACR,8CAA8C,SAAS,CAAA;AAAA,KACzD;AAAA,EACF;AACA,EAAA,MAAM,kBAAkB,OAAA,CAAQ,eAAA;AAChC,EAAA,MAAM,+BAA+B,OAAA,CAAQ,4BAAA;AAG7C,EAAA,MAAM,WAAW,kBAAA,EAA2B;AAC5C,EAAA,MAAM,2BAA2B,kBAAA,EAA2B;AAC5D,EAAA,MAAM,qBAAqB,kBAAA,EAA2B;AAWtD,EAAA,MAAM,YAAA,uBAAmB,GAAA,EAAoB;AAC7C,EAAA,IAAI,QAAA,GAAW,CAAA;AAEf,EAAA,IAAI,MAAA;AACJ,EAAA,WAAS;AACP,IAAA,IAAI,KAAA;AACJ,IAAA,IAAI;AACF,MAAA,KAAA,GAAQ,MAAM,gBAAgB,OAAA,EAAS;AAAA,QACrC,eAAA;AAAA,QACA,OAAA;AAAA,QACA,SAAA;AAAA,QACA,KAAA,EAAO;AAAA,OACR,CAAA;AAAA,IACH,SAAS,KAAA,EAAO;AAGd,MAAA,IAAI,MAAA,KAAW,MAAA,IAAa,mBAAA,CAAoB,KAAK,CAAA,EAAG;AACtD,QAAA,OAAO;AAAA,UACL,QAAA,EAAU,CAAA;AAAA,UACV,UAAU,EAAC;AAAA,UACX,0BAA0B,EAAC;AAAA,UAC3B,oBAAoB,EAAC;AAAA,UACrB,kBAAA,EAAoB;AAAA,SACtB;AAAA,MACF;AACA,MAAA,MAAM,KAAA;AAAA,IACR;AAEA,IAAA,IAAI,KAAA,CAAM,WAAW,CAAA,EAAG;AAExB,IAAA,KAAA,MAAW,OAAO,KAAA,EAAO;AACvB,MAAA,MAAM,UAAU,CAAA,EAAG,GAAA,CAAI,SAAS,CAAA,CAAA,EAAI,IAAI,UAAU,CAAA,CAAA;AAElD,MAAA,IAAIA,UAAAA;AACJ,MAAA,IAAI;AACF,QAAAA,UAAAA,GAAY,oBAAoB,GAAG,CAAA;AAAA,MACrC,CAAA,CAAA,MAAQ;AAIN,QAAA,kBAAA,CAAmB,OAAO,CAAA,GAAA,CAAK,kBAAA,CAAmB,OAAO,KAAK,CAAA,IAAK,CAAA;AACnE,QAAA;AAAA,MACF;AACA,MAAA,MAAM,MAAA,GAAS,iBAAA,GAAoB,GAAA,CAAI,SAAA,EAAW,IAAI,UAAU,CAAA;AAGhE,MAAA,MAAM,IAAA,GAAO;AAAA,QACX,SAAS,GAAA,CAAI,QAAA;AAAA,QACb,UAAU,GAAA,CAAI,SAAA;AAAA,QACd,WAAW,GAAA,CAAI,UAAA;AAAA,QACf,YAAYA,UAAAA,CAAU,MAAA;AAAA,QACtB,MAAA,EAAQ,QAAQ,MAAA,IAAU,mBAAA;AAAA,QAC1B,SAAA,EAAW,QAAQ,SAAA,IAAa;AAAA,OAClC;AAMA,MAAA,MAAM,UAAA,GAAa,KAAK,SAAA,CAAU;AAAA,QAChC,GAAA,CAAI,QAAA;AAAA,QACJ,GAAA,CAAI,SAAA;AAAA,QACJ,GAAA,CAAI;AAAA,OACL,CAAA;AACD,MAAA,IACE,iCAAiC,MAAA,IACjC,CAAC,YAAA,CAAa,GAAA,CAAI,UAAU,CAAA,EAC5B;AACA,QAAA,MAAM,6BAA6B,IAAI,CAAA;AACvC,QAAA,YAAA,CAAa,GAAA,CAAI,UAAA,EAAY,IAAA,CAAK,UAAU,CAAA;AAAA,MAC9C;AAOA,MAAA,MAAM,qBAAA,GAAwB,YAAA,CAAa,GAAA,CAAI,UAAU,CAAA;AACzD,MAAA,IACE,qBAAA,KAA0B,MAAA,IAC1B,qBAAA,KAA0BA,UAAAA,CAAU,MAAA,EACpC;AACA,QAAA,wBAAA,CAAyB,OAAO,CAAA,GAAA,CAC7B,wBAAA,CAAyB,OAAO,KAAK,CAAA,IAAK,CAAA;AAC7C,QAAA;AAAA,MACF;AAEA,MAAA,IAAI;AACF,QAAA,MAAM,eAAA,CAAgB,EAAE,GAAG,IAAA,EAAM,QAAQ,GAAA,CAAI,OAAA,EAAS,SAAA,EAAAA,UAAAA,EAAW,CAAA;AAAA,MACnE,SAAS,KAAA,EAAO;AAKd,QAAA,IAAI,iBAAiB,8BAAA,EAAgC;AACnD,UAAA,wBAAA,CAAyB,OAAO,CAAA,GAAA,CAC7B,wBAAA,CAAyB,OAAO,KAAK,CAAA,IAAK,CAAA;AAC7C,UAAA;AAAA,QACF;AACA,QAAA,MAAM,KAAA;AAAA,MACR;AAEA,MAAA,QAAA,IAAY,CAAA;AACZ,MAAA,QAAA,CAAS,OAAO,CAAA,GAAA,CAAK,QAAA,CAAS,OAAO,KAAK,CAAA,IAAK,CAAA;AAAA,IACjD;AAEA,IAAA,IAAI,KAAA,CAAM,SAAS,SAAA,EAAW;AAC9B,IAAA,MAAM,IAAA,GAAO,cAAA,CAAe,KAAA,CAAM,EAAA,CAAG,EAAE,CAAC,CAAA;AACxC,IAAA,MAAA,GAAS;AAAA,MACP,SAAS,IAAA,CAAK,QAAA;AAAA,MACd,UAAU,IAAA,CAAK,SAAA;AAAA,MACf,QAAQ,IAAA,CAAK,OAAA;AAAA,MACb,WAAW,IAAA,CAAK;AAAA,KAClB;AAAA,EACF;AAUA,EAAA,OAAO;AAAA,IACL,QAAA;AAAA,IACA,QAAA,EAAU,EAAE,GAAG,QAAA,EAAS;AAAA,IACxB,wBAAA,EAA0B,EAAE,GAAG,wBAAA,EAAyB;AAAA,IACxD,kBAAA,EAAoB,EAAE,GAAG,kBAAA,EAAmB;AAAA,IAC5C,kBAAA,EAAoB;AAAA,GACtB;AACF;AA0BA,eAAe,eAAA,CACb,SACA,MAAA,EACwC;AACxC,EAAA,MAAM,KAAA,GAAQ,GAAA,CAAI,UAAA,CAAW,MAAA,CAAO,eAAe,CAAA;AACnD,EAAA,MAAM,aAAA,GAAgB,gCAAgC,OAAO,CAAA;AAE7D,EAAA,MAAM,aAA4B,EAAC;AACnC,EAAA,IAAI,MAAA,CAAO,YAAY,MAAA,EAAW;AAChC,IAAA,UAAA,CAAW,IAAA,CAAK,GAAA,CAAA,aAAA,EAAmB,MAAA,CAAO,OAAO,CAAA,CAAE,CAAA;AAAA,EACrD;AACA,EAAA,IAAI,MAAA,CAAO,UAAU,MAAA,EAAW;AAC9B,IAAA,UAAA,CAAW,IAAA,CAAK,oBAAA,CAAqB,MAAA,CAAO,KAAK,CAAC,CAAA;AAAA,EACpD;AAEA,EAAA,MAAM,WAAA,GACJ,UAAA,CAAW,MAAA,KAAW,CAAA,GACpB,GAAA,CAAA,CAAA,GACA,aAAa,GAAA,CAAI,IAAA,CAAK,UAAA,EAAY,GAAA,CAAA,KAAA,CAAU,CAAC,CAAA,CAAA;AAEjD,EAAA,MAAM,KAAA,GAAQ,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAAA,EAMR,aAAa,CAAA;AAAA,SAAA,EACV,KAAK,GAAG,WAAW;AAAA;AAAA,UAAA,EAElB,OAAO,SAAS;AAAA,EAAA,CAAA;AAG1B,EAAA,OAAO,OAAA,CAAQ,OAAA,CAA4B,iBAAA,CAAkB,KAAK,CAAC,CAAA;AACrE;AAQA,SAAS,qBAAqB,KAAA,EAAqC;AACjE,EAAA,OAAO,GAAA;AAAA;AAAA,qBAAA,EAEc,MAAM,OAAO;AAAA,yBAAA,EACT,KAAA,CAAM,OAAO,CAAA,mBAAA,EAAsB,KAAA,CAAM,QAAQ,CAAA;AAAA,yBAAA,EACjD,MAAM,OAAO,CAAA,mBAAA,EAAsB,MAAM,QAAQ,CAAA,iBAAA,EAAoB,MAAM,MAAM,CAAA;AAAA;AAAA,uBAAA,EAEnF,MAAM,OAAO;AAAA,4BAAA,EACR,MAAM,QAAQ;AAAA,0BAAA,EAChB,MAAM,MAAM;AAAA,6BAAA,EACT,MAAM,SAAS;AAAA;AAAA;AAAA,EAAA,CAAA;AAI9C;AASA,SAAS,gCAAgC,OAAA,EAAoC;AAC3E,EAAA,QAAQ,QAAQ,OAAA;AAAS,IACvB,KAAK,QAAA,EAAU;AAMb,MAAA,OAAO,GAAA,CAAA,wBAAA,CAAA;AAAA,IACT;AAAA,IACA,KAAK,UAAA,EAAY;AAGf,MAAA,OAAO,GAAA,CAAA,iBAAA,CAAA;AAAA,IACT;AAAA,IACA,SAAS;AACP,MAAA,MAAM,cAAqB,OAAA,CAAQ,OAAA;AACnC,MAAA,MAAM,IAAI,KAAA;AAAA,QACR,CAAA,kDAAA,EAAqD,MAAA,CAAO,WAAW,CAAC,CAAA;AAAA,OAC1E;AAAA,IACF;AAAA;AAEJ;AAOA,SAAS,oBAAoB,GAAA,EAA4C;AACvE,EAAA,IAAI,MAAA;AACJ,EAAA,IAAI;AACF,IAAA,MAAA,GAAS,IAAA,CAAK,KAAA,CAAM,GAAA,CAAI,cAAc,CAAA;AAAA,EACxC,SAAS,KAAA,EAAO;AACd,IAAA,MAAM,IAAI,KAAA;AAAA,MACR,CAAA,sCAAA,EAAyC,GAAA,CAAI,SAAS,CAAA,CAAA,EAAI,GAAA,CAAI,UAAU,CAAA,QAAA,EAC5D,GAAA,CAAI,QAAQ,CAAA,OAAA,EAAU,GAAA,CAAI,OAAO,CAAA,kBAAA,CAAA;AAAA,MAC7C,EAAE,OAAO,KAAA;AAAM,KACjB;AAAA,EACF;AACA,EAAA,IAAI,CAAC,KAAA,CAAM,OAAA,CAAQ,MAAM,CAAA,IAAK,MAAA,CAAO,WAAW,CAAA,EAAG;AACjD,IAAA,MAAM,IAAI,KAAA;AAAA,MACR,CAAA,qBAAA,EAAwB,GAAA,CAAI,SAAS,CAAA,CAAA,EAAI,GAAA,CAAI,UAAU,CAAA,QAAA,EAC3C,GAAA,CAAI,QAAQ,CAAA,OAAA,EAAU,GAAA,CAAI,OAAO,CAAA,wCAAA;AAAA,KAE/C;AAAA,EACF;AACA,EAAA,KAAA,MAAW,CAAC,KAAA,EAAO,KAAK,CAAA,IAAK,MAAA,CAAO,SAAQ,EAAG;AAC7C,IAAA,IAAI,OAAO,KAAA,KAAU,QAAA,IAAY,CAAC,MAAA,CAAO,QAAA,CAAS,KAAK,CAAA,EAAG;AACxD,MAAA,MAAM,IAAI,SAAA;AAAA,QACR,wBAAwB,GAAA,CAAI,SAAS,CAAA,CAAA,EAAI,GAAA,CAAI,UAAU,CAAA,QAAA,EAC3C,GAAA,CAAI,QAAQ,CAAA,OAAA,EAAU,IAAI,OAAO,CAAA,kCAAA,EACzB,KAAK,CAAA,EAAA,EAAK,MAAA,CAAO,KAAK,CAAC,CAAA,CAAA;AAAA,OAC7C;AAAA,IACF;AAAA,EACF;AACA,EAAA,OAAO,MAAA;AACT","file":"index.js","sourcesContent":["import { type GraphDef, type GraphIdentityConfig } from \"../core/define-graph\";\nimport { storeRuntime } from \"../store/runtime-port\";\nimport { type Store } from \"../store/store\";\n\n/**\n * Rebuilds the derived current identity closure for an identity-enabled store.\n * This is a repair operation: it does not change graph revision or assertions.\n */\nexport async function rebuildIdentityClosure<\n  G extends GraphDef & Readonly<{ identity: GraphIdentityConfig }>,\n>(store: Store<G>): Promise<void> {\n  await storeRuntime(store).rebuildIdentityClosure();\n}\n","import {\n  type AllNodeTypes,\n  type GraphDef,\n  type NodeKinds,\n} from \"../core/define-graph\";\nimport { ValidationError } from \"../errors\";\nimport {\n  type DynamicNode,\n  type DynamicNodeReference,\n  type GraphNodeReference,\n  type Node,\n  type NodeRef,\n} from \"../store/types\";\n\n/**\n * The accepted *input* form for every identity facade method: a whole node or\n * a `{ kind, id }` pair for any compile-time graph kind, plus a proof-bearing\n * node or reference produced through the runtime collection lane. Runtime\n * values stay nominal so accepting them does not make an arbitrary\n * `{ kind: string, id: string }` object type-safe.\n *\n * Identity results use {@link IdentityNodeReference}, which honestly includes\n * runtime kinds because an evolved kind can belong to a class reached from a\n * compile-time node.\n */\nexport type IdentityNodeRefInput<G extends GraphDef> =\n  NodeRef<AllNodeTypes<G>> | DynamicNode | DynamicNodeReference;\n\n/**\n * A node reference returned by Operational Identity.\n *\n * Identity classes can contain runtime-evolved kinds even when a read starts\n * from a compile-time node, so results honestly include both lanes.\n */\nexport type IdentityNodeReference<G extends GraphDef> =\n  GraphNodeReference<G> | DynamicNodeReference;\n\n/** A hydrated compile-time or runtime identity member. */\nexport type IdentityNode<G extends GraphDef> =\n  | {\n      [K in NodeKinds<G>]: Node<G[\"nodes\"][K][\"type\"]>;\n    }[NodeKinds<G>]\n  | DynamicNode;\n\ndeclare const __identityAssertionId: unique symbol;\n\nexport type IdentityAssertionId = string &\n  Readonly<{ [__identityAssertionId]: true }>;\n\n/**\n * Brands a non-empty string as an {@link IdentityAssertionId}.\n *\n * Use this when a persisted identity assertion id has round-tripped through\n * untyped storage or an external boundary and must be passed back to a\n * retraction surface such as `retractAssertion` or `bulkRetractAssertions`.\n * Mirrors the `asNodeId` / `asEdgeId` precedent.\n *\n * @throws {ValidationError} when `value` is empty.\n */\nexport function asIdentityAssertionId(value: string): IdentityAssertionId {\n  if (value.length === 0) {\n    throw new ValidationError(\n      \"asIdentityAssertionId must be a non-empty string.\",\n      {\n        issues: [\n          {\n            path: \"asIdentityAssertionId\",\n            message: \"Expected a non-empty string.\",\n          },\n        ],\n      },\n      {\n        suggestion: \"Use a persisted identity assertion id value.\",\n      },\n    );\n  }\n  return value as IdentityAssertionId;\n}\n\n/**\n * What one assertion claims about a pair of nodes: `\"same\"` merges them into\n * one equivalence set, `\"different\"` records a disjointness that a later\n * `\"same\"` claim must not contradict.\n */\nexport type IdentityRelation = \"same\" | \"different\";\n\n/**\n * One persisted identity claim about an ordered pair of nodes. Returned by the\n * assertion writers and by `identity.assertionsOf(...)`; `validTo` is set when\n * the assertion has been retracted, so a historical read can still see it.\n */\nexport type IdentityAssertion<G extends GraphDef> = Readonly<{\n  id: IdentityAssertionId;\n  relation: IdentityRelation;\n  a: IdentityNodeReference<G>;\n  b: IdentityNodeReference<G>;\n  validFrom: string;\n  validTo?: string;\n}>;\n\n/** Result of an idempotent assertion write. */\nexport type IdentityAssertionResult<G extends GraphDef> = Readonly<{\n  assertion: IdentityAssertion<G>;\n  action: \"created\" | \"existing\";\n}>;\n\n/** The half-open effective-time window of an identity assertion. */\nexport type IdentityValidityWindow = Readonly<{\n  validFrom?: string;\n  validTo?: string;\n}>;\n\n/** One ordered node pair handed to `bulkAssertSame` / `bulkAssertDifferent`. */\nexport type IdentityPair<G extends GraphDef> = Readonly<{\n  a: IdentityNodeRefInput<G>;\n  b: IdentityNodeRefInput<G>;\n}> &\n  IdentityValidityWindow;\n\n/**\n * The read half of the identity surface: equivalence-set membership,\n * representative selection, and the assertions behind them.\n *\n * Obtained from a read-only lens — `store.asOf(...).identity`,\n * `store.snapshot().identity` — where it answers at that view's coordinate.\n * The full read+write surface is {@link IdentityFacade}.\n */\nexport type IdentityReadFacade<G extends GraphDef> = Readonly<{\n  representativeOf: (\n    ref: IdentityNodeRefInput<G>,\n  ) => Promise<IdentityNodeReference<G> | undefined>;\n  membersOf: (\n    ref: IdentityNodeRefInput<G>,\n  ) => Promise<readonly IdentityNodeReference<G>[]>;\n  nodesOf: (\n    ref: IdentityNodeRefInput<G>,\n  ) => Promise<readonly IdentityNode<G>[]>;\n  areSame: (\n    a: IdentityNodeRefInput<G>,\n    b: IdentityNodeRefInput<G>,\n  ) => Promise<boolean>;\n  areDifferent: (\n    a: IdentityNodeRefInput<G>,\n    b: IdentityNodeRefInput<G>,\n  ) => Promise<boolean>;\n  assertionsOf: (\n    ref: IdentityNodeRefInput<G>,\n  ) => Promise<readonly IdentityAssertion<G>[]>;\n}>;\n\n/**\n * The full TypeGraph Identity Profile surface: {@link IdentityReadFacade} plus\n * the assertion writers and retractions.\n *\n * Obtained from `store.identity` or `tx.identity`, and present only on graphs\n * that declared `identity: { ... }` in `defineGraph`. Every writer is\n * idempotent — re-asserting an existing claim returns it with\n * `action: \"existing\"` rather than duplicating it.\n */\nexport type IdentityFacade<G extends GraphDef> = IdentityReadFacade<G> &\n  Readonly<{\n    assertSame: (\n      a: IdentityNodeRefInput<G>,\n      b: IdentityNodeRefInput<G>,\n      window?: IdentityValidityWindow,\n    ) => Promise<IdentityAssertionResult<G>>;\n    assertDifferent: (\n      a: IdentityNodeRefInput<G>,\n      b: IdentityNodeRefInput<G>,\n      window?: IdentityValidityWindow,\n    ) => Promise<IdentityAssertionResult<G>>;\n    bulkAssertSame: (\n      pairs: readonly IdentityPair<G>[],\n    ) => Promise<readonly IdentityAssertionResult<G>[]>;\n    bulkAssertDifferent: (\n      pairs: readonly IdentityPair<G>[],\n    ) => Promise<readonly IdentityAssertionResult<G>[]>;\n    retractAssertion: (\n      id: IdentityAssertionId,\n    ) => Promise<IdentityAssertion<G> | undefined>;\n    retractSameAssertion: (\n      a: IdentityNodeRefInput<G>,\n      b: IdentityNodeRefInput<G>,\n    ) => Promise<IdentityAssertion<G> | undefined>;\n    retractDifferentAssertion: (\n      a: IdentityNodeRefInput<G>,\n      b: IdentityNodeRefInput<G>,\n    ) => Promise<IdentityAssertion<G> | undefined>;\n    bulkRetractAssertions: (\n      ids: readonly IdentityAssertionId[],\n    ) => Promise<readonly IdentityAssertion<G>[]>;\n  }>;\n\n/**\n * The assertion-only write surface of the TypeGraph Identity Profile.\n *\n * This deliberately excludes reads and retractions so constrained staging\n * handles can accept incoming identity claims without exposing the broader\n * operational identity surface.\n */\nexport type IdentityAssertionWriteFacade<G extends GraphDef> = Pick<\n  IdentityFacade<G>,\n  \"assertSame\" | \"assertDifferent\" | \"bulkAssertSame\" | \"bulkAssertDifferent\"\n>;\n\n/**\n * Per-transaction identity write counts carried by a transaction receipt.\n * `total` is the sum of the three preceding counters.\n */\nexport type IdentityWriteSummary = Readonly<{\n  sameAssertions: number;\n  differentAssertions: number;\n  retractions: number;\n  total: number;\n}>;\n","/**\n * One-time offline migration: legacy shared embeddings table → per-field\n * strategy storage.\n *\n * ## What this is for\n *\n * The cross-backend vector cutover (#157) dropped the single shared\n * `typegraph_node_embeddings` table. Each\n * `VectorStrategy` now OWNS one typed, fixed-dimension structure per\n * `(nodeKind, fieldPath)` — the only layout that can be ANN-indexed on\n * libSQL and sqlite-vec, not just pgvector.\n *\n * Deployments that wrote embeddings under the old shared table before\n * upgrading still hold those rows. This utility drains them into the new\n * per-field storage **once**, during the upgrade, so existing embedded\n * data survives the cutover without re-embedding from source.\n *\n * It is an explicitly-run, offline step — not wired into `materializeIndexes`\n * or any boot path. Run it once after deploying the new version and before\n * (or alongside) the first `materializeIndexes()`, then drop the legacy\n * table at your leisure.\n *\n * ## How it works\n *\n * - Skips cleanly (returns a zero summary) when the legacy table is absent —\n *   a fresh install, or a re-run after the table was dropped.\n * - Reads rows in keyset-paginated batches (never the whole table at once),\n *   decoding the engine-native embedding column to a numeric array at the SQL\n *   level: sqlite-vec stored a `vec_f32` blob (`vec_to_json` decodes it);\n *   pgvector stored a native `vector` (`::text` yields a `[…]` literal).\n * - Re-inserts each row through `backend.upsertEmbedding`, which routes the\n *   active strategy's `buildUpsert` and idempotently provisions the per-field\n *   storage (the same `(nodeKind, fieldPath)` slot a fresh store write uses).\n *   The migration stays graph-agnostic and execution-correct on both the\n *   sync (better-sqlite3) and async (libsql / Postgres) backends — it does\n *   not re-implement the backend's statement-execution glue.\n *\n * Idempotent and resumable: a partial run followed by a full run converges\n * to the same per-field tables, because every write is an upsert keyed by\n * `(graph_id, node_id)` in the strategy's owned storage.\n */\nimport {\n  DEFAULT_EMBEDDING_INDEX_TYPE,\n  DEFAULT_EMBEDDING_METRIC,\n  type EmbeddingIndexType,\n  type EmbeddingMetric,\n} from \"../core/embedding\";\nimport { EmbeddingDimensionChangedError } from \"../errors\";\nimport { sql, type SqlFragment } from \"../query/sql-fragment\";\nimport { asCompiledRowsSql } from \"../query/sql-intent\";\nimport { createDataKeyedBag } from \"../utils/object\";\nimport { requireDefined } from \"../utils/presence\";\nimport { isMissingTableError } from \"../utils/sql-errors\";\nimport { LEGACY_EMBEDDINGS_TABLE_NAME } from \"./table-names\";\nimport { type GraphBackend } from \"./types\";\n\n/**\n * Default rows read per round-trip. Large enough to amortize round-trip\n * latency, small enough to bound peak memory regardless of table size.\n */\nconst DEFAULT_BATCH_SIZE = 500;\n\n/**\n * Metric / index type applied to a migrated field when no\n * {@link MigrateLegacyEmbeddingsOptions.resolveSlotConfig} is supplied (or\n * it returns `undefined`). Matches the defaults `embedding()` and\n * `resolveEmbeddingFields` apply, so a migrated field lands in storage shaped\n * identically to one written fresh through the store. Migrated data is only\n * ever brute-forceable until `materializeIndexes()` builds the ANN index, so\n * the index-type default governs only which ANN structure the per-field\n * storage DDL provisions, not the migration's correctness.\n */\nconst DEFAULT_SLOT_METRIC: EmbeddingMetric = DEFAULT_EMBEDDING_METRIC;\nconst DEFAULT_SLOT_INDEX_TYPE: EmbeddingIndexType =\n  DEFAULT_EMBEDDING_INDEX_TYPE;\n\n/**\n * The resolved storage config for one `(nodeKind, fieldPath)` slot that the\n * legacy table did not record. The legacy shared table stored only the\n * vector and its dimension count — not the metric or index type — so a\n * caller that wants migrated fields to match a specific graph's `embedding()`\n * declarations supplies this resolver.\n */\nexport type LegacyEmbeddingSlotConfig = Readonly<{\n  metric: EmbeddingMetric;\n  indexType: EmbeddingIndexType;\n}>;\n\n/**\n * Options for {@link migrateLegacyEmbeddings}.\n */\nexport type MigrateLegacyEmbeddingsOptions = Readonly<{\n  /**\n   * The backend to migrate, wired with the destination `VectorStrategy`\n   * (i.e. the post-cutover backend). Its `vectorStrategy` owns the per-field\n   * storage rows are written into and its `upsertEmbedding` performs the\n   * writes.\n   */\n  backend: GraphBackend;\n\n  /**\n   * Restrict the migration to a single graph. When omitted, every graph's\n   * rows in the legacy table are migrated (the table is graph-scoped by its\n   * `graph_id` column).\n   */\n  graphId?: string;\n\n  /**\n   * Resolves the metric / index type for a `(nodeKind, fieldPath)` slot the\n   * legacy table didn't persist. Return `undefined` to fall back to the\n   * cosine / hnsw defaults. Supply this (typically reading the graph's\n   * `embedding()` declarations) when migrated fields must match a specific\n   * metric — e.g. an `l2` field, which scores incorrectly under the cosine\n   * default.\n   */\n  resolveSlotConfig?: (\n    nodeKind: string,\n    fieldPath: string,\n  ) => LegacyEmbeddingSlotConfig | undefined;\n\n  /** Rows read per round-trip. Defaults to {@link DEFAULT_BATCH_SIZE}. */\n  batchSize?: number;\n\n  /**\n   * Physical name of the legacy table to drain. Defaults to\n   * {@link LEGACY_EMBEDDINGS_TABLE_NAME}. Override only for a non-default\n   * deployment that renamed the embeddings table.\n   */\n  legacyTableName?: string;\n}>;\n\n/**\n * Summary of a {@link migrateLegacyEmbeddings} run.\n */\nexport type MigrateLegacyEmbeddingsResult = Readonly<{\n  /** Total embedding rows re-inserted into per-field storage. */\n  migrated: number;\n  /**\n   * Per-`(nodeKind, fieldPath)` counts, keyed `\"<nodeKind>.<fieldPath>\"`\n   * (the strategy's logical-slot key form). Empty when the legacy table was\n   * absent or held no rows for the requested scope.\n   */\n  perField: Readonly<Record<string, number>>;\n  /**\n   * Rows skipped because their vector length didn't match the per-field\n   * table's fixed dimension. The legacy shared column allowed mixed\n   * dimensions for one `(nodeKind, fieldPath)` (e.g. an unmigrated model\n   * change); the first migrated row fixes the typed table's dimension and\n   * any differently-sized rows for that slot are skipped rather than aborting\n   * the whole migration. Keyed `\"<nodeKind>.<fieldPath>\"`. Non-empty here\n   * means those fields need a deliberate re-embed at a single dimension.\n   */\n  skippedDimensionMismatch: Readonly<Record<string, number>>;\n  /**\n   * Rows skipped because their legacy embedding could not be decoded into a\n   * finite-number array — a corrupt value (e.g. a pgvector `vector` column\n   * permits `NaN`/`Infinity`, which is not valid JSON). Keyed\n   * `\"<nodeKind>.<fieldPath>\"`. Skipping + reporting keeps one bad row from\n   * aborting the whole migration; non-empty here means those rows need manual\n   * repair.\n   */\n  skippedDecodeError: Readonly<Record<string, number>>;\n  /**\n   * Whether the legacy table existed. `false` means the run was a clean\n   * no-op (fresh install, or already-dropped table on a re-run).\n   */\n  legacyTablePresent: boolean;\n}>;\n\n/**\n * A single legacy embedding row, with the engine-native vector already\n * decoded to a JSON array string by the dialect-specific SELECT. The\n * legacy `dimensions` column is intentionally not read: the decoded array's\n * length is the authoritative fixed dimension for the destination slot, and\n * relying on it sidesteps the per-driver string/number coercion the legacy\n * integer column would otherwise need.\n */\ntype LegacyEmbeddingRow = Readonly<{\n  graph_id: string;\n  node_kind: string;\n  node_id: string;\n  field_path: string;\n  /** JSON array text, e.g. `\"[0.1,0.2,0.3]\"` — decoded per dialect. */\n  embedding_json: string;\n}>;\n\n/**\n * Re-inserts every embedding from the legacy shared\n * `typegraph_node_embeddings` table into the active\n * `backend.vectorStrategy`'s per-`(nodeKind, fieldPath)` storage.\n *\n * One-time, explicitly-run upgrade step for the shared-table → per-field\n * cutover (#157). Idempotent, batched, and a clean no-op when the legacy\n * table is absent. See the module doc comment for the full contract.\n *\n * @throws Error when the backend exposes no `vectorStrategy` /\n *         `upsertEmbedding` (nothing to migrate *into*) — a configuration\n *         error the caller must fix by wiring the destination strategy\n *         before migrating.\n */\nexport async function migrateLegacyEmbeddings(\n  options: MigrateLegacyEmbeddingsOptions,\n): Promise<MigrateLegacyEmbeddingsResult> {\n  const {\n    backend,\n    graphId,\n    resolveSlotConfig,\n    batchSize = DEFAULT_BATCH_SIZE,\n    legacyTableName = LEGACY_EMBEDDINGS_TABLE_NAME,\n  } = options;\n\n  if (\n    backend.vectorStrategy === undefined ||\n    backend.upsertEmbedding === undefined\n  ) {\n    throw new Error(\n      \"migrateLegacyEmbeddings requires a backend wired with a vectorStrategy \" +\n        \"(the destination per-field storage). Pass the post-cutover backend.\",\n    );\n  }\n  if (!Number.isInteger(batchSize) || batchSize <= 0) {\n    throw new RangeError(\n      `batchSize must be a positive integer, got: ${batchSize}`,\n    );\n  }\n  const upsertEmbedding = backend.upsertEmbedding;\n  const ensureVectorSlotContribution = backend.ensureVectorSlotContribution;\n\n  // Data-keyed: slot keys are built from a row's `node_kind` / `field_path`.\n  const perField = createDataKeyedBag<number>();\n  const skippedDimensionMismatch = createDataKeyedBag<number>();\n  const skippedDecodeError = createDataKeyedBag<number>();\n  // (kind, field) slots whose per-field table + durable marker this run has\n  // already provisioned, mapped to the dimension the table was fixed at.\n  // `upsertEmbedding` asserts the marker (#135) and no longer self-creates\n  // the table, so this offline migration (privileged) provisions each slot\n  // once — at the first row's dimension, which fixes the typed table just as\n  // the original lazy write did. Differently-sized later rows for the same\n  // slot are detected against this map and skipped BEFORE the upsert: the\n  // marker assert would otherwise read the differently-dimensioned slot as\n  // stale and abort the whole migration, and the ensure is deliberately not\n  // re-run per row (that would trip the marker drift-guard).\n  const ensuredSlots = new Map<string, number>();\n  let migrated = 0;\n\n  let cursor: LegacyRowCursor | undefined;\n  for (;;) {\n    let batch: readonly LegacyEmbeddingRow[];\n    try {\n      batch = await readLegacyBatch(backend, {\n        legacyTableName,\n        graphId,\n        batchSize,\n        after: cursor,\n      });\n    } catch (error) {\n      // A missing legacy table is the expected \"nothing to migrate\" path on\n      // the first read — surface it as a clean no-op, not a failure.\n      if (cursor === undefined && isMissingTableError(error)) {\n        return {\n          migrated: 0,\n          perField: {},\n          skippedDimensionMismatch: {},\n          skippedDecodeError: {},\n          legacyTablePresent: false,\n        };\n      }\n      throw error;\n    }\n\n    if (batch.length === 0) break;\n\n    for (const row of batch) {\n      const slotKey = `${row.node_kind}.${row.field_path}`;\n\n      let embedding: readonly number[];\n      try {\n        embedding = decodeEmbeddingJson(row);\n      } catch {\n        // A corrupt legacy value (e.g. a pgvector `vector` column permits\n        // NaN/Infinity, which is not valid JSON) is skipped + reported rather\n        // than aborting the whole migration on one bad row.\n        skippedDecodeError[slotKey] = (skippedDecodeError[slotKey] ?? 0) + 1;\n        continue;\n      }\n      const config = resolveSlotConfig?.(row.node_kind, row.field_path);\n      // The decoded length is the authoritative fixed dimension — the\n      // strategy provisions its column type (e.g. `F32_BLOB(N)`) from it.\n      const slot = {\n        graphId: row.graph_id,\n        nodeKind: row.node_kind,\n        fieldPath: row.field_path,\n        dimensions: embedding.length,\n        metric: config?.metric ?? DEFAULT_SLOT_METRIC,\n        indexType: config?.indexType ?? DEFAULT_SLOT_INDEX_TYPE,\n      };\n\n      // Provision the per-field table + durable marker before the first\n      // write into this slot. Once per (graph, kind, field): the first row's\n      // dimension fixes the table. Keyed by graph id too — the legacy table\n      // is graph-scoped, so the same `kind.field` can recur across graphs.\n      const ensuredKey = JSON.stringify([\n        row.graph_id,\n        row.node_kind,\n        row.field_path,\n      ]);\n      if (\n        ensureVectorSlotContribution !== undefined &&\n        !ensuredSlots.has(ensuredKey)\n      ) {\n        await ensureVectorSlotContribution(slot);\n        ensuredSlots.set(ensuredKey, slot.dimensions);\n      }\n\n      // The legacy shared column allowed mixed dimensions for one\n      // (nodeKind, fieldPath); the per-field table is fixed at the first\n      // migrated row's dimension. Skip a differently-sized row up front —\n      // its slot would fail the marker assert as stale (different\n      // signature), aborting the migration instead of skipping the row.\n      const provisionedDimensions = ensuredSlots.get(ensuredKey);\n      if (\n        provisionedDimensions !== undefined &&\n        provisionedDimensions !== embedding.length\n      ) {\n        skippedDimensionMismatch[slotKey] =\n          (skippedDimensionMismatch[slotKey] ?? 0) + 1;\n        continue;\n      }\n\n      try {\n        await upsertEmbedding({ ...slot, nodeId: row.node_id, embedding });\n      } catch (error) {\n        // The legacy shared column allowed mixed dimensions for one\n        // (nodeKind, fieldPath); the per-field table is fixed at the first\n        // migrated row's dimension, so a differently-sized row is skipped and\n        // reported rather than aborting the whole migration.\n        if (error instanceof EmbeddingDimensionChangedError) {\n          skippedDimensionMismatch[slotKey] =\n            (skippedDimensionMismatch[slotKey] ?? 0) + 1;\n          continue;\n        }\n        throw error;\n      }\n\n      migrated += 1;\n      perField[slotKey] = (perField[slotKey] ?? 0) + 1;\n    }\n\n    if (batch.length < batchSize) break;\n    const last = requireDefined(batch.at(-1));\n    cursor = {\n      graphId: last.graph_id,\n      nodeKind: last.node_kind,\n      nodeId: last.node_id,\n      fieldPath: last.field_path,\n    };\n  }\n\n  // SPREAD at the boundary. The three maps are null-prototype accumulators\n  // because their keys are slot names built from row data; that protection is\n  // internal, and returning the bags as-is handed a caller three maps with no\n  // `toString` and `instanceof Object === false` — while the early\n  // \"nothing to migrate\" return above hands back `{}` literals, so the same\n  // exported function answered with two different kinds of object depending on\n  // whether the legacy table existed. Spread copies own properties with\n  // CreateDataProperty, so a `__proto__` slot key survives as an own key.\n  return {\n    migrated,\n    perField: { ...perField },\n    skippedDimensionMismatch: { ...skippedDimensionMismatch },\n    skippedDecodeError: { ...skippedDecodeError },\n    legacyTablePresent: true,\n  };\n}\n\n/**\n * Composite keyset cursor over the legacy table's primary key\n * `(graph_id, node_kind, node_id, field_path)`. Stable under concurrent\n * writes and immune to OFFSET drift, so a batched walk reads every row once.\n */\ntype LegacyRowCursor = Readonly<{\n  graphId: string;\n  nodeKind: string;\n  nodeId: string;\n  fieldPath: string;\n}>;\n\ntype ReadLegacyBatchParams = Readonly<{\n  legacyTableName: string;\n  graphId: string | undefined;\n  batchSize: number;\n  after: LegacyRowCursor | undefined;\n}>;\n\n/**\n * Reads one keyset-paginated batch of legacy rows, ordered by the primary\n * key, with the engine-native embedding column decoded to a JSON array\n * string by the dialect.\n */\nasync function readLegacyBatch(\n  backend: GraphBackend,\n  params: ReadLegacyBatchParams,\n): Promise<readonly LegacyEmbeddingRow[]> {\n  const table = sql.identifier(params.legacyTableName);\n  const embeddingJson = legacyEmbeddingDecodeExpression(backend);\n\n  const conditions: SqlFragment[] = [];\n  if (params.graphId !== undefined) {\n    conditions.push(sql`\"graph_id\" = ${params.graphId}`);\n  }\n  if (params.after !== undefined) {\n    conditions.push(keysetAfterCondition(params.after));\n  }\n\n  const whereClause =\n    conditions.length === 0 ?\n      sql``\n    : sql` WHERE ${sql.join(conditions, sql` AND `)}`;\n\n  const query = sql`\n    SELECT\n      \"graph_id\" AS graph_id,\n      \"node_kind\" AS node_kind,\n      \"node_id\" AS node_id,\n      \"field_path\" AS field_path,\n      ${embeddingJson} AS embedding_json\n    FROM ${table}${whereClause}\n    ORDER BY \"graph_id\" ASC, \"node_kind\" ASC, \"node_id\" ASC, \"field_path\" ASC\n    LIMIT ${params.batchSize}\n  `;\n\n  return backend.execute<LegacyEmbeddingRow>(asCompiledRowsSql(query));\n}\n\n/**\n * The strict `>` comparison over the composite primary key, expressed as\n * the standard lexicographic OR-chain so it works on every dialect (SQLite\n * supports row-value comparison, but Postgres + SQLite both accept this\n * portable form).\n */\nfunction keysetAfterCondition(after: LegacyRowCursor): SqlFragment {\n  return sql`\n    (\n        \"graph_id\" > ${after.graphId}\n        OR (\"graph_id\" = ${after.graphId} AND \"node_kind\" > ${after.nodeKind})\n        OR (\"graph_id\" = ${after.graphId} AND \"node_kind\" = ${after.nodeKind} AND \"node_id\" > ${after.nodeId})\n        OR (\n          \"graph_id\" = ${after.graphId}\n          AND \"node_kind\" = ${after.nodeKind}\n          AND \"node_id\" = ${after.nodeId}\n          AND \"field_path\" > ${after.fieldPath}\n        )\n      )\n  `;\n}\n\n/**\n * The SQL expression that decodes the legacy engine-native embedding column\n * into a JSON array string `embedding_json`. The single dialect branch in\n * this whole module: the legacy storage formats are genuinely engine-\n * specific, and there is no longer a strategy abstraction over the *legacy*\n * table to delegate to.\n */\nfunction legacyEmbeddingDecodeExpression(backend: GraphBackend): SqlFragment {\n  switch (backend.dialect) {\n    case \"sqlite\": {\n      // Legacy SQLite embeddings were written via `vec_f32('[…]')`\n      // (sqlite-vec binary). `vec_to_json` is its inverse, yielding the\n      // JSON array text. Requires sqlite-vec on the connection — which the\n      // legacy write path also required, so any deployment with legacy rows\n      // has it loaded.\n      return sql`vec_to_json(\"embedding\")`;\n    }\n    case \"postgres\": {\n      // pgvector's native `vector` casts to its `[…]` text literal, which is\n      // valid JSON for `JSON.parse`.\n      return sql`\"embedding\"::text`;\n    }\n    default: {\n      const _exhaustive: never = backend.dialect;\n      throw new Error(\n        `migrateLegacyEmbeddings does not support dialect: ${String(_exhaustive)}`,\n      );\n    }\n  }\n}\n\n/**\n * Parses a decoded `embedding_json` array, asserting it is a non-empty array\n * of finite numbers. A bad decode (wrong type, NaN) names the offending row\n * loudly instead of writing a corrupt vector into per-field storage.\n */\nfunction decodeEmbeddingJson(row: LegacyEmbeddingRow): readonly number[] {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(row.embedding_json) as unknown;\n  } catch (error) {\n    throw new Error(\n      `Failed to decode legacy embedding for ${row.node_kind}.${row.field_path} ` +\n        `(graph ${row.graph_id}, node ${row.node_id}): not valid JSON.`,\n      { cause: error },\n    );\n  }\n  if (!Array.isArray(parsed) || parsed.length === 0) {\n    throw new Error(\n      `Legacy embedding for ${row.node_kind}.${row.field_path} ` +\n        `(graph ${row.graph_id}, node ${row.node_id}) decoded to a non-array ` +\n        `or empty value.`,\n    );\n  }\n  for (const [index, value] of parsed.entries()) {\n    if (typeof value !== \"number\" || !Number.isFinite(value)) {\n      throw new TypeError(\n        `Legacy embedding for ${row.node_kind}.${row.field_path} ` +\n          `(graph ${row.graph_id}, node ${row.node_id}) has a non-finite ` +\n          `value at index ${index}: ${String(value)}.`,\n      );\n    }\n  }\n  return parsed as readonly number[];\n}\n"]}

package/dist/indexes/index.cjs

@@ -1,13 +1,15 @@
 'use strict';
 
 var chunkUWG5GX6E_cjs = require('../chunk-UWG5GX6E.cjs');
-var chunkCSNOYIB4_cjs = require('../chunk-CSNOYIB4.cjs');
-var chunkSHC7BCG5_cjs = require('../chunk-SHC7BCG5.cjs');
-var chunkHY5BNOUN_cjs = require('../chunk-HY5BNOUN.cjs');
+var chunkTM54OBHX_cjs = require('../chunk-TM54OBHX.cjs');
+var chunkI7YAY2VQ_cjs = require('../chunk-I7YAY2VQ.cjs');
+var chunkOTNTGEXR_cjs = require('../chunk-OTNTGEXR.cjs');
 require('../chunk-ZY4GXIVN.cjs');
+require('../chunk-JVA3KDEA.cjs');
+require('../chunk-A4C4NJ5U.cjs');
 require('../chunk-NAUA4PW5.cjs');
-require('../chunk-TEC24ZDA.cjs');
-require('../chunk-OJHD3LXJ.cjs');
+require('../chunk-H2VWDQWC.cjs');
+require('../chunk-H5IJSROF.cjs');
 require('../chunk-7EO3TCQB.cjs');
 require('../chunk-RT5ZY4XA.cjs');
 require('../chunk-HAHNRASW.cjs');
@@ -39,31 +41,31 @@ Object.defineProperty(exports, "toDeclaredIndexes", {
 });
 Object.defineProperty(exports, "generateEdgeIndexDDL", {
   enumerable: true,
-  get: function () { return chunkCSNOYIB4_cjs.generateEdgeIndexDDL; }
+  get: function () { return chunkTM54OBHX_cjs.generateEdgeIndexDDL; }
 });
 Object.defineProperty(exports, "generateIndexDDL", {
   enumerable: true,
-  get: function () { return chunkCSNOYIB4_cjs.generateIndexDDL; }
+  get: function () { return chunkTM54OBHX_cjs.generateIndexDDL; }
 });
 Object.defineProperty(exports, "generateNodeIndexDDL", {
   enumerable: true,
-  get: function () { return chunkCSNOYIB4_cjs.generateNodeIndexDDL; }
+  get: function () { return chunkTM54OBHX_cjs.generateNodeIndexDDL; }
 });
 Object.defineProperty(exports, "SYSTEM_INDEX_DECLARATIONS", {
   enumerable: true,
-  get: function () { return chunkSHC7BCG5_cjs.SYSTEM_INDEX_DECLARATIONS; }
+  get: function () { return chunkI7YAY2VQ_cjs.SYSTEM_INDEX_DECLARATIONS; }
 });
 Object.defineProperty(exports, "generateSystemIndexDDL", {
   enumerable: true,
-  get: function () { return chunkSHC7BCG5_cjs.generateSystemIndexDDL; }
+  get: function () { return chunkI7YAY2VQ_cjs.generateSystemIndexDDL; }
 });
 Object.defineProperty(exports, "defineEdgeIndex", {
   enumerable: true,
-  get: function () { return chunkHY5BNOUN_cjs.defineEdgeIndex; }
+  get: function () { return chunkOTNTGEXR_cjs.defineEdgeIndex; }
 });
 Object.defineProperty(exports, "defineNodeIndex", {
   enumerable: true,
-  get: function () { return chunkHY5BNOUN_cjs.defineNodeIndex; }
+  get: function () { return chunkOTNTGEXR_cjs.defineNodeIndex; }
 });
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map

package/dist/indexes/index.d.cts

@@ -1,7 +1,7 @@
-import { ag as EdgeIndexDeclaration, ce as SqlDialect, bQ as RelationalIndexDeclaration, bB as NodeIndexDeclaration, I as IndexDeclaration } from '../types-CWg4dTjj.cjs';
-export { dm as EdgeIndexConfig, ah as EdgeIndexDirection, dn as EdgeIndexWhereBuilder, bd as IndexOrigin, be as IndexScope, bf as IndexWhereExpression, dp as IndexWhereFieldBuilder, dq as IndexWhereInput, dr as NodeIndexConfig, ds as NodeIndexWhereBuilder, co as SystemColumnName, cM as VectorIndexDeclaration, cN as VectorIndexImplementation, cO as VectorIndexMetric, cP as VectorIndexParams } from '../types-CWg4dTjj.cjs';
-export { S as SYSTEM_INDEX_DECLARATIONS, a as SystemIndexDeclaration, b as SystemIndexTable, c as andWhere, d as defineEdgeIndex, e as defineNodeIndex, g as generateSystemIndexDDL, n as notWhere, o as orWhere } from '../where-CNtx1aLc.cjs';
-import { D as DeclaredIndex } from '../types-BE921wRl.cjs';
+import { ap as EdgeIndexDeclaration, cn as SqlDialect, bZ as RelationalIndexDeclaration, bF as NodeIndexDeclaration, I as IndexDeclaration } from '../types-6yf0Vv-_.cjs';
+export { dz as EdgeIndexConfig, aq as EdgeIndexDirection, dA as EdgeIndexWhereBuilder, bj as IndexOrigin, bk as IndexScope, bl as IndexWhereExpression, dB as IndexWhereFieldBuilder, dC as IndexWhereInput, dD as NodeIndexConfig, dE as NodeIndexWhereBuilder, cx as SystemColumnName, cU as VectorIndexDeclaration, cV as VectorIndexImplementation, cW as VectorIndexMetric, cX as VectorIndexParams } from '../types-6yf0Vv-_.cjs';
+export { S as SYSTEM_INDEX_DECLARATIONS, a as SystemIndexDeclaration, b as SystemIndexTable, c as andWhere, d as defineEdgeIndex, e as defineNodeIndex, g as generateSystemIndexDDL, n as notWhere, o as orWhere } from '../where-Mhf_yyKX.cjs';
+import { D as DeclaredIndex } from '../types-DzJ4dlzk.cjs';
 import 'zod';
 
 type GenerateIndexDdlOptions = Readonly<{

package/dist/indexes/index.d.ts

@@ -1,7 +1,7 @@
-import { ag as EdgeIndexDeclaration, ce as SqlDialect, bQ as RelationalIndexDeclaration, bB as NodeIndexDeclaration, I as IndexDeclaration } from '../types-CWg4dTjj.js';
-export { dm as EdgeIndexConfig, ah as EdgeIndexDirection, dn as EdgeIndexWhereBuilder, bd as IndexOrigin, be as IndexScope, bf as IndexWhereExpression, dp as IndexWhereFieldBuilder, dq as IndexWhereInput, dr as NodeIndexConfig, ds as NodeIndexWhereBuilder, co as SystemColumnName, cM as VectorIndexDeclaration, cN as VectorIndexImplementation, cO as VectorIndexMetric, cP as VectorIndexParams } from '../types-CWg4dTjj.js';
-export { S as SYSTEM_INDEX_DECLARATIONS, a as SystemIndexDeclaration, b as SystemIndexTable, c as andWhere, d as defineEdgeIndex, e as defineNodeIndex, g as generateSystemIndexDDL, n as notWhere, o as orWhere } from '../where-BWXUPV3C.js';
-import { D as DeclaredIndex } from '../types-BScHXVM7.js';
+import { ap as EdgeIndexDeclaration, cn as SqlDialect, bZ as RelationalIndexDeclaration, bF as NodeIndexDeclaration, I as IndexDeclaration } from '../types-6yf0Vv-_.js';
+export { dz as EdgeIndexConfig, aq as EdgeIndexDirection, dA as EdgeIndexWhereBuilder, bj as IndexOrigin, bk as IndexScope, bl as IndexWhereExpression, dB as IndexWhereFieldBuilder, dC as IndexWhereInput, dD as NodeIndexConfig, dE as NodeIndexWhereBuilder, cx as SystemColumnName, cU as VectorIndexDeclaration, cV as VectorIndexImplementation, cW as VectorIndexMetric, cX as VectorIndexParams } from '../types-6yf0Vv-_.js';
+export { S as SYSTEM_INDEX_DECLARATIONS, a as SystemIndexDeclaration, b as SystemIndexTable, c as andWhere, d as defineEdgeIndex, e as defineNodeIndex, g as generateSystemIndexDDL, n as notWhere, o as orWhere } from '../where-DuG2LCLe.js';
+import { D as DeclaredIndex } from '../types-_vVSB9k-.js';
 import 'zod';
 
 type GenerateIndexDdlOptions = Readonly<{

package/dist/indexes/index.js

@@ -1,11 +1,13 @@
 export { andWhere, notWhere, orWhere, toDeclaredIndex, toDeclaredIndexes } from '../chunk-QZ7A6HBM.js';
-export { generateEdgeIndexDDL, generateIndexDDL, generateNodeIndexDDL } from '../chunk-WQBAQZHR.js';
-export { SYSTEM_INDEX_DECLARATIONS, generateSystemIndexDDL } from '../chunk-H3XP6BAV.js';
-export { defineEdgeIndex, defineNodeIndex } from '../chunk-ZRJTM7MT.js';
+export { generateEdgeIndexDDL, generateIndexDDL, generateNodeIndexDDL } from '../chunk-6NLYIMJO.js';
+export { SYSTEM_INDEX_DECLARATIONS, generateSystemIndexDDL } from '../chunk-36VYWVQU.js';
+export { defineEdgeIndex, defineNodeIndex } from '../chunk-LZMQ3SFK.js';
 import '../chunk-K34OPSJK.js';
+import '../chunk-7G5IYROL.js';
+import '../chunk-4QKOZYMV.js';
 import '../chunk-2EBMPJBO.js';
-import '../chunk-EDLKIQRI.js';
-import '../chunk-46UGOVRW.js';
+import '../chunk-PC5NGH5A.js';
+import '../chunk-7QFRK6PU.js';
 import '../chunk-AMKPPFUO.js';
 import '../chunk-W6OG3HDG.js';
 import '../chunk-PC2UBAUB.js';

package/dist/{ingestion-import-target-CI8OWIkM.d.ts → ingestion-import-target-CAs1OX-l.d.cts}

@@ -1,4 +1,4 @@
-import { dk as GraphDef } from './types-CWg4dTjj.js';
+import { d as GraphDef } from './types-6yf0Vv-_.cjs';
 
 /**
  * Private capability bridge from an opaque ingestion branch to interchange.

package/dist/{ingestion-import-target-DCpfM1PX.d.cts → ingestion-import-target-DCQSPfNx.d.ts}

@@ -1,4 +1,4 @@
-import { dk as GraphDef } from './types-CWg4dTjj.cjs';
+import { d as GraphDef } from './types-6yf0Vv-_.js';
 
 /**
  * Private capability bridge from an opaque ingestion branch to interchange.

package/dist/interchange/index.cjs

@@ -1,21 +1,23 @@
 'use strict';
 
-var chunkCS6JTQQ2_cjs = require('../chunk-CS6JTQQ2.cjs');
-require('../chunk-C76WFIVZ.cjs');
-var chunkTUVD4DFR_cjs = require('../chunk-TUVD4DFR.cjs');
-require('../chunk-7PRMDZIA.cjs');
-require('../chunk-5OWHU7Z7.cjs');
-require('../chunk-RDP6ZRSM.cjs');
-var chunkZBFZGLZE_cjs = require('../chunk-ZBFZGLZE.cjs');
-require('../chunk-IHK5KA2Q.cjs');
-require('../chunk-GHZPZNFC.cjs');
-require('../chunk-G2TLHH6T.cjs');
-require('../chunk-LLVOQOWE.cjs');
+var chunkKACEYDYV_cjs = require('../chunk-KACEYDYV.cjs');
+require('../chunk-2KCTP3U2.cjs');
+var chunk2CVDZCXH_cjs = require('../chunk-2CVDZCXH.cjs');
+require('../chunk-FMMW3KX7.cjs');
+require('../chunk-L6EVYIID.cjs');
+require('../chunk-JQKMEKKW.cjs');
+var chunkNLX5OWK7_cjs = require('../chunk-NLX5OWK7.cjs');
+require('../chunk-ZGVTNKTX.cjs');
+require('../chunk-NUQ2YFFH.cjs');
+require('../chunk-7B7I7YAW.cjs');
+require('../chunk-CRZ56SZU.cjs');
 require('../chunk-DWUDZ66O.cjs');
 var chunkM5MSP3BI_cjs = require('../chunk-M5MSP3BI.cjs');
+require('../chunk-JVA3KDEA.cjs');
+require('../chunk-A4C4NJ5U.cjs');
 require('../chunk-NAUA4PW5.cjs');
-require('../chunk-TEC24ZDA.cjs');
-require('../chunk-OJHD3LXJ.cjs');
+require('../chunk-H2VWDQWC.cjs');
+require('../chunk-H5IJSROF.cjs');
 require('../chunk-RT5ZY4XA.cjs');
 var chunkHAHNRASW_cjs = require('../chunk-HAHNRASW.cjs');
 require('../chunk-VLBTRXA2.cjs');
@@ -261,7 +263,7 @@ async function consumeTrustedChunks(store, session, chunks) {
 }
 async function trustedImportGraphStream(store, chunks) {
   rejectUnsupportedStoreFeatures(store);
-  const backend = chunkTUVD4DFR_cjs.storeBackend(store);
+  const backend = chunk2CVDZCXH_cjs.storeBackend(store);
   const trustedImport = backend.trustedImport;
   if (trustedImport === void 0) {
     throw new chunkX4GDXBOP_cjs.TrustedImportError(
@@ -270,10 +272,10 @@ async function trustedImportGraphStream(store, chunks) {
       { dialect: backend.dialect }
     );
   }
-  const sourceBackend = Symbol.asyncIterator in chunks ? chunkCS6JTQQ2_cjs.exportStreamBackend(chunks) : void 0;
-  const contention = sourceBackend === void 0 ? void 0 : chunkZBFZGLZE_cjs.snapshotExportContention(sourceBackend, backend);
+  const sourceBackend = Symbol.asyncIterator in chunks ? chunkKACEYDYV_cjs.exportStreamBackend(chunks) : void 0;
+  const contention = sourceBackend === void 0 ? void 0 : chunkNLX5OWK7_cjs.snapshotExportContention(sourceBackend, backend);
   if (contention !== void 0) {
-    throw chunkCS6JTQQ2_cjs.serializedStreamRefusal({
+    throw chunkKACEYDYV_cjs.serializedStreamRefusal({
       graphId: store.graphId,
       requested: "import-stream",
       heldBy: "export-snapshot",
@@ -287,7 +289,7 @@ async function trustedImportGraphStream(store, chunks) {
       expectedVersion: schemaVersion
     }
   };
-  return chunkCS6JTQQ2_cjs.withImportStreamLease(
+  return chunkKACEYDYV_cjs.withImportStreamLease(
     store,
     () => trustedImport(
       (session) => consumeTrustedChunks(store, session, chunks),
@@ -316,87 +318,87 @@ function trustedImportGraph(store, data) {
 
 Object.defineProperty(exports, "ConflictStrategySchema", {
   enumerable: true,
-  get: function () { return chunkCS6JTQQ2_cjs.ConflictStrategySchema; }
+  get: function () { return chunkKACEYDYV_cjs.ConflictStrategySchema; }
 });
 Object.defineProperty(exports, "ExportOptionsSchema", {
   enumerable: true,
-  get: function () { return chunkCS6JTQQ2_cjs.ExportOptionsSchema; }
+  get: function () { return chunkKACEYDYV_cjs.ExportOptionsSchema; }
 });
 Object.defineProperty(exports, "ExportStreamOptionsSchema", {
   enumerable: true,
-  get: function () { return chunkCS6JTQQ2_cjs.ExportStreamOptionsSchema; }
+  get: function () { return chunkKACEYDYV_cjs.ExportStreamOptionsSchema; }
 });
 Object.defineProperty(exports, "FORMAT_VERSION", {
   enumerable: true,
-  get: function () { return chunkCS6JTQQ2_cjs.FORMAT_VERSION; }
+  get: function () { return chunkKACEYDYV_cjs.FORMAT_VERSION; }
 });
 Object.defineProperty(exports, "GraphDataHeaderSchema", {
   enumerable: true,
-  get: function () { return chunkCS6JTQQ2_cjs.GraphDataHeaderSchema; }
+  get: function () { return chunkKACEYDYV_cjs.GraphDataHeaderSchema; }
 });
 Object.defineProperty(exports, "GraphDataSchema", {
   enumerable: true,
-  get: function () { return chunkCS6JTQQ2_cjs.GraphDataSchema; }
+  get: function () { return chunkKACEYDYV_cjs.GraphDataSchema; }
 });
 Object.defineProperty(exports, "GraphDataSourceSchema", {
   enumerable: true,
-  get: function () { return chunkCS6JTQQ2_cjs.GraphDataSourceSchema; }
+  get: function () { return chunkKACEYDYV_cjs.GraphDataSourceSchema; }
 });
 Object.defineProperty(exports, "GraphInterchangeChunkSchema", {
   enumerable: true,
-  get: function () { return chunkCS6JTQQ2_cjs.GraphInterchangeChunkSchema; }
+  get: function () { return chunkKACEYDYV_cjs.GraphInterchangeChunkSchema; }
 });
 Object.defineProperty(exports, "IdentityInterchangeModeSchema", {
   enumerable: true,
-  get: function () { return chunkCS6JTQQ2_cjs.IdentityInterchangeModeSchema; }
+  get: function () { return chunkKACEYDYV_cjs.IdentityInterchangeModeSchema; }
 });
 Object.defineProperty(exports, "ImportErrorSchema", {
   enumerable: true,
-  get: function () { return chunkCS6JTQQ2_cjs.ImportErrorSchema; }
+  get: function () { return chunkKACEYDYV_cjs.ImportErrorSchema; }
 });
 Object.defineProperty(exports, "ImportOptionsSchema", {
   enumerable: true,
-  get: function () { return chunkCS6JTQQ2_cjs.ImportOptionsSchema; }
+  get: function () { return chunkKACEYDYV_cjs.ImportOptionsSchema; }
 });
 Object.defineProperty(exports, "ImportResultSchema", {
   enumerable: true,
-  get: function () { return chunkCS6JTQQ2_cjs.ImportResultSchema; }
+  get: function () { return chunkKACEYDYV_cjs.ImportResultSchema; }
 });
 Object.defineProperty(exports, "InterchangeEdgeSchema", {
   enumerable: true,
-  get: function () { return chunkCS6JTQQ2_cjs.InterchangeEdgeSchema; }
+  get: function () { return chunkKACEYDYV_cjs.InterchangeEdgeSchema; }
 });
 Object.defineProperty(exports, "InterchangeIdentityAssertionSchema", {
   enumerable: true,
-  get: function () { return chunkCS6JTQQ2_cjs.InterchangeIdentityAssertionSchema; }
+  get: function () { return chunkKACEYDYV_cjs.InterchangeIdentityAssertionSchema; }
 });
 Object.defineProperty(exports, "InterchangeIdentitySchema", {
   enumerable: true,
-  get: function () { return chunkCS6JTQQ2_cjs.InterchangeIdentitySchema; }
+  get: function () { return chunkKACEYDYV_cjs.InterchangeIdentitySchema; }
 });
 Object.defineProperty(exports, "InterchangeNodeSchema", {
   enumerable: true,
-  get: function () { return chunkCS6JTQQ2_cjs.InterchangeNodeSchema; }
+  get: function () { return chunkKACEYDYV_cjs.InterchangeNodeSchema; }
 });
 Object.defineProperty(exports, "UnknownPropertyStrategySchema", {
   enumerable: true,
-  get: function () { return chunkCS6JTQQ2_cjs.UnknownPropertyStrategySchema; }
+  get: function () { return chunkKACEYDYV_cjs.UnknownPropertyStrategySchema; }
 });
 Object.defineProperty(exports, "exportGraph", {
   enumerable: true,
-  get: function () { return chunkCS6JTQQ2_cjs.exportGraph; }
+  get: function () { return chunkKACEYDYV_cjs.exportGraph; }
 });
 Object.defineProperty(exports, "exportGraphStream", {
   enumerable: true,
-  get: function () { return chunkCS6JTQQ2_cjs.exportGraphStream; }
+  get: function () { return chunkKACEYDYV_cjs.exportGraphStream; }
 });
 Object.defineProperty(exports, "importGraph", {
   enumerable: true,
-  get: function () { return chunkCS6JTQQ2_cjs.importGraph; }
+  get: function () { return chunkKACEYDYV_cjs.importGraph; }
 });
 Object.defineProperty(exports, "importGraphStream", {
   enumerable: true,
-  get: function () { return chunkCS6JTQQ2_cjs.importGraphStream; }
+  get: function () { return chunkKACEYDYV_cjs.importGraphStream; }
 });
 exports.trustedImportGraph = trustedImportGraph;
 exports.trustedImportGraphStream = trustedImportGraphStream;

package/dist/interchange/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/interchange/trusted-import.ts"],"names":["TrustedImportError","getSearchableFields","resolveGraphVectorSlots","isCanonicalIsoDate","isInvertedValidityWindow","storeBackend","exportStreamBackend","snapshotExportContention","serializedStreamRefusal","withImportStreamLease"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAS,+BACP,KAAA,EACM;AACN,EAAA,IAAI,MAAM,cAAA,EAAgB;AACxB,IAAA,MAAM,IAAIA,oCAAA;AAAA,MACR,gEAAA;AAAA,MACA,qBAAA;AAAA,MACA,EAAE,OAAA,EAAS,KAAA,CAAM,OAAA;AAAQ,KAC3B;AAAA,EACF;AACA,EAAA,IAAI,MAAM,uBAAA,EAAyB;AACjC,IAAA,MAAM,IAAIA,oCAAA;AAAA,MACR,oDAAA;AAAA,MACA,+BAAA;AAAA,MACA,EAAE,OAAA,EAAS,KAAA,CAAM,OAAA;AAAQ,KAC3B;AAAA,EACF;AACA,EAAA,IAAI,KAAA,CAAM,KAAA,CAAM,QAAA,KAAa,MAAA,EAAW;AACtC,IAAA,MAAM,IAAIA,oCAAA;AAAA,MACR,8EAAA;AAAA,MACA,sBAAA;AAAA,MACA,EAAE,OAAA,EAAS,KAAA,CAAM,OAAA;AAAQ,KAC3B;AAAA,EACF;AAEA,EAAA,MAAM,WAAA,GAAc,OAAO,MAAA,CAAO,KAAA,CAAM,MAAM,KAAK,CAAA,CAChD,OAAO,CAAC,YAAA,KAAA,CAAkB,aAAa,MAAA,EAAQ,MAAA,IAAU,KAAK,CAAC,CAAA,CAC/D,IAAI,CAAC,YAAA,KAAiB,YAAA,CAAa,IAAA,CAAK,IAAI,CAAA;AAC/C,EAAA,IAAI,WAAA,CAAY,SAAS,CAAA,EAAG;AAC1B,IAAA,MAAM,IAAIA,oCAAA;AAAA,MACR,4DAAA;AAAA,MACA,wBAAA;AAAA,MACA,EAAE,OAAA,EAAS,KAAA,CAAM,OAAA,EAAS,WAAW,WAAA;AAAY,KACnD;AAAA,EACF;AAEA,EAAA,MAAM,kBAAkB,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,KAAA,CAAM,KAAK,CAAA,CACpD,MAAA;AAAA,IACC,CAAC,YAAA,KACCC,qCAAA,CAAoB,aAAa,IAAA,CAAK,MAAM,EAAE,MAAA,GAAS;AAAA,IAE1D,GAAA,CAAI,CAAC,YAAA,KAAiB,YAAA,CAAa,KAAK,IAAI,CAAA;AAC/C,EAAA,IAAI,eAAA,CAAgB,SAAS,CAAA,EAAG;AAC9B,IAAA,MAAM,IAAID,oCAAA;AAAA,MACR,qDAAA;AAAA,MACA,sBAAA;AAAA,MACA,EAAE,OAAA,EAAS,KAAA,CAAM,OAAA,EAAS,WAAW,eAAA;AAAgB,KACvD;AAAA,EACF;AAEA,EAAA,MAAM,WAAA,GAAcE,yCAAA,CAAwB,KAAA,CAAM,KAAK,CAAA;AACvD,EAAA,IAAI,WAAA,CAAY,SAAS,CAAA,EAAG;AAC1B,IAAA,MAAM,IAAIF,oCAAA;AAAA,MACR,mDAAA;AAAA,MACA,oBAAA;AAAA,MACA;AAAA,QACE,SAAS,KAAA,CAAM,OAAA;AAAA,QACf,MAAA,EAAQ,WAAA,CAAY,GAAA,CAAI,CAAC,IAAA,KAAS,CAAA,EAAG,IAAA,CAAK,QAAQ,CAAA,CAAA,EAAI,IAAA,CAAK,SAAS,CAAA,CAAE;AAAA;AACxE,KACF;AAAA,EACF;AACF;AAEA,SAAS,cAAc,OAAA,EAAqC;AAC1D,EAAA,OAAO,IAAIA,oCAAA,CAAmB,OAAA,EAAS,gBAAgB,CAAA;AACzD;AAoCA,SAAS,qBACP,MAAA,EACgC;AAChC,EAAA,MAAM,EAAE,SAAA,EAAW,OAAA,EAAQ,GAAI,MAAA;AAC/B,EAAA,IAAI,OAAO,SAAA,KAAc,QAAA,IAAY,CAACG,oCAAA,CAAmB,SAAS,CAAA,EAAG;AACnE,IAAA,OAAO,EAAE,KAAA,EAAO,WAAA,EAAa,KAAA,EAAO,SAAA,EAAU;AAAA,EAChD;AACA,EAAA,IAAI,OAAO,OAAA,KAAY,QAAA,IAAY,CAACA,oCAAA,CAAmB,OAAO,CAAA,EAAG;AAC/D,IAAA,OAAO,EAAE,KAAA,EAAO,SAAA,EAAW,KAAA,EAAO,OAAA,EAAQ;AAAA,EAC5C;AACA,EAAA,OAAO,MAAA;AACT;AAOA,SAAS,uBACP,QAAA,EACiE;AACjE,EAAA,KAAA,MAAW,UAAU,QAAA,EAAU;AAC7B,IAAA,MAAM,YAAA,GAAe,qBAAqB,MAAM,CAAA;AAChD,IAAA,IAAI,iBAAiB,MAAA,EAAW,OAAO,EAAE,MAAA,EAAQ,GAAG,YAAA,EAAa;AAAA,EACnE;AACA,EAAA,OAAO,MAAA;AACT;AAGA,SAAS,yBAAA,CACP,OAAA,EACA,KAAA,EACA,KAAA,EACQ;AACR,EAAA,OACE,CAAA,cAAA,EAAiB,KAAK,CAAA,oBAAA,EAAuB,OAAO,YAAY,KAAK,CAAA,8MAAA,CAAA;AAKzE;AAeA,SAAS,kBAAkB,MAAA,EAAuC;AAChE,EAAA,OAAOC,0CAAA;AAAA,IACL,OAAO,SAAA,IAAa,MAAA;AAAA,IACpB,MAAA,CAAO;AAAA,GACT;AACF;AAEA,SAAS,UAAA,CAAW,SAAiB,IAAA,EAAyC;AAC5E,EAAA,OAAO;AAAA,IACL,OAAA;AAAA,IACA,MAAM,IAAA,CAAK,IAAA;AAAA,IACX,IAAI,IAAA,CAAK,EAAA;AAAA,IACT,OAAO,IAAA,CAAK,UAAA;AAAA,IACZ,GAAI,KAAK,SAAA,KAAc,MAAA,GAAY,EAAC,GAAI,EAAE,SAAA,EAAW,IAAA,CAAK,SAAA,EAAU;AAAA,IACpE,GAAI,KAAK,OAAA,KAAY,MAAA,GAAY,EAAC,GAAI,EAAE,OAAA,EAAS,IAAA,CAAK,OAAA;AAAQ,GAChE;AACF;AAEA,SAAS,UAAA,CAAW,SAAiB,IAAA,EAAyC;AAC5E,EAAA,OAAO;AAAA,IACL,OAAA;AAAA,IACA,IAAI,IAAA,CAAK,EAAA;AAAA,IACT,MAAM,IAAA,CAAK,IAAA;AAAA,IACX,QAAA,EAAU,KAAK,IAAA,CAAK,IAAA;AAAA,IACpB,MAAA,EAAQ,KAAK,IAAA,CAAK,EAAA;AAAA,IAClB,MAAA,EAAQ,KAAK,EAAA,CAAG,IAAA;AAAA,IAChB,IAAA,EAAM,KAAK,EAAA,CAAG,EAAA;AAAA,IACd,OAAO,IAAA,CAAK,UAAA;AAAA,IACZ,GAAI,KAAK,SAAA,KAAc,MAAA,GAAY,EAAC,GAAI,EAAE,SAAA,EAAW,IAAA,CAAK,SAAA,EAAU;AAAA,IACpE,GAAI,KAAK,OAAA,KAAY,MAAA,GAAY,EAAC,GAAI,EAAE,OAAA,EAAS,IAAA,CAAK,OAAA;AAAQ,GAChE;AACF;AAEA,eAAe,oBAAA,CACb,KAAA,EACA,OAAA,EACA,MAAA,EAE8B;AAC9B,EAAA,MAAM,YAAY,IAAI,GAAA;AAAA,IACpB,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,KAAA,CAAM,KAAK,CAAA,CAAE,GAAA;AAAA,MAC/B,CAAC,YAAA,KAAiB,YAAA,CAAa,IAAA,CAAK;AAAA;AACtC,GACF;AACA,EAAA,MAAM,YAAY,IAAI,GAAA;AAAA,IACpB,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,KAAA,CAAM,KAAK,CAAA,CAAE,GAAA;AAAA,MAC/B,CAAC,YAAA,KAAiB,YAAA,CAAa,IAAA,CAAK;AAAA;AACtC,GACF;AACA,EAAA,IAAI,cAAA,GAAiB,KAAA;AACrB,EAAA,IAAI,aAAA,GAAgB,KAAA;AACpB,EAAA,IAAI,SAAA,GAAY,CAAA;AAChB,EAAA,IAAI,SAAA,GAAY,CAAA;AAEhB,EAAA,WAAA,MAAiB,SAAS,MAAA,EAAQ;AAChC,IAAA,QAAQ,MAAM,IAAA;AAAM,MAClB,KAAK,QAAA,EAAU;AACb,QAAA,IAAI,cAAA,EAAgB;AAClB,UAAA,MAAM,aAAA;AAAA,YACJ;AAAA,WACF;AAAA,QACF;AACA,QAAA,IAAI,KAAA,CAAM,MAAA,CAAO,QAAA,KAAa,MAAA,EAAW;AACvC,UAAA,MAAM,aAAA;AAAA,YACJ;AAAA,WAEF;AAAA,QACF;AACA,QAAA,cAAA,GAAiB,IAAA;AACjB,QAAA;AAAA,MACF;AAAA,MACA,KAAK,OAAA,EAAS;AACZ,QAAA,IAAI,CAAC,cAAA,EAAgB;AACnB,UAAA,MAAM,aAAA;AAAA,YACJ;AAAA,WACF;AAAA,QACF;AACA,QAAA,IAAI,aAAA,EAAe;AACjB,UAAA,MAAM,aAAA;AAAA,YACJ;AAAA,WACF;AAAA,QACF;AACA,QAAA,MAAM,WAAA,GAAc,MAAM,KAAA,CAAM,IAAA;AAAA,UAC9B,CAAC,IAAA,KAAS,CAAC,SAAA,CAAU,GAAA,CAAI,KAAK,IAAI;AAAA,SACpC,EAAG,IAAA;AACH,QAAA,IAAI,gBAAgB,MAAA,EAAW;AAC7B,UAAA,MAAM,aAAA;AAAA,YACJ,wCAAwC,WAAW,CAAA;AAAA,WACrD;AAAA,QACF;AACA,QAAA,MAAM,gBAAA,GAAmB,sBAAA,CAAuB,KAAA,CAAM,KAAK,CAAA;AAC3D,QAAA,IAAI,qBAAqB,MAAA,EAAW;AAClC,UAAA,MAAM,EAAE,MAAA,EAAQ,KAAA,EAAO,KAAA,EAAM,GAAI,gBAAA;AACjC,UAAA,MAAM,aAAA;AAAA,YACJ,yBAAA;AAAA,cACE,CAAA,EAAG,MAAA,CAAO,IAAI,CAAA,EAAA,EAAK,OAAO,EAAE,CAAA,CAAA,CAAA;AAAA,cAC5B,KAAA;AAAA,cACA;AAAA;AACF,WACF;AAAA,QACF;AACA,QAAA,MAAM,YAAA,GAAe,MAAM,KAAA,CAAM,IAAA;AAAA,UAAK,CAAC,IAAA,KACrC,iBAAA,CAAkB,IAAI;AAAA,SACxB;AACA,QAAA,IAAI,iBAAiB,MAAA,EAAW;AAC9B,UAAA,MAAM,aAAA;AAAA,YACJ,CAAA,4CAAA,EAA+C,YAAA,CAAa,IAAI,CAAA,EAAA,EAAK,aAAa,EAAE,CAAA,WAAA,EAC9E,MAAA,CAAO,YAAA,CAAa,OAAO,CAAC,CAAA,yBAAA,EAA4B,MAAA,CAAO,YAAA,CAAa,SAAS,CAAC,CAAA,EAAA;AAAA,WAC9F;AAAA,QACF;AACA,QAAA,MAAM,OAAA,CAAQ,WAAA;AAAA,UACZ,KAAA,CAAM,MAAM,GAAA,CAAI,CAAC,SAAS,UAAA,CAAW,KAAA,CAAM,OAAA,EAAS,IAAI,CAAC;AAAA,SAC3D;AACA,QAAA,SAAA,IAAa,MAAM,KAAA,CAAM,MAAA;AACzB,QAAA;AAAA,MACF;AAAA,MACA,KAAK,OAAA,EAAS;AACZ,QAAA,IAAI,CAAC,cAAA,EAAgB;AACnB,UAAA,MAAM,aAAA;AAAA,YACJ;AAAA,WACF;AAAA,QACF;AACA,QAAA,aAAA,GAAgB,IAAA;AAChB,QAAA,MAAM,WAAA,GAAc,MAAM,KAAA,CAAM,IAAA;AAAA,UAC9B,CAAC,SACC,CAAC,SAAA,CAAU,IAAI,IAAA,CAAK,IAAI,KACxB,CAAC,SAAA,CAAU,IAAI,IAAA,CAAK,IAAA,CAAK,IAAI,CAAA,IAC7B,CAAC,UAAU,GAAA,CAAI,IAAA,CAAK,GAAG,IAAI;AAAA,SAC/B;AACA,QAAA,IAAI,gBAAgB,MAAA,EAAW;AAC7B,UAAA,MAAM,aAAA;AAAA,YACJ,CAAA,iDAAA,EAAoD,YAAY,IAAI,CAAA;AAAA,WACtE;AAAA,QACF;AACA,QAAA,MAAM,gBAAA,GAAmB,sBAAA,CAAuB,KAAA,CAAM,KAAK,CAAA;AAC3D,QAAA,IAAI,qBAAqB,MAAA,EAAW;AAClC,UAAA,MAAM,EAAE,MAAA,EAAQ,KAAA,EAAO,KAAA,EAAM,GAAI,gBAAA;AACjC,UAAA,MAAM,aAAA;AAAA,YACJ,yBAAA;AAAA,cACE,CAAA,EAAG,MAAA,CAAO,IAAI,CAAA,OAAA,EAAU,OAAO,EAAE,CAAA,CAAA,CAAA;AAAA,cACjC,KAAA;AAAA,cACA;AAAA;AACF,WACF;AAAA,QACF;AACA,QAAA,MAAM,YAAA,GAAe,MAAM,KAAA,CAAM,IAAA;AAAA,UAAK,CAAC,IAAA,KACrC,iBAAA,CAAkB,IAAI;AAAA,SACxB;AACA,QAAA,IAAI,iBAAiB,MAAA,EAAW;AAC9B,UAAA,MAAM,aAAA;AAAA,YACJ,CAAA,4CAAA,EAA+C,YAAA,CAAa,IAAI,CAAA,OAAA,EAAU,aAAa,EAAE,CAAA,WAAA,EACnF,MAAA,CAAO,YAAA,CAAa,OAAO,CAAC,CAAA,yBAAA,EAA4B,MAAA,CAAO,YAAA,CAAa,SAAS,CAAC,CAAA,EAAA;AAAA,WAC9F;AAAA,QACF;AACA,QAAA,MAAM,OAAA,CAAQ,WAAA;AAAA,UACZ,KAAA,CAAM,MAAM,GAAA,CAAI,CAAC,SAAS,UAAA,CAAW,KAAA,CAAM,OAAA,EAAS,IAAI,CAAC;AAAA,SAC3D;AACA,QAAA,SAAA,IAAa,MAAM,KAAA,CAAM,MAAA;AACzB,QAAA;AAAA,MACF;AAAA,MACA,KAAK,UAAA,EAAY;AAKf,QAAA,MAAM,aAAA;AAAA,UACJ;AAAA,SAEF;AAAA,MACF;AAAA;AACF,EACF;AAEA,EAAA,IAAI,CAAC,cAAA,EAAgB;AACnB,IAAA,MAAM,aAAA;AAAA,MACJ;AAAA,KACF;AAAA,EACF;AACA,EAAA,OAAO,EAAE,KAAA,EAAO,SAAA,EAAW,KAAA,EAAO,SAAA,EAAU;AAC9C;AAqBA,eAAsB,wBAAA,CACpB,OACA,MAAA,EAE8B;AAC9B,EAAA,8BAAA,CAA+B,KAAK,CAAA;AACpC,EAAA,MAAM,OAAA,GAAUC,+BAAa,KAAK,CAAA;AAClC,EAAA,MAAM,gBAAgB,OAAA,CAAQ,aAAA;AAC9B,EAAA,IAAI,kBAAkB,MAAA,EAAW;AAC/B,IAAA,MAAM,IAAIL,oCAAA;AAAA,MACR,CAAA,IAAA,EAAO,QAAQ,OAAO,CAAA,yCAAA,CAAA;AAAA,MACtB,qBAAA;AAAA,MACA,EAAE,OAAA,EAAS,OAAA,CAAQ,OAAA;AAAQ,KAC7B;AAAA,EACF;AAKA,EAAA,MAAM,gBACJ,MAAA,CAAO,aAAA,IAAiB,MAAA,GAASM,qCAAA,CAAoB,MAAM,CAAA,GAAI,MAAA;AACjE,EAAA,MAAM,aACJ,aAAA,KAAkB,MAAA,GAAY,MAAA,GAC5BC,0CAAA,CAAyB,eAAe,OAAO,CAAA;AAEnD,EAAA,IAAI,eAAe,MAAA,EAAW;AAC5B,IAAA,MAAMC,yCAAA,CAAwB;AAAA,MAC5B,SAAS,KAAA,CAAM,OAAA;AAAA,MACf,SAAA,EAAW,eAAA;AAAA,MACX,MAAA,EAAQ,iBAAA;AAAA,MACR,QAAA,EAAU;AAAA,KACX,CAAA;AAAA,EACH;AACA,EAAA,MAAM,aAAA,GAAgB,KAAA,CAAM,UAAA,EAAW,CAAE,aAAA;AACzC,EAAA,MAAM,OAAA,GACJ,aAAA,KAAkB,MAAA,GAAY,MAAA,GAC5B;AAAA,IACE,WAAA,EAAa;AAAA,MACX,SAAS,KAAA,CAAM,OAAA;AAAA,MACf,eAAA,EAAiB;AAAA;AACnB,GACF;AAEJ,EAAA,OAAOC,uCAAA;AAAA,IAAsB,KAAA;AAAA,IAAO,MAClC,aAAA;AAAA,MACE,CAAC,OAAA,KAAY,oBAAA,CAAqB,KAAA,EAAO,SAAS,MAAM,CAAA;AAAA,MACxD;AAAA;AACF,GACF;AACF;AAEA,UAAU,gBAAgB,IAAA,EAAkD;AAC1E,EAAA,MAAM,EAAE,KAAA,EAAO,KAAA,EAAO,QAAA,EAAU,GAAG,QAAO,GAAI,IAAA;AAC9C,EAAA,MAAM;AAAA,IACJ,IAAA,EAAM,QAAA;AAAA,IACN,MAAA,EACE,QAAA,KAAa,MAAA,GAAY,MAAA,GACvB;AAAA,MACE,GAAG,MAAA;AAAA,MACH,UAAU,EAAE,OAAA,EAAS,SAAS,OAAA,EAAS,IAAA,EAAM,SAAS,IAAA;AAAK;AAC7D,GAEN;AACA,EAAA,MAAM,EAAE,IAAA,EAAM,OAAA,EAAS,KAAA,EAAM;AAC7B,EAAA,MAAM,EAAE,IAAA,EAAM,OAAA,EAAS,KAAA,EAAM;AAC7B,EAAA,IAAI,aAAa,MAAA,EAAW;AAC1B,IAAA,MAAM,EAAE,IAAA,EAAM,UAAA,EAAY,UAAA,EAAY,SAAS,UAAA,EAAW;AAAA,EAC5D;AACF;AAGO,SAAS,kBAAA,CACd,OACA,IAAA,EAC8B;AAC9B,EAAA,OAAO,wBAAA,CAAyB,KAAA,EAAO,eAAA,CAAgB,IAAI,CAAC,CAAA;AAC9D","file":"index.cjs","sourcesContent":["import { snapshotExportContention } from \"../backend/transaction-resource\";\nimport type {\n  InsertEdgeParams,\n  InsertNodeParams,\n  TrustedImportOptions,\n  TrustedImportSession,\n} from \"../backend/types\";\nimport type { GraphDef } from \"../core/define-graph\";\nimport { resolveGraphVectorSlots } from \"../core/embedding\";\nimport { getSearchableFields } from \"../core/searchable\";\nimport { TrustedImportError } from \"../errors\";\nimport { storeBackend } from \"../store/runtime-port\";\nimport type { Store } from \"../store/store\";\nimport { isCanonicalIsoDate, isInvertedValidityWindow } from \"../utils/date\";\nimport { serializedStreamRefusal, withImportStreamLease } from \"./import\";\nimport { exportStreamBackend } from \"./stream-source\";\nimport type {\n  GraphData,\n  GraphInterchangeChunk,\n  InterchangeEdge,\n  InterchangeNode,\n} from \"./types\";\n\n/** Counts committed by a trusted initial import. */\nexport type TrustedImportResult = Readonly<{\n  nodes: number;\n  edges: number;\n}>;\n\nfunction rejectUnsupportedStoreFeatures<G extends GraphDef>(\n  store: Store<G>,\n): void {\n  if (store.historyEnabled) {\n    throw new TrustedImportError(\n      \"Trusted import does not support recorded-time history capture.\",\n      \"history_unsupported\",\n      { graphId: store.graphId },\n    );\n  }\n  if (store.revisionTrackingEnabled) {\n    throw new TrustedImportError(\n      \"Trusted import does not support revision tracking.\",\n      \"revision_tracking_unsupported\",\n      { graphId: store.graphId },\n    );\n  }\n  if (store.graph.identity !== undefined) {\n    throw new TrustedImportError(\n      \"Trusted import does not maintain Operational Identity assertions or closure.\",\n      \"identity_unsupported\",\n      { graphId: store.graphId },\n    );\n  }\n\n  const uniqueKinds = Object.values(store.graph.nodes)\n    .filter((registration) => (registration.unique?.length ?? 0) > 0)\n    .map((registration) => registration.type.kind);\n  if (uniqueKinds.length > 0) {\n    throw new TrustedImportError(\n      \"Trusted import does not maintain node uniqueness sidecars.\",\n      \"uniqueness_unsupported\",\n      { graphId: store.graphId, nodeKinds: uniqueKinds },\n    );\n  }\n\n  const searchableKinds = Object.values(store.graph.nodes)\n    .filter(\n      (registration) =>\n        getSearchableFields(registration.type.schema).length > 0,\n    )\n    .map((registration) => registration.type.kind);\n  if (searchableKinds.length > 0) {\n    throw new TrustedImportError(\n      \"Trusted import does not maintain fulltext sidecars.\",\n      \"fulltext_unsupported\",\n      { graphId: store.graphId, nodeKinds: searchableKinds },\n    );\n  }\n\n  const vectorSlots = resolveGraphVectorSlots(store.graph);\n  if (vectorSlots.length > 0) {\n    throw new TrustedImportError(\n      \"Trusted import does not maintain vector sidecars.\",\n      \"vector_unsupported\",\n      {\n        graphId: store.graphId,\n        fields: vectorSlots.map((slot) => `${slot.nodeKind}.${slot.fieldPath}`),\n      },\n    );\n  }\n}\n\nfunction invalidStream(message: string): TrustedImportError {\n  return new TrustedImportError(message, \"invalid_stream\");\n}\n\n/** The stated validity window of a streamed node or edge. */\ntype StatedValidityWindow = Readonly<{\n  validFrom?: string | null | undefined;\n  validTo?: string | undefined;\n}>;\n\ntype ValidityWindowField = \"validFrom\" | \"validTo\";\n\n/** A stated window field that is not canonical, with the offending value. */\ntype NonCanonicalWindow = Readonly<{\n  field: ValidityWindowField;\n  value: string;\n}>;\n\n/**\n * The first window field of `entity` stating a timestamp that is not canonical\n * fixed-width UTC ISO 8601 — with the offending value — or `undefined` when\n * every stated one is canonical.\n *\n * A trusted stream is never re-parsed, so this is the only place its timestamps\n * are held to the format the rest of the system assumes. It is deliberately\n * format-ONLY — the same {@link isCanonicalIsoDate} decision the untrusted\n * path's schema and the store's own write validation make, and nothing more —\n * because a non-canonical instant is not merely ugly: every temporal filter\n * compares these values AS TEXT against an `asOf` coordinate, so a variable-width\n * one (`...:00.1Z`, an offset, date-only) mis-sorts and silently includes or\n * excludes the wrong rows once stored, and it would mis-decide the negative-width\n * check below on the way in. Two field tests per row costs about a microsecond\n * against the ~4µs an in-memory SQLite row already costs — the price of the\n * stream's ordering claims meaning anything.\n *\n * An absent field states nothing, and a `null` validFrom is a confirmed\n * open-left window (see {@link nodeParams}) — neither is a timestamp to check.\n */\nfunction nonCanonicalWindowOf(\n  entity: StatedValidityWindow,\n): NonCanonicalWindow | undefined {\n  const { validFrom, validTo } = entity;\n  if (typeof validFrom === \"string\" && !isCanonicalIsoDate(validFrom)) {\n    return { field: \"validFrom\", value: validFrom };\n  }\n  if (typeof validTo === \"string\" && !isCanonicalIsoDate(validTo)) {\n    return { field: \"validTo\", value: validTo };\n  }\n  return undefined;\n}\n\n/**\n * The first entity in `entities` stating a non-canonical window timestamp, with\n * the offending field and value. Allocates only on the failing path, so a clean\n * chunk pays one predicate per stated timestamp and nothing else.\n */\nfunction findNonCanonicalWindow<Entity extends StatedValidityWindow>(\n  entities: readonly Entity[],\n): (NonCanonicalWindow & Readonly<{ entity: Entity }>) | undefined {\n  for (const entity of entities) {\n    const nonCanonical = nonCanonicalWindowOf(entity);\n    if (nonCanonical !== undefined) return { entity, ...nonCanonical };\n  }\n  return undefined;\n}\n\n/** The refusal message for a non-canonical window timestamp on `subject`. */\nfunction nonCanonicalWindowMessage(\n  subject: string,\n  field: ValidityWindowField,\n  value: string,\n): string {\n  return (\n    `Non-canonical ${field} in trusted import: ${subject} states \"${value}\". ` +\n    `Expected canonical fixed-width UTC ISO 8601 (YYYY-MM-DDTHH:mm:ss.sssZ), ` +\n    `which is what makes a stored timestamp sort chronologically against an asOf ` +\n    `coordinate. Convert with new Date(value).toISOString().`\n  );\n}\n\n/**\n * An entity whose stated window has negative width. Trusted import writes\n * straight to SQL and skips schema validation for throughput, but a row that\n * stopped being true before it started is a stream SHAPE fault rather than a\n * policy check: it is unobservable at every `asOf` coordinate, and no later\n * write repairs it. `null` validFrom is a confirmed open-left window, so there\n * is no lower bound to invert against; zero width is legal (see\n * {@link isInvertedValidityWindow}).\n *\n * Only ever reached for a chunk whose timestamps {@link findNonCanonicalWindow}\n * has already accepted, which is what makes the lexicographic compare inside a\n * chronological one.\n */\nfunction hasInvertedWindow(entity: StatedValidityWindow): boolean {\n  return isInvertedValidityWindow(\n    entity.validFrom ?? undefined,\n    entity.validTo,\n  );\n}\n\nfunction nodeParams(graphId: string, node: InterchangeNode): InsertNodeParams {\n  return {\n    graphId,\n    kind: node.kind,\n    id: node.id,\n    props: node.properties,\n    ...(node.validFrom === undefined ? {} : { validFrom: node.validFrom }),\n    ...(node.validTo === undefined ? {} : { validTo: node.validTo }),\n  };\n}\n\nfunction edgeParams(graphId: string, edge: InterchangeEdge): InsertEdgeParams {\n  return {\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: edge.properties,\n    ...(edge.validFrom === undefined ? {} : { validFrom: edge.validFrom }),\n    ...(edge.validTo === undefined ? {} : { validTo: edge.validTo }),\n  };\n}\n\nasync function consumeTrustedChunks<G extends GraphDef>(\n  store: Store<G>,\n  session: TrustedImportSession,\n  chunks:\n    AsyncIterable<GraphInterchangeChunk> | Iterable<GraphInterchangeChunk>,\n): Promise<TrustedImportResult> {\n  const nodeKinds = new Set(\n    Object.values(store.graph.nodes).map(\n      (registration) => registration.type.kind,\n    ),\n  );\n  const edgeKinds = new Set(\n    Object.values(store.graph.edges).map(\n      (registration) => registration.type.kind,\n    ),\n  );\n  let receivedHeader = false;\n  let receivedEdges = false;\n  let nodeCount = 0;\n  let edgeCount = 0;\n\n  for await (const chunk of chunks) {\n    switch (chunk.type) {\n      case \"header\": {\n        if (receivedHeader) {\n          throw invalidStream(\n            \"Trusted graph interchange stream emitted more than one header.\",\n          );\n        }\n        if (chunk.header.identity !== undefined) {\n          throw invalidStream(\n            \"Trusted graph interchange import does not support identity data. \" +\n              \"Use importGraphStream() for an identity export.\",\n          );\n        }\n        receivedHeader = true;\n        break;\n      }\n      case \"nodes\": {\n        if (!receivedHeader) {\n          throw invalidStream(\n            \"Trusted graph interchange stream must start with a header.\",\n          );\n        }\n        if (receivedEdges) {\n          throw invalidStream(\n            \"Trusted graph interchange stream cannot emit nodes after edges.\",\n          );\n        }\n        const unknownKind = chunk.nodes.find(\n          (node) => !nodeKinds.has(node.kind),\n        )?.kind;\n        if (unknownKind !== undefined) {\n          throw invalidStream(\n            `Unknown node kind in trusted import: ${unknownKind}`,\n          );\n        }\n        const nonCanonicalNode = findNonCanonicalWindow(chunk.nodes);\n        if (nonCanonicalNode !== undefined) {\n          const { entity, field, value } = nonCanonicalNode;\n          throw invalidStream(\n            nonCanonicalWindowMessage(\n              `${entity.kind} \"${entity.id}\"`,\n              field,\n              value,\n            ),\n          );\n        }\n        const invertedNode = chunk.nodes.find((node) =>\n          hasInvertedWindow(node),\n        );\n        if (invertedNode !== undefined) {\n          throw invalidStream(\n            `Inverted validity window in trusted import: ${invertedNode.kind} \"${invertedNode.id}\" ends at ` +\n              `\"${String(invertedNode.validTo)}\", before its validFrom \"${String(invertedNode.validFrom)}\".`,\n          );\n        }\n        await session.insertNodes(\n          chunk.nodes.map((node) => nodeParams(store.graphId, node)),\n        );\n        nodeCount += chunk.nodes.length;\n        break;\n      }\n      case \"edges\": {\n        if (!receivedHeader) {\n          throw invalidStream(\n            \"Trusted graph interchange stream must start with a header.\",\n          );\n        }\n        receivedEdges = true;\n        const invalidEdge = chunk.edges.find(\n          (edge) =>\n            !edgeKinds.has(edge.kind) ||\n            !nodeKinds.has(edge.from.kind) ||\n            !nodeKinds.has(edge.to.kind),\n        );\n        if (invalidEdge !== undefined) {\n          throw invalidStream(\n            `Unknown edge or endpoint kind in trusted import: ${invalidEdge.kind}`,\n          );\n        }\n        const nonCanonicalEdge = findNonCanonicalWindow(chunk.edges);\n        if (nonCanonicalEdge !== undefined) {\n          const { entity, field, value } = nonCanonicalEdge;\n          throw invalidStream(\n            nonCanonicalWindowMessage(\n              `${entity.kind} edge \"${entity.id}\"`,\n              field,\n              value,\n            ),\n          );\n        }\n        const invertedEdge = chunk.edges.find((edge) =>\n          hasInvertedWindow(edge),\n        );\n        if (invertedEdge !== undefined) {\n          throw invalidStream(\n            `Inverted validity window in trusted import: ${invertedEdge.kind} edge \"${invertedEdge.id}\" ends at ` +\n              `\"${String(invertedEdge.validTo)}\", before its validFrom \"${String(invertedEdge.validFrom)}\".`,\n          );\n        }\n        await session.insertEdges(\n          chunk.edges.map((edge) => edgeParams(store.graphId, edge)),\n        );\n        edgeCount += chunk.edges.length;\n        break;\n      }\n      case \"identity\": {\n        // The trusted session writes only the node and edge relations, so it\n        // has no way to persist assertions or materialize the derived closure.\n        // Refuse rather than drop identity truth from an identity-enabled\n        // export: `importGraph` / `importGraphStream` carry it correctly.\n        throw invalidStream(\n          \"Trusted graph interchange import does not support identity assertions. \" +\n            \"Use importGraphStream() for an export that carries identity truth.\",\n        );\n      }\n    }\n  }\n\n  if (!receivedHeader) {\n    throw invalidStream(\n      \"Trusted graph interchange stream ended before emitting a header.\",\n    );\n  }\n  return { nodes: nodeCount, edges: edgeCount };\n}\n\n/**\n * Atomically imports a header-first stream into a fresh, dedicated database.\n *\n * This is an intentionally trusted path. It checks stream ordering and kind\n * names, but it does not validate properties, references, cardinality, or\n * conflicts. The caller must guarantee those invariants. Use\n * {@link importGraphStream} for untrusted data.\n *\n * Trusted of the DATA, not of the connection: this holds ONE write transaction\n * open for the entire stream, which makes it a long-lived import holder exactly\n * like {@link importGraphStream}, and it is guarded the same way — the source\n * stream's own backend is checked against the target before the first chunk, and\n * the target connection's exclusive stream lease is held for the whole import.\n * `trustedImportGraphStream(target, exportGraphStream(source))` over one\n * serialized connection is therefore refused with the shared typed\n * {@link ConfigurationError} (codes and `details.heldBy` / `details.requested`\n * as documented on `importGraphStream`) rather than reaching the driver as a\n * nested BEGIN.\n */\nexport async function trustedImportGraphStream<G extends GraphDef>(\n  store: Store<G>,\n  chunks:\n    AsyncIterable<GraphInterchangeChunk> | Iterable<GraphInterchangeChunk>,\n): Promise<TrustedImportResult> {\n  rejectUnsupportedStoreFeatures(store);\n  const backend = storeBackend(store);\n  const trustedImport = backend.trustedImport;\n  if (trustedImport === undefined) {\n    throw new TrustedImportError(\n      `The ${backend.dialect} backend does not support trusted import.`,\n      \"backend_unsupported\",\n      { dialect: backend.dialect },\n    );\n  }\n  // The same pre-flight `importGraphStream` runs, through the same owner of\n  // \"would this export hold the connection that write needs\": a synchronous\n  // iterable was materialized by its producer and holds nothing, so only an\n  // async stream can name a source backend.\n  const sourceBackend =\n    Symbol.asyncIterator in chunks ? exportStreamBackend(chunks) : undefined;\n  const contention =\n    sourceBackend === undefined ? undefined : (\n      snapshotExportContention(sourceBackend, backend)\n    );\n  if (contention !== undefined) {\n    throw serializedStreamRefusal({\n      graphId: store.graphId,\n      requested: \"import-stream\",\n      heldBy: \"export-snapshot\",\n      detector: contention,\n    });\n  }\n  const schemaVersion = store.introspect().schemaVersion;\n  const options: TrustedImportOptions | undefined =\n    schemaVersion === undefined ? undefined : (\n      {\n        schemaWrite: {\n          graphId: store.graphId,\n          expectedVersion: schemaVersion,\n        },\n      }\n    );\n  return withImportStreamLease(store, () =>\n    trustedImport(\n      (session) => consumeTrustedChunks(store, session, chunks),\n      options,\n    ),\n  );\n}\n\nfunction* graphDataChunks(data: GraphData): Iterable<GraphInterchangeChunk> {\n  const { nodes, edges, identity, ...header } = data;\n  yield {\n    type: \"header\",\n    header:\n      identity === undefined ? header : (\n        {\n          ...header,\n          identity: { profile: identity.profile, mode: identity.mode },\n        }\n      ),\n  };\n  yield { type: \"nodes\", nodes };\n  yield { type: \"edges\", edges };\n  if (identity !== undefined) {\n    yield { type: \"identity\", assertions: identity.assertions };\n  }\n}\n\n/** In-memory convenience wrapper around {@link trustedImportGraphStream}. */\nexport function trustedImportGraph<G extends GraphDef>(\n  store: Store<G>,\n  data: GraphData,\n): Promise<TrustedImportResult> {\n  return trustedImportGraphStream(store, graphDataChunks(data));\n}\n"]}
+{"version":3,"sources":["../../src/interchange/trusted-import.ts"],"names":["TrustedImportError","getSearchableFields","resolveGraphVectorSlots","isCanonicalIsoDate","isInvertedValidityWindow","storeBackend","exportStreamBackend","snapshotExportContention","serializedStreamRefusal","withImportStreamLease"],"mappings":"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","file":"index.cjs","sourcesContent":["import { snapshotExportContention } from \"../backend/transaction-resource\";\nimport type {\n  InsertEdgeParams,\n  InsertNodeParams,\n  TrustedImportOptions,\n  TrustedImportSession,\n} from \"../backend/types\";\nimport type { GraphDef } from \"../core/define-graph\";\nimport { resolveGraphVectorSlots } from \"../core/embedding\";\nimport { getSearchableFields } from \"../core/searchable\";\nimport { TrustedImportError } from \"../errors\";\nimport { storeBackend } from \"../store/runtime-port\";\nimport type { Store } from \"../store/store\";\nimport { isCanonicalIsoDate, isInvertedValidityWindow } from \"../utils/date\";\nimport { serializedStreamRefusal, withImportStreamLease } from \"./import\";\nimport { exportStreamBackend } from \"./stream-source\";\nimport type {\n  GraphData,\n  GraphInterchangeChunk,\n  InterchangeEdge,\n  InterchangeNode,\n} from \"./types\";\n\n/** Counts committed by a trusted initial import. */\nexport type TrustedImportResult = Readonly<{\n  nodes: number;\n  edges: number;\n}>;\n\nfunction rejectUnsupportedStoreFeatures<G extends GraphDef>(\n  store: Store<G>,\n): void {\n  if (store.historyEnabled) {\n    throw new TrustedImportError(\n      \"Trusted import does not support recorded-time history capture.\",\n      \"history_unsupported\",\n      { graphId: store.graphId },\n    );\n  }\n  if (store.revisionTrackingEnabled) {\n    throw new TrustedImportError(\n      \"Trusted import does not support revision tracking.\",\n      \"revision_tracking_unsupported\",\n      { graphId: store.graphId },\n    );\n  }\n  if (store.graph.identity !== undefined) {\n    throw new TrustedImportError(\n      \"Trusted import does not maintain Operational Identity assertions or closure.\",\n      \"identity_unsupported\",\n      { graphId: store.graphId },\n    );\n  }\n\n  const uniqueKinds = Object.values(store.graph.nodes)\n    .filter((registration) => (registration.unique?.length ?? 0) > 0)\n    .map((registration) => registration.type.kind);\n  if (uniqueKinds.length > 0) {\n    throw new TrustedImportError(\n      \"Trusted import does not maintain node uniqueness sidecars.\",\n      \"uniqueness_unsupported\",\n      { graphId: store.graphId, nodeKinds: uniqueKinds },\n    );\n  }\n\n  const searchableKinds = Object.values(store.graph.nodes)\n    .filter(\n      (registration) =>\n        getSearchableFields(registration.type.schema).length > 0,\n    )\n    .map((registration) => registration.type.kind);\n  if (searchableKinds.length > 0) {\n    throw new TrustedImportError(\n      \"Trusted import does not maintain fulltext sidecars.\",\n      \"fulltext_unsupported\",\n      { graphId: store.graphId, nodeKinds: searchableKinds },\n    );\n  }\n\n  const vectorSlots = resolveGraphVectorSlots(store.graph);\n  if (vectorSlots.length > 0) {\n    throw new TrustedImportError(\n      \"Trusted import does not maintain vector sidecars.\",\n      \"vector_unsupported\",\n      {\n        graphId: store.graphId,\n        fields: vectorSlots.map((slot) => `${slot.nodeKind}.${slot.fieldPath}`),\n      },\n    );\n  }\n}\n\nfunction invalidStream(message: string): TrustedImportError {\n  return new TrustedImportError(message, \"invalid_stream\");\n}\n\n/** The stated validity window of a streamed node or edge. */\ntype StatedValidityWindow = Readonly<{\n  validFrom?: string | null | undefined;\n  validTo?: string | undefined;\n}>;\n\ntype ValidityWindowField = \"validFrom\" | \"validTo\";\n\n/** A stated window field that is not canonical, with the offending value. */\ntype NonCanonicalWindow = Readonly<{\n  field: ValidityWindowField;\n  value: string;\n}>;\n\n/**\n * The first window field of `entity` stating a timestamp that is not canonical\n * fixed-width UTC ISO 8601 — with the offending value — or `undefined` when\n * every stated one is canonical.\n *\n * A trusted stream is never re-parsed, so this is the only place its timestamps\n * are held to the format the rest of the system assumes. It is deliberately\n * format-ONLY — the same {@link isCanonicalIsoDate} decision the untrusted\n * path's schema and the store's own write validation make, and nothing more —\n * because a non-canonical instant is not merely ugly: every temporal filter\n * compares these values AS TEXT against an `asOf` coordinate, so a variable-width\n * one (`...:00.1Z`, an offset, date-only) mis-sorts and silently includes or\n * excludes the wrong rows once stored, and it would mis-decide the negative-width\n * check below on the way in. Two field tests per row costs about a microsecond\n * against the ~4µs an in-memory SQLite row already costs — the price of the\n * stream's ordering claims meaning anything.\n *\n * An absent field states nothing, and a `null` validFrom is a confirmed\n * open-left window (see {@link nodeParams}) — neither is a timestamp to check.\n */\nfunction nonCanonicalWindowOf(\n  entity: StatedValidityWindow,\n): NonCanonicalWindow | undefined {\n  const { validFrom, validTo } = entity;\n  if (typeof validFrom === \"string\" && !isCanonicalIsoDate(validFrom)) {\n    return { field: \"validFrom\", value: validFrom };\n  }\n  if (typeof validTo === \"string\" && !isCanonicalIsoDate(validTo)) {\n    return { field: \"validTo\", value: validTo };\n  }\n  return undefined;\n}\n\n/**\n * The first entity in `entities` stating a non-canonical window timestamp, with\n * the offending field and value. Allocates only on the failing path, so a clean\n * chunk pays one predicate per stated timestamp and nothing else.\n */\nfunction findNonCanonicalWindow<Entity extends StatedValidityWindow>(\n  entities: readonly Entity[],\n): (NonCanonicalWindow & Readonly<{ entity: Entity }>) | undefined {\n  for (const entity of entities) {\n    const nonCanonical = nonCanonicalWindowOf(entity);\n    if (nonCanonical !== undefined) return { entity, ...nonCanonical };\n  }\n  return undefined;\n}\n\n/** The refusal message for a non-canonical window timestamp on `subject`. */\nfunction nonCanonicalWindowMessage(\n  subject: string,\n  field: ValidityWindowField,\n  value: string,\n): string {\n  return (\n    `Non-canonical ${field} in trusted import: ${subject} states \"${value}\". ` +\n    `Expected canonical fixed-width UTC ISO 8601 (YYYY-MM-DDTHH:mm:ss.sssZ), ` +\n    `which is what makes a stored timestamp sort chronologically against an asOf ` +\n    `coordinate. Convert with new Date(value).toISOString().`\n  );\n}\n\n/**\n * An entity whose stated window has negative width. Trusted import writes\n * straight to SQL and skips schema validation for throughput, but a row that\n * stopped being true before it started is a stream SHAPE fault rather than a\n * policy check: it is unobservable at every `asOf` coordinate, and no later\n * write repairs it. `null` validFrom is a confirmed open-left window, so there\n * is no lower bound to invert against; zero width is legal (see\n * {@link isInvertedValidityWindow}).\n *\n * Only ever reached for a chunk whose timestamps {@link findNonCanonicalWindow}\n * has already accepted, which is what makes the lexicographic compare inside a\n * chronological one.\n */\nfunction hasInvertedWindow(entity: StatedValidityWindow): boolean {\n  return isInvertedValidityWindow(\n    entity.validFrom ?? undefined,\n    entity.validTo,\n  );\n}\n\nfunction nodeParams(graphId: string, node: InterchangeNode): InsertNodeParams {\n  return {\n    graphId,\n    kind: node.kind,\n    id: node.id,\n    props: node.properties,\n    ...(node.validFrom === undefined ? {} : { validFrom: node.validFrom }),\n    ...(node.validTo === undefined ? {} : { validTo: node.validTo }),\n  };\n}\n\nfunction edgeParams(graphId: string, edge: InterchangeEdge): InsertEdgeParams {\n  return {\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: edge.properties,\n    ...(edge.validFrom === undefined ? {} : { validFrom: edge.validFrom }),\n    ...(edge.validTo === undefined ? {} : { validTo: edge.validTo }),\n  };\n}\n\nasync function consumeTrustedChunks<G extends GraphDef>(\n  store: Store<G>,\n  session: TrustedImportSession,\n  chunks:\n    AsyncIterable<GraphInterchangeChunk> | Iterable<GraphInterchangeChunk>,\n): Promise<TrustedImportResult> {\n  const nodeKinds = new Set(\n    Object.values(store.graph.nodes).map(\n      (registration) => registration.type.kind,\n    ),\n  );\n  const edgeKinds = new Set(\n    Object.values(store.graph.edges).map(\n      (registration) => registration.type.kind,\n    ),\n  );\n  let receivedHeader = false;\n  let receivedEdges = false;\n  let nodeCount = 0;\n  let edgeCount = 0;\n\n  for await (const chunk of chunks) {\n    switch (chunk.type) {\n      case \"header\": {\n        if (receivedHeader) {\n          throw invalidStream(\n            \"Trusted graph interchange stream emitted more than one header.\",\n          );\n        }\n        if (chunk.header.identity !== undefined) {\n          throw invalidStream(\n            \"Trusted graph interchange import does not support identity data. \" +\n              \"Use importGraphStream() for an identity export.\",\n          );\n        }\n        receivedHeader = true;\n        break;\n      }\n      case \"nodes\": {\n        if (!receivedHeader) {\n          throw invalidStream(\n            \"Trusted graph interchange stream must start with a header.\",\n          );\n        }\n        if (receivedEdges) {\n          throw invalidStream(\n            \"Trusted graph interchange stream cannot emit nodes after edges.\",\n          );\n        }\n        const unknownKind = chunk.nodes.find(\n          (node) => !nodeKinds.has(node.kind),\n        )?.kind;\n        if (unknownKind !== undefined) {\n          throw invalidStream(\n            `Unknown node kind in trusted import: ${unknownKind}`,\n          );\n        }\n        const nonCanonicalNode = findNonCanonicalWindow(chunk.nodes);\n        if (nonCanonicalNode !== undefined) {\n          const { entity, field, value } = nonCanonicalNode;\n          throw invalidStream(\n            nonCanonicalWindowMessage(\n              `${entity.kind} \"${entity.id}\"`,\n              field,\n              value,\n            ),\n          );\n        }\n        const invertedNode = chunk.nodes.find((node) =>\n          hasInvertedWindow(node),\n        );\n        if (invertedNode !== undefined) {\n          throw invalidStream(\n            `Inverted validity window in trusted import: ${invertedNode.kind} \"${invertedNode.id}\" ends at ` +\n              `\"${String(invertedNode.validTo)}\", before its validFrom \"${String(invertedNode.validFrom)}\".`,\n          );\n        }\n        await session.insertNodes(\n          chunk.nodes.map((node) => nodeParams(store.graphId, node)),\n        );\n        nodeCount += chunk.nodes.length;\n        break;\n      }\n      case \"edges\": {\n        if (!receivedHeader) {\n          throw invalidStream(\n            \"Trusted graph interchange stream must start with a header.\",\n          );\n        }\n        receivedEdges = true;\n        const invalidEdge = chunk.edges.find(\n          (edge) =>\n            !edgeKinds.has(edge.kind) ||\n            !nodeKinds.has(edge.from.kind) ||\n            !nodeKinds.has(edge.to.kind),\n        );\n        if (invalidEdge !== undefined) {\n          throw invalidStream(\n            `Unknown edge or endpoint kind in trusted import: ${invalidEdge.kind}`,\n          );\n        }\n        const nonCanonicalEdge = findNonCanonicalWindow(chunk.edges);\n        if (nonCanonicalEdge !== undefined) {\n          const { entity, field, value } = nonCanonicalEdge;\n          throw invalidStream(\n            nonCanonicalWindowMessage(\n              `${entity.kind} edge \"${entity.id}\"`,\n              field,\n              value,\n            ),\n          );\n        }\n        const invertedEdge = chunk.edges.find((edge) =>\n          hasInvertedWindow(edge),\n        );\n        if (invertedEdge !== undefined) {\n          throw invalidStream(\n            `Inverted validity window in trusted import: ${invertedEdge.kind} edge \"${invertedEdge.id}\" ends at ` +\n              `\"${String(invertedEdge.validTo)}\", before its validFrom \"${String(invertedEdge.validFrom)}\".`,\n          );\n        }\n        await session.insertEdges(\n          chunk.edges.map((edge) => edgeParams(store.graphId, edge)),\n        );\n        edgeCount += chunk.edges.length;\n        break;\n      }\n      case \"identity\": {\n        // The trusted session writes only the node and edge relations, so it\n        // has no way to persist assertions or materialize the derived closure.\n        // Refuse rather than drop identity truth from an identity-enabled\n        // export: `importGraph` / `importGraphStream` carry it correctly.\n        throw invalidStream(\n          \"Trusted graph interchange import does not support identity assertions. \" +\n            \"Use importGraphStream() for an export that carries identity truth.\",\n        );\n      }\n    }\n  }\n\n  if (!receivedHeader) {\n    throw invalidStream(\n      \"Trusted graph interchange stream ended before emitting a header.\",\n    );\n  }\n  return { nodes: nodeCount, edges: edgeCount };\n}\n\n/**\n * Atomically imports a header-first stream into a fresh, dedicated database.\n *\n * This is an intentionally trusted path. It checks stream ordering and kind\n * names, but it does not validate properties, references, cardinality, or\n * conflicts. The caller must guarantee those invariants. Use\n * {@link importGraphStream} for untrusted data.\n *\n * Trusted of the DATA, not of the connection: this holds ONE write transaction\n * open for the entire stream, which makes it a long-lived import holder exactly\n * like {@link importGraphStream}, and it is guarded the same way — the source\n * stream's own backend is checked against the target before the first chunk, and\n * the target connection's exclusive stream lease is held for the whole import.\n * `trustedImportGraphStream(target, exportGraphStream(source))` over one\n * serialized connection is therefore refused with the shared typed\n * {@link ConfigurationError} (codes and `details.heldBy` / `details.requested`\n * as documented on `importGraphStream`) rather than reaching the driver as a\n * nested BEGIN.\n */\nexport async function trustedImportGraphStream<G extends GraphDef>(\n  store: Store<G>,\n  chunks:\n    AsyncIterable<GraphInterchangeChunk> | Iterable<GraphInterchangeChunk>,\n): Promise<TrustedImportResult> {\n  rejectUnsupportedStoreFeatures(store);\n  const backend = storeBackend(store);\n  const trustedImport = backend.trustedImport;\n  if (trustedImport === undefined) {\n    throw new TrustedImportError(\n      `The ${backend.dialect} backend does not support trusted import.`,\n      \"backend_unsupported\",\n      { dialect: backend.dialect },\n    );\n  }\n  // The same pre-flight `importGraphStream` runs, through the same owner of\n  // \"would this export hold the connection that write needs\": a synchronous\n  // iterable was materialized by its producer and holds nothing, so only an\n  // async stream can name a source backend.\n  const sourceBackend =\n    Symbol.asyncIterator in chunks ? exportStreamBackend(chunks) : undefined;\n  const contention =\n    sourceBackend === undefined ? undefined : (\n      snapshotExportContention(sourceBackend, backend)\n    );\n  if (contention !== undefined) {\n    throw serializedStreamRefusal({\n      graphId: store.graphId,\n      requested: \"import-stream\",\n      heldBy: \"export-snapshot\",\n      detector: contention,\n    });\n  }\n  const schemaVersion = store.introspect().schemaVersion;\n  const options: TrustedImportOptions | undefined =\n    schemaVersion === undefined ? undefined : (\n      {\n        schemaWrite: {\n          graphId: store.graphId,\n          expectedVersion: schemaVersion,\n        },\n      }\n    );\n  return withImportStreamLease(store, () =>\n    trustedImport(\n      (session) => consumeTrustedChunks(store, session, chunks),\n      options,\n    ),\n  );\n}\n\nfunction* graphDataChunks(data: GraphData): Iterable<GraphInterchangeChunk> {\n  const { nodes, edges, identity, ...header } = data;\n  yield {\n    type: \"header\",\n    header:\n      identity === undefined ? header : (\n        {\n          ...header,\n          identity: { profile: identity.profile, mode: identity.mode },\n        }\n      ),\n  };\n  yield { type: \"nodes\", nodes };\n  yield { type: \"edges\", edges };\n  if (identity !== undefined) {\n    yield { type: \"identity\", assertions: identity.assertions };\n  }\n}\n\n/** In-memory convenience wrapper around {@link trustedImportGraphStream}. */\nexport function trustedImportGraph<G extends GraphDef>(\n  store: Store<G>,\n  data: GraphData,\n): Promise<TrustedImportResult> {\n  return trustedImportGraphStream(store, graphDataChunks(data));\n}\n"]}