@nicia-ai/typegraph 0.48.0 → 0.50.0

package/dist/chunk-Y55DLLEG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/query/compiler/schema.ts"],"names":[],"mappings":"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","file":"chunk-Y55DLLEG.js","sourcesContent":["/**\n * SQL Schema Configuration for Query Compilation\n *\n * Provides table and column identifiers that the query compiler uses.\n * This allows the compiler to work with custom table names instead of\n * hard-coded defaults.\n */\nimport { type VectorIndexType, type VectorMetric } from \"../../backend/types\";\nimport { MAX_PG_IDENTIFIER_LENGTH } from \"../../constants\";\nimport { ConfigurationError } from \"../../errors\";\nimport { typeGraphGlobalSymbol } from \"../../utils/global-symbol\";\nimport { isSqlFragment, sql, type SqlFragment } from \"../sql-fragment\";\n\nconst SQL_SCHEMA_BRAND: unique symbol = typeGraphGlobalSymbol(\"sql-schema-v1\");\n\n/**\n * Table names for TypeGraph SQL schema.\n *\n * Carries every customizable physical-table name the backend exposes,\n * including the secondary tables (`uniques`, `edgeClaims`) that the query compiler\n * itself doesn't reference but `materializeRemovals` and other\n * cleanup paths need to address by name. Backends without a\n * `uniques` table (custom embeddings-only stores) leave it as the\n * default — the cleanup path is a no-op for kinds with no unique\n * rows.\n */\nexport type SqlTableNames = Readonly<{\n  /** Nodes table name (default: \"typegraph_nodes\") */\n  nodes: string;\n  /** Edges table name (default: \"typegraph_edges\") */\n  edges: string;\n  /** Recorded node relation table name (default: \"typegraph_recorded_nodes\") */\n  recordedNodes?: string | undefined;\n  /** Recorded edge relation table name (default: \"typegraph_recorded_edges\") */\n  recordedEdges?: string | undefined;\n  /** Recorded-time commit clock table name (default: \"typegraph_recorded_clock\") */\n  recordedClock?: string | undefined;\n  /** Durable per-graph revision-origin table name (default: \"typegraph_revision_origins\") */\n  revisionOrigins?: string | undefined;\n  /** Identity assertion ledger (default: \"typegraph_identity_assertions\") */\n  identityAssertions?: string | undefined;\n  /** Recorded identity assertion relation */\n  recordedIdentityAssertions?: string | undefined;\n  /** Derived current identity closure */\n  identityClosure?: string | undefined;\n  /** Derived separation relation over identity classes */\n  identitySeparation?: string | undefined;\n  /** Node fulltext table name (default: \"typegraph_node_fulltext\") */\n  fulltext: string;\n  /** Node uniques table name (default: \"typegraph_node_uniques\") */\n  uniques: string;\n  /** Edge cardinality claim table name (default: \"typegraph_edge_claims\") */\n  edgeClaims?: string | undefined;\n}>;\n\nexport type ResolvedSqlTableNames = Readonly<{\n  /** Nodes table name */\n  nodes: string;\n  /** Edges table name */\n  edges: string;\n  /** Recorded node relation table name */\n  recordedNodes: string;\n  /** Recorded edge relation table name */\n  recordedEdges: string;\n  /** Recorded-time commit clock table name */\n  recordedClock: string;\n  /** Durable per-graph revision-origin table name */\n  revisionOrigins: string;\n  identityAssertions: string;\n  recordedIdentityAssertions: string;\n  identityClosure: string;\n  identitySeparation: string;\n  /** Node fulltext table name */\n  fulltext: string;\n  /** Node uniques table name */\n  uniques: string;\n  /** Edge cardinality claim table name */\n  edgeClaims: string;\n}>;\n\ntype SqlSchemaFields = Readonly<{\n  /** Table names */\n  tables: ResolvedSqlTableNames;\n  /** Get a `SqlFragment` reference to the nodes table. */\n  nodesTable: SqlFragment;\n  /** Get a `SqlFragment` reference to the edges table. */\n  edgesTable: SqlFragment;\n  /** Get a `SqlFragment` reference to the recorded node relation. */\n  recordedNodesTable: SqlFragment;\n  /** Get a `SqlFragment` reference to the recorded edge relation. */\n  recordedEdgesTable: SqlFragment;\n  /** Get a `SqlFragment` reference to the recorded-time commit clock. */\n  recordedClockTable: SqlFragment;\n  /** Get a `SqlFragment` reference to the durable per-graph revision origins. */\n  revisionOriginsTable: SqlFragment;\n  /** Get a `SqlFragment` reference to the identity assertion ledger. */\n  identityAssertionsTable: SqlFragment;\n  /** Get a `SqlFragment` reference to the recorded identity assertion relation. */\n  recordedIdentityAssertionsTable: SqlFragment;\n  /** Get a `SqlFragment` reference to the derived identity closure. */\n  identityClosureTable: SqlFragment;\n  /** Get a `SqlFragment` reference to the derived identity separation relation. */\n  identitySeparationTable: SqlFragment;\n  /** Get a `SqlFragment` reference to the fulltext table. */\n  fulltextTable: SqlFragment;\n}>;\n\n/**\n * SQL schema configuration for query compilation.\n * Contains table identifiers and utility methods for generating `SqlFragment` references.\n *\n * Branded and frozen by {@link createSqlSchema}; callers should not construct\n * schema-shaped objects by hand.\n */\nexport abstract class SqlSchema implements SqlSchemaFields {\n  declare private readonly typeGraphSqlSchemaBrand: true;\n  abstract readonly tables: ResolvedSqlTableNames;\n  abstract readonly nodesTable: SqlFragment;\n  abstract readonly edgesTable: SqlFragment;\n  abstract readonly recordedNodesTable: SqlFragment;\n  abstract readonly recordedEdgesTable: SqlFragment;\n  abstract readonly recordedClockTable: SqlFragment;\n  abstract readonly revisionOriginsTable: SqlFragment;\n  abstract readonly identityAssertionsTable: SqlFragment;\n  abstract readonly recordedIdentityAssertionsTable: SqlFragment;\n  abstract readonly identityClosureTable: SqlFragment;\n  abstract readonly identitySeparationTable: SqlFragment;\n  abstract readonly fulltextTable: SqlFragment;\n}\n\nclass SqlSchemaDescriptor extends SqlSchema {\n  declare readonly [SQL_SCHEMA_BRAND]: true;\n  readonly tables: ResolvedSqlTableNames;\n  readonly nodesTable: SqlFragment;\n  readonly edgesTable: SqlFragment;\n  readonly recordedNodesTable: SqlFragment;\n  readonly recordedEdgesTable: SqlFragment;\n  readonly recordedClockTable: SqlFragment;\n  readonly revisionOriginsTable: SqlFragment;\n  readonly identityAssertionsTable: SqlFragment;\n  readonly recordedIdentityAssertionsTable: SqlFragment;\n  readonly identityClosureTable: SqlFragment;\n  readonly identitySeparationTable: SqlFragment;\n  readonly fulltextTable: SqlFragment;\n\n  constructor(fields: SqlSchemaFields) {\n    super();\n    Object.defineProperty(this, SQL_SCHEMA_BRAND, {\n      configurable: false,\n      enumerable: false,\n      value: true,\n      writable: false,\n    });\n    this.tables = fields.tables;\n    this.nodesTable = fields.nodesTable;\n    this.edgesTable = fields.edgesTable;\n    this.recordedNodesTable = fields.recordedNodesTable;\n    this.recordedEdgesTable = fields.recordedEdgesTable;\n    this.recordedClockTable = fields.recordedClockTable;\n    this.revisionOriginsTable = fields.revisionOriginsTable;\n    this.identityAssertionsTable = fields.identityAssertionsTable;\n    this.recordedIdentityAssertionsTable =\n      fields.recordedIdentityAssertionsTable;\n    this.identityClosureTable = fields.identityClosureTable;\n    this.identitySeparationTable = fields.identitySeparationTable;\n    this.fulltextTable = fields.fulltextTable;\n    Object.freeze(this);\n  }\n}\n\n/**\n * Default table names matching the standard TypeGraph schema.\n */\nconst DEFAULT_TABLE_NAMES: ResolvedSqlTableNames = {\n  nodes: \"typegraph_nodes\",\n  edges: \"typegraph_edges\",\n  recordedNodes: \"typegraph_recorded_nodes\",\n  recordedEdges: \"typegraph_recorded_edges\",\n  recordedClock: \"typegraph_recorded_clock\",\n  revisionOrigins: \"typegraph_revision_origins\",\n  identityAssertions: \"typegraph_identity_assertions\",\n  recordedIdentityAssertions: \"typegraph_recorded_identity_assertions\",\n  identityClosure: \"typegraph_identity_closure\",\n  identitySeparation: \"typegraph_identity_separation\",\n  fulltext: \"typegraph_node_fulltext\",\n  uniques: \"typegraph_node_uniques\",\n  edgeClaims: \"typegraph_edge_claims\",\n};\n\nfunction resolveTableNames(\n  names: Partial<SqlTableNames>,\n): ResolvedSqlTableNames {\n  return {\n    nodes: names.nodes ?? DEFAULT_TABLE_NAMES.nodes,\n    edges: names.edges ?? DEFAULT_TABLE_NAMES.edges,\n    recordedNodes: names.recordedNodes ?? DEFAULT_TABLE_NAMES.recordedNodes,\n    recordedEdges: names.recordedEdges ?? DEFAULT_TABLE_NAMES.recordedEdges,\n    recordedClock: names.recordedClock ?? DEFAULT_TABLE_NAMES.recordedClock,\n    revisionOrigins:\n      names.revisionOrigins ?? DEFAULT_TABLE_NAMES.revisionOrigins,\n    identityAssertions:\n      names.identityAssertions ?? DEFAULT_TABLE_NAMES.identityAssertions,\n    recordedIdentityAssertions:\n      names.recordedIdentityAssertions ??\n      DEFAULT_TABLE_NAMES.recordedIdentityAssertions,\n    identityClosure:\n      names.identityClosure ?? DEFAULT_TABLE_NAMES.identityClosure,\n    identitySeparation:\n      names.identitySeparation ?? DEFAULT_TABLE_NAMES.identitySeparation,\n    fulltext: names.fulltext ?? DEFAULT_TABLE_NAMES.fulltext,\n    uniques: names.uniques ?? DEFAULT_TABLE_NAMES.uniques,\n    edgeClaims: names.edgeClaims ?? DEFAULT_TABLE_NAMES.edgeClaims,\n  };\n}\n\n/**\n * Regex for valid SQL identifiers.\n * Must start with a letter or underscore.\n * Can contain letters, digits, underscores, and dollar signs.\n * Dollar signs are a PostgreSQL extension but commonly supported.\n */\nconst VALID_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_$]*$/i;\n\n/**\n * Validates that a table name is a valid SQL identifier.\n *\n * @throws Error if the table name is invalid\n */\nfunction validateTableName(name: string, label: string): void {\n  if (!name || name.length === 0) {\n    throw new ConfigurationError(`${label} table name cannot be empty`);\n  }\n  if (name.length > MAX_PG_IDENTIFIER_LENGTH) {\n    throw new ConfigurationError(\n      `${label} table name exceeds maximum length of ${MAX_PG_IDENTIFIER_LENGTH} characters`,\n    );\n  }\n  if (!VALID_IDENTIFIER_PATTERN.test(name)) {\n    throw new ConfigurationError(\n      `${label} table name \"${name}\" is not a valid SQL identifier. ` +\n        `Table names must start with a letter or underscore and contain only letters, digits, underscores, or dollar signs.`,\n    );\n  }\n}\n\nfunction freezeSqlSchema(fields: SqlSchemaFields): SqlSchema {\n  return new SqlSchemaDescriptor(fields);\n}\n\nfunction isSqlSchema(schema: unknown): schema is SqlSchema {\n  if (typeof schema !== \"object\" || schema === null) return false;\n  const candidate = schema as Record<PropertyKey, unknown>;\n  return (\n    candidate[SQL_SCHEMA_BRAND] === true &&\n    typeof candidate[\"tables\"] === \"object\" &&\n    candidate[\"tables\"] !== null &&\n    Object.isFrozen(candidate[\"tables\"]) &&\n    isSqlFragment(candidate[\"nodesTable\"]) &&\n    isSqlFragment(candidate[\"edgesTable\"]) &&\n    isSqlFragment(candidate[\"recordedNodesTable\"]) &&\n    isSqlFragment(candidate[\"recordedEdgesTable\"]) &&\n    isSqlFragment(candidate[\"recordedClockTable\"]) &&\n    isSqlFragment(candidate[\"revisionOriginsTable\"]) &&\n    isSqlFragment(candidate[\"fulltextTable\"]) &&\n    Object.isFrozen(candidate)\n  );\n}\n\nexport function requireSqlSchema(\n  schema: unknown,\n  surface = \"SqlSchema\",\n): SqlSchema {\n  if (isSqlSchema(schema)) return schema;\n  throw new ConfigurationError(\n    `${surface} must be created with createSqlSchema(...).`,\n    { code: \"INVALID_SQL_SCHEMA\", surface },\n    {\n      suggestion:\n        \"Pass the result of createSqlSchema(...) instead of a plain schema-shaped object.\",\n    },\n  );\n}\n\n/**\n * Creates a SqlSchema configuration from table names.\n *\n * Table names are validated to ensure they are valid SQL identifiers.\n * This prevents SQL injection and ensures compatibility across databases.\n *\n * @param names - Optional custom table names (defaults to standard names)\n * @returns SqlSchema configuration for query compilation\n * @throws Error if any table name is invalid\n *\n * @example\n * ```typescript\n * // Use default table names\n * const schema = createSqlSchema();\n *\n * // Use custom table names\n * const schema = createSqlSchema({\n *   nodes: \"myapp_nodes\",\n *   edges: \"myapp_edges\",\n *   fulltext: \"myapp_fulltext\",\n * });\n * ```\n */\nexport function createSqlSchema(names: Partial<SqlTableNames> = {}): SqlSchema {\n  const tables = resolveTableNames(names);\n\n  // Validate all table names\n  validateTableName(tables.nodes, \"nodes\");\n  validateTableName(tables.edges, \"edges\");\n  validateTableName(tables.recordedNodes, \"recordedNodes\");\n  validateTableName(tables.recordedEdges, \"recordedEdges\");\n  validateTableName(tables.recordedClock, \"recordedClock\");\n  validateTableName(tables.revisionOrigins, \"revisionOrigins\");\n  validateTableName(tables.identityAssertions, \"identityAssertions\");\n  validateTableName(\n    tables.recordedIdentityAssertions,\n    \"recordedIdentityAssertions\",\n  );\n  validateTableName(tables.identityClosure, \"identityClosure\");\n  validateTableName(tables.identitySeparation, \"identitySeparation\");\n  validateTableName(tables.fulltext, \"fulltext\");\n  validateTableName(tables.uniques, \"uniques\");\n  validateTableName(tables.edgeClaims, \"edgeClaims\");\n\n  return freezeSqlSchema({\n    tables: Object.freeze(tables),\n    nodesTable: sql.identifier(tables.nodes),\n    edgesTable: sql.identifier(tables.edges),\n    recordedNodesTable: sql.identifier(tables.recordedNodes),\n    recordedEdgesTable: sql.identifier(tables.recordedEdges),\n    recordedClockTable: sql.identifier(tables.recordedClock),\n    revisionOriginsTable: sql.identifier(tables.revisionOrigins),\n    identityAssertionsTable: sql.identifier(tables.identityAssertions),\n    recordedIdentityAssertionsTable: sql.identifier(\n      tables.recordedIdentityAssertions,\n    ),\n    identityClosureTable: sql.identifier(tables.identityClosure),\n    identitySeparationTable: sql.identifier(tables.identitySeparation),\n    fulltextTable: sql.identifier(tables.fulltext),\n  });\n}\n\n/**\n * The recorded/system-time relation a read coordinate may reconstruct from.\n *\n * TypeGraph's built-in capture relation is bound by `createStore(..., {\n * history: true })`. Hosts can also bind externally populated row-compatible\n * recorded relations through `recordedRelation({ schema })`. Keeping both as\n * explicit values separates the read contract from the write-capture mechanism\n * so future external/TMS-owned recorded relations can feed the same query\n * machinery without changing StoreView or ReadCoordinate.\n */\nconst EXTERNAL_RECORDED_READ_SOURCE: unique symbol = typeGraphGlobalSymbol(\n  \"external-recorded-read-source-v1\",\n);\n\nexport type ExternalRecordedReadSource = Readonly<{\n  source: \"external\";\n  schema: SqlSchema;\n  [EXTERNAL_RECORDED_READ_SOURCE]: true;\n}>;\n\ntype ExternalRecordedReadSourceCandidate = Readonly<{\n  source?: unknown;\n  schema?: unknown;\n  [EXTERNAL_RECORDED_READ_SOURCE]?: unknown;\n}>;\n\nconst TYPEGRAPH_RECORDED_READ_SOURCE: unique symbol = typeGraphGlobalSymbol(\n  \"typegraph-recorded-read-source-v1\",\n);\n\nexport type TypeGraphRecordedReadSource = Readonly<{\n  source: \"typegraph-capture\";\n  schema: SqlSchema;\n  [TYPEGRAPH_RECORDED_READ_SOURCE]: true;\n}>;\n\ntype RecordedReadSource =\n  ExternalRecordedReadSource | TypeGraphRecordedReadSource;\n\nexport type RecordedReadBinding = RecordedReadSource;\n\nexport type RecordedRelationOptions = Readonly<{\n  schema: SqlSchema;\n}>;\n\nexport function recordedRelation(\n  options: RecordedRelationOptions,\n): ExternalRecordedReadSource {\n  const schema = requireSqlSchema(options.schema, \"recordedRelation schema\");\n  return Object.freeze({\n    source: \"external\",\n    schema,\n    [EXTERNAL_RECORDED_READ_SOURCE]: true as const,\n  });\n}\n\nexport function requireExternalRecordedReadSource(\n  source: unknown,\n): ExternalRecordedReadSource | undefined {\n  if (source === undefined) return undefined;\n  if (isExternalRecordedReadSource(source)) return source;\n  throw new ConfigurationError(\n    \"recordedRead must be created with recordedRelation({ schema }).\",\n    { code: \"INVALID_RECORDED_READ_SOURCE\" },\n    {\n      suggestion:\n        \"Pass { recordedRead: recordedRelation({ schema }) } for an externally populated recorded relation. Use { history: true } when TypeGraph should capture writes.\",\n    },\n  );\n}\n\nfunction isExternalRecordedReadSource(\n  source: unknown,\n): source is ExternalRecordedReadSource {\n  if (typeof source !== \"object\" || source === null) return false;\n  const candidate = source as ExternalRecordedReadSourceCandidate;\n  return (\n    candidate.source === \"external\" &&\n    candidate[EXTERNAL_RECORDED_READ_SOURCE] === true &&\n    isSqlSchema(candidate.schema) &&\n    Object.isFrozen(candidate)\n  );\n}\n\nexport function createRecordedReadBinding(\n  schema: SqlSchema,\n): TypeGraphRecordedReadSource {\n  const readSchema = requireSqlSchema(schema, \"recorded read binding schema\");\n  return Object.freeze({\n    source: \"typegraph-capture\",\n    schema: readSchema,\n    [TYPEGRAPH_RECORDED_READ_SOURCE]: true as const,\n  });\n}\n\nexport function requireRecordedReadBinding(\n  binding: unknown,\n  surface: string,\n): RecordedReadBinding {\n  if (isRecordedReadBinding(binding)) return binding;\n  if (binding !== undefined) {\n    throw new ConfigurationError(\n      \"Recorded-time reads require a recorded read relation created by TypeGraph.\",\n      { code: \"INVALID_RECORDED_READ_BINDING\", surface },\n      {\n        suggestion:\n          \"Use createStore(graph, backend, { history: true }) or { recordedRead: recordedRelation({ schema }) } instead of passing a plain object.\",\n      },\n    );\n  }\n  throw new ConfigurationError(\n    \"Recorded-time reads require a recorded read relation.\",\n    { code: \"RECORDED_READ_REQUIRES_BINDING\", surface },\n    {\n      suggestion:\n        \"Create the store with createStore(graph, backend, { history: true }) to bind TypeGraph's built-in captured relation, or pass { recordedRead: recordedRelation({ schema }) } for an externally populated recorded relation.\",\n    },\n  );\n}\n\ntype TypeGraphRecordedReadSourceCandidate = Readonly<{\n  source?: unknown;\n  schema?: unknown;\n  [TYPEGRAPH_RECORDED_READ_SOURCE]?: unknown;\n}>;\n\nfunction isTypeGraphRecordedReadSource(\n  source: unknown,\n): source is TypeGraphRecordedReadSource {\n  if (typeof source !== \"object\" || source === null) return false;\n  const candidate = source as TypeGraphRecordedReadSourceCandidate;\n  return (\n    candidate.source === \"typegraph-capture\" &&\n    candidate[TYPEGRAPH_RECORDED_READ_SOURCE] === true &&\n    isSqlSchema(candidate.schema) &&\n    Object.isFrozen(candidate)\n  );\n}\n\nfunction isRecordedReadBinding(\n  binding: unknown,\n): binding is RecordedReadBinding {\n  return (\n    isExternalRecordedReadSource(binding) ||\n    isTypeGraphRecordedReadSource(binding)\n  );\n}\n\n/**\n * Returns a schema view whose primary node/edge sources are the recorded-time\n * relations. The recorded relations are row-compatible with the live tables\n * for every column the query compiler, subgraph extractor, and algorithms\n * already read; the temporal filter adds the `recorded_from/to` predicate.\n */\nexport function recordedReadSqlSchema(binding: RecordedReadBinding): SqlSchema {\n  const { schema } = requireRecordedReadBinding(\n    binding,\n    \"recorded-read-schema\",\n  );\n  return freezeSqlSchema({\n    tables: schema.tables,\n    nodesTable: schema.recordedNodesTable,\n    edgesTable: schema.recordedEdgesTable,\n    recordedNodesTable: schema.recordedNodesTable,\n    recordedEdgesTable: schema.recordedEdgesTable,\n    recordedClockTable: schema.recordedClockTable,\n    revisionOriginsTable: schema.revisionOriginsTable,\n    identityAssertionsTable: schema.identityAssertionsTable,\n    recordedIdentityAssertionsTable: schema.recordedIdentityAssertionsTable,\n    identityClosureTable: schema.identityClosureTable,\n    identitySeparationTable: schema.identitySeparationTable,\n    fulltextTable: schema.fulltextTable,\n  });\n}\n\n/**\n * Resolves the read schema for a coordinate: the live schema when no recorded\n * pin is set, or the recorded-relation view when `recordedAsOf` is present. The\n * single place every read path decides whether to source the recorded tables.\n */\nexport function recordedReadSchemaFor(\n  schema: SqlSchema,\n  recordedAsOf: string | undefined,\n  binding: RecordedReadBinding | undefined,\n  surface: string,\n): SqlSchema {\n  const baseSchema = requireSqlSchema(schema, `${surface} schema`);\n  if (recordedAsOf === undefined) return baseSchema;\n  return recordedReadSqlSchema(requireRecordedReadBinding(binding, surface));\n}\n\n/**\n * Default SqlSchema using standard TypeGraph table names.\n */\nexport const DEFAULT_SQL_SCHEMA: SqlSchema = createSqlSchema();\n\n/**\n * The compiler's resolved view of one declared embedding field — the\n * `(dimensions, metric, indexType)` a {@link VectorStrategy} needs to\n * name and scan the field's typed per-`(kind, field)` storage. Sourced\n * from the registered node schema's `embedding()` declaration when the\n * store builds its compile options.\n */\nexport type VectorSlotDescriptor = Readonly<{\n  dimensions: number;\n  metric: VectorMetric;\n  indexType: VectorIndexType;\n}>;\n\n/**\n * Map of declared embedding slots keyed by {@link vectorSlotKey} -\n * `\"<nodeKind>\\0<fieldPath>\"` (NUL-separated). Carries every `(concrete kind,\n * fieldPath)` that declares an embedding field, so the compiler's\n * `field.similarTo(...)` CTE can UNION ALL the per-field tables for the\n * kinds in an alias that actually declare the field (only\n * `includeSubClasses` yields more than one).\n */\nexport type VectorSlotMap = ReadonlyMap<string, VectorSlotDescriptor>;\n\n/** NUL-delimited composite key for {@link VectorSlotMap}. */\nexport function vectorSlotKey(nodeKind: string, fieldPath: string): string {\n  return `${nodeKind}\\u0000${fieldPath}`;\n}\n\n/**\n * CTE aliases used by the standard query emitter. Joining on these names\n * across multiple builder files is fragile when typed as raw strings —\n * import these constants instead.\n */\nexport const ALIAS_CTE_PREFIX = \"cte_\" as const;\nexport const EMBEDDINGS_CTE_ALIAS = \"cte_embeddings\" as const;\nexport const FULLTEXT_CTE_ALIAS = \"cte_fulltext\" as const;\nexport const HYBRID_CANDIDATES_CTE_ALIAS = \"cte_relevance_candidates\" as const;\n"]}

package/dist/chunk-YA36ABIL.js

@@ -0,0 +1,174 @@
+import { isMissingTableError } from './chunk-IRPYOHRC.js';
+import { edgeCardinalityAxis, encodeTupleKey, compareClaimTargets, checkUniqueEdge, checkCardinality } from './chunk-5LKOVCPP.js';
+import { ConfigurationError, CardinalityError } from './chunk-YDEJQWOL.js';
+import { requireDefined } from './chunk-DYATYRY4.js';
+
+// src/store/claims/backing.ts
+var CLAIM_MEMBER_NAMES = [
+  "claimEdgeCardinality",
+  "claimEdgeCardinalityBatch",
+  "purgeEdgeClaims",
+  "hardDeleteUniquesByConcreteKind"
+];
+function claimSupport(target) {
+  const declared = target.capabilities.constraintClaims === true;
+  const present = CLAIM_MEMBER_NAMES.filter(
+    (name) => target[name] !== void 0
+  );
+  if (declared && present.length === CLAIM_MEMBER_NAMES.length) {
+    return {
+      supported: true,
+      claims: {
+        claimEdgeCardinality: requireDefined(target.claimEdgeCardinality),
+        claimEdgeCardinalityBatch: requireDefined(
+          target.claimEdgeCardinalityBatch
+        ),
+        purgeEdgeClaims: requireDefined(target.purgeEdgeClaims),
+        hardDeleteUniquesByConcreteKind: requireDefined(
+          target.hardDeleteUniquesByConcreteKind
+        )
+      }
+    };
+  }
+  if (!declared && present.length === 0) return { supported: false };
+  const missing = CLAIM_MEMBER_NAMES.filter(
+    (name) => target[name] === void 0
+  );
+  throw new ConfigurationError(
+    declared ? `This backend declares \`constraintClaims: true\` but does not implement ${missing.join(", ")}. A declared constraint would then be written without the fence the declaration promises.` : `This backend implements ${present.join(", ")} but does not declare \`constraintClaims: true\`. Claim support is read from the declaration, so these members would never be called.`,
+    { code: "CONSTRAINT_CLAIM_SURFACE_MISMATCH", missing, present },
+    {
+      suggestion: declared ? "Implement the missing members, or drop `constraintClaims` from the backend's capabilities." : "Declare `constraintClaims: true` in the backend's capabilities, or drop the claim members."
+    }
+  );
+}
+
+// src/store/claims/edge-claims.ts
+var EDGE_CARDINALITY_SPECS = {
+  one: { keyShape: "from", claimsWhenBornEnded: true, holderLiveness: "live" },
+  unique: {
+    keyShape: "fromAndTo",
+    claimsWhenBornEnded: true,
+    holderLiveness: "live"
+  },
+  oneActive: {
+    keyShape: "from",
+    claimsWhenBornEnded: false,
+    holderLiveness: "liveAndActive"
+  }
+};
+function edgeCardinalityAxesForKind(edgeKind) {
+  return Object.keys(EDGE_CARDINALITY_SPECS).map(
+    (cardinality) => edgeCardinalityAxis(cardinality, edgeKind)
+  );
+}
+function edgeCardinalityClaimTarget(params) {
+  const spec = EDGE_CARDINALITY_SPECS[params.cardinality];
+  return {
+    relation: "edgeClaims",
+    graphId: params.graphId,
+    axis: edgeCardinalityAxis(params.cardinality, params.edgeKind),
+    key: spec.keyShape === "from" ? encodeTupleKey([params.fromKind, params.fromId]) : encodeTupleKey([
+      params.fromKind,
+      params.fromId,
+      params.toKind,
+      params.toId
+    ])
+  };
+}
+function edgeCardinalityClaim(cardinality, subject) {
+  if (cardinality === "many") return void 0;
+  if (!EDGE_CARDINALITY_SPECS[cardinality].claimsWhenBornEnded && subject.validTo !== void 0) {
+    return void 0;
+  }
+  return {
+    graphId: subject.graphId,
+    cardinality,
+    edgeKind: subject.kind,
+    edgeId: subject.id,
+    fromKind: subject.fromKind,
+    fromId: subject.fromId,
+    toKind: subject.toKind,
+    toId: subject.toId
+  };
+}
+function edgeClaimRefusal(params) {
+  const error = params.cardinality === "unique" ? checkUniqueEdge(
+    params.edgeKind,
+    params.fromKind,
+    params.fromId,
+    params.toKind,
+    params.toId,
+    1
+  ) : checkCardinality(
+    params.edgeKind,
+    params.fromKind,
+    params.fromId,
+    params.cardinality,
+    1,
+    true
+  );
+  return error ?? new CardinalityError({
+    edgeKind: params.edgeKind,
+    fromKind: params.fromKind,
+    fromId: params.fromId,
+    cardinality: params.cardinality,
+    existingCount: 1
+  });
+}
+async function withEdgeClaimRelationPrecondition(graphId, issue) {
+  try {
+    return await issue();
+  } catch (error) {
+    if (!isMissingTableError(error)) throw error;
+    throw new ConfigurationError(
+      "Enforcing a declared edge cardinality needs the edge claim relation (typegraph_edge_claims), and this database does not have it. Databases initialized before this relation existed were never sent its CREATE TABLE, because the bootstrap DDL runs only on first boot.",
+      { code: "EDGE_CLAIM_RELATION_MISSING", graphId },
+      {
+        cause: error,
+        suggestion: 'Run the generated migration SQL (generatePostgresMigrationSQL / generateSqliteMigrationSQL) against this database, or declare the edge kind `cardinality: "many"` and enforce the limit in application code.'
+      }
+    );
+  }
+}
+async function claimEdgeCardinality(backend, claim) {
+  const support = claimSupport(backend);
+  if (!support.supported) return;
+  const outcome = await withEdgeClaimRelationPrecondition(
+    claim.graphId,
+    () => support.claims.claimEdgeCardinality(claim)
+  );
+  if (outcome.status === "refused") throw edgeClaimRefusal(claim);
+}
+async function claimEdgeCardinalityBatch(backend, claims) {
+  if (claims.length === 0) return;
+  const support = claimSupport(backend);
+  if (!support.supported) return;
+  const ordered = claims.map((claim) => ({ claim, target: edgeCardinalityClaimTarget(claim) })).toSorted((left, right) => compareClaimTargets(left.target, right.target));
+  const graphId = ordered[0]?.claim.graphId ?? "";
+  const outcomes = await withEdgeClaimRelationPrecondition(
+    graphId,
+    () => support.claims.claimEdgeCardinalityBatch(
+      ordered.map((entry) => entry.claim)
+    )
+  );
+  for (const [index, outcome] of outcomes.entries()) {
+    const entry = ordered[index];
+    if (entry !== void 0 && outcome.status === "refused") {
+      throw edgeClaimRefusal(entry.claim);
+    }
+  }
+}
+async function purgeEdgeClaims(backend, graphId, edgeIds) {
+  if (edgeIds.length === 0) return;
+  const support = claimSupport(backend);
+  if (!support.supported) return;
+  await withEdgeClaimRelationPrecondition(
+    graphId,
+    () => support.claims.purgeEdgeClaims({ graphId, edgeIds })
+  );
+}
+
+export { EDGE_CARDINALITY_SPECS, claimEdgeCardinality, claimEdgeCardinalityBatch, edgeCardinalityAxesForKind, edgeCardinalityClaim, edgeCardinalityClaimTarget, purgeEdgeClaims };
+//# sourceMappingURL=chunk-YA36ABIL.js.map
+//# sourceMappingURL=chunk-YA36ABIL.js.map

package/dist/chunk-YA36ABIL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/store/claims/backing.ts","../src/store/claims/edge-claims.ts"],"names":[],"mappings":"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","file":"chunk-YA36ABIL.js","sourcesContent":["/**\n * What backs each constraint fence class.\n *\n * A constrained write is fenced by one of two things: a per-graph lock that\n * serializes the probe with the write it guards, or a CLAIM row whose primary\n * key refuses a second claimant outright. The second is strictly stronger — it\n * holds without a lock, which is what an import needs — and this module records\n * which class has reached it, so \"is this fence a lock or a key?\" is answered\n * from one table rather than inferred from whichever module a reader lands in.\n *\n * It also owns the runtime half of the same question — {@link claimSupport},\n * the one reader of \"can THIS object hold a claim?\" — so the declaration and\n * the surface are reconciled in one place rather than at each claim site.\n */\nimport {\n  type GraphBackend,\n  type TransactionBackend,\n} from \"../../backend/types\";\nimport { ConfigurationError } from \"../../errors\";\nimport { requireDefined } from \"../../utils/presence\";\n\n/**\n * The runtime extent of the fence classes. {@link ConstraintFenceReason} is\n * DERIVED from it rather than declared beside it: a union type has no runtime\n * extent, so a totality test over a map keyed by the union could only iterate\n * that map's own keys and would be trivially true.\n */\nexport const CONSTRAINT_FENCE_REASONS = [\n  \"edgeCardinality\",\n  \"edgeMatchKeyConvergence\",\n  \"nodeDisjointness\",\n  \"nodeUniquenessClaim\",\n  \"nodeUniquenessScope\",\n] as const;\n\n/**\n * WHICH declared constraint makes a write constrained.\n *\n * The classification names the reason rather than answering yes/no, because\n * the reason is load-bearing twice over: it is what the fence is taken FOR, and\n * — on a backend that cannot hold the fence — it is what the refusal has to\n * tell the caller. \"This backend cannot fence constrained writes\" is unusable\n * advice; \"your `cardinality: 'one'` edge cannot be enforced here\" is\n * actionable, and only the classifier knows which it was.\n */\nexport type ConstraintFenceReason = (typeof CONSTRAINT_FENCE_REASONS)[number];\n\n/** The relation whose key fences a class, or `lockOnly` when nothing does yet. */\ntype ConstraintFenceBacking = \"uniques\" | \"edgeClaims\" | \"lockOnly\";\n\n/**\n * Which claim relation backs each fence class. The `satisfies` forces totality:\n * a new reason cannot be added without stating what backs it.\n *\n * `nodeUniquenessScope` is `\"uniques\"` because a shared-scope claim is now\n * written at the scope's axis, so two writers of two kinds in one hierarchy\n * contend for one row. `nodeUniquenessClaim` is the same relation seen from the\n * other side: the claim row is the fence, and the class exists because a write\n * that must issue it BEFORE the row it gates needs a transaction to undo the\n * pair together — which is what its refusal names. `nodeDisjointness` is the\n * same relation again, at a third kind of axis: a claim keyed on the declared\n * PAIR and on the node's id, which is the axis disjointness actually declares\n * and the one the nodes primary key `(graph_id, kind, id)` cannot fence.\n * `edgeCardinality` is the other relation: a claim keyed on\n * `(<cardinality>:<edgeKind>, endpoint identity)`, which is the axis the\n * declaration actually spans and the one the edges primary key `(graph_id, id)`\n * cannot fence. The classes still marked `lockOnly` are fenced by the per-graph\n * write lock alone, which is why they are also the classes a non-transactional\n * backend refuses.\n */\nexport const CONSTRAINT_FENCE_BACKING = {\n  edgeCardinality: \"edgeClaims\",\n  edgeMatchKeyConvergence: \"lockOnly\",\n  nodeDisjointness: \"uniques\",\n  nodeUniquenessClaim: \"uniques\",\n  nodeUniquenessScope: \"uniques\",\n} as const satisfies Record<ConstraintFenceReason, ConstraintFenceBacking>;\n\n/**\n * The claim members, narrowed to present. A caller holding this has been told\n * by ONE reader that this object both declares claim support and carries every\n * member that support consists of.\n */\ntype RequiredClaimMembers = Readonly<{\n  claimEdgeCardinality: NonNullable<GraphBackend[\"claimEdgeCardinality\"]>;\n  claimEdgeCardinalityBatch: NonNullable<\n    GraphBackend[\"claimEdgeCardinalityBatch\"]\n  >;\n  purgeEdgeClaims: NonNullable<GraphBackend[\"purgeEdgeClaims\"]>;\n  hardDeleteUniquesByConcreteKind: NonNullable<\n    GraphBackend[\"hardDeleteUniquesByConcreteKind\"]\n  >;\n}>;\n\n/** The decision {@link claimSupport} returns — never a flag a caller re-derives. */\nexport type ClaimSupport =\n  /** Capability declared AND every claim member present: the members, narrowed. */\n  | Readonly<{ supported: true; claims: RequiredClaimMembers }>\n  /** Capability absent or false AND no claim member present: the declared gap. */\n  | Readonly<{ supported: false }>;\n\n/** The members `constraintClaims: true` promises, in one list. */\nconst CLAIM_MEMBER_NAMES = [\n  \"claimEdgeCardinality\",\n  \"claimEdgeCardinalityBatch\",\n  \"purgeEdgeClaims\",\n  \"hardDeleteUniquesByConcreteKind\",\n] as const satisfies readonly (keyof RequiredClaimMembers)[];\n\n/**\n * THE one reader of \"can this object hold a claim?\", asked about the object the\n * claim is about to be written to.\n *\n * It reads BOTH the declaration and the surface, and returns the decision — the\n * narrowed members — rather than a boolean a caller then re-derives the members\n * from. Reading only `capabilities` would let a projection that forwards the\n * capability verbatim while dropping a method produce a verdict about a\n * different object than the write goes to; reading only member presence would\n * be the `undefined`-means-something inference the capability exists to\n * replace.\n *\n * @throws ConfigurationError (`CONSTRAINT_CLAIM_SURFACE_MISMATCH`) when the two\n *   disagree in either direction — a backend or projection declaring\n *   `constraintClaims: true` while missing a member, or one shipping the\n *   members without declaring the capability. Both are defects in the object,\n *   and a silent fallback would unfence exactly the writes the capability\n *   exists to fence.\n */\nexport function claimSupport(\n  target: GraphBackend | TransactionBackend,\n): ClaimSupport {\n  const declared = target.capabilities.constraintClaims === true;\n  const present = CLAIM_MEMBER_NAMES.filter(\n    (name) => target[name] !== undefined,\n  );\n  if (declared && present.length === CLAIM_MEMBER_NAMES.length) {\n    return {\n      supported: true,\n      claims: {\n        claimEdgeCardinality: requireDefined(target.claimEdgeCardinality),\n        claimEdgeCardinalityBatch: requireDefined(\n          target.claimEdgeCardinalityBatch,\n        ),\n        purgeEdgeClaims: requireDefined(target.purgeEdgeClaims),\n        hardDeleteUniquesByConcreteKind: requireDefined(\n          target.hardDeleteUniquesByConcreteKind,\n        ),\n      },\n    };\n  }\n  if (!declared && present.length === 0) return { supported: false };\n\n  const missing = CLAIM_MEMBER_NAMES.filter(\n    (name) => target[name] === undefined,\n  );\n  throw new ConfigurationError(\n    declared ?\n      `This backend declares \\`constraintClaims: true\\` but does not implement ${missing.join(\", \")}. ` +\n        \"A declared constraint would then be written without the fence the \" +\n        \"declaration promises.\"\n    : `This backend implements ${present.join(\", \")} but does not declare \\`constraintClaims: true\\`. ` +\n        \"Claim support is read from the declaration, so these members would \" +\n        \"never be called.\",\n    { code: \"CONSTRAINT_CLAIM_SURFACE_MISMATCH\", missing, present },\n    {\n      suggestion:\n        declared ?\n          \"Implement the missing members, or drop `constraintClaims` from the backend's capabilities.\"\n        : \"Declare `constraintClaims: true` in the backend's capabilities, or drop the claim members.\",\n    },\n  );\n}\n","/**\n * Edge claims — what an edge write reserves on a declared cardinality axis.\n *\n * A declared cardinality is a predicate over `(kind, from)` or\n * `(kind, from, to)`, and the edges relation's only uniqueness is its\n * `(graph_id, id)` primary key, so nothing in the schema re-decides at write\n * time what the probe decided at read time. This module is the reservation that\n * does: one row per `(graph_id, axis, key)` in `typegraph_edge_claims`, whose\n * primary key refuses a second concurrent claimant.\n *\n * The claim needs no release path. A claim whose holder is no longer live (or,\n * for `oneActive`, no longer active) fails the liveness predicate the takeover\n * statement carries and is taken over in place, so the fence never depends on\n * any delete path having run. `purgeEdgeClaims` exists to bound table growth,\n * not to make the fence correct.\n */\nimport {\n  type ClaimEdgeCardinalityParams,\n  type GraphBackend,\n  type InsertEdgeParams,\n  type TransactionBackend,\n} from \"../../backend/types\";\nimport { checkCardinality, checkUniqueEdge } from \"../../constraints\";\nimport { type Cardinality } from \"../../core/types\";\nimport { CardinalityError, ConfigurationError } from \"../../errors\";\nimport { isMissingTableError } from \"../../utils/sql-errors\";\nimport { encodeTupleKey } from \"../../utils/tuple-key\";\nimport {\n  type ClaimTarget,\n  compareClaimTargets,\n  edgeCardinalityAxis,\n} from \"./axis\";\nimport { claimSupport } from \"./backing\";\n\n/** A cardinality that declares something — `many` declares nothing. */\nexport type ConstrainedCardinality = Exclude<Cardinality, \"many\">;\n\n/**\n * What one declared cardinality means to every layer that has to agree about\n * it: which endpoints its axis key covers, whether an edge born already ended\n * claims at all, and what a holder must still BE for its claim to stand.\n */\nexport type EdgeCardinalitySpec = Readonly<{\n  /** Which endpoints the axis key covers. */\n  keyShape: \"from\" | \"fromAndTo\";\n  /** Whether a new edge that is born ENDED makes a claim at all. */\n  claimsWhenBornEnded: boolean;\n  /** What a holder must still be for its claim to stand. */\n  holderLiveness: \"live\" | \"liveAndActive\";\n}>;\n\n/**\n * THE table both renderers of the cardinality predicate read: the TypeScript\n * probe ({@link file://../constraints.ts checkCardinalityConstraint}) and the\n * SQL takeover statement\n * ({@link file://../../backend/drizzle/operations/edge-claims.ts}).\n *\n * Two renderers, one table, exhaustive by type: a new cardinality cannot be\n * added without stating all three facts, and the probe and the fence cannot\n * disagree about any of them — a disagreement is exactly the shape where the\n * probe accepts a write the fence then refuses forever (or the reverse).\n */\nexport const EDGE_CARDINALITY_SPECS = {\n  one: { keyShape: \"from\", claimsWhenBornEnded: true, holderLiveness: \"live\" },\n  unique: {\n    keyShape: \"fromAndTo\",\n    claimsWhenBornEnded: true,\n    holderLiveness: \"live\",\n  },\n  oneActive: {\n    keyShape: \"from\",\n    claimsWhenBornEnded: false,\n    holderLiveness: \"liveAndActive\",\n  },\n} as const satisfies Record<ConstrainedCardinality, EdgeCardinalitySpec>;\n\n/** Every axis an edge kind's claims can sit on, for housekeeping reaps. */\nexport function edgeCardinalityAxesForKind(\n  edgeKind: string,\n): readonly string[] {\n  return Object.keys(EDGE_CARDINALITY_SPECS).map((cardinality) =>\n    edgeCardinalityAxis(cardinality, edgeKind),\n  );\n}\n\n/**\n * THE claim row one edge write reserves: its axis, and the endpoint identity\n * the axis is keyed by.\n *\n * The key is {@link encodeTupleKey}, not a delimiter join: node ids are\n * arbitrary caller data (only kind names pass `assertClaimAxisSafe`), and a\n * delimiter that a value may contain makes two different endpoint tuples\n * collapse onto one key — which would refuse a write no constraint forbids.\n */\nexport function edgeCardinalityClaimTarget(\n  params: ClaimEdgeCardinalityParams,\n): ClaimTarget {\n  const spec = EDGE_CARDINALITY_SPECS[params.cardinality];\n  return {\n    relation: \"edgeClaims\",\n    graphId: params.graphId,\n    axis: edgeCardinalityAxis(params.cardinality, params.edgeKind),\n    key:\n      spec.keyShape === \"from\" ?\n        encodeTupleKey([params.fromKind, params.fromId])\n      : encodeTupleKey([\n          params.fromKind,\n          params.fromId,\n          params.toKind,\n          params.toId,\n        ]),\n  };\n}\n\n/**\n * The fields a claim is decided from: the row's identity and the upper bound\n * that decides whether it joins an active-only population. Narrower than\n * {@link InsertEdgeParams} on purpose — a resurrect has no insert params to\n * hand over, and passing an invented `props` to satisfy a type would be a\n * fabricated value a reader has to check is unread.\n */\nexport type EdgeClaimSubject = Pick<\n  InsertEdgeParams,\n  \"graphId\" | \"id\" | \"kind\" | \"fromKind\" | \"fromId\" | \"toKind\" | \"toId\"\n> &\n  Readonly<{ validTo?: string }>;\n\n/**\n * THE claim an edge insert owes, or `undefined` when it owes none.\n *\n * `many` declares no constraint, and an `oneActive` edge born already ended\n * joins no active population — `claimsWhenBornEnded` is the one place that\n * second exemption is written down, and the probe reads the same field, so the\n * two cannot drift into \"probed but unclaimed\" (a silent hole) or \"claimed but\n * unprobed\" (a refusal with no matching error).\n */\nexport function edgeCardinalityClaim(\n  cardinality: Cardinality,\n  subject: EdgeClaimSubject,\n): ClaimEdgeCardinalityParams | undefined {\n  if (cardinality === \"many\") return undefined;\n  if (\n    !EDGE_CARDINALITY_SPECS[cardinality].claimsWhenBornEnded &&\n    subject.validTo !== undefined\n  ) {\n    return undefined;\n  }\n  return {\n    graphId: subject.graphId,\n    cardinality,\n    edgeKind: subject.kind,\n    edgeId: subject.id,\n    fromKind: subject.fromKind,\n    fromId: subject.fromId,\n    toKind: subject.toKind,\n    toId: subject.toId,\n  };\n}\n\n/**\n * The refusal a lost claim raises — built by the SAME owners the probe calls,\n * so the fence's error is `instanceof` the same class and carries the same\n * payload as the probe's for the same violation (I3).\n */\nfunction edgeClaimRefusal(\n  params: ClaimEdgeCardinalityParams,\n): CardinalityError {\n  const error =\n    params.cardinality === \"unique\" ?\n      checkUniqueEdge(\n        params.edgeKind,\n        params.fromKind,\n        params.fromId,\n        params.toKind,\n        params.toId,\n        1,\n      )\n    : checkCardinality(\n        params.edgeKind,\n        params.fromKind,\n        params.fromId,\n        params.cardinality,\n        1,\n        true,\n      );\n  // Both owners refuse for an incumbent count of one on every constrained\n  // cardinality; the fallback keeps the return type honest without inventing a\n  // second spelling of the message.\n  return (\n    error ??\n    new CardinalityError({\n      edgeKind: params.edgeKind,\n      fromKind: params.fromKind,\n      fromId: params.fromId,\n      cardinality: params.cardinality,\n      existingCount: 1,\n    })\n  );\n}\n\n/**\n * Converts the engine's \"relation does not exist\" into a typed precondition\n * error naming the relation and the way to create it.\n *\n * Checked at FIRST USE rather than at store construction: a graph with no\n * constrained edge kind never issues a claim and must not pay a catalog read\n * for a relation it will never touch. A database bootstrapped before this\n * relation existed reaches it here, on the first constrained edge write, with\n * an error that says what to run instead of an opaque driver failure.\n */\nasync function withEdgeClaimRelationPrecondition<T>(\n  graphId: string,\n  issue: () => Promise<T>,\n): Promise<T> {\n  try {\n    return await issue();\n  } catch (error) {\n    if (!isMissingTableError(error)) throw error;\n    throw new ConfigurationError(\n      \"Enforcing a declared edge cardinality needs the edge claim relation \" +\n        \"(typegraph_edge_claims), and this database does not have it. \" +\n        \"Databases initialized before this relation existed were never sent \" +\n        \"its CREATE TABLE, because the bootstrap DDL runs only on first boot.\",\n      { code: \"EDGE_CLAIM_RELATION_MISSING\", graphId },\n      {\n        cause: error,\n        suggestion:\n          \"Run the generated migration SQL (generatePostgresMigrationSQL / \" +\n          \"generateSqliteMigrationSQL) against this database, or declare the \" +\n          'edge kind `cardinality: \"many\"` and enforce the limit in ' +\n          \"application code.\",\n      },\n    );\n  }\n}\n\n/** The backend an edge claim is written to — the object inside the transaction. */\ntype ClaimTargetBackend = GraphBackend | TransactionBackend;\n\n/**\n * Issues ONE edge cardinality claim against the object the row write goes to,\n * refusing with the declared error when a live incumbent holds the axis.\n *\n * A backend that declares no claim support writes no claim and keeps exactly\n * the fence it has today (the per-graph write lock around the probe) — a\n * declared gap with a parity-matrix row, never a silent unfencing and never a\n * new refusal.\n */\nexport async function claimEdgeCardinality(\n  backend: ClaimTargetBackend,\n  claim: ClaimEdgeCardinalityParams,\n): Promise<void> {\n  const support = claimSupport(backend);\n  if (!support.supported) return;\n  const outcome = await withEdgeClaimRelationPrecondition(claim.graphId, () =>\n    support.claims.claimEdgeCardinality(claim),\n  );\n  if (outcome.status === \"refused\") throw edgeClaimRefusal(claim);\n}\n\n/**\n * Issues a batch's claims as ONE statement, entries sorted by\n * {@link compareClaimTargets}.\n *\n * One statement takes its row locks in a fixed order, so a batch cannot\n * deadlock against itself; sorting is what stops two writers of the same two\n * axes from taking them in opposite orders. In-batch duplicates are refused\n * before this by the batch validation wrapper's pending-cardinality state, so\n * the backend's duplicate-conflict-target guard stays a defensive invariant.\n */\nexport async function claimEdgeCardinalityBatch(\n  backend: ClaimTargetBackend,\n  claims: readonly ClaimEdgeCardinalityParams[],\n): Promise<void> {\n  if (claims.length === 0) return;\n  const support = claimSupport(backend);\n  if (!support.supported) return;\n  const ordered = claims\n    .map((claim) => ({ claim, target: edgeCardinalityClaimTarget(claim) }))\n    .toSorted((left, right) => compareClaimTargets(left.target, right.target));\n  const graphId = ordered[0]?.claim.graphId ?? \"\";\n  const outcomes = await withEdgeClaimRelationPrecondition(graphId, () =>\n    support.claims.claimEdgeCardinalityBatch(\n      ordered.map((entry) => entry.claim),\n    ),\n  );\n  for (const [index, outcome] of outcomes.entries()) {\n    const entry = ordered[index];\n    if (entry !== undefined && outcome.status === \"refused\") {\n      throw edgeClaimRefusal(entry.claim);\n    }\n  }\n}\n\n/**\n * Housekeeping: drops the claim rows named edges held.\n *\n * Never a fence and never load-bearing — a claim whose holder is gone already\n * fails the takeover statement's liveness predicate, so the axis is reusable\n * whether or not this ran. It exists so a hard delete does not leave a row\n * behind forever. A backend without claim support has nothing to purge.\n */\nexport async function purgeEdgeClaims(\n  backend: ClaimTargetBackend,\n  graphId: string,\n  edgeIds: readonly string[],\n): Promise<void> {\n  if (edgeIds.length === 0) return;\n  const support = claimSupport(backend);\n  if (!support.supported) return;\n  await withEdgeClaimRelationPrecondition(graphId, () =>\n    support.claims.purgeEdgeClaims({ graphId, edgeIds }),\n  );\n}\n"]}

package/dist/{chunk-ZLONH2UD.js → chunk-YDEJQWOL.js}

@@ -757,5 +757,5 @@ function getErrorSuggestion(error) {
 }
 
 export { BackendDisposedError, CardinalityError, CompilerInvariantError, ConfigurationError, ContributionRebuildUnsupportedError, ContributionUnavailableError, DatabaseOperationError, DisjointError, EDGE_IDENTITY_MISMATCH_CODE, ENTITY_ALREADY_EXISTS_CODE, EagerMaterializationError, EdgeNotFoundError, EmbeddingDimensionChangedError, EndpointError, EndpointNotFoundError, ExportStreamCancelledError, ExportStreamIdleTimeoutError, GraphAlgorithmConvergenceError, IMMUTABLE_VALIDITY_LOWER_BOUND_CODE, INVERTED_VALIDITY_WINDOW_CODE, IdentityContradictionError, IdentityEndpointValidityError, IdentitySeparationViolationError, IdentityValidityWindowError, InvalidEdgeWeightError, KindNotFoundError, MIGRATION_FAILURE_REASONS, MigrationError, NodeConstraintNotFoundError, NodeIndexNotFoundError, NodeNotFoundError, RECORDED_CAPTURE_GUARD_CODES, RestrictedDeleteError, SchemaContentConflictError, SchemaMismatchError, StaleVersionError, StoreNotInitializedError, TransactionClosedError, TrustedImportError, TypeGraphError, UniquenessError, UnsupportedBackendCapabilityError, UnsupportedPredicateError, ValidationError, VersionConflictError, getErrorSuggestion, isConstraintError, isRecordedCaptureGuardError, isSystemError, isTypeGraphError, isUserRecoverable };
-//# sourceMappingURL=chunk-ZLONH2UD.js.map
-//# sourceMappingURL=chunk-ZLONH2UD.js.map
+//# sourceMappingURL=chunk-YDEJQWOL.js.map
+//# sourceMappingURL=chunk-YDEJQWOL.js.map

package/dist/chunk-YDEJQWOL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors/index.ts"],"names":[],"mappings":"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","file":"chunk-YDEJQWOL.js","sourcesContent":["/**\n * TypeGraph Error Hierarchy\n *\n * All errors extend TypeGraphError with:\n * - `code`: Machine-readable error code for programmatic handling\n * - `category`: Classification for error handling strategies\n * - `suggestion`: Optional recovery guidance for users\n * - `details`: Structured context about the error\n *\n * @example\n * ```typescript\n * try {\n *   await store.nodes.Person.create({ name: \"\" });\n * } catch (error) {\n *   if (isTypeGraphError(error)) {\n *     console.error(error.toUserMessage());\n *     if (isUserRecoverable(error)) {\n *       // Show to user for correction\n *     }\n *   }\n * }\n * ```\n */\n\nimport type { KindEntity } from \"../core/types\";\nimport type { SchemaDiff } from \"../schema/migration\";\n// Type-only import: `materialize-indexes.ts` value-imports\n// `ConfigurationError` from this file, but type-only imports are erased\n// at runtime so this back-edge does not create a value cycle.\nimport type { MaterializeIndexesResult } from \"../store/materialize-indexes\";\n\n// ============================================================\n// Types\n// ============================================================\n\n/**\n * Error category for programmatic handling.\n *\n * - `user`: Caused by invalid input or incorrect usage. Recoverable by fixing input.\n * - `constraint`: Business rule or schema constraint violation. Recoverable by changing data.\n * - `system`: Internal error or infrastructure issue. May require investigation or retry.\n */\nexport type ErrorCategory = \"user\" | \"constraint\" | \"system\";\n\n/**\n * Options for TypeGraphError constructor.\n */\nexport type TypeGraphErrorOptions = Readonly<{\n  /** Structured context about the error */\n  details?: Record<string, unknown>;\n  /** Error category for handling strategies */\n  category: ErrorCategory;\n  /** Recovery guidance for users */\n  suggestion?: string;\n  /** Underlying cause of the error */\n  cause?: unknown;\n}>;\n\nfunction formatCause(cause: unknown): string {\n  if (cause instanceof Error) {\n    return cause.stack ?? cause.message;\n  }\n  if (typeof cause === \"string\") {\n    return cause;\n  }\n  if (\n    typeof cause === \"number\" ||\n    typeof cause === \"boolean\" ||\n    typeof cause === \"bigint\"\n  ) {\n    return String(cause);\n  }\n  if (typeof cause === \"symbol\") {\n    return cause.description ?? \"Symbol\";\n  }\n  if (cause === undefined) {\n    return \"Unknown cause\";\n  }\n\n  try {\n    return JSON.stringify(cause);\n  } catch (error) {\n    return `Unserializable cause: ${\n      error instanceof Error ? error.message : \"Unknown error\"\n    }`;\n  }\n}\n\n// ============================================================\n// Base Error\n// ============================================================\n\n/**\n * Base error class for all TypeGraph errors.\n *\n * Provides structured error information for both programmatic handling\n * and user-friendly messages.\n */\nexport class TypeGraphError extends Error {\n  /** Machine-readable error code (e.g., \"VALIDATION_ERROR\") */\n  readonly code: string;\n\n  /** Error category for handling strategies */\n  readonly category: ErrorCategory;\n\n  /** Structured context about the error */\n  readonly details: Readonly<Record<string, unknown>>;\n\n  /** Recovery guidance for users */\n  readonly suggestion?: string;\n\n  constructor(message: string, code: string, options: TypeGraphErrorOptions) {\n    super(message, options.cause ? { cause: options.cause } : undefined);\n    this.name = \"TypeGraphError\";\n    this.code = code;\n    this.category = options.category;\n    this.details = Object.freeze(options.details ?? {});\n    if (options.suggestion !== undefined) {\n      this.suggestion = options.suggestion;\n    }\n  }\n\n  /**\n   * Returns a user-friendly error message with suggestion if available.\n   */\n  toUserMessage(): string {\n    if (this.suggestion) {\n      return `${this.message}\\n\\nSuggestion: ${this.suggestion}`;\n    }\n    return this.message;\n  }\n\n  /**\n   * Returns a detailed string representation for logging.\n   */\n  toLogString(): string {\n    const lines = [\n      `[${this.code}] ${this.message}`,\n      `  Category: ${this.category}`,\n    ];\n\n    if (this.suggestion) {\n      lines.push(`  Suggestion: ${this.suggestion}`);\n    }\n\n    const detailKeys = Object.keys(this.details);\n    if (detailKeys.length > 0) {\n      lines.push(`  Details: ${JSON.stringify(this.details)}`);\n    }\n\n    if (this.cause) {\n      lines.push(`  Cause: ${formatCause(this.cause)}`);\n    }\n\n    return lines.join(\"\\n\");\n  }\n}\n\n// ============================================================\n// Validation Errors (category: \"user\")\n// ============================================================\n\n/**\n * Validation issue from Zod or custom validation.\n */\nexport type ValidationIssue = Readonly<{\n  /** Path to the invalid field (e.g., \"address.city\") */\n  path: string;\n  /** Human-readable error message */\n  message: string;\n  /** Zod error code if from Zod validation */\n  code?: string;\n  /**\n   * The identity assertion the issue is about, carried structurally so\n   * consumers (e.g. interchange import error reporting) never have to parse\n   * the human-readable message for it.\n   */\n  assertionId?: string;\n}>;\n\n/**\n * The stable {@link ValidationIssue.code} every inverted-validity-window\n * refusal carries, so a caller can recognize that specific failure without\n * matching on the message. `ValidationError`'s own code is the family-wide\n * `VALIDATION_ERROR`, so the discriminator lives on the issue — mirroring the\n * identity-import window refusal (`IDENTITY_IMPORT_INVALID_WINDOW`).\n *\n * A write carrying it was refused because `validTo` precedes the row's\n * effective `validFrom`: the row would have stopped being true before it\n * started, observable at no `asOf` coordinate at all. Zero-width windows\n * (`validTo === validFrom`) are legal and never raise it.\n */\nexport const INVERTED_VALIDITY_WINDOW_CODE = \"INVERTED_VALIDITY_WINDOW\";\n\n/**\n * The stable {@link ValidationIssue.code} carried by a refusal to accept a\n * `validFrom` the write cannot apply: the target row is LIVE, and an in-place\n * update never rewrites a live row's lower bound — that bound is history.\n * `ValidationError`'s own code is the family-wide `VALIDATION_ERROR`, so the\n * discriminator lives on the issue — mirroring\n * {@link INVERTED_VALIDITY_WINDOW_CODE}.\n *\n * Only a bound naming a DIFFERENT instant than the row already stores raises it.\n * Restating the stored bound is legal and writes nothing new, and a resurrection\n * — which does rewrite `valid_from` — applies a stated bound rather than\n * refusing it.\n *\n * The message names both instants: the one stated and the one the row stores, so\n * the caller can restate the stored bound without a second read.\n */\nexport const IMMUTABLE_VALIDITY_LOWER_BOUND_CODE =\n  \"IMMUTABLE_VALIDITY_LOWER_BOUND\";\n\n/**\n * Stable {@link ValidationIssue.code} for an edge-id ownership mismatch.\n *\n * Edge ids are graph-global. A collection-scoped write therefore has to prove\n * that the stored row has the collection's kind and, when the caller supplies\n * endpoints, the same immutable endpoints. This refusal prevents a collection\n * from mutating another kind's row and prevents an upsert from silently\n * ignoring an attempted repoint.\n */\nexport const EDGE_IDENTITY_MISMATCH_CODE = \"EDGE_IDENTITY_MISMATCH\";\n\n/**\n * The stable {@link ValidationIssue.code} every \"this id is already taken\"\n * create refusal carries, whichever way the create found out: its own existence\n * probe, or the engine refusing the INSERT. `ValidationError`'s own code is the\n * family-wide `VALIDATION_ERROR`, so the discriminator lives on the issue —\n * mirroring {@link INVERTED_VALIDITY_WINDOW_CODE}.\n *\n * `details.entityType` says whether a node or an edge was refused and\n * `details.kind` names its kind. `details.id` names the taken id, and is absent\n * only when the refused statement inserted MORE THAN ONE row: the engine reports\n * that the statement collided without saying which row did.\n */\nexport const ENTITY_ALREADY_EXISTS_CODE = \"ENTITY_ALREADY_EXISTS\";\n\n/**\n * Details for ValidationError.\n */\nexport type ValidationErrorDetails = Readonly<{\n  /** Type of entity being validated */\n  entityType?: KindEntity;\n  /** Kind/type name of the entity */\n  kind?: string;\n  /** Operation being performed */\n  operation?: \"create\" | \"update\" | \"delete\" | \"hardDelete\";\n  /** Entity ID if updating */\n  id?: string;\n  /** Individual validation issues */\n  issues: readonly ValidationIssue[];\n}>;\n\n/**\n * Thrown when schema validation fails during node or edge operations.\n *\n * @example\n * ```typescript\n * try {\n *   await store.nodes.Person.create({ email: \"invalid\" });\n * } catch (error) {\n *   if (error instanceof ValidationError) {\n *     console.log(error.details.issues);\n *     // [{ path: \"email\", message: \"Invalid email\" }]\n *   }\n * }\n * ```\n */\nexport class ValidationError extends TypeGraphError {\n  declare readonly details: ValidationErrorDetails;\n\n  constructor(\n    message: string,\n    details: ValidationErrorDetails,\n    options?: { cause?: unknown; suggestion?: string },\n  ) {\n    const fieldList =\n      details.issues.length > 0 ?\n        details.issues.map((index) => index.path || \"(root)\").join(\", \")\n      : \"unknown\";\n\n    super(message, \"VALIDATION_ERROR\", {\n      details,\n      category: \"user\",\n      suggestion:\n        options?.suggestion ??\n        `Check the following fields: ${fieldList}. See error.details.issues for specific validation failures.`,\n      cause: options?.cause,\n    });\n    this.name = \"ValidationError\";\n  }\n}\n\n// ============================================================\n// Not Found Errors (category: \"user\")\n// ============================================================\n\n/**\n * Details for NodeNotFoundError.\n */\nexport type NodeNotFoundErrorDetails = Readonly<{\n  kind: string;\n  id: string;\n}>;\n\n/**\n * Thrown when a node is not found.\n *\n * @example\n * ```typescript\n * try {\n *   await store.nodes.Person.get(\"nonexistent-id\");\n * } catch (error) {\n *   if (error instanceof NodeNotFoundError) {\n *     console.log(error.details.kind, error.details.id);\n *   }\n * }\n * ```\n */\nexport class NodeNotFoundError extends TypeGraphError {\n  declare readonly details: NodeNotFoundErrorDetails;\n\n  constructor(kind: string, id: string, options?: { cause?: unknown }) {\n    super(`Node not found: ${kind}/${id}`, \"NODE_NOT_FOUND\", {\n      details: { kind, id },\n      category: \"user\",\n      suggestion: `Verify the node ID \"${id}\" exists and has not been deleted.`,\n      cause: options?.cause,\n    });\n    this.name = \"NodeNotFoundError\";\n  }\n}\n\n/**\n * Details for EdgeNotFoundError.\n */\nexport type EdgeNotFoundErrorDetails = Readonly<{\n  kind: string;\n  id: string;\n}>;\n\n/**\n * Thrown when an edge is not found.\n */\nexport class EdgeNotFoundError extends TypeGraphError {\n  declare readonly details: EdgeNotFoundErrorDetails;\n\n  constructor(kind: string, id: string, options?: { cause?: unknown }) {\n    super(`Edge not found: ${kind}/${id}`, \"EDGE_NOT_FOUND\", {\n      details: { kind, id },\n      category: \"user\",\n      suggestion: `Verify the edge ID \"${id}\" exists and has not been deleted.`,\n      cause: options?.cause,\n    });\n    this.name = \"EdgeNotFoundError\";\n  }\n}\n\n/**\n * Details for KindNotFoundError.\n */\nexport type KindNotFoundErrorDetails = Readonly<{\n  kindName: string;\n  entity: KindEntity;\n  graphId?: string;\n}>;\n\n/**\n * Thrown when an operation references a kind that isn't registered on\n * the graph — `getNodeCollectionOrThrow` against an unknown kind, a\n * `materializeIndexes({ kinds })` filter naming a missing kind, an\n * extension referencing an unresolved endpoint, search facade typos,\n * etc. Carries the offending `kindName` and `entity` plus the host\n * `graphId` so logs are unambiguous when multiple stores share a\n * process.\n */\nexport class KindNotFoundError extends TypeGraphError {\n  declare readonly details: KindNotFoundErrorDetails;\n  readonly kindName: string;\n  readonly entity: KindEntity;\n\n  constructor(\n    kindName: string,\n    entity: KindEntity,\n    options?: Readonly<{\n      graphId?: string;\n      suggestion?: string;\n      cause?: unknown;\n    }>,\n  ) {\n    const where =\n      options?.graphId === undefined ? \"\" : ` on graph \"${options.graphId}\"`;\n    super(\n      `${entity === \"node\" ? \"Node\" : \"Edge\"} kind \"${kindName}\" is not registered${where}.`,\n      \"KIND_NOT_FOUND\",\n      {\n        details: {\n          kindName,\n          entity,\n          ...(options?.graphId === undefined ?\n            {}\n          : { graphId: options.graphId }),\n        },\n        category: \"user\",\n        suggestion:\n          options?.suggestion ??\n          \"Compile-time kinds come from defineGraph; extension kinds appear after store.evolve() returns. Check store.introspect() for the registered set.\",\n        cause: options?.cause,\n      },\n    );\n    this.name = \"KindNotFoundError\";\n    this.kindName = kindName;\n    this.entity = entity;\n  }\n}\n\n/**\n * Details for NodeConstraintNotFoundError.\n */\nexport type NodeConstraintNotFoundErrorDetails = Readonly<{\n  constraintName: string;\n  kind: string;\n}>;\n\n/**\n * Thrown when a uniqueness constraint name is not found on a node kind.\n */\nexport class NodeConstraintNotFoundError extends TypeGraphError {\n  declare readonly details: NodeConstraintNotFoundErrorDetails;\n\n  constructor(\n    constraintName: string,\n    kind: string,\n    options?: { cause?: unknown },\n  ) {\n    super(\n      `Constraint not found: \"${constraintName}\" on node kind \"${kind}\"`,\n      \"CONSTRAINT_NOT_FOUND\",\n      {\n        details: { constraintName, kind },\n        category: \"user\",\n        suggestion: `Verify the constraint name \"${constraintName}\" is defined in the unique constraints for \"${kind}\".`,\n        cause: options?.cause,\n      },\n    );\n    this.name = \"NodeConstraintNotFoundError\";\n  }\n}\n\n/**\n * Details for NodeIndexNotFoundError.\n */\nexport type NodeIndexNotFoundErrorDetails = Readonly<{\n  indexName: string;\n  kind: string;\n}>;\n\n/**\n * Thrown when a declared node index name is not found on a node kind.\n */\nexport class NodeIndexNotFoundError extends TypeGraphError {\n  declare readonly details: NodeIndexNotFoundErrorDetails;\n\n  constructor(indexName: string, kind: string, options?: { cause?: unknown }) {\n    super(\n      `Index not found: \"${indexName}\" on node kind \"${kind}\"`,\n      \"INDEX_NOT_FOUND\",\n      {\n        details: { indexName, kind },\n        category: \"user\",\n        suggestion: `Verify the index name \"${indexName}\" is declared via defineNodeIndex for \"${kind}\" and passed to defineGraph({ indexes }).`,\n        cause: options?.cause,\n      },\n    );\n    this.name = \"NodeIndexNotFoundError\";\n  }\n}\n\n// ============================================================\n// Constraint Errors (category: \"constraint\")\n// ============================================================\n\n/**\n * Details for EndpointNotFoundError.\n */\nexport type EndpointNotFoundErrorDetails = Readonly<{\n  edgeKind: string;\n  endpoint: \"from\" | \"to\";\n  nodeKind: string;\n  nodeId: string;\n}>;\n\n/**\n * Thrown when edge endpoint node does not exist or is deleted.\n */\nexport class EndpointNotFoundError extends TypeGraphError {\n  declare readonly details: EndpointNotFoundErrorDetails;\n\n  constructor(\n    details: EndpointNotFoundErrorDetails,\n    options?: { cause?: unknown },\n  ) {\n    super(\n      `Endpoint node not found for edge \"${details.edgeKind}\": ${details.nodeKind}/${details.nodeId} (${details.endpoint})`,\n      \"ENDPOINT_NOT_FOUND\",\n      {\n        details,\n        category: \"constraint\",\n        suggestion: `Ensure the ${details.endpoint} node exists before creating the edge.`,\n        cause: options?.cause,\n      },\n    );\n    this.name = \"EndpointNotFoundError\";\n  }\n}\n\n/**\n * Details for EndpointError.\n */\nexport type EndpointErrorDetails = Readonly<{\n  edgeKind: string;\n  endpoint: \"from\" | \"to\";\n  actualKind: string;\n  expectedKinds: readonly string[];\n}>;\n\n/**\n * Thrown when edge endpoint has wrong node type.\n */\nexport class EndpointError extends TypeGraphError {\n  declare readonly details: EndpointErrorDetails;\n\n  constructor(details: EndpointErrorDetails, options?: { cause?: unknown }) {\n    const expected = details.expectedKinds.join(\" | \");\n    super(\n      `Invalid ${details.endpoint} endpoint for edge \"${details.edgeKind}\": got \"${details.actualKind}\", expected ${expected}`,\n      \"ENDPOINT_ERROR\",\n      {\n        details,\n        category: \"constraint\",\n        suggestion: `Use a node of type ${expected} as the ${details.endpoint} endpoint.`,\n        cause: options?.cause,\n      },\n    );\n    this.name = \"EndpointError\";\n  }\n}\n\n/**\n * Details for UniquenessError.\n */\nexport type UniquenessErrorDetails = Readonly<{\n  constraintName: string;\n  kind: string;\n  existingId: string;\n  newId: string;\n  fields: readonly string[];\n  /**\n   * The claim row's `node_kind` — the axis this violation was found at.\n   * Optional so a third-party backend implementing the documented \"throws\n   * `UniquenessError`\" contract keeps working unchanged; when a throw site\n   * omits it, a caller loses only the disambiguation this field exists for,\n   * never correctness of the refusal itself.\n   *\n   * `constraintName` alone cannot tell two disjoint pairs apart — every\n   * `disjointWith` pair shares the single reserved `DISJOINT_CONSTRAINT_NAME`\n   * — so `mapClaimRefusal` (`store/claims/node-claims.ts`) matches on this\n   * field together with `constraintName` and the key, which is exactly the\n   * claim row's primary key and therefore unambiguous.\n   */\n  axis?: string;\n}>;\n\n/**\n * Thrown when uniqueness constraint is violated.\n */\nexport class UniquenessError extends TypeGraphError {\n  declare readonly details: UniquenessErrorDetails;\n\n  constructor(details: UniquenessErrorDetails, options?: { cause?: unknown }) {\n    const fieldList = details.fields.join(\", \");\n    super(\n      `Uniqueness violation on \"${details.kind}\": constraint \"${details.constraintName}\" (fields: ${fieldList}) conflicts with existing node ${details.existingId}`,\n      \"UNIQUENESS_VIOLATION\",\n      {\n        details,\n        category: \"constraint\",\n        suggestion: `Change the values for fields [${fieldList}] to be unique, or update the existing node ${details.existingId} instead.`,\n        cause: options?.cause,\n      },\n    );\n    this.name = \"UniquenessError\";\n  }\n}\n\n/**\n * Details for CardinalityError.\n */\nexport type CardinalityErrorDetails = Readonly<{\n  edgeKind: string;\n  fromKind: string;\n  fromId: string;\n  cardinality: string;\n  existingCount: number;\n}>;\n\n/**\n * Thrown when cardinality constraint is violated.\n */\nexport class CardinalityError extends TypeGraphError {\n  declare readonly details: CardinalityErrorDetails;\n\n  constructor(details: CardinalityErrorDetails, options?: { cause?: unknown }) {\n    super(\n      `Cardinality violation: \"${details.edgeKind}\" from ${details.fromKind}/${details.fromId} allows \"${details.cardinality}\" but ${details.existingCount} edge(s) already exist`,\n      \"CARDINALITY_ERROR\",\n      {\n        details,\n        category: \"constraint\",\n        suggestion:\n          details.cardinality === \"one\" || details.cardinality === \"unique\" ?\n            `Delete the existing edge before creating a new one, or use cardinality \"many\".`\n          : `Check if the cardinality constraint \"${details.cardinality}\" is correct for your use case.`,\n        cause: options?.cause,\n      },\n    );\n    this.name = \"CardinalityError\";\n  }\n}\n\n/**\n * Details for DisjointError.\n */\nexport type DisjointErrorDetails = Readonly<{\n  nodeId: string;\n  attemptedKind: string;\n  conflictingKind: string;\n}>;\n\n/**\n * Thrown when disjointness constraint is violated.\n *\n * Disjoint types cannot share the same ID - a node cannot be both\n * a Person and an Organization if they are declared disjoint.\n */\nexport class DisjointError extends TypeGraphError {\n  declare readonly details: DisjointErrorDetails;\n\n  constructor(details: DisjointErrorDetails, options?: { cause?: unknown }) {\n    super(\n      `Disjoint constraint violation: cannot create ${details.attemptedKind} with ID \"${details.nodeId}\" - conflicts with existing ${details.conflictingKind}`,\n      \"DISJOINT_ERROR\",\n      {\n        details,\n        category: \"constraint\",\n        suggestion: `Use a different ID for the new ${details.attemptedKind} node, or delete the existing ${details.conflictingKind}/${details.nodeId} first.`,\n        cause: options?.cause,\n      },\n    );\n    this.name = \"DisjointError\";\n  }\n}\n\nexport type IdentityContradictionErrorDetails = Readonly<{\n  /**\n   * The identity write that could not stand. `merge` is the post-write\n   * affected-class assertion a graph merge runs inside its commit\n   * transaction, which names the whole merge rather than a single assertion\n   * because the contradiction is a property of the state the merge would\n   * leave behind.\n   */\n  operation: \"assertSame\" | \"assertDifferent\" | \"fold\" | \"import\" | \"merge\";\n  a: Readonly<{ kind: string; id: string }>;\n  b: Readonly<{ kind: string; id: string }>;\n  reason: \"different-assertion\" | \"same-class\" | \"disjoint-kinds\";\n  conflictingAssertionId?: string;\n  conflictingKinds?: readonly [string, string];\n}>;\n\n/** Thrown when an identity mutation would make the ledger contradictory. */\nexport class IdentityContradictionError extends TypeGraphError {\n  declare readonly details: IdentityContradictionErrorDetails;\n\n  constructor(\n    details: IdentityContradictionErrorDetails,\n    options?: Readonly<{ cause?: unknown }>,\n  ) {\n    super(\n      `Identity contradiction: ${details.a.kind}/${details.a.id} and ${details.b.kind}/${details.b.id} cannot satisfy ${details.operation}.`,\n      \"IDENTITY_CONTRADICTION\",\n      {\n        details,\n        category: \"constraint\",\n        suggestion:\n          \"Retract the conflicting identity assertion or correct the graph ontology before retrying.\",\n        cause: options?.cause,\n      },\n    );\n    this.name = \"IdentityContradictionError\";\n  }\n}\n\nexport type IdentityValidityWindowErrorDetails = Readonly<{\n  reason:\n    | \"future-valid-from\"\n    | \"future-valid-to\"\n    | \"inverted\"\n    | \"overlapping-open-window\";\n  validFrom: string;\n  validTo?: string;\n  operationInstant: string;\n}>;\n\n/** Thrown when an identity assertion validity window cannot be applied. */\nexport class IdentityValidityWindowError extends TypeGraphError {\n  declare readonly details: IdentityValidityWindowErrorDetails;\n\n  constructor(details: IdentityValidityWindowErrorDetails) {\n    const code =\n      details.reason === \"future-valid-from\" ? \"IDENTITY_VALIDITY_FUTURE_START\"\n      : details.reason === \"future-valid-to\" ? \"IDENTITY_VALIDITY_FUTURE_END\"\n      : details.reason === \"inverted\" ? \"IDENTITY_VALIDITY_INVERTED\"\n      : \"IDENTITY_VALIDITY_OPEN_WINDOW_CONFLICT\";\n    super(\n      `Identity assertion validity window cannot be applied: ${details.reason}.`,\n      code,\n      {\n        details,\n        category:\n          details.reason === \"overlapping-open-window\" ? \"constraint\" : \"user\",\n        suggestion:\n          details.reason === \"inverted\" ? \"Pass validFrom at or before validTo.\"\n          : details.reason === \"overlapping-open-window\" ?\n            \"Retract the existing open assertion before creating a different open validity window for the same relation and pair.\"\n          : \"Use a boundary at or before the current operation clock; future-scheduled identity transitions are not supported.\",\n      },\n    );\n    this.name = \"IdentityValidityWindowError\";\n  }\n}\n\nexport type IdentityEndpointValidityErrorDetails = Readonly<{\n  endpoint: Readonly<{ kind: string; id: string }>;\n  assertionWindow: Readonly<{ validFrom: string; validTo?: string }>;\n  endpointWindow: Readonly<{\n    validFrom?: string;\n    validTo?: string;\n    deletedAt?: string;\n  }>;\n}>;\n\n/** Thrown when an identity endpoint does not exist throughout the assertion window. */\nexport class IdentityEndpointValidityError extends TypeGraphError {\n  declare readonly details: IdentityEndpointValidityErrorDetails;\n\n  constructor(details: IdentityEndpointValidityErrorDetails) {\n    super(\n      `Identity endpoint ${details.endpoint.kind}/${details.endpoint.id} does not exist throughout the requested assertion validity window.`,\n      \"IDENTITY_ENDPOINT_VALIDITY\",\n      {\n        details,\n        category: \"constraint\",\n        suggestion:\n          \"Choose an assertion window contained by both endpoint validity windows.\",\n      },\n    );\n    this.name = \"IdentityEndpointValidityError\";\n  }\n}\n\nexport type IdentitySeparationViolationErrorDetails = Readonly<{\n  graphId: string;\n  /**\n   * `\"database\"` when the CHECK constraint on the separation relation aborted\n   * the write — the backstop firing as designed. `\"writer\"` when the write was\n   * accepted, which means the relation was provisioned without its constraint\n   * and only the writer's own re-check caught the contradiction.\n   */\n  enforcedBy: \"database\" | \"writer\";\n  /** The single class key both endpoints collapsed onto. */\n  classKey: string;\n  /** The `different` assertion whose endpoints landed in one class. */\n  assertionId: string;\n  a: Readonly<{ kind: string; id: string }>;\n  b: Readonly<{ kind: string; id: string }>;\n}>;\n\n/**\n * Thrown when the derived separation relation refuses a write that would place\n * both endpoints of a current `different` assertion in one identity class.\n *\n * This is the database-level backstop beneath the plan-time simulation and the\n * applier's validation. Reaching it means an earlier layer let a contradiction\n * through: the transaction is aborted rather than committed, but the layer that\n * should have refused it typed and early is worth investigating.\n */\nexport class IdentitySeparationViolationError extends TypeGraphError {\n  declare readonly details: IdentitySeparationViolationErrorDetails;\n\n  constructor(\n    details: IdentitySeparationViolationErrorDetails,\n    options?: Readonly<{ cause?: unknown }>,\n  ) {\n    super(\n      `Identity separation violated: ${details.a.kind}/${details.a.id} and ${details.b.kind}/${details.b.id} are held apart by assertion ${details.assertionId}, but this write would put both in identity class ${details.classKey}.`,\n      \"IDENTITY_SEPARATION_VIOLATION\",\n      {\n        details,\n        category: \"constraint\",\n        suggestion:\n          \"Retract the conflicting different assertion before merging these identity classes. If no application call requested this merge, the write reached the ledger through a path that skipped identity validation.\",\n        cause: options?.cause,\n      },\n    );\n    this.name = \"IdentitySeparationViolationError\";\n  }\n}\n\n/**\n * Details for RestrictedDeleteError.\n */\nexport type RestrictedDeleteErrorDetails = Readonly<{\n  nodeKind: string;\n  nodeId: string;\n  edgeCount: number;\n  edgeKinds: readonly string[];\n}>;\n\n/**\n * Thrown when deletion is blocked due to existing edges (restrict behavior).\n */\nexport class RestrictedDeleteError extends TypeGraphError {\n  declare readonly details: RestrictedDeleteErrorDetails;\n\n  constructor(\n    details: RestrictedDeleteErrorDetails,\n    options?: { cause?: unknown },\n  ) {\n    const edgeList = details.edgeKinds.join(\", \");\n    super(\n      `Cannot delete ${details.nodeKind}/${details.nodeId}: ${details.edgeCount} connected edge(s) exist (${edgeList})`,\n      \"RESTRICTED_DELETE\",\n      {\n        details,\n        category: \"constraint\",\n        suggestion: `Delete the connected edges first, or change onDelete behavior to \"cascade\" (auto-delete edges) or \"disconnect\" (soft-delete edges).`,\n        cause: options?.cause,\n      },\n    );\n    this.name = \"RestrictedDeleteError\";\n  }\n}\n\n// ============================================================\n// Concurrency Errors (category: \"system\")\n// ============================================================\n\n/**\n * Details for VersionConflictError.\n */\nexport type VersionConflictErrorDetails = Readonly<{\n  kind: string;\n  id: string;\n  expectedVersion: number;\n  actualVersion: number;\n}>;\n\n/**\n * Thrown when optimistic locking detects a concurrent modification.\n *\n * This occurs when two operations try to update the same entity simultaneously.\n * The operation with the stale version fails.\n */\nexport class VersionConflictError extends TypeGraphError {\n  declare readonly details: VersionConflictErrorDetails;\n\n  constructor(\n    details: VersionConflictErrorDetails,\n    options?: { cause?: unknown },\n  ) {\n    super(\n      `Version conflict on ${details.kind}/${details.id}: expected version ${details.expectedVersion}, found ${details.actualVersion}`,\n      \"VERSION_CONFLICT\",\n      {\n        details,\n        category: \"system\",\n        suggestion: `Fetch the latest version of the entity and retry the operation. This error indicates concurrent modification.`,\n        cause: options?.cause,\n      },\n    );\n    this.name = \"VersionConflictError\";\n  }\n}\n\n// ============================================================\n// Schema Errors (category: \"system\")\n// ============================================================\n\n/**\n * Details for SchemaMismatchError.\n */\nexport type SchemaMismatchErrorDetails = Readonly<{\n  graphId: string;\n  expectedHash: string;\n  actualHash: string;\n}>;\n\n/**\n * Thrown when the schema in code doesn't match the schema in the database.\n */\nexport class SchemaMismatchError extends TypeGraphError {\n  declare readonly details: SchemaMismatchErrorDetails;\n\n  constructor(\n    details: SchemaMismatchErrorDetails,\n    options?: { cause?: unknown },\n  ) {\n    super(\n      `Schema mismatch for graph \"${details.graphId}\": code schema differs from database schema`,\n      \"SCHEMA_MISMATCH\",\n      {\n        details,\n        category: \"system\",\n        suggestion: `Run schema migration to update the database, or use createStoreWithSchema() for automatic migration.`,\n        cause: options?.cause,\n      },\n    );\n    this.name = \"SchemaMismatchError\";\n  }\n}\n\n/**\n * Details for MigrationError.\n */\n/**\n * Why a migration operation failed. A stable discriminant so callers can\n * branch on the outcome instead of matching the message text, which is free\n * to be reworded in any release.\n */\nexport const MIGRATION_FAILURE_REASONS = [\n  /**\n   * The persisted schema is behind the code graph. Raised on the\n   * least-privilege runtime path, which cannot run DDL — a privileged\n   * migrator must advance the schema first. Inspect `details.diff`\n   * (`hasBreakingChanges`) to tell an additive change from an incompatible\n   * one.\n   */\n  \"schema-behind\",\n  /** Breaking changes were detected while `throwOnBreaking` was set. */\n  \"breaking-change\",\n  /** No active schema version exists for the graph. */\n  \"no-active-version\",\n  /** The requested schema version does not exist for the graph. */\n  \"version-not-found\",\n  /**\n   * The schema about to be committed drops node or edge kinds that still\n   * hold rows. Committing would make those rows unreachable, and the next\n   * `materializeRemovals()` — which re-derives removals from schema history —\n   * would delete them. Inspect `details.droppedKinds` for the names. Use\n   * `Store.removeKinds()`, the removal path that queues cleanup explicitly,\n   * or pass `discardDroppedKindRows` to `migrateSchema` if losing the rows is\n   * the intent.\n   */\n  \"kind-removal\",\n] as const;\n\nexport type MigrationFailureReason = (typeof MIGRATION_FAILURE_REASONS)[number];\n\n/**\n * Structured context for a {@link MigrationError}, discriminated on `reason`.\n *\n * Modelled as a union rather than one shape with optional fields so the\n * payload a reason promises is the payload it must carry: narrowing on\n * `reason === \"kind-removal\"` gives you a non-optional `droppedKinds`, and the\n * constructor cannot be handed a `kind-removal` without one.\n *\n * The common fields are repeated per member rather than factored into a shared\n * base alias, which would be a hoisted-unexported symbol on the public\n * entrypoint.\n */\nexport type MigrationErrorDetails =\n  | Readonly<{\n      graphId: string;\n      fromVersion: number;\n      toVersion: number;\n      /** Stable discriminant — branch on this, not the message. */\n      reason: \"schema-behind\" | \"breaking-change\";\n      /**\n       * The structured diff behind the failure. Carries per-change `severity`\n       * alongside `hasChanges` / `hasBreakingChanges`, so a caller can decide\n       * \"additive → proceed, incompatible → ask the user\" without re-querying.\n       */\n      diff?: SchemaDiff;\n    }>\n  | Readonly<{\n      graphId: string;\n      fromVersion: number;\n      toVersion: number;\n      reason: \"no-active-version\" | \"version-not-found\";\n    }>\n  | Readonly<{\n      graphId: string;\n      fromVersion: number;\n      toVersion: number;\n      reason: \"kind-removal\";\n      /**\n       * The dropped kinds that still held rows, and so caused the refusal. A\n       * kind the commit drops but that is already empty is permitted and does\n       * NOT appear here. Both lists are sorted; at least one is non-empty.\n       */\n      droppedKinds: Readonly<{\n        nodes: readonly string[];\n        edges: readonly string[];\n      }>;\n    }>;\n\n/**\n * Thrown when schema migration fails.\n */\nexport class MigrationError extends TypeGraphError {\n  declare readonly details: MigrationErrorDetails;\n\n  constructor(\n    message: string,\n    details: MigrationErrorDetails,\n    options?: { cause?: unknown },\n  ) {\n    super(message, \"MIGRATION_ERROR\", {\n      details,\n      category: \"system\",\n      suggestion: `Review the schema changes and ensure they are backwards compatible, or implement a data migration.`,\n      cause: options?.cause,\n    });\n    this.name = \"MigrationError\";\n  }\n}\n\n/**\n * Details for EagerMaterializationError.\n */\nexport type EagerMaterializationErrorDetails = Readonly<{\n  graphId: string;\n  failedIndexNames: readonly string[];\n}>;\n\n/**\n * Thrown by `Store.evolve(extension, { eager })` when the schema\n * commit succeeded but the follow-on `materializeIndexes()` produced\n * one or more failed entries.\n *\n * Recovery: the schema commit is NOT rolled back. The new `Store` is\n * fully constructed and (when `options.ref` was supplied) `ref.current`\n * already points to it — the caller can read the new store via the ref\n * and decide how to handle the failed indexes (retry, skip, alert).\n * The full `MaterializeIndexesResult` is attached as `.materialization`.\n *\n * @example\n * ```ts\n * const ref = { current: store };\n * try {\n *   await store.evolve(extension, { ref, eager: {} });\n * } catch (error) {\n *   if (error instanceof EagerMaterializationError) {\n *     // schema is committed; ref.current is the new store\n *     log.warn(\n *       { failed: error.failedIndexNames },\n *       \"indexes did not materialize; will retry\",\n *     );\n *     await ref.current.materializeIndexes();\n *   } else {\n *     throw error;\n *   }\n * }\n * ```\n */\nexport class EagerMaterializationError extends TypeGraphError {\n  declare readonly details: EagerMaterializationErrorDetails;\n\n  /**\n   * The full materialization result, including successful and failed\n   * entries. Same shape as `Store.materializeIndexes()` returns.\n   */\n  readonly materialization: MaterializeIndexesResult;\n\n  constructor(materialization: MaterializeIndexesResult, graphId: string) {\n    const names = collectFailedIndexNames(materialization);\n    super(\n      `Eager materialization failed for ${names.length} index(es) on graph \"${graphId}\": ${names.join(\", \")}. The schema commit succeeded; the new Store is available via the ref handle (when supplied) and the failed indexes can be retried via store.materializeIndexes().`,\n      \"EAGER_MATERIALIZATION_FAILED\",\n      {\n        details: { graphId, failedIndexNames: names },\n        category: \"system\",\n        suggestion: `Inspect error.materialization for per-index errors. Each failure preserves any prior successful materialization timestamp; the schema is committed regardless.`,\n      },\n    );\n    this.name = \"EagerMaterializationError\";\n    this.materialization = materialization;\n  }\n\n  /**\n   * Names of just the indexes that failed — derived from\n   * `materialization.results` so the two views can never disagree.\n   */\n  get failedIndexNames(): readonly string[] {\n    return collectFailedIndexNames(this.materialization);\n  }\n}\n\nfunction collectFailedIndexNames(\n  materialization: MaterializeIndexesResult,\n): readonly string[] {\n  const names: string[] = [];\n  for (const entry of materialization.results) {\n    if (entry.status === \"failed\") names.push(entry.indexName);\n  }\n  return names;\n}\n\n/**\n * Details for StaleVersionError. `actual` is the active version the rejecting\n * read observed, and is `0` only when the graph genuinely has no active version\n * (an initial-commit race where another writer initialized first, or a graph\n * whose schema rows were removed out of band). A concurrent advance always\n * reports the newly active version, so `0` is a reliable signal of absence\n * rather than of contention.\n */\nexport type StaleVersionErrorDetails = Readonly<{\n  graphId: string;\n  expected: number;\n  actual: number;\n}>;\n\n/**\n * Thrown by `commitSchemaVersion`, `setActiveVersion`, and the schema write\n * fence a schema-managed Store write takes, when the caller's view of the\n * active schema version is out of date — another writer has already advanced\n * it.\n *\n * Recovery: re-read the active version with `getActiveSchema(graphId)`,\n * recompute against the new baseline, and retry. This is a routine\n * concurrency signal, not a bug.\n */\nexport class StaleVersionError extends TypeGraphError {\n  declare readonly details: StaleVersionErrorDetails;\n\n  constructor(\n    details: StaleVersionErrorDetails,\n    options?: { cause?: unknown },\n  ) {\n    super(\n      `Schema version was advanced by another writer for graph \"${details.graphId}\": expected active version ${details.expected}, actual is ${details.actual}`,\n      \"STALE_SCHEMA_VERSION\",\n      {\n        details,\n        category: \"system\",\n        suggestion: `Re-read the active schema version, recompute the new version against that baseline, and retry the commit.`,\n        cause: options?.cause,\n      },\n    );\n    this.name = \"StaleVersionError\";\n  }\n}\n\n/**\n * Details for SchemaContentConflictError.\n */\nexport type SchemaContentConflictErrorDetails = Readonly<{\n  graphId: string;\n  version: number;\n  existingHash: string;\n  incomingHash: string;\n}>;\n\n/**\n * Thrown by `commitSchemaVersion` when a row already exists at the\n * target version with a *different* schema hash — i.e. two writers\n * committed materially different schemas at the same version number.\n *\n * Distinct from `StaleVersionError`: this is not a refetch-and-retry\n * situation, it's a content disagreement that needs operator\n * intervention. Typically caused by inconsistent application\n * deployments writing schemas that hash differently.\n */\nexport class SchemaContentConflictError extends TypeGraphError {\n  declare readonly details: SchemaContentConflictErrorDetails;\n\n  constructor(\n    details: SchemaContentConflictErrorDetails,\n    options?: { cause?: unknown },\n  ) {\n    super(\n      `Schema content conflict for graph \"${details.graphId}\" at version ${details.version}: existing hash ${details.existingHash} differs from incoming hash ${details.incomingHash}`,\n      \"SCHEMA_CONTENT_CONFLICT\",\n      {\n        details,\n        category: \"system\",\n        suggestion: `Two writers committed different schemas at the same version. Reconcile the application deployments so they produce the same canonical schema, then retry.`,\n        cause: options?.cause,\n      },\n    );\n    this.name = \"SchemaContentConflictError\";\n  }\n}\n\n// ============================================================\n// Configuration Errors (category: \"user\")\n// ============================================================\n\n/**\n * Thrown when graph configuration is invalid.\n *\n * This includes invalid schema definitions, ontology conflicts,\n * and other configuration issues detected at graph creation time.\n */\nexport class ConfigurationError extends TypeGraphError {\n  constructor(\n    message: string,\n    details: Record<string, unknown> = {},\n    options?: { cause?: unknown; suggestion?: string },\n  ) {\n    super(message, \"CONFIGURATION_ERROR\", {\n      details,\n      category: \"user\",\n      suggestion:\n        options?.suggestion ?? `Review your graph definition for errors.`,\n      cause: options?.cause,\n    });\n    this.name = \"ConfigurationError\";\n  }\n}\n\n/**\n * Why a destructive contribution rebuild is refused.\n *\n * - `vector-source-unavailable` — the projection is vector storage.\n *   TypeGraph stores caller-supplied embeddings and nothing else: the\n *   vectors exist only in the table a rebuild would drop, so there is no\n *   source to reconstruct them from. Dropping anyway would silently\n *   destroy the embeddings and hand back storage that looks healthy and\n *   returns nothing. `store.reembedVectorField(kind, fieldPath, {\n *   embed })` is the sanctioned destructive path — it takes the callback\n *   that can regenerate what the drop destroys.\n * - `no-drop-ddl` — the active strategy declares no `dropDdl` for the\n *   contribution, so TypeGraph does not know how to tear its storage\n *   down. Synthesizing a `DROP TABLE` from the resolved name would\n *   guess at a teardown the strategy never sanctioned.\n * - `no-schema-fence` — the backend exposes no transactional schema\n *   fence (`schemaWriteTransaction`), so the drop, recreate, refill, and\n *   stamp could not be made atomic. Running them unfenced could leave\n *   storage attested but empty, or a concurrent schema writer\n *   interleaved with the drop.\n * - `shared-storage-in-use` — the contribution's recorded shape is stale,\n *   so only recreating its storage repairs it, but that storage is one\n *   table holding other graphs' rows as well. Their content is derived\n *   from their own nodes through their own schemas, so this process cannot\n *   put it back. A rebuild that dropped anyway would leave every other\n *   graph's search silently empty; one that re-stamped this graph's marker\n *   without the drop would bless a physical shape nothing verified.\n */\nexport type ContributionRebuildRefusal =\n  | \"vector-source-unavailable\"\n  | \"no-drop-ddl\"\n  | \"no-schema-fence\"\n  | \"shared-storage-in-use\";\n\nconst CONTRIBUTION_REBUILD_REFUSAL_MESSAGE: Readonly<\n  Record<ContributionRebuildRefusal, string>\n> = {\n  \"vector-source-unavailable\":\n    \"Vector contributions cannot be rebuilt: TypeGraph stores the vectors \" +\n    \"callers supply and never the inputs that produced them, so the \" +\n    \"embeddings exist only in the storage a rebuild would drop.\",\n  \"no-drop-ddl\":\n    \"The active strategy declares no teardown DDL for this contribution, so \" +\n    \"its storage cannot be dropped and recreated.\",\n  \"no-schema-fence\":\n    \"This backend exposes no transactional schema fence, so a rebuild's \" +\n    \"drop, recreate, refill, and marker stamp cannot be made atomic.\",\n  \"shared-storage-in-use\":\n    \"This contribution's storage is provisioned at a different shape than \" +\n    \"the current declaration, and the only repair — recreating it — would \" +\n    \"destroy fulltext content belonging to other graphs that share the same \" +\n    \"table and can only be rebuilt from their own processes.\",\n};\n\nconst CONTRIBUTION_REBUILD_REFUSAL_SUGGESTION: Readonly<\n  Record<ContributionRebuildRefusal, string>\n> = {\n  \"vector-source-unavailable\":\n    \"Run store.reembedVectorField(kind, fieldPath, { embed }) instead: it \" +\n    \"recreates the field's storage and takes the callback that regenerates \" +\n    \"the embeddings the recreate discards.\",\n  \"no-drop-ddl\":\n    \"Declare dropDdl on the contribution returned from the strategy's \" +\n    \"ownedTables(), or drop and recreate the table out of band and then run \" +\n    \"store.repairContributions() to re-stamp its marker.\",\n  \"no-schema-fence\":\n    \"Use a backend that implements schemaWriteTransaction, or perform the \" +\n    \"drop and recreate out of band during a maintenance window and then run \" +\n    \"store.repairContributions() followed by store.search.rebuildFulltext().\",\n  \"shared-storage-in-use\":\n    \"Recreate the shared table during a maintenance window with every graph \" +\n    \"that uses it offline: drop it out of band, then run \" +\n    'store.rebuildContribution(\"fulltext\") once per graph on this database. ' +\n    \"Each run recreates the table from the current DDL and refills that \" +\n    \"graph's rows from its own nodes.\",\n};\n\n/**\n * Thrown when `store.rebuildContribution()` cannot honor a rebuild.\n *\n * A refusal, never a partial attempt: nothing has been dropped when this\n * throws. The point is that the alternative — proceeding — destroys data\n * that cannot be reconstructed, so the operation declines instead of\n * quietly doing less than its name promises.\n */\nexport class ContributionRebuildUnsupportedError extends TypeGraphError {\n  readonly reason: ContributionRebuildRefusal;\n\n  constructor(\n    reason: ContributionRebuildRefusal,\n    details: Readonly<Record<string, unknown>> = {},\n    options?: { cause?: unknown },\n  ) {\n    super(\n      CONTRIBUTION_REBUILD_REFUSAL_MESSAGE[reason],\n      \"CONTRIBUTION_REBUILD_UNSUPPORTED\",\n      {\n        details: { ...details, reason },\n        category: \"user\",\n        suggestion: CONTRIBUTION_REBUILD_REFUSAL_SUGGESTION[reason],\n        cause: options?.cause,\n      },\n    );\n    this.name = \"ContributionRebuildUnsupportedError\";\n    this.reason = reason;\n  }\n}\n\n/**\n * Thrown when an iterative graph algorithm exhausts its caller-visible round\n * budget before reaching its convergence predicate.\n */\nexport class GraphAlgorithmConvergenceError extends TypeGraphError {\n  constructor(\n    algorithm: string,\n    maxIterations: number,\n    options: Readonly<{ oscillating?: boolean }> = {},\n  ) {\n    const oscillating = options.oscillating === true;\n    super(\n      oscillating ?\n        `${algorithm} entered a periodic label oscillation and can never converge.`\n      : `${algorithm} did not converge within ${maxIterations} iterations.`,\n      \"GRAPH_ALGORITHM_CONVERGENCE_ERROR\",\n      {\n        details: {\n          algorithm,\n          maxIterations,\n          ...(oscillating ? { oscillating } : {}),\n        },\n        category: \"user\",\n        suggestion:\n          oscillating ?\n            'Pass onMaxIterations: \"return\" to accept the fixed-round labeling, or exclude the oscillating component from the selection.'\n          : \"Increase maxIterations or reduce the selected graph before retrying.\",\n      },\n    );\n    this.name = \"GraphAlgorithmConvergenceError\";\n  }\n}\n\n/** Stable reasons a weighted traversal can reject an edge's weight value. */\nexport type InvalidEdgeWeightReason =\n  \"missing\" | \"negative\" | \"non_numeric\" | \"out_of_range\";\n\n/** Details for InvalidEdgeWeightError. */\nexport type InvalidEdgeWeightErrorDetails = Readonly<{\n  /** Id of the first offending edge, in binary-collation order. */\n  edgeId: string;\n  /** Kind of the offending edge. */\n  edgeKind: string;\n  /** The audited weight property. */\n  property: string;\n  /** Why the weight was rejected. */\n  reason: InvalidEdgeWeightReason;\n  /** The offending value, when one was present and renderable. */\n  value?: string;\n}>;\n\nconst EDGE_WEIGHT_REASONS: Readonly<\n  Record<\n    InvalidEdgeWeightReason,\n    Readonly<{ message: string; suggestion: string }>\n  >\n> = {\n  missing: {\n    message: \"has no value for weight property\",\n    suggestion:\n      \"Set the property on every selected edge, or provide defaultWeight for edges without it.\",\n  },\n  negative: {\n    message: \"has a negative value for weight property\",\n    suggestion:\n      \"Weighted traversal requires non-negative weights; repair the edge data before retrying.\",\n  },\n  non_numeric: {\n    message: \"has a non-numeric value for weight property\",\n    suggestion:\n      \"Store the weight property as a JSON number on every selected edge before retrying.\",\n  },\n  out_of_range: {\n    message: \"has a value outside the supported range for weight property\",\n    suggestion:\n      \"Keep weight magnitudes within the range weightedShortestPath documents (large enough to be a normal IEEE 754 double, small enough that path sums cannot overflow).\",\n  },\n};\n\n/**\n * Thrown when a weighted graph algorithm finds an edge whose weight property\n * violates the weighted-traversal contract (missing without a default,\n * non-numeric, or negative). Raised before any traversal rounds run, so a\n * weighted call either observes a fully valid weight domain or fails fast.\n */\nexport class InvalidEdgeWeightError extends TypeGraphError {\n  declare readonly details: InvalidEdgeWeightErrorDetails;\n\n  constructor(details: InvalidEdgeWeightErrorDetails) {\n    super(\n      `Edge '${details.edgeId}' (kind '${details.edgeKind}') ${EDGE_WEIGHT_REASONS[details.reason].message} '${details.property}'${\n        details.value === undefined ? \"\" : ` (value: ${details.value})`\n      }.`,\n      \"INVALID_EDGE_WEIGHT\",\n      {\n        details: { ...details },\n        category: \"user\",\n        suggestion: EDGE_WEIGHT_REASONS[details.reason].suggestion,\n      },\n    );\n    this.name = \"InvalidEdgeWeightError\";\n  }\n}\n\n/** Thrown when an operation requires a backend capability it does not expose. */\nexport class UnsupportedBackendCapabilityError extends TypeGraphError {\n  constructor(\n    operation: string,\n    capability: string,\n    details: Readonly<Record<string, unknown>> = {},\n    suggestion?: string,\n  ) {\n    super(\n      `${operation} requires backend capability '${capability}'.`,\n      \"UNSUPPORTED_BACKEND_CAPABILITY\",\n      {\n        details: { operation, capability, ...details },\n        category: \"user\",\n        suggestion:\n          suggestion ??\n          \"Use a backend that advertises this capability before invoking the operation.\",\n      },\n    );\n    this.name = \"UnsupportedBackendCapabilityError\";\n  }\n}\n\n/** Stable reasons an intentionally trusted initial import can be rejected. */\nexport type TrustedImportErrorReason =\n  | \"backend_unsupported\"\n  | \"database_not_empty\"\n  | \"fulltext_unsupported\"\n  | \"history_unsupported\"\n  | \"identity_unsupported\"\n  | \"invalid_stream\"\n  | \"revision_tracking_unsupported\"\n  | \"uniqueness_unsupported\"\n  | \"vector_unsupported\";\n\n/** Thrown when the trusted initial-import contract is unavailable or violated. */\nexport class TrustedImportError extends TypeGraphError {\n  constructor(\n    message: string,\n    reason: TrustedImportErrorReason,\n    details: Readonly<Record<string, unknown>> = {},\n    options?: Readonly<{ cause?: unknown; suggestion?: string }>,\n  ) {\n    super(message, \"TRUSTED_IMPORT_ERROR\", {\n      details: { ...details, reason },\n      category: \"user\",\n      suggestion:\n        options?.suggestion ??\n        \"Use the validating bulk or interchange import APIs unless every trusted-import precondition is satisfied.\",\n      cause: options?.cause,\n    });\n    this.name = \"TrustedImportError\";\n  }\n}\n\n/**\n * Thrown to a graph export stream's consumer when the caller's `AbortSignal`\n * settled the stream instead of it reaching its end.\n *\n * Raised only after the export has given back everything it took, so receiving\n * it means the connection is already usable again. WHAT it took depends on the\n * backend: an export on one reporting `capabilities.transactions` holds a\n * repeatable-read snapshot (and, on a serialized connection, that connection's\n * stream lease), and both are settled before this is thrown; an export on a\n * backend without transactions holds neither, and its remaining reads are\n * simply abandoned — its already-delivered chunks were never one snapshot to\n * begin with. The message says which case applies. `cause` carries the signal's\n * own `reason` when the caller supplied one.\n */\nexport class ExportStreamCancelledError extends TypeGraphError {\n  constructor(\n    message: string,\n    details: Readonly<Record<string, unknown>> = {},\n    options?: Readonly<{ cause?: unknown; suggestion?: string }>,\n  ) {\n    super(message, \"INTERCHANGE_EXPORT_STREAM_ABORTED\", {\n      details,\n      category: \"user\",\n      suggestion:\n        options?.suggestion ??\n        \"Start a new export; the aborted one released its snapshot transaction and the connection it held.\",\n      cause: options?.cause,\n    });\n    this.name = \"ExportStreamCancelledError\";\n  }\n}\n\n/**\n * Thrown when an export stream's consumer leaves a delivered chunk\n * unacknowledged for longer than its configured idle timeout.\n *\n * The timeout measures consumer idleness only: it starts when a chunk is\n * yielded and stops when the consumer asks for the next one. Receiving this\n * error means the timed-out export has settled its snapshot transaction and\n * released any serialized connection lease it held. `details.idleTimeoutMs`\n * carries the configured bound.\n */\nexport class ExportStreamIdleTimeoutError extends TypeGraphError {\n  constructor(graphId: string, idleTimeoutMs: number, transactional: boolean) {\n    super(\n      transactional ?\n        `The graph export stream consumer did not request its next chunk within ${idleTimeoutMs}ms: its repeatable-read snapshot has been rolled back and the connection it held released.`\n      : `The graph export stream consumer did not request its next chunk within ${idleTimeoutMs}ms: its remaining reads were abandoned. This backend does not support transactions, so the export held no snapshot and no connection.`,\n      \"INTERCHANGE_EXPORT_STREAM_IDLE_TIMEOUT\",\n      {\n        details: { graphId, idleTimeoutMs },\n        category: \"user\",\n        suggestion:\n          transactional ?\n            \"Start a new export and consume each chunk within the configured idle timeout, increase idleTimeoutMs, or cancel explicitly with an AbortSignal.\"\n          : \"Start a new export and consume each chunk within the configured idle timeout, increase idleTimeoutMs, or cancel explicitly with an AbortSignal; discard the partial export unless mutually-inconsistent chunks are acceptable.\",\n      },\n    );\n    this.name = \"ExportStreamIdleTimeoutError\";\n  }\n}\n\n/**\n * The stable `details.code` values raised by the recorded-capture guards on a\n * history- or revision-tracked store. These are the sanctioned branch points\n * for a portable caller that must pick a transaction strategy without\n * substring-matching {@link ConfigurationError} messages.\n *\n * - `RECORDED_CAPTURE_REQUIRES_CALLBACK_TRANSACTION`: `store.withTransaction`\n *   was called on a history-enabled store, which has no flush point before the\n *   caller commits — use `store.withRecordedTransaction` instead.\n * - `RECORDED_CAPTURE_RAW_SQL_DISABLED`: a raw SQL escape (`tx.sql`,\n *   `backend.executeStatement`/`executeDdl`) was reached on a history-enabled\n *   store, where it would bypass recorded-time capture.\n * - `REVISION_TRACKING_RAW_SQL_DISABLED`: the same raw SQL escape on a\n *   revision-tracked store, where it would bypass the revision anchor.\n *\n * @see isRecordedCaptureGuardError\n */\nexport const RECORDED_CAPTURE_GUARD_CODES = [\n  \"RECORDED_CAPTURE_REQUIRES_CALLBACK_TRANSACTION\",\n  \"RECORDED_CAPTURE_RAW_SQL_DISABLED\",\n  \"REVISION_TRACKING_RAW_SQL_DISABLED\",\n] as const;\n\n/** A stable, branchable code raised by a recorded-capture guard. */\nexport type RecordedCaptureGuardCode =\n  (typeof RECORDED_CAPTURE_GUARD_CODES)[number];\n\n/**\n * A {@link ConfigurationError} narrowed to carry a {@link RecordedCaptureGuardCode}\n * in `details.code` — the shape {@link isRecordedCaptureGuardError} guarantees.\n * `C` narrows `details.code` to a single code when the guard was called with a\n * specific one; it defaults to the full union.\n */\nexport type RecordedCaptureGuardError<\n  C extends RecordedCaptureGuardCode = RecordedCaptureGuardCode,\n> = ConfigurationError & Readonly<{ details: Readonly<{ code: C }> }>;\n\nfunction isRecordedCaptureGuardCode(\n  value: unknown,\n): value is RecordedCaptureGuardCode {\n  // Widen the readonly tuple so `includes` accepts an `unknown` needle.\n  return (RECORDED_CAPTURE_GUARD_CODES as readonly unknown[]).includes(value);\n}\n\n/**\n * Type guard for the recorded-capture guard errors, so a portable caller can\n * branch on the invariant a store enforced instead of substring-matching the\n * message. Pass `code` to narrow to a single guard; omit it to match any.\n *\n * Distinguishes \"history capture forbids raw SQL here\" from \"this backend has\n * no transactions\" (the latter carries no guard code — see\n * `TransactionContext.sqlAvailability` for the capability discriminant).\n *\n * Passing `code` also narrows `details.code` to that literal on the guarded\n * branch, so a caller can read the payload without re-checking.\n *\n * @example\n * ```typescript\n * // `withTransaction` is a compile error on a history-enabled store, so widen\n * // to the base Store surface to reach the runtime guard this branches on.\n * const store: Store<typeof graph> = historyStore;\n * try {\n *   store.withTransaction(externalTx);\n * } catch (error) {\n *   if (\n *     isRecordedCaptureGuardError(\n *       error,\n *       \"RECORDED_CAPTURE_REQUIRES_CALLBACK_TRANSACTION\",\n *     )\n *   ) {\n *     // error.details.code is now the literal, not the union.\n *     await historyStore.withRecordedTransaction(externalTx, run);\n *   } else {\n *     throw error;\n *   }\n * }\n * ```\n */\nexport function isRecordedCaptureGuardError<C extends RecordedCaptureGuardCode>(\n  error: unknown,\n  code: C,\n): error is RecordedCaptureGuardError<C>;\nexport function isRecordedCaptureGuardError(\n  error: unknown,\n): error is RecordedCaptureGuardError;\nexport function isRecordedCaptureGuardError(\n  error: unknown,\n  code?: RecordedCaptureGuardCode,\n): error is RecordedCaptureGuardError {\n  if (!(error instanceof ConfigurationError)) return false;\n  const actual = error.details[\"code\"];\n  if (!isRecordedCaptureGuardCode(actual)) return false;\n  return code === undefined || actual === code;\n}\n\n/**\n * Why a store's strategy-owned storage is not usable on the current\n * connection. Drives the {@link StoreNotInitializedError} message and\n * is surfaced in `details.reason` for programmatic handling.\n *\n * - `missing`: no durable materialization marker exists — the database\n *   was never initialized for this graph's runtime contributions.\n * - `stale`: a marker exists but its recorded signature no longer\n *   matches the resolved contribution DDL (strategy swap or DDL drift).\n *   The hot path refuses rather than silently re-materializing.\n * - `failed`: the most recent boot-time materialization attempt\n *   recorded an error. Boot may retry; the hot path refuses.\n */\nexport type StoreNotInitializedReason = \"missing\" | \"stale\" | \"failed\";\n\nconst STORE_NOT_INITIALIZED_REASON_PHRASE: Readonly<\n  Record<StoreNotInitializedReason, string>\n> = {\n  missing: \"is not initialized\",\n  stale: \"is stale (recorded materialization signature no longer matches)\",\n  failed: \"failed its last initialization attempt\",\n};\n\n/**\n * Details for StoreNotInitializedError. `graphId`/`reason` are always\n * present; callers may merge additional context (e.g. `logicalName`) via\n * `options.details`.\n */\nexport type StoreNotInitializedErrorDetails = Readonly<{\n  graphId: string;\n  reason: StoreNotInitializedReason;\n}> &\n  Readonly<Record<string, unknown>>;\n\n/**\n * Thrown when a fulltext- or vector-dependent operation runs against a\n * connection whose strategy-owned storage has not been durably materialized.\n *\n * `createStore()` is a synchronous, zero-I/O attach: it never creates\n * tables, repairs DDL, or writes materialization markers. The durable\n * marker is written exclusively by the async boot path\n * (`createStoreWithSchema`). When a fulltext or embedding read/write — or\n * an adopted/business transaction — observes no valid marker, it refuses\n * loudly here instead of lazily emitting DDL on the hot path.\n */\nexport class StoreNotInitializedError extends TypeGraphError {\n  declare readonly details: StoreNotInitializedErrorDetails;\n\n  // `graphId`/`reason` are positional and required: both are\n  // load-bearing for the message and for programmatic handling via\n  // `details.reason`. Caller `details` merge underneath — spread first\n  // so `graphId`/`reason` win and can't be clobbered by an\n  // accidentally-colliding extra key.\n  constructor(\n    graphId: string,\n    reason: StoreNotInitializedReason,\n    options?: {\n      cause?: unknown;\n      details?: Readonly<Record<string, unknown>> &\n        Readonly<{ graphId?: never; reason?: never }>;\n    },\n  ) {\n    super(\n      `${storageLabelFromLogicalName(options?.details?.[\"logicalName\"])} for ` +\n        `graph \"${graphId}\" ${STORE_NOT_INITIALIZED_REASON_PHRASE[reason]}. ` +\n        storeNotInitializedAction(reason, options?.details?.[\"logicalName\"]),\n      \"STORE_NOT_INITIALIZED\",\n      {\n        details: { ...options?.details, graphId, reason },\n        category: \"user\",\n        suggestion:\n          isStaleVectorSlot(reason, options?.details?.[\"logicalName\"]) ?\n            \"The field's declared shape (e.g. its dimension) changed after \" +\n            \"its storage was provisioned. Run store.reembedVectorField(\" +\n            \"kind, fieldPath) to recreate the storage at the new shape and \" +\n            \"re-embed.\"\n          : \"Call createStoreWithSchema(graph, backend) once at application \" +\n            \"startup. createStore() attaches to an already-initialized \" +\n            \"database and does not materialize storage itself.\",\n        cause: options?.cause,\n      },\n    );\n    this.name = \"StoreNotInitializedError\";\n  }\n}\n\nconst VECTOR_LOGICAL_NAME_PREFIX = \"vector:\";\n\n/**\n * A stale VECTOR slot is its own failure mode: the storage exists but was\n * provisioned at a different shape (the declared dimension changed), and\n * the fix is `store.reembedVectorField`, not a re-run of\n * `createStoreWithSchema` (whose boot pass deliberately skips drifted\n * slots). Drives the action sentence and the suggestion.\n */\nfunction isStaleVectorSlot(\n  reason: StoreNotInitializedReason,\n  logicalName: unknown,\n): boolean {\n  return (\n    reason === \"stale\" &&\n    typeof logicalName === \"string\" &&\n    logicalName.startsWith(VECTOR_LOGICAL_NAME_PREFIX)\n  );\n}\n\n/** The actionable trailing sentence of the error message, per failure mode. */\nfunction storeNotInitializedAction(\n  reason: StoreNotInitializedReason,\n  logicalName: unknown,\n): string {\n  if (isStaleVectorSlot(reason, logicalName)) {\n    return (\n      `The declared shape changed after provisioning — run ` +\n      `store.reembedVectorField(kind, fieldPath) to recreate the storage ` +\n      `at the new shape.`\n    );\n  }\n  return (\n    `Run createStoreWithSchema(graph, backend) during application boot, ` +\n    `outside request handlers and adopted transactions, before using createStore().`\n  );\n}\n\n/** Details for a runtime contribution whose durable marker outlived storage. */\nexport type ContributionUnavailableErrorDetails = Readonly<{\n  graphId: string;\n  logicalName: \"fulltext\";\n  physicalName: string;\n  state: \"physical-storage-missing\";\n}>;\n\n/**\n * Thrown when a gated fulltext operation discovers that materialized storage\n * disappeared after its durable marker recorded successful initialization.\n */\nexport class ContributionUnavailableError extends TypeGraphError {\n  declare readonly details: ContributionUnavailableErrorDetails;\n\n  constructor(\n    graphId: string,\n    physicalName: string,\n    options?: Readonly<{ cause?: unknown }>,\n  ) {\n    const suggestion =\n      'Run store.rebuildContribution(\"fulltext\") to recreate the lost ' +\n      \"storage and repopulate it from the graph's nodes.\";\n    super(\n      `Fulltext storage \"${physicalName}\" for graph \"${graphId}\" ` +\n        `disappeared after initialization. ${suggestion}`,\n      \"CONTRIBUTION_UNAVAILABLE\",\n      {\n        details: {\n          graphId,\n          logicalName: \"fulltext\",\n          physicalName,\n          state: \"physical-storage-missing\",\n        },\n        category: \"user\",\n        suggestion,\n        cause: options?.cause,\n      },\n    );\n    this.name = \"ContributionUnavailableError\";\n  }\n}\n\n/**\n * Human label for the un-materialized storage, derived from the\n * contribution `logicalName`: fulltext keeps \"fulltext storage\"; a vector\n * slot (\"vector:&lt;kind&gt;.&lt;field&gt;\") reads as `vector storage\n * \"&lt;kind&gt;.&lt;field&gt;\"` so the message names the exact embedding\n * field. Falls back to a neutral phrase when no logical name is supplied.\n */\nfunction storageLabelFromLogicalName(logicalName: unknown): string {\n  if (typeof logicalName !== \"string\") return \"runtime storage\";\n  if (logicalName.startsWith(VECTOR_LOGICAL_NAME_PREFIX)) {\n    return `vector storage \"${logicalName.slice(VECTOR_LOGICAL_NAME_PREFIX.length)}\"`;\n  }\n  if (logicalName === \"fulltext\") return \"fulltext storage\";\n  return `\"${logicalName}\" storage`;\n}\n\n// ============================================================\n// Database Errors (category: \"system\")\n// ============================================================\n\n/**\n * Details for DatabaseOperationError.\n */\nexport type DatabaseOperationErrorDetails = Readonly<{\n  operation: string;\n  entity: string;\n  /**\n   * `\"duplicate_key\"` means the engine refused the write because the entity's\n   * identity is already taken — the shape a concurrent create of the same new id\n   * produces on an engine that does not serialize the two writers. It is a\n   * *classified* driver failure, so callers that own a better error for the\n   * condition (the create paths, which report it as \"already exists\") translate\n   * it rather than surfacing it.\n   */\n  reason?: \"no_row_returned\" | \"duplicate_key\";\n  /**\n   * The entities the failed statement tried to insert, carried structurally so a\n   * translating caller never has to parse the driver's message for them. One\n   * element for a single insert; for a batch, every row in the failing chunk —\n   * the engine reports the collision without saying which row lost.\n   */\n  attempted?: readonly Readonly<{ kind: string; id: string }>[];\n}>;\n\n/**\n * Thrown when a database operation fails unexpectedly.\n *\n * This indicates a system-level failure in the database backend,\n * not a user-recoverable error.\n */\nexport class DatabaseOperationError extends TypeGraphError {\n  declare readonly details: DatabaseOperationErrorDetails;\n\n  constructor(\n    message: string,\n    details: DatabaseOperationErrorDetails,\n    options?: { cause?: unknown },\n  ) {\n    super(message, \"DATABASE_OPERATION_ERROR\", {\n      details,\n      category: \"system\",\n      suggestion: `This is a system-level database error. Check the database connection and retry the operation. If the problem persists, investigate the underlying cause.`,\n      cause: options?.cause,\n    });\n    this.name = \"DatabaseOperationError\";\n  }\n}\n\n// ============================================================\n// Vector / Embedding Errors (category: \"user\")\n// ============================================================\n\n/**\n * Details for EmbeddingDimensionChangedError.\n */\nexport type EmbeddingDimensionChangedErrorDetails = Readonly<{\n  kind: string;\n  fieldPath: string;\n  declaredDimensions?: number;\n  storedDimensions?: number;\n}>;\n\n/**\n * Thrown when an embedding field's declared dimension no longer matches the\n * dimension of its materialized per-field storage — i.e. a field's\n * `embedding(N)` was changed to `embedding(M)`. The stored vectors are invalid\n * under the new dimension and cannot be converted, only recomputed, so this is\n * a deliberate app-driven migration: call\n * `store.reembedVectorField(kind, fieldPath, ...)` to recreate the storage at\n * the new dimension and re-embed existing rows.\n */\nexport class EmbeddingDimensionChangedError extends TypeGraphError {\n  declare readonly details: EmbeddingDimensionChangedErrorDetails;\n\n  constructor(\n    message: string,\n    details: EmbeddingDimensionChangedErrorDetails,\n    options?: { cause?: unknown },\n  ) {\n    super(message, \"EMBEDDING_DIMENSION_CHANGED\", {\n      details,\n      category: \"user\",\n      suggestion: `Run store.reembedVectorField(\"${details.kind}\", \"${details.fieldPath}\", { embed }) to recreate the field's storage at the new dimension and re-embed existing rows.`,\n      cause: options?.cause,\n    });\n    this.name = \"EmbeddingDimensionChangedError\";\n  }\n}\n\n// ============================================================\n// Query Errors (category: \"system\")\n// ============================================================\n\n/**\n * Thrown when a query predicate cannot be compiled for the target database.\n */\nexport class UnsupportedPredicateError extends TypeGraphError {\n  constructor(\n    message: string,\n    details: Readonly<Record<string, unknown>> = {},\n    options?: { cause?: unknown; suggestion?: string },\n  ) {\n    super(message, \"UNSUPPORTED_PREDICATE\", {\n      details,\n      category: \"system\",\n      suggestion:\n        options?.suggestion ??\n        `This predicate may not be supported by your database backend. Check the documentation for supported predicates.`,\n      cause: options?.cause,\n    });\n    this.name = \"UnsupportedPredicateError\";\n  }\n}\n\n// ============================================================\n// Compiler Errors (category: \"system\")\n// ============================================================\n\n/**\n * Thrown when a compiler invariant is violated.\n *\n * This indicates a bug in the query compiler — the compiler reached\n * a state that should be unreachable. These errors are not user-recoverable.\n */\nexport class CompilerInvariantError extends TypeGraphError {\n  constructor(\n    message: string,\n    details?: Readonly<Record<string, unknown>>,\n    options?: { cause?: unknown },\n  ) {\n    super(message, \"COMPILER_INVARIANT_ERROR\", {\n      details: details ?? {},\n      category: \"system\",\n      suggestion: `This is an internal compiler error. Please report it as a bug with the query that triggered it.`,\n      cause: options?.cause,\n    });\n    this.name = \"CompilerInvariantError\";\n  }\n}\n\n// ============================================================\n// Lifecycle Errors (category: \"system\")\n// ============================================================\n\n/**\n * Thrown when an operation is attempted on a backend that has been disposed.\n *\n * This typically occurs during runtime teardown — for example, when a\n * Cloudflare Workers test runner resets Durable Object storage while\n * the TypeGraph backend still has queued operations.\n */\nexport class BackendDisposedError extends TypeGraphError {\n  constructor(options?: { cause?: unknown }) {\n    super(\n      \"Backend has been disposed — the underlying database connection is no longer available\",\n      \"BACKEND_DISPOSED\",\n      {\n        category: \"system\",\n        suggestion:\n          \"Ensure all store operations complete before calling backend.close(). \" +\n          \"In test environments, await store teardown before resetting the database.\",\n        cause: options?.cause,\n      },\n    );\n    this.name = \"BackendDisposedError\";\n  }\n}\n\n/**\n * Thrown when a statement is issued on a transaction-scoped backend after\n * its transaction boundary has already returned.\n *\n * The usual source is a callback that lets work escape it. `Promise.all`\n * rejects on its first rejection while its siblings keep running, so\n *\n * ```typescript\n * await store.transaction(async (tx) => {\n *   await Promise.all([tx.nodes.Doc.create(a), tx.nodes.Doc.create(b)]);\n * });\n * ```\n *\n * leaves `b`'s remaining statements in flight when `a` fails. Those\n * statements have nowhere safe to go: the driver is about to emit `ROLLBACK`\n * on the same pinned connection and then hand it back to the pool, where a\n * late arrival would execute inside somebody else's transaction. TypeGraph\n * refuses them here instead.\n *\n * The error is normally invisible — `Promise.all` has already rejected with\n * the original failure, and discards this one.\n */\nexport class TransactionClosedError extends TypeGraphError {\n  constructor(options?: { cause?: unknown }) {\n    super(\n      \"Statement issued on a transaction-scoped backend after its transaction \" +\n        \"boundary returned. The connection has been released; the statement was not run.\",\n      \"TRANSACTION_CLOSED\",\n      {\n        category: \"user\",\n        suggestion:\n          \"Await every write started inside store.transaction(...) before the \" +\n          \"callback returns. Prefer awaiting a Promise.allSettled(...) over a \" +\n          \"Promise.all(...) whose rejection would orphan its siblings.\",\n        cause: options?.cause,\n      },\n    );\n    this.name = \"TransactionClosedError\";\n  }\n}\n\n// ============================================================\n// Utility Functions\n// ============================================================\n\n/**\n * Type guard for TypeGraphError.\n *\n * @example\n * ```typescript\n * try {\n *   await store.nodes.Person.create({});\n * } catch (error) {\n *   if (isTypeGraphError(error)) {\n *     console.log(error.code, error.category);\n *   }\n * }\n * ```\n */\nexport function isTypeGraphError(error: unknown): error is TypeGraphError {\n  return error instanceof TypeGraphError;\n}\n\n/**\n * Check if error is recoverable by user action (user or constraint error).\n *\n * User-recoverable errors can typically be resolved by:\n * - Fixing invalid input data\n * - Using different IDs or values\n * - Deleting conflicting data first\n *\n * @example\n * ```typescript\n * if (isUserRecoverable(error)) {\n *   showErrorToUser(error.toUserMessage());\n * } else {\n *   logAndAlertOps(error);\n * }\n * ```\n */\nexport function isUserRecoverable(error: unknown): boolean {\n  if (!isTypeGraphError(error)) return false;\n  return error.category === \"user\" || error.category === \"constraint\";\n}\n\n/**\n * Check if error indicates a system/infrastructure issue.\n *\n * System errors typically require:\n * - Retry logic (for transient failures)\n * - Investigation (for persistent failures)\n * - Ops team notification\n */\nexport function isSystemError(error: unknown): boolean {\n  return isTypeGraphError(error) && error.category === \"system\";\n}\n\n/**\n * Check if error is a constraint violation.\n */\nexport function isConstraintError(error: unknown): boolean {\n  return isTypeGraphError(error) && error.category === \"constraint\";\n}\n\n/**\n * Extract suggestion from error if available.\n */\nexport function getErrorSuggestion(error: unknown): string | undefined {\n  return isTypeGraphError(error) ? error.suggestion : undefined;\n}\n"]}

package/dist/{chunk-JONXFAPO.js → chunk-ZAQUKCUC.js}

@@ -1,6 +1,6 @@
-import { vectorPageClause } from './chunk-OVI7IXYX.js';
-import { vectorPhysicalName, quoteIdentifier, vectorScoreExpression, vectorMinScoreCondition, VECTOR_CONTRIBUTION_PREFIX, assertFiniteEmbedding } from './chunk-ZDKTPBGV.js';
-import { sql } from './chunk-3DMMGT6S.js';
+import { vectorPageClause } from './chunk-6S3PTHL4.js';
+import { vectorPhysicalName, quoteIdentifier, vectorScoreExpression, vectorMinScoreCondition, VECTOR_CONTRIBUTION_PREFIX, assertFiniteEmbedding } from './chunk-EDLKIQRI.js';
+import { sql } from './chunk-46UGOVRW.js';
 
 // src/query/dialect/vector/pgvector-strategy.ts
 var TABLE_PREFIX = "tg_vec";
@@ -288,5 +288,5 @@ function pgvectorIndexDdl(table, slot, concurrent) {
 }
 
 export { assertPgvectorEfSearch, pgvectorStrategy };
-//# sourceMappingURL=chunk-JONXFAPO.js.map
-//# sourceMappingURL=chunk-JONXFAPO.js.map
+//# sourceMappingURL=chunk-ZAQUKCUC.js.map
+//# sourceMappingURL=chunk-ZAQUKCUC.js.map