@nicia-ai/typegraph 0.46.2 → 0.48.0

package/dist/chunk-GVAMRRZR.cjs

@@ -1,268 +0,0 @@
-'use strict';
-
-var chunkKCH7WQA5_cjs = require('./chunk-KCH7WQA5.cjs');
-
-// src/utils/sql-errors.ts
-var SQLITE_MISSING_TABLE_PATTERN = "no such table";
-var SQLITE_GENERIC_ERROR_CODE = "SQLITE_ERROR";
-var SQLITE_NOT_AUTHORIZED_CODE = "SQLITE_AUTH";
-var SQLITE_STALE_SNAPSHOT_CODE = "SQLITE_BUSY_SNAPSHOT";
-var SQLITE_STALE_SNAPSHOT_EXTENDED_CODE = 517;
-var DRIZZLE_QUERY_ERROR_PREFIX = "Failed query:";
-var POSTGRES_UNDEFINED_RELATION_PATTERN = /\b(?:relation|table)\s+"[^"]+"\s+does not exist\b/i;
-var POSTGRES_UNDEFINED_TABLE_CODE = "42P01";
-var POSTGRES_UNIQUE_VIOLATION_CODE = "23505";
-var POSTGRES_CONCURRENT_DDL_RACE_SQL_STATES = [
-  POSTGRES_UNIQUE_VIOLATION_CODE,
-  "42701"
-];
-var POSTGRES_INTERNAL_ERROR_CODE = "XX000";
-var POSTGRES_CONCURRENT_TUPLE_UPDATE_MESSAGE = "tuple concurrently updated";
-var POSTGRES_TEMPORARY_TABLE_UNAVAILABLE_SQL_STATES = [
-  "25006",
-  "42501"
-];
-var POSTGRES_READ_WRITE_REFUSED_SQL_STATES = ["0A000", "25006"];
-function* errorChain(error) {
-  const seen = /* @__PURE__ */ new Set();
-  let current = error;
-  while (current !== void 0 && current !== null && !seen.has(current)) {
-    seen.add(current);
-    yield current;
-    current = canReadProperty(current) ? Reflect.get(current, "cause") : void 0;
-  }
-}
-function canReadProperty(value) {
-  return typeof value === "object" && value !== null || typeof value === "function";
-}
-function isPostgresUndefinedTable(link) {
-  return canReadProperty(link) && Reflect.get(link, "code") === POSTGRES_UNDEFINED_TABLE_CODE;
-}
-function messageProperty(link) {
-  if (typeof link === "string") return link;
-  if (link instanceof Error) return link.message;
-  const message = canReadProperty(link) ? Reflect.get(link, "message") : void 0;
-  return typeof message === "string" ? message : void 0;
-}
-function errorMessage(link) {
-  return messageProperty(link) ?? String(link);
-}
-function missingTableMessage(link) {
-  return typeof link === "string" || link instanceof Error ? messageProperty(link) : void 0;
-}
-function sqliteErrorCode(link) {
-  if (!canReadProperty(link)) return void 0;
-  return Reflect.get(link, "code");
-}
-function isBareSqliteErrorMarker(link) {
-  const message = messageProperty(link);
-  if (message === SQLITE_GENERIC_ERROR_CODE) return true;
-  if (sqliteErrorCode(link) !== SQLITE_GENERIC_ERROR_CODE) return false;
-  return message === void 0 || message === SQLITE_GENERIC_ERROR_CODE || message.includes(SQLITE_MISSING_TABLE_PATTERN);
-}
-function isPostgresUndefinedRelationMessage(link) {
-  const message = errorMessage(link);
-  if (message.startsWith(DRIZZLE_QUERY_ERROR_PREFIX)) return false;
-  return POSTGRES_UNDEFINED_RELATION_PATTERN.test(message);
-}
-function isInsufficientResourcesError(error) {
-  for (const link of errorChain(error)) {
-    if (!canReadProperty(link)) continue;
-    const code = Reflect.get(link, "code");
-    if (typeof code === "string" && code.length === 5 && code.startsWith("53"))
-      return true;
-  }
-  return false;
-}
-function isMissingTableError(error) {
-  let everyPriorLinkWasError = true;
-  for (const link of errorChain(error)) {
-    if (isPostgresUndefinedTable(link)) return true;
-    if (isPostgresUndefinedRelationMessage(link)) return true;
-    if (isBareSqliteErrorMarker(link)) return true;
-    if (everyPriorLinkWasError) {
-      const message = missingTableMessage(link);
-      if (message?.includes(SQLITE_MISSING_TABLE_PATTERN) === true) {
-        return true;
-      }
-    }
-    if (!(link instanceof Error)) everyPriorLinkWasError = false;
-  }
-  return false;
-}
-function isPostgresConcurrentTupleUpdate(link) {
-  if (!canReadProperty(link)) return false;
-  if (Reflect.get(link, "code") !== POSTGRES_INTERNAL_ERROR_CODE) return false;
-  return messageProperty(link)?.includes(
-    POSTGRES_CONCURRENT_TUPLE_UPDATE_MESSAGE
-  ) === true;
-}
-function isPostgresConcurrentDdlRaceError(error) {
-  for (const link of errorChain(error)) {
-    if (!canReadProperty(link)) continue;
-    if (isSqlStateIn(
-      Reflect.get(link, "code"),
-      POSTGRES_CONCURRENT_DDL_RACE_SQL_STATES
-    )) {
-      return true;
-    }
-    if (isPostgresConcurrentTupleUpdate(link)) return true;
-  }
-  return false;
-}
-var POSTGRES_CONSTRAINT_FIELDS = ["constraint", "constraint_name"];
-var POSTGRES_RELATION_FIELDS = ["table", "table_name"];
-var SQLITE_PRIMARY_KEY_VIOLATION_CODE = "SQLITE_CONSTRAINT_PRIMARYKEY";
-var SQLITE_PRIMARY_KEY_VIOLATION_EXTENDED_CODE = 1555;
-var SQLITE_EXTENDED_CODE_FIELDS = ["rawCode", "extendedCode"];
-function firstStringField(link, fields) {
-  for (const field of fields) {
-    const value = Reflect.get(link, field);
-    if (typeof value === "string") return value;
-  }
-  return void 0;
-}
-function isPostgresPrimaryKeyViolation(link, relation) {
-  if (Reflect.get(link, "code") !== POSTGRES_UNIQUE_VIOLATION_CODE)
-    return false;
-  if (firstStringField(link, POSTGRES_RELATION_FIELDS) !== relation.table) {
-    return false;
-  }
-  const constraint = firstStringField(link, POSTGRES_CONSTRAINT_FIELDS);
-  return constraint !== void 0 && relation.constraintNames.includes(constraint);
-}
-function isSqlitePrimaryKeyViolation(link) {
-  if (Reflect.get(link, "code") === SQLITE_PRIMARY_KEY_VIOLATION_CODE) {
-    return true;
-  }
-  for (const field of SQLITE_EXTENDED_CODE_FIELDS) {
-    const value = Reflect.get(link, field);
-    if (typeof value === "number" && value === SQLITE_PRIMARY_KEY_VIOLATION_EXTENDED_CODE) {
-      return true;
-    }
-  }
-  return false;
-}
-function isDuplicatePrimaryKeyError(error, relation) {
-  for (const link of errorChain(error)) {
-    if (!canReadProperty(link)) continue;
-    if (isPostgresPrimaryKeyViolation(link, relation)) return true;
-    if (isSqlitePrimaryKeyViolation(link)) return true;
-  }
-  return false;
-}
-function isSqlStateIn(code, states) {
-  const known = states;
-  return typeof code === "string" && known.includes(code);
-}
-function matchSqlState(error, states) {
-  for (const link of errorChain(error)) {
-    if (!canReadProperty(link)) continue;
-    const code = Reflect.get(link, "code");
-    if (isSqlStateIn(code, states)) return code;
-  }
-  return void 0;
-}
-function postgresTemporaryTableUnavailableSqlState(error) {
-  return matchSqlState(error, POSTGRES_TEMPORARY_TABLE_UNAVAILABLE_SQL_STATES);
-}
-function postgresReadWriteRefusedSqlState(error) {
-  return matchSqlState(error, POSTGRES_READ_WRITE_REFUSED_SQL_STATES);
-}
-function isSqliteNotAuthorizedError(error) {
-  for (const link of errorChain(error)) {
-    if (sqliteErrorCode(link) === SQLITE_NOT_AUTHORIZED_CODE) return true;
-    const message = messageProperty(link);
-    if (message?.includes(SQLITE_NOT_AUTHORIZED_CODE) === true && message.toLowerCase().includes("not authorized")) {
-      return true;
-    }
-  }
-  return false;
-}
-function isSqliteStaleSnapshotError(error) {
-  for (const link of errorChain(error)) {
-    if (sqliteErrorCode(link) === SQLITE_STALE_SNAPSHOT_CODE) return true;
-    if (!canReadProperty(link)) continue;
-    for (const field of SQLITE_EXTENDED_CODE_FIELDS) {
-      if (Reflect.get(link, field) === SQLITE_STALE_SNAPSHOT_EXTENDED_CODE) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function historyMissingRecordedRelationsError(details, cause) {
-  return new chunkKCH7WQA5_cjs.ConfigurationError(
-    "history: true requires the recorded-time relations to exist, but a recorded relation is missing.",
-    details,
-    {
-      cause,
-      suggestion: "Create the recorded-time relations (typegraph_recorded_nodes, typegraph_recorded_edges, typegraph_recorded_clock) \u2014 e.g. re-run the generated migration SQL \u2014 on this database before enabling history capture."
-    }
-  );
-}
-async function withRecordedRelationsPrecondition(promise, details) {
-  try {
-    return await promise;
-  } catch (error) {
-    if (!isMissingTableError(error)) throw error;
-    throw historyMissingRecordedRelationsError(
-      { ...details, code: "RECORDED_RELATIONS_MISSING" },
-      error
-    );
-  }
-}
-var DIMENSION_MISMATCH_PATTERN = /expected (\d+) dimensions(?:[,\s]+(?:not|got|but got|but)\s*(\d+))?/i;
-function parseDimensionMismatch(error) {
-  for (const link of errorChain(error)) {
-    const message = errorMessage(link);
-    const match = DIMENSION_MISMATCH_PATTERN.exec(message);
-    if (match) {
-      return {
-        expected: Number(match[1]),
-        actual: match[2] === void 0 ? void 0 : Number(match[2])
-      };
-    }
-  }
-  return void 0;
-}
-
-// src/utils/array.ts
-function chunk(items, size) {
-  if (!Number.isSafeInteger(size) || size < 1) {
-    throw new RangeError(`chunk size must be a positive integer, got: ${size}`);
-  }
-  if (items.length === 0) return [];
-  if (items.length <= size) return [items];
-  const chunks = [];
-  for (let start = 0; start < items.length; start += size) {
-    chunks.push(items.slice(start, start + size));
-  }
-  return chunks;
-}
-function groupBy(items, keyFor) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    const key = keyFor(item);
-    const group = groups.get(key) ?? [];
-    group.push(item);
-    groups.set(key, group);
-  }
-  return groups;
-}
-
-exports.chunk = chunk;
-exports.errorChain = errorChain;
-exports.groupBy = groupBy;
-exports.isDuplicatePrimaryKeyError = isDuplicatePrimaryKeyError;
-exports.isInsufficientResourcesError = isInsufficientResourcesError;
-exports.isMissingTableError = isMissingTableError;
-exports.isPostgresConcurrentDdlRaceError = isPostgresConcurrentDdlRaceError;
-exports.isSqliteNotAuthorizedError = isSqliteNotAuthorizedError;
-exports.isSqliteStaleSnapshotError = isSqliteStaleSnapshotError;
-exports.parseDimensionMismatch = parseDimensionMismatch;
-exports.postgresReadWriteRefusedSqlState = postgresReadWriteRefusedSqlState;
-exports.postgresTemporaryTableUnavailableSqlState = postgresTemporaryTableUnavailableSqlState;
-exports.withRecordedRelationsPrecondition = withRecordedRelationsPrecondition;
-//# sourceMappingURL=chunk-GVAMRRZR.cjs.map
-//# sourceMappingURL=chunk-GVAMRRZR.cjs.map

package/dist/chunk-GVAMRRZR.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/utils/sql-errors.ts","../src/utils/array.ts"],"names":["ConfigurationError"],"mappings":"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","file":"chunk-GVAMRRZR.cjs","sourcesContent":["/**\n * Cross-dialect detection of \"this relation does not exist yet\" errors.\n *\n * Shared so the schema bootstrap (`loadActiveSchemaWithBootstrap`) and\n * the durable contribution-materialization gate (#135) agree on what a\n * missing-table failure looks like, and — critically — so neither one\n * swallows a genuine system fault (connection/permission/driver error)\n * as a benign \"not bootstrapped yet\".\n *\n * Detection walks the error's `cause` chain because Drizzle (>= the\n * `DrizzleQueryError` era, drizzle-orm ≥ 0.36) wraps every failure from a\n * query-builder call (`db.select()`, `db.insert()`, …): the wrapper's\n * `.message` becomes the failed query text and the real driver error —\n * which carries both the missing-relation text and the SQLSTATE — is\n * preserved on `.cause`. node-postgres / postgres-js nest the pg error\n * one link deep; better-sqlite3 throws it unwrapped; raw `client.query()`\n * fast paths surface it directly. Walking the chain makes the check\n * wrapper- and driver-agnostic instead of only matching the outermost\n * `.message`, which on Postgres is just the SQL string.\n */\n\nimport { ConfigurationError } from \"../errors\";\n\nconst SQLITE_MISSING_TABLE_PATTERN = \"no such table\";\nconst SQLITE_GENERIC_ERROR_CODE = \"SQLITE_ERROR\";\nconst SQLITE_NOT_AUTHORIZED_CODE = \"SQLITE_AUTH\";\n\n/**\n * SQLite's EXTENDED result code for \"this read transaction cannot become a\n * write transaction\": the connection began a DEFERRED transaction, took a read\n * snapshot, and another connection has committed since. SQLite refuses the\n * upgrade because honoring it would let the writer act on a stale view; the\n * only recovery is `ROLLBACK` and a fresh transaction (SQLite's own rule — the\n * failure is not retryable in place).\n *\n * It is the one code that names the DEFERRED frame itself. A transaction opened\n * `BEGIN IMMEDIATE` holds the writer slot from the start and can never produce\n * it, and plain `SQLITE_BUSY` says something else entirely (\"another writer\n * holds the slot right now\"), so this code alone can be attributed to how the\n * transaction was begun. The numeric spelling is accepted for libSQL, which\n * surfaces only `rawCode`/`extendedCode` over a remote connection.\n */\nconst SQLITE_STALE_SNAPSHOT_CODE = \"SQLITE_BUSY_SNAPSHOT\";\nconst SQLITE_STALE_SNAPSHOT_EXTENDED_CODE = 517;\nconst DRIZZLE_QUERY_ERROR_PREFIX = \"Failed query:\";\nconst POSTGRES_UNDEFINED_RELATION_PATTERN =\n  /\\b(?:relation|table)\\s+\"[^\"]+\"\\s+does not exist\\b/i;\n\n/**\n * SQLSTATE for PostgreSQL `undefined_table`. Preferred over the\n * human-readable message: it is locale-independent (the \"... does not\n * exist\" text is translated under a non-English `lc_messages`) and is\n * preserved on the underlying driver error even when Drizzle overwrites\n * `.message` with the query text.\n */\nconst POSTGRES_UNDEFINED_TABLE_CODE = \"42P01\";\nconst POSTGRES_UNIQUE_VIOLATION_CODE = \"23505\";\n\n/**\n * SQLSTATEs a racing IDEMPOTENT DDL statement loses with — the ones that mean\n * \"another session is committing the very thing this statement asks for\", not\n * \"this statement is wrong\".\n *\n * PostgreSQL's `IF NOT EXISTS` is not a concurrency primitive: the existence\n * check cannot see another session's uncommitted catalog rows, so the loser\n * waits for the winner and is then handed the conflict the winner's commit\n * produced — `unique_violation` (23505) from `pg_type`/`pg_class` for a racing\n * CREATE, `duplicate_column` (42701) for a racing `ALTER TABLE ... ADD COLUMN\n * IF NOT EXISTS`. Retrying once after that wait observes the committed object\n * and succeeds; a failure the retry cannot clear stays loud.\n */\nconst POSTGRES_CONCURRENT_DDL_RACE_SQL_STATES = [\n  POSTGRES_UNIQUE_VIOLATION_CODE,\n  \"42701\",\n] as const;\n\n/**\n * The one concurrent-DDL race PostgreSQL reports with no SQLSTATE of its own:\n * `heap_update` losing a catalog row to a concurrent updater raises\n * `elog(ERROR, \"tuple concurrently updated\")`, which carries the catch-all\n * `internal_error` (XX000).\n *\n * XX000 alone is far too broad to retry on — it covers genuine server faults —\n * so this shape is identified by SQLSTATE AND message together. Matching the\n * message is sound here specifically because `elog` emits it through\n * `errmsg_internal`, which is NOT run through gettext: unlike an `ereport`\n * message, it reads identically under every `lc_messages`.\n */\nconst POSTGRES_INTERNAL_ERROR_CODE = \"XX000\";\nconst POSTGRES_CONCURRENT_TUPLE_UPDATE_MESSAGE = \"tuple concurrently updated\";\n\n/**\n * PostgreSQL failures that mean a temporary table cannot be created here:\n * `read_only_sql_transaction` (a replica or otherwise read-only execution\n * context) and `insufficient_privilege` (a role without the database `TEMP`\n * privilege).\n */\nconst POSTGRES_TEMPORARY_TABLE_UNAVAILABLE_SQL_STATES = [\n  \"25006\",\n  \"42501\",\n] as const;\n\n/**\n * PostgreSQL failures that mean the read-write transaction hosting temporary\n * tables cannot even start. A standby rejects the read-write access mode in\n * the `BEGIN` itself with `feature_not_supported` (\"cannot set transaction\n * read-write mode during recovery\"), so the failure never reaches a\n * `CREATE TEMP TABLE`; a session pinned read-only by a proxy or by\n * `default_transaction_read_only` reports `read_only_sql_transaction`.\n */\nconst POSTGRES_READ_WRITE_REFUSED_SQL_STATES = [\"0A000\", \"25006\"] as const;\n\nexport type PostgresTemporaryTableUnavailableSqlState =\n  (typeof POSTGRES_TEMPORARY_TABLE_UNAVAILABLE_SQL_STATES)[number];\n\nexport type PostgresReadWriteRefusedSqlState =\n  (typeof POSTGRES_READ_WRITE_REFUSED_SQL_STATES)[number];\n\n/**\n * Yields an error and each error reachable by following `.cause`,\n * outermost first. `seen` guards the pathological cyclic-cause case so a\n * self-referential chain can't spin forever.\n *\n * The walk intentionally follows `.cause` through *non-`Error`* links, not just\n * `Error` instances: postgres-js surfaces its driver error as a plain object\n * (message + SQLSTATE `code`) on a Drizzle wrapper's `.cause`, so stopping at\n * the first non-`Error` link would miss it (see the postgres-js test). A plain\n * object is classified by its locale-independent SQLSTATE alone\n * ({@link isPostgresUndefinedTable}); the looser SQLite message substring is\n * consulted only for `Error` instances and raw strings\n * ({@link missingTableMessage}), so an unrelated object in a cause chain that\n * merely mentions one of those phrases is not mistaken for a missing table.\n */\nexport function* errorChain(error: unknown): Generator<unknown, void, void> {\n  const seen = new Set<unknown>();\n  let current: unknown = error;\n  while (current !== undefined && current !== null && !seen.has(current)) {\n    seen.add(current);\n    yield current;\n    current =\n      canReadProperty(current) ? Reflect.get(current, \"cause\") : undefined;\n  }\n}\n\nfunction canReadProperty(value: unknown): value is object {\n  return (\n    (typeof value === \"object\" && value !== null) || typeof value === \"function\"\n  );\n}\n\n/**\n * Whether a single chain link is a PostgreSQL `undefined_table` failure,\n * identified by its SQLSTATE rather than a message substring.\n */\nfunction isPostgresUndefinedTable(link: unknown): boolean {\n  return (\n    canReadProperty(link) &&\n    Reflect.get(link, \"code\") === POSTGRES_UNDEFINED_TABLE_CODE\n  );\n}\n\nfunction messageProperty(link: unknown): string | undefined {\n  if (typeof link === \"string\") return link;\n  if (link instanceof Error) return link.message;\n  const message =\n    canReadProperty(link) ?\n      (Reflect.get(link, \"message\") as unknown)\n    : undefined;\n  return typeof message === \"string\" ? message : undefined;\n}\n\nfunction errorMessage(link: unknown): string {\n  return messageProperty(link) ?? String(link);\n}\n\n/**\n * The message a SQLite missing-table substring match may be tested against — but\n * only for `Error` instances and raw `string` links, never an arbitrary plain\n * object.\n *\n * Generic \"does not exist\" is deliberately not substring-matched: PostgreSQL uses\n * that phrase for undefined columns, functions, types, and relations. PostgreSQL\n * missing tables are classified by SQLSTATE 42P01 when available, or by the\n * narrower driver-message shape `relation/table \"...\" does not exist` when a\n * bring-your-own driver omits SQLSTATE. SQLite does not expose a portable\n * SQLSTATE here, so the narrow \"no such table\" engine message is still accepted.\n */\nfunction missingTableMessage(link: unknown): string | undefined {\n  return typeof link === \"string\" || link instanceof Error ?\n      messageProperty(link)\n    : undefined;\n}\n\nfunction sqliteErrorCode(link: unknown): unknown {\n  if (!canReadProperty(link)) return undefined;\n  return Reflect.get(link, \"code\");\n}\n\n/**\n * Cloudflare D1 / Durable Objects may surface a missing-table failure as the\n * generic SQLite code with no detail. Accept the bare marker, but do not\n * substring-match detailed `SQLITE_ERROR: ...` failures: those include syntax\n * errors and bind-limit faults that must stay loud.\n */\nfunction isBareSqliteErrorMarker(link: unknown): boolean {\n  const message = messageProperty(link);\n  if (message === SQLITE_GENERIC_ERROR_CODE) return true;\n  if (sqliteErrorCode(link) !== SQLITE_GENERIC_ERROR_CODE) return false;\n  return (\n    message === undefined ||\n    message === SQLITE_GENERIC_ERROR_CODE ||\n    message.includes(SQLITE_MISSING_TABLE_PATTERN)\n  );\n}\n\nfunction isPostgresUndefinedRelationMessage(link: unknown): boolean {\n  const message = errorMessage(link);\n  if (message.startsWith(DRIZZLE_QUERY_ERROR_PREFIX)) return false;\n  return POSTGRES_UNDEFINED_RELATION_PATTERN.test(message);\n}\n\n/**\n * Whether any link in the cause chain is a PostgreSQL \"insufficient\n * resources\" failure (SQLSTATE class 53: disk_full, out_of_memory,\n * configuration_limit_exceeded, ...). Parallel index builds surface\n * shared-memory exhaustion this way (53100 from dsm_impl_posix on hosts\n * with a small /dev/shm); callers retry such work with parallelism\n * disabled. Identified by the locale-independent 5-character SQLSTATE\n * prefix only — never by message text.\n */\nexport function isInsufficientResourcesError(error: unknown): boolean {\n  for (const link of errorChain(error)) {\n    if (!canReadProperty(link)) continue;\n    const code: unknown = Reflect.get(link, \"code\");\n    if (typeof code === \"string\" && code.length === 5 && code.startsWith(\"53\"))\n      return true;\n  }\n  return false;\n}\n\nexport function isMissingTableError(error: unknown): boolean {\n  // SQLSTATE 42P01 is locale-independent and structural, so it is honored on\n  // *every* link — including a plain driver-error object reached only by walking\n  // through a non-`Error` `.cause` (postgres-js).\n  //\n  // The SQLite message substring is honored only while every prior link in the\n  // chain was an `Error` (or the top-level string) — the reach of the\n  // pre-broadening walk, which stopped at the first non-`Error` `.cause`.\n  let everyPriorLinkWasError = true;\n  for (const link of errorChain(error)) {\n    if (isPostgresUndefinedTable(link)) return true;\n    if (isPostgresUndefinedRelationMessage(link)) return true;\n    if (isBareSqliteErrorMarker(link)) return true;\n    if (everyPriorLinkWasError) {\n      const message = missingTableMessage(link);\n      if (message?.includes(SQLITE_MISSING_TABLE_PATTERN) === true) {\n        return true;\n      }\n    }\n    if (!(link instanceof Error)) everyPriorLinkWasError = false;\n  }\n  return false;\n}\n\n/** Whether one chain link is the un-coded `tuple concurrently updated` race. */\nfunction isPostgresConcurrentTupleUpdate(link: unknown): boolean {\n  if (!canReadProperty(link)) return false;\n  if (Reflect.get(link, \"code\") !== POSTGRES_INTERNAL_ERROR_CODE) return false;\n  return (\n    messageProperty(link)?.includes(\n      POSTGRES_CONCURRENT_TUPLE_UPDATE_MESSAGE,\n    ) === true\n  );\n}\n\n/**\n * Whether PostgreSQL refused an IDEMPOTENT DDL statement because another\n * session was concurrently committing the same catalog change — the single\n * owner of \"this DDL lost a race and is worth one retry\".\n *\n * Every idempotent-DDL site in the codebase classifies through this one\n * function: the Postgres backend's `executeConcurrentCreateDdl` (bootstrap\n * tables, contribution materialization, identity relations, the index\n * materialization table and its additive columns) and the identity\n * schema-transition retry. A second copy of the predicate would drift the\n * moment one site learned about a new race SQLSTATE — as `ALTER TABLE ... ADD\n * COLUMN IF NOT EXISTS` (42701) did (#445).\n *\n * Callers MUST use it only around DDL that is a no-op when the object already\n * exists. On any other statement 23505/42701 are real defects, and retrying\n * them would hide a duplicate write.\n */\nexport function isPostgresConcurrentDdlRaceError(error: unknown): boolean {\n  for (const link of errorChain(error)) {\n    if (!canReadProperty(link)) continue;\n    if (\n      isSqlStateIn(\n        Reflect.get(link, \"code\"),\n        POSTGRES_CONCURRENT_DDL_RACE_SQL_STATES,\n      )\n    ) {\n      return true;\n    }\n    if (isPostgresConcurrentTupleUpdate(link)) return true;\n  }\n  return false;\n}\n\n/**\n * The PostgreSQL error fields naming the violated constraint and its relation.\n * Both spellings are read because the drivers disagree: node-postgres and\n * PGlite expose the protocol fields as `constraint` / `table`, while\n * postgres-js exposes them as `constraint_name` / `table_name`. Reading only\n * one spelling would silently classify nothing on the other driver.\n */\nconst POSTGRES_CONSTRAINT_FIELDS = [\"constraint\", \"constraint_name\"] as const;\nconst POSTGRES_RELATION_FIELDS = [\"table\", \"table_name\"] as const;\n\n/**\n * SQLite's EXTENDED result code for a primary-key duplicate, in both spellings a\n * driver reports it: the symbolic name (better-sqlite3 `code`, and the\n * `SqliteError` the libSQL client nests on its own error's `.cause`) and the\n * numeric value (libSQL `rawCode` / `extendedCode`, the only form a remote\n * connection surfaces).\n *\n * The extended code — not the base `SQLITE_CONSTRAINT` — is what makes the\n * classification possible at all: SQLite distinguishes a PRIMARY KEY duplicate\n * (1555) from any other unique-index duplicate (`SQLITE_CONSTRAINT_UNIQUE`,\n * 2067) in the code itself, so nothing has to read the message, which names the\n * columns rather than the constraint.\n */\nconst SQLITE_PRIMARY_KEY_VIOLATION_CODE = \"SQLITE_CONSTRAINT_PRIMARYKEY\";\nconst SQLITE_PRIMARY_KEY_VIOLATION_EXTENDED_CODE = 1555;\nconst SQLITE_EXTENDED_CODE_FIELDS = [\"rawCode\", \"extendedCode\"] as const;\n\n/**\n * A relation plus the names its PRIMARY KEY constraint can carry — how far a\n * duplicate-key classification is allowed to reach on an engine that reports the\n * violated constraint by name. See {@link isDuplicatePrimaryKeyError}.\n */\nexport type PrimaryKeyRelation = Readonly<{\n  table: string;\n  constraintNames: readonly string[];\n}>;\n\nfunction firstStringField(\n  link: object,\n  fields: readonly string[],\n): string | undefined {\n  for (const field of fields) {\n    const value: unknown = Reflect.get(link, field);\n    if (typeof value === \"string\") return value;\n  }\n  return undefined;\n}\n\n/**\n * Whether PostgreSQL reported this link as a duplicate of `relation`'s PRIMARY\n * KEY: SQLSTATE, relation, and constraint name must all agree on the SAME link\n * (the driver error), so a 23505 raised by an unrelated statement deeper in the\n * chain cannot be attributed to this relation.\n */\nfunction isPostgresPrimaryKeyViolation(\n  link: object,\n  relation: PrimaryKeyRelation,\n): boolean {\n  if (Reflect.get(link, \"code\") !== POSTGRES_UNIQUE_VIOLATION_CODE)\n    return false;\n  if (firstStringField(link, POSTGRES_RELATION_FIELDS) !== relation.table) {\n    return false;\n  }\n  const constraint = firstStringField(link, POSTGRES_CONSTRAINT_FIELDS);\n  return (\n    constraint !== undefined && relation.constraintNames.includes(constraint)\n  );\n}\n\n/**\n * Whether SQLite reported this link as a PRIMARY KEY duplicate. The relation is\n * not checked because SQLite does not report one — see\n * {@link isDuplicatePrimaryKeyError} for why the call site supplies that scope.\n */\nfunction isSqlitePrimaryKeyViolation(link: object): boolean {\n  if (Reflect.get(link, \"code\") === SQLITE_PRIMARY_KEY_VIOLATION_CODE) {\n    return true;\n  }\n  for (const field of SQLITE_EXTENDED_CODE_FIELDS) {\n    const value: unknown = Reflect.get(link, field);\n    if (\n      typeof value === \"number\" &&\n      value === SQLITE_PRIMARY_KEY_VIOLATION_EXTENDED_CODE\n    ) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Whether the engine refused a statement because it duplicated a PRIMARY KEY —\n * on PostgreSQL, `relation`'s specifically.\n *\n * Classification is structural: SQLSTATE and SQLite extended result codes, plus\n * the PostgreSQL protocol's own constraint and relation fields. Never message\n * text, which is translated under a non-English `lc_messages`, is overwritten\n * with the query string by Drizzle's wrapper, and on SQLite names the key's\n * COLUMNS rather than the constraint. The `.cause` chain is walked because every\n * driver here nests the real error under at least one wrapper.\n *\n * Narrowing to the primary key is the whole point. A `unique: true` index\n * declaration materializes a UNIQUE INDEX on the same relation, and violating\n * THAT is a declared-uniqueness failure about the row's VALUES, not a duplicate\n * identity. PostgreSQL reports it under the index's own name and SQLite under a\n * different extended code, so it never matches here and keeps surfacing as it\n * did before.\n *\n * `relation` scopes the PostgreSQL arm, which is the one that can see a\n * constraint name. SQLite reports no relation at all, so its scope comes from\n * the CALL SITE instead: callers must invoke this only for a statement that\n * writes exactly one relation — the node or edge insert — where a primary-key\n * duplicate can only be that relation's. Applying it to a multi-relation\n * statement would attribute the wrong table's collision.\n */\nexport function isDuplicatePrimaryKeyError(\n  error: unknown,\n  relation: PrimaryKeyRelation,\n): boolean {\n  for (const link of errorChain(error)) {\n    if (!canReadProperty(link)) continue;\n    if (isPostgresPrimaryKeyViolation(link, relation)) return true;\n    if (isSqlitePrimaryKeyViolation(link)) return true;\n  }\n  return false;\n}\n\nfunction isSqlStateIn<SqlState extends string>(\n  code: unknown,\n  states: readonly SqlState[],\n): code is SqlState {\n  const known: readonly string[] = states;\n  return typeof code === \"string\" && known.includes(code);\n}\n\n/**\n * The first SQLSTATE in the error's cause chain that belongs to `states`. The\n * walk handles both direct driver errors and wrappers such as\n * DrizzleQueryError, which keeps the SQLSTATE-bearing error on `.cause`.\n */\nfunction matchSqlState<SqlState extends string>(\n  error: unknown,\n  states: readonly SqlState[],\n): SqlState | undefined {\n  for (const link of errorChain(error)) {\n    if (!canReadProperty(link)) continue;\n    const code: unknown = Reflect.get(link, \"code\");\n    if (isSqlStateIn(code, states)) return code;\n  }\n  return undefined;\n}\n\n/**\n * Returns the PostgreSQL SQLSTATE that prevented temporary-table creation.\n *\n * Callers must use this only at a `CREATE TEMP TABLE` execution seam: 42501\n * is otherwise a generic permission failure, and translating it elsewhere\n * would hide a different authorization problem.\n */\nexport function postgresTemporaryTableUnavailableSqlState(\n  error: unknown,\n): PostgresTemporaryTableUnavailableSqlState | undefined {\n  return matchSqlState(error, POSTGRES_TEMPORARY_TABLE_UNAVAILABLE_SQL_STATES);\n}\n\n/**\n * Returns the PostgreSQL SQLSTATE with which the server refused to open a\n * read-write transaction.\n *\n * Callers must use this only for a failure raised while opening such a\n * transaction — 0A000 is otherwise a generic \"unsupported feature\" report\n * that any statement can raise.\n */\nexport function postgresReadWriteRefusedSqlState(\n  error: unknown,\n): PostgresReadWriteRefusedSqlState | undefined {\n  return matchSqlState(error, POSTGRES_READ_WRITE_REFUSED_SQL_STATES);\n}\n\n/**\n * Whether SQLite rejected a statement through its authorizer. Cloudflare D1\n * and Durable Objects surface this as `not authorized: SQLITE_AUTH`, usually on\n * a Drizzle wrapper's `.cause`; native drivers may instead expose\n * `code: \"SQLITE_AUTH\"`. Both shapes are structural enough to distinguish from\n * an unrelated permission or connection failure.\n */\nexport function isSqliteNotAuthorizedError(error: unknown): boolean {\n  for (const link of errorChain(error)) {\n    if (sqliteErrorCode(link) === SQLITE_NOT_AUTHORIZED_CODE) return true;\n    const message = messageProperty(link);\n    if (\n      message?.includes(SQLITE_NOT_AUTHORIZED_CODE) === true &&\n      message.toLowerCase().includes(\"not authorized\")\n    ) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Whether SQLite refused a write because the enclosing DEFERRED transaction's\n * read snapshot went stale before it could take the writer slot\n * ({@link SQLITE_STALE_SNAPSHOT_CODE}).\n *\n * Classified structurally — the extended result code in either spelling a\n * driver reports it (better-sqlite3's symbolic `code`, libSQL's numeric\n * `rawCode`/`extendedCode`) — and never by message: SQLite renders this as the\n * bare, indistinguishable \"database is locked\".\n */\nexport function isSqliteStaleSnapshotError(error: unknown): boolean {\n  for (const link of errorChain(error)) {\n    if (sqliteErrorCode(link) === SQLITE_STALE_SNAPSHOT_CODE) return true;\n    if (!canReadProperty(link)) continue;\n    for (const field of SQLITE_EXTENDED_CODE_FIELDS) {\n      if (Reflect.get(link, field) === SQLITE_STALE_SNAPSHOT_EXTENDED_CODE) {\n        return true;\n      }\n    }\n  }\n  return false;\n}\n\nfunction historyMissingRecordedRelationsError(\n  details: Record<string, unknown>,\n  cause: unknown,\n): ConfigurationError {\n  return new ConfigurationError(\n    \"history: true requires the recorded-time relations to exist, but a recorded relation is missing.\",\n    details,\n    {\n      cause,\n      suggestion:\n        \"Create the recorded-time relations (typegraph_recorded_nodes, typegraph_recorded_edges, typegraph_recorded_clock) — e.g. re-run the generated migration SQL — on this database before enabling history capture.\",\n    },\n  );\n}\n\n/**\n * Converts missing recorded-relation failures into the actionable precondition\n * error used by construction-time history checks. Capture paths use this after\n * the live write has already succeeded inside the same transaction; recorded\n * read paths use it when query/schema swapping reaches a recorded table that\n * has not been materialized yet.\n */\nexport async function withRecordedRelationsPrecondition<T>(\n  promise: Promise<T>,\n  details: Record<string, unknown>,\n): Promise<T> {\n  try {\n    return await promise;\n  } catch (error) {\n    if (!isMissingTableError(error)) throw error;\n    throw historyMissingRecordedRelationsError(\n      { ...details, code: \"RECORDED_RELATIONS_MISSING\" },\n      error,\n    );\n  }\n}\n\n/**\n * Engine \"vector dimension mismatch\" message shapes. pgvector:\n * `expected 384 dimensions, not 512`; libSQL / sqlite-vec surface a similar\n * `expected N … got/not M`. The first capture is the dimension the *stored*\n * column expects; the optional second is the dimension that was *attempted*.\n */\nconst DIMENSION_MISMATCH_PATTERN =\n  /expected (\\d+) dimensions(?:[,\\s]+(?:not|got|but got|but)\\s*(\\d+))?/i;\n\n/**\n * Parses an engine vector-dimension-mismatch error into `{ expected, actual }`\n * by walking the `.cause` chain (drivers wrap the real error). `expected` is\n * the stored column's dimension; `actual` (when the message includes it) is the\n * attempted vector's dimension. Returns `undefined` for unrelated errors.\n */\nexport function parseDimensionMismatch(\n  error: unknown,\n): { expected: number; actual: number | undefined } | undefined {\n  for (const link of errorChain(error)) {\n    const message = errorMessage(link);\n    const match = DIMENSION_MISMATCH_PATTERN.exec(message);\n    if (match) {\n      return {\n        expected: Number(match[1]),\n        actual: match[2] === undefined ? undefined : Number(match[2]),\n      };\n    }\n  }\n  return undefined;\n}\n","/**\n * Splits `items` into consecutive chunks of at most `size` elements.\n *\n * An empty input yields no chunks (`[]`), and an input that already fits in a\n * single chunk is returned without copying. Callers rely on the empty-input\n * behavior to skip work entirely rather than issue a statement with an empty\n * `IN ()` list.\n */\nexport function chunk<T>(\n  items: readonly T[],\n  size: number,\n): readonly (readonly T[])[] {\n  // A non-positive, non-finite, or fractional size would make the slice loop\n  // fail to advance correctly; fail loud rather than spin or emit empty chunks.\n  // All current callers derive size from a positive integer bind-parameter\n  // budget, so this only guards against a future regression.\n  if (!Number.isSafeInteger(size) || size < 1) {\n    throw new RangeError(`chunk size must be a positive integer, got: ${size}`);\n  }\n  if (items.length === 0) return [];\n  if (items.length <= size) return [items];\n  const chunks: T[][] = [];\n  for (let start = 0; start < items.length; start += size) {\n    chunks.push(items.slice(start, start + size));\n  }\n  return chunks;\n}\n\n/**\n * Groups items by a caller-supplied key while preserving input order within\n * each group.\n */\nexport function groupBy<T, K>(\n  items: Iterable<T>,\n  keyFor: (item: T) => K,\n): Map<K, T[]> {\n  const groups = new Map<K, T[]>();\n  for (const item of items) {\n    const key = keyFor(item);\n    const group = groups.get(key) ?? [];\n    group.push(item);\n    groups.set(key, group);\n  }\n  return groups;\n}\n"]}