@nicia-ai/typegraph 0.47.0 → 0.48.0

package/dist/chunk-NAZ2RA4L.js

@@ -1,254 +0,0 @@
-import { ConfigurationError } from './chunk-ZLONH2UD.js';
-
-// 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 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;
-}
-
-export { chunk, errorChain, groupBy, isDuplicatePrimaryKeyError, isInsufficientResourcesError, isMissingTableError, isPostgresConcurrentDdlRaceError, isSqliteNotAuthorizedError, isSqliteStaleSnapshotError, parseDimensionMismatch, postgresReadWriteRefusedSqlState, postgresTemporaryTableUnavailableSqlState, withRecordedRelationsPrecondition };
-//# sourceMappingURL=chunk-NAZ2RA4L.js.map
-//# sourceMappingURL=chunk-NAZ2RA4L.js.map

package/dist/chunk-NAZ2RA4L.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/utils/sql-errors.ts","../src/utils/array.ts"],"names":[],"mappings":"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","file":"chunk-NAZ2RA4L.js","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"]}

package/dist/chunk-NG2RB5WL.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/utils/date.ts"],"names":[],"mappings":"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","file":"chunk-NG2RB5WL.js","sourcesContent":["/**\n * Date encoding utilities for consistent storage.\n *\n * Contract: All dates are stored as ISO 8601 strings in UTC.\n * - Always includes milliseconds\n * - Always UTC (Z suffix)\n * - Sorts correctly as strings\n */\n\nimport {\n  IMMUTABLE_VALIDITY_LOWER_BOUND_CODE,\n  INVERTED_VALIDITY_WINDOW_CODE,\n  ValidationError,\n} from \"../errors\";\n\n/**\n * ISO 8601 datetime pattern.\n * Matches formats like:\n * - 2024-01-15T10:30:00.000Z\n * - 2024-01-15T10:30:00Z\n * - 2024-01-15T10:30:00.123Z\n */\nconst ISO_DATE_PATTERN = /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,3})?Z$/;\n\n/**\n * Checks if a string is a valid ISO 8601 datetime.\n *\n * @param value - String to validate\n * @returns True if valid ISO 8601 datetime\n */\nexport function isValidIsoDate(value: string): boolean {\n  if (!ISO_DATE_PATTERN.test(value)) {\n    return false;\n  }\n  // Also check that Date parsing produces a valid date\n  const date = new Date(value);\n  return !Number.isNaN(date.getTime());\n}\n\n/**\n * Validates that a string is a valid ISO 8601 datetime.\n * Throws ValidationError if invalid.\n *\n * @param value - String to validate\n * @param fieldName - Name of field for error message\n * @returns The validated string\n * @throws ValidationError if not a valid ISO datetime\n */\nexport function validateIsoDate(value: string, fieldName: string): string {\n  if (!isValidIsoDate(value)) {\n    throw new ValidationError(\n      `Invalid ISO 8601 datetime for \"${fieldName}\": \"${value}\". ` +\n        `Expected format: YYYY-MM-DDTHH:mm:ss.sssZ`,\n      {\n        issues: [\n          {\n            path: fieldName,\n            message: `Invalid ISO 8601 datetime format. Expected: YYYY-MM-DDTHH:mm:ss.sssZ, got: \"${value}\"`,\n          },\n        ],\n      },\n      {\n        suggestion: `Use a valid ISO 8601 UTC datetime like \"2024-01-15T10:30:00.000Z\"`,\n      },\n    );\n  }\n  return value;\n}\n\n/**\n * Strict canonical ISO 8601 pattern: fixed-width UTC with exactly\n * millisecond precision (`YYYY-MM-DDTHH:mm:ss.sssZ`). Unlike\n * {@link ISO_DATE_PATTERN}, which tolerates a missing or variable-width\n * fractional part, this is the only shape whose lexicographic text order\n * matches chronological order — avoiding cases like `\"...:00.1Z\"` (= `.100`)\n * sorting *after* `\"...:00.101Z\"`.\n */\nconst CANONICAL_ISO_DATE_PATTERN =\n  /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$/;\n\nconst ZONELESS_DATETIME_PATTERN =\n  /^\\d{4}-\\d{2}-\\d{2}[ T]\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d+)?)?$/;\nconst OFFSET_DATETIME_PATTERN =\n  /^(\\d{4}-\\d{2}-\\d{2})[ T](\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d+)?)?)(Z|[+-]\\d{2}(?::?\\d{2})?)$/i;\nconst DATE_ONLY_PATTERN = /^\\d{4}-\\d{2}-\\d{2}$/;\n\nfunction normalizedOffset(offset: string): string {\n  if (offset.toUpperCase() === \"Z\") return \"Z\";\n  if (/^[+-]\\d{2}$/.test(offset)) return `${offset}:00`;\n  if (/^[+-]\\d{4}$/.test(offset)) {\n    return `${offset.slice(0, 3)}:${offset.slice(3)}`;\n  }\n  return offset;\n}\n\nfunction databaseTimestampMilliseconds(value: string): number {\n  if (ZONELESS_DATETIME_PATTERN.test(value)) {\n    return Date.parse(`${value.replace(\" \", \"T\")}Z`);\n  }\n  const offsetMatch = OFFSET_DATETIME_PATTERN.exec(value);\n  if (offsetMatch !== null) {\n    const date = offsetMatch[1];\n    const time = offsetMatch[2];\n    const offset = offsetMatch[3];\n    if (date === undefined || time === undefined || offset === undefined) {\n      return Number.NaN;\n    }\n    return Date.parse(`${date}T${time}${normalizedOffset(offset)}`);\n  }\n  if (DATE_ONLY_PATTERN.test(value)) {\n    return Date.parse(`${value}T00:00:00.000Z`);\n  }\n  return Number.NaN;\n}\n\n/**\n * Canonicalizes a database-driver timestamp without interpreting a zoneless\n * string in the host timezone. PostgreSQL drivers can return values such as\n * `2026-06-25 12:00:00`; TypeGraph treats that shape as UTC so the same stored\n * clock value cannot move across hosts or daylight-saving boundaries.\n *\n * Returns `undefined` for an unsupported or unrepresentable value so callers\n * can raise an error specific to their storage boundary.\n */\nexport function canonicalizeDatabaseTimestamp(\n  value: unknown,\n): string | undefined {\n  if (value instanceof Date) {\n    if (Number.isNaN(value.getTime())) return undefined;\n    return value.toISOString();\n  }\n  if (typeof value !== \"string\") return undefined;\n  const milliseconds = databaseTimestampMilliseconds(value);\n  if (Number.isNaN(milliseconds)) return undefined;\n  return new Date(milliseconds).toISOString();\n}\n\n/**\n * Checks if a string is a canonical UTC ISO 8601 datetime with fixed\n * millisecond width (`YYYY-MM-DDTHH:mm:ss.sssZ`).\n */\nexport function isCanonicalIsoDate(value: string): boolean {\n  if (!CANONICAL_ISO_DATE_PATTERN.test(value)) return false;\n  const date = new Date(value);\n  return !Number.isNaN(date.getTime()) && date.toISOString() === value;\n}\n\n/**\n * Validates that a string is a canonical UTC ISO 8601 datetime with fixed\n * millisecond width. Stricter than {@link validateIsoDate} (which also\n * accepts missing or 1–2 digit milliseconds): required wherever the value\n * is compared **as text** against stored timestamps and must sort\n * chronologically — e.g. a temporal `asOf` coordinate, where a\n * variable-width value would mis-order and silently include or exclude the\n * wrong rows. Produce one with `new Date(value).toISOString()`.\n *\n * @param value - String to validate\n * @param fieldName - Name of field for error message\n * @returns The validated string\n * @throws ValidationError if not a canonical UTC ISO datetime\n */\nexport function validateCanonicalIsoDate(\n  value: string,\n  fieldName: string,\n): string {\n  if (!isCanonicalIsoDate(value)) {\n    throw new ValidationError(\n      `Invalid canonical ISO 8601 datetime for \"${fieldName}\": \"${value}\". ` +\n        `Expected fixed-width UTC: YYYY-MM-DDTHH:mm:ss.sssZ`,\n      {\n        issues: [\n          {\n            path: fieldName,\n            message: `Expected canonical UTC ISO 8601 (YYYY-MM-DDTHH:mm:ss.sssZ), got: \"${value}\"`,\n          },\n        ],\n      },\n      {\n        suggestion: `Use a fixed-width UTC datetime like \"2024-01-15T10:30:00.000Z\" (e.g. new Date(value).toISOString()).`,\n      },\n    );\n  }\n  return value;\n}\n\n/**\n * Validates an optional canonical ISO date string. Returns `undefined` for an\n * absent value; otherwise enforces canonical fixed-width UTC ISO 8601 via\n * {@link validateCanonicalIsoDate}. Used for stored validity-window inputs\n * (`validFrom` / `validTo`) so every timestamp the temporal filters compare as\n * text is canonical and sorts chronologically — the same contract the `asOf`\n * read coordinate already enforces.\n */\nexport function validateOptionalCanonicalIsoDate(\n  value: string | undefined,\n  fieldName: string,\n): string | undefined {\n  if (value === undefined) return undefined;\n  return validateCanonicalIsoDate(value, fieldName);\n}\n\n/**\n * Whether a CANONICAL stated bound names the same instant a row already stores.\n *\n * The one comparison of a caller's bound against a stored one, so the coalesce\n * dirty check (\"would this write move the window?\") and the write guard (\"can\n * this stated bound be applied?\") can never disagree about what \"the same bound\"\n * means. Two copies of it did disagree — one comparing driver text, one\n * comparing instants — which is how a re-stated window wrote on one backend and\n * coalesced on the other.\n *\n * Only the STORED side is canonicalized. It arrives as the driver rendered it,\n * and the dialects do not render a timestamp the same way (SQLite returns the\n * written text; a Postgres driver may hand back a zoned string equivalent to the\n * canonical form without being identical to it). The stated side needs no\n * canonicalization because every write path validates it as canonical first —\n * which is a PRECONDITION here, not an assumption: a non-canonical stated bound\n * would compare unequal to an equivalent stored instant and must be rejected by\n * {@link validateCanonicalIsoDate} rather than silently treated as a mismatch.\n */\nexport function statedBoundMatchesStored(\n  stated: string,\n  stored: string | undefined,\n): boolean {\n  return stated === canonicalizeDatabaseTimestamp(stored);\n}\n\n/**\n * Whether a stated validity window has NEGATIVE width — a row that stopped\n * being true before it started. The one comparison every window refusal is\n * built on, so paths that must report the fault through their own error type\n * (trusted import) decide it identically to the ones that throw a\n * `ValidationError`.\n *\n * PRECONDITION: both endpoints are canonical fixed-width UTC ISO 8601, which is\n * what makes a lexicographic compare a chronological one. Every caller\n * establishes that before comparing, with no exception: the paths that throw a\n * `ValidationError` reach this through {@link validateOptionalCanonicalIsoDate},\n * and trusted import — which skips schema validation for throughput —\n * format-checks the stated window fields of every streamed row against\n * {@link isCanonicalIsoDate} before reaching here. A bound read back from a row\n * needs no check of its own: it is canonical because the write that stored it\n * was held to this same contract — SQLite hands that text back verbatim, and the\n * PostgreSQL row mapper normalizes the driver's shape back to it. So no caller\n * can compare a value that would mis-sort, here or later against an `asOf`\n * coordinate.\n *\n * ZERO width (`validFrom === validTo`) is not inverted: it is what a\n * same-instant retraction produces at millisecond precision, and the store's own\n * output must round-trip.\n */\nexport function isInvertedValidityWindow(\n  validFrom: string | undefined,\n  validTo: string | undefined,\n): boolean {\n  if (validFrom === undefined || validTo === undefined) return false;\n  return validFrom > validTo;\n}\n\n/**\n * Refuses a `validTo` whose EFFECTIVE lower bound would invert the window. On an\n * in-place update the row's stored lower bound is the effective one and must stay\n * <= the new `validTo`; on a resurrection that RESETS `valid_from` it is the\n * write instant, so a lone past `validTo` would be born inverted.\n *\n * A ZERO-width window (`validTo === effectiveValidFrom`) is legal and stays\n * legal: it is what a same-instant retraction produces at millisecond\n * precision, and the identity-import window check sanctions it for the same\n * reason. Only NEGATIVE width refuses.\n *\n * Reached through {@link assertWritableValidityWindow} rather than called\n * directly, so no writer can check the effective bound without also checking a\n * stated pair.\n */\nfunction assertEffectiveValidityLowerBound(\n  subject: string,\n  effectiveValidFrom: string | undefined,\n  validTo: string | undefined,\n): void {\n  if (!isInvertedValidityWindow(effectiveValidFrom, validTo)) return;\n  throw new ValidationError(\n    `Inverted validity window for ${subject}: the effective validFrom \"${effectiveValidFrom}\" is after validTo \"${validTo}\".`,\n    {\n      issues: [\n        {\n          path: \"validTo\",\n          code: INVERTED_VALIDITY_WINDOW_CODE,\n          message: `Expected the effective validFrom <= validTo, got \"${effectiveValidFrom}\" > \"${validTo}\". The effective validFrom is the row's stored lower bound, or the write instant where the write stamps one.`,\n        },\n      ],\n    },\n    {\n      suggestion:\n        \"Provide both validFrom and validTo for a historical window, or drop validTo to keep the row current.\",\n    },\n  );\n}\n\n/**\n * Rejects an inverted validity window. `validFrom > validTo` describes a row\n * that stopped being true before it started, so no current-mode or `asOf` read\n * can ever observe it — the write succeeds and the row is then reachable only\n * through `includeEnded`, which reads as data loss rather than as the error it\n * is. Call this wherever both endpoints are supplied together; both are\n * canonical ISO 8601 by then, so a lexicographic compare is a chronological\n * compare.\n *\n * @param subject - Human-readable identification of the row, for the message\n *   (e.g. `Person \"01H...\"`).\n * @throws ValidationError if both endpoints are present and out of order\n */\nexport function assertOrderedValidityWindow(\n  subject: string,\n  validFrom: string | undefined,\n  validTo: string | undefined,\n): void {\n  if (!isInvertedValidityWindow(validFrom, validTo)) return;\n  throw new ValidationError(\n    `Inverted validity window for ${subject}: validFrom \"${validFrom}\" is after validTo \"${validTo}\".`,\n    {\n      issues: [\n        {\n          path: \"validFrom\",\n          code: INVERTED_VALIDITY_WINDOW_CODE,\n          message: `Expected validFrom <= validTo, got \"${validFrom}\" > \"${validTo}\"`,\n        },\n      ],\n    },\n    {\n      suggestion:\n        \"Pass a validFrom at or before validTo, or omit validTo to leave the window open.\",\n    },\n  );\n}\n\n/**\n * What an UPDATE will do with the row's validity lower bound — the two facts the\n * write guard needs, stated by the writer that knows them.\n *\n * Every update path must decide `appliesStatedValidFrom` explicitly, because the\n * answer is not a property of the guard's other arguments: the same\n * `(validFrom, storedBound, validTo)` triple is a legal window restatement on a\n * resurrection and an unappliable bound on an in-place update.\n */\nexport type UpdateValidityLowerBound = Readonly<{\n  /**\n   * The bound the row will hold when the caller states no `validFrom`: the\n   * stored `valid_from` for an in-place update, the write instant for a\n   * resurrection that stamps a new one, `undefined` where there is no bound to\n   * invert against.\n   */\n  effectiveValidFrom: string | undefined;\n  /**\n   * Whether the write STORES a stated `validFrom`. False for an in-place update\n   * of a live row — `buildUpdateNode` / `buildUpdateEdge` rewrite `valid_from`\n   * only on a resurrection — which is what makes a differing stated bound a\n   * refusal rather than a silent drop.\n   */\n  appliesStatedValidFrom: boolean;\n  /**\n   * Whether `effectiveValidFrom` IS the row's stored `valid_from` — the value an\n   * `expectedValidFrom` predicate would name — rather than a bound this write is\n   * about to stamp itself.\n   *\n   * A node resurrection resets `valid_from` to the write instant and passes THAT\n   * as the effective bound, so its verdict never looked at what the row holds and\n   * a fence on the stored value would predicate the write on something nothing\n   * read. An edge retains its bound through a resurrection, so its effective\n   * bound is the stored one on both legs.\n   */\n  effectiveBoundIsStored: boolean;\n}>;\n\n/**\n * The `expectedValidFrom` predicate a write owes its verdict, shaped for\n * spreading straight into the backend's update params.\n *\n * `{}` means \"assert nothing\"; `{ expectedValidFrom: null }` means \"assert the\n * row still has NO lower bound\". The two are different claims and the object\n * form keeps them distinguishable at every call site — see\n * `UpdateNodeParams.expectedValidFrom`.\n */\nexport type ValidityLowerBoundFence = Readonly<{\n  expectedValidFrom?: string | null;\n}>;\n\n/**\n * What {@link assertWritableValidityWindow} reports back about the verdict it\n * just reached — not about the window, but about what the verdict DEPENDED ON.\n *\n * THE SINGLE OWNER of the question \"must this write assert the row's stored\n * lower bound?\", and it answers by handing over the predicate ITSELF rather than\n * a flag a caller then turns into one. A write asserts every component its\n * verdict read (see `UpdateNodeParams.expectedValidFrom`), and which components\n * those are is decided by which branches the guard actually took — so a caller\n * that could still spell the fence on its own would eventually spell a different\n * one. Interchange import did exactly that: it asserted the probed\n * `valid_from` unconditionally, over-fencing props-only updates the store paths\n * (correctly) left unfenced. There is now nothing to re-derive.\n *\n * Too FEW assertions is a silent race; too many is a refusal of writes that are\n * legitimate. Both failures come from a second spelling.\n */\nexport type ValidityWindowVerdict = Readonly<{\n  /**\n   * The fence this verdict obliges the write to carry. Non-empty when the\n   * verdict consulted the row's STORED `valid_from` — either by comparing a\n   * stated bound against it, or by inverting a lone `validTo` against it — and\n   * empty when the caller named no window at all, when the write applies the\n   * bound it stated, or when the effective bound was one this write will stamp\n   * rather than one the row holds. In those cases the verdict is independent of\n   * what the row carries, and predicating the write on it would refuse a\n   * concurrent recreate that changed nothing this decision looked at.\n   */\n  storedLowerBoundFence: ValidityLowerBoundFence;\n}>;\n\n/**\n * Whether an upsert explicitly treats its stated lower bound as\n * create/resurrection-only input.\n *\n * This predicate owns the policy decision for both write execution and\n * unchanged-upsert coalescing, so those paths cannot drift on whether a live\n * row's stored lower bound is preserved.\n */\nexport function preservesImmutableLowerBound(\n  policy: \"preserve\" | \"refuse\" | undefined,\n): policy is \"preserve\" {\n  return policy === \"preserve\";\n}\n\n/**\n * Refuses a stated `validFrom` the write would not apply.\n *\n * A live row's lower bound is HISTORY: it records when the row started being\n * true, and an in-place update never moves it. Accepting a bound that names a\n * different instant and then dropping it is the API lying — the caller's stated\n * window silently is not the stored one, while the write still spends a version\n * bump and a history row moving nothing. Restating the bound the row already\n * holds stays legal, so a caller that echoes a row's own window back (a merge\n * commit, a re-delivered upsert) is unaffected.\n *\n * Reached through {@link assertWritableValidityWindow} rather than called\n * directly, so no writer can accept a lower bound without declaring whether it\n * applies one.\n */\nfunction assertStatedLowerBoundIsApplicable(\n  subject: string,\n  statedValidFrom: string,\n  storedValidFrom: string | undefined,\n): void {\n  if (statedBoundMatchesStored(statedValidFrom, storedValidFrom)) return;\n  const storedDescription =\n    storedValidFrom === undefined ?\n      \"the row has no lower bound\"\n    : `the row's stored lower bound is \"${storedValidFrom}\"`;\n  throw new ValidationError(\n    `Unappliable validFrom for ${subject}: stated \"${statedValidFrom}\", but ${storedDescription} and the row is live.`,\n    {\n      issues: [\n        {\n          path: \"validFrom\",\n          code: IMMUTABLE_VALIDITY_LOWER_BOUND_CODE,\n          message: `A live row's lower bound is history and an in-place update never rewrites it, so \"${statedValidFrom}\" could not be applied.`,\n        },\n      ],\n    },\n    {\n      suggestion:\n        storedValidFrom === undefined ?\n          \"Omit validFrom: this row has no lower bound to restate, and only a resurrection can give it one.\"\n        : `Restate the stored bound (\"${storedValidFrom}\") or omit validFrom.`,\n    },\n  );\n}\n\n/**\n * THE window-ordering guard a valid-time UPDATE goes through, identically for\n * nodes and edges. Refuses a window of negative width — a row that stopped\n * being true before it started — whether the caller states both endpoints or\n * only the new end. Also refuses a stated lower bound the write cannot apply,\n * so no update accepts a `validFrom` it will ignore.\n *\n * Three checks, because the failures deserve different messages: the caller who\n * supplied both endpoints out of order gets told about the pair, the caller who\n * stated a lower bound this write cannot store gets told which bound the row\n * holds, and the caller whose lone `validTo` inverts against the bound the row\n * will actually carry gets told which bound that is.\n *\n * The stated pair is judged FIRST — an inverted pair is wrong whatever the row\n * holds — and the applicability of the lower bound before the effective-bound\n * check, so a caller is told their bound will not be stored rather than being\n * told about a bound they did not name.\n *\n * INSERTS use {@link assertOrderedValidityWindow} alone. An insert carrying a\n * lone historical `validTo` means \"born already ended\", and the write instant\n * the backend stamps as `valid_from` is a storage convention rather than a\n * caller assertion — the row is deliberately not current and is read back\n * through `includeEnded`. Only an UPDATE has a lower bound the caller can be\n * held to.\n *\n * @param subject - Human-readable identification of the row, for the message\n *   (e.g. `Person \"01H...\"`).\n * @param validFrom - The caller's explicit lower bound, if any.\n * @param lowerBound - What the write will do with the row's lower bound; see\n *   {@link UpdateValidityLowerBound}.\n * @returns {@link ValidityWindowVerdict} — the `expectedValidFrom` fence this\n *   verdict obliges the write to carry, empty when it read no stored bound.\n * @throws ValidationError with issue code {@link INVERTED_VALIDITY_WINDOW_CODE}\n *   or {@link IMMUTABLE_VALIDITY_LOWER_BOUND_CODE}\n */\nexport function assertWritableValidityWindow(\n  subject: string,\n  validFrom: string | undefined,\n  lowerBound: UpdateValidityLowerBound,\n  validTo: string | undefined,\n): ValidityWindowVerdict {\n  assertOrderedValidityWindow(subject, validFrom, validTo);\n\n  // The stated bound is COMPARED against the stored one only here — a write\n  // that applies what the caller stated has nothing to compare it to.\n  const comparedStatedBound =\n    validFrom !== undefined && !lowerBound.appliesStatedValidFrom;\n  if (comparedStatedBound) {\n    assertStatedLowerBoundIsApplicable(\n      subject,\n      validFrom,\n      lowerBound.effectiveValidFrom,\n    );\n  }\n\n  assertEffectiveValidityLowerBound(\n    subject,\n    validFrom ?? lowerBound.effectiveValidFrom,\n    validTo,\n  );\n  // ...and the inversion check falls back to the row's bound only when the\n  // caller named an end without a start. Note this is true whether or not the\n  // row HAS a bound: \"no lower bound to invert against\" is itself a reading of\n  // the row, and a recreate that gives the row one changes the answer.\n  const comparedStoredBoundAgainstEnd =\n    validFrom === undefined && validTo !== undefined;\n\n  const readEffectiveLowerBound =\n    comparedStatedBound || comparedStoredBoundAgainstEnd;\n  return {\n    storedLowerBoundFence:\n      readEffectiveLowerBound && lowerBound.effectiveBoundIsStored ?\n        // eslint-disable-next-line unicorn/no-null -- `expectedValidFrom` distinguishes \"assert IS NULL\" (null) from \"assert nothing\" (an absent key); see UpdateNodeParams.\n        { expectedValidFrom: lowerBound.effectiveValidFrom ?? null }\n      : {},\n  };\n}\n\n/**\n * Encodes a Date to an ISO 8601 string for storage.\n */\nexport function encodeDate(date: Date): string {\n  return date.toISOString();\n}\n\n/**\n * Decodes an ISO 8601 string to a Date.\n * Validates the string format first.\n *\n * @throws ValidationError if not a valid ISO datetime\n */\nexport function decodeDate(isoString: string): Date {\n  validateIsoDate(isoString, \"date\");\n  return new Date(isoString);\n}\n\n/**\n * Returns the current timestamp as an ISO string.\n */\nexport function nowIso(): string {\n  return new Date().toISOString();\n}\n"]}