@nicia-ai/typegraph 0.45.0 → 0.46.1

package/dist/chunk-MCLYU6BN.cjs

@@ -0,0 +1,332 @@
+'use strict';
+
+var chunkNI72YOJB_cjs = require('./chunk-NI72YOJB.cjs');
+
+// src/utils/date.ts
+var CANONICAL_ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+var ZONELESS_DATETIME_PATTERN = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?$/;
+var OFFSET_DATETIME_PATTERN = /^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)(Z|[+-]\d{2}(?::?\d{2})?)$/i;
+var DATE_ONLY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+function normalizedOffset(offset) {
+  if (offset.toUpperCase() === "Z") return "Z";
+  if (/^[+-]\d{2}$/.test(offset)) return `${offset}:00`;
+  if (/^[+-]\d{4}$/.test(offset)) {
+    return `${offset.slice(0, 3)}:${offset.slice(3)}`;
+  }
+  return offset;
+}
+function databaseTimestampMilliseconds(value) {
+  if (ZONELESS_DATETIME_PATTERN.test(value)) {
+    return Date.parse(`${value.replace(" ", "T")}Z`);
+  }
+  const offsetMatch = OFFSET_DATETIME_PATTERN.exec(value);
+  if (offsetMatch !== null) {
+    const date = offsetMatch[1];
+    const time = offsetMatch[2];
+    const offset = offsetMatch[3];
+    if (date === void 0 || time === void 0 || offset === void 0) {
+      return Number.NaN;
+    }
+    return Date.parse(`${date}T${time}${normalizedOffset(offset)}`);
+  }
+  if (DATE_ONLY_PATTERN.test(value)) {
+    return Date.parse(`${value}T00:00:00.000Z`);
+  }
+  return Number.NaN;
+}
+function canonicalizeDatabaseTimestamp(value) {
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) return void 0;
+    return value.toISOString();
+  }
+  if (typeof value !== "string") return void 0;
+  const milliseconds = databaseTimestampMilliseconds(value);
+  if (Number.isNaN(milliseconds)) return void 0;
+  return new Date(milliseconds).toISOString();
+}
+function isCanonicalIsoDate(value) {
+  if (!CANONICAL_ISO_DATE_PATTERN.test(value)) return false;
+  const date = new Date(value);
+  return !Number.isNaN(date.getTime()) && date.toISOString() === value;
+}
+function validateCanonicalIsoDate(value, fieldName) {
+  if (!isCanonicalIsoDate(value)) {
+    throw new chunkNI72YOJB_cjs.ValidationError(
+      `Invalid canonical ISO 8601 datetime for "${fieldName}": "${value}". Expected fixed-width UTC: YYYY-MM-DDTHH:mm:ss.sssZ`,
+      {
+        issues: [
+          {
+            path: fieldName,
+            message: `Expected canonical UTC ISO 8601 (YYYY-MM-DDTHH:mm:ss.sssZ), got: "${value}"`
+          }
+        ]
+      },
+      {
+        suggestion: `Use a fixed-width UTC datetime like "2024-01-15T10:30:00.000Z" (e.g. new Date(value).toISOString()).`
+      }
+    );
+  }
+  return value;
+}
+function validateOptionalCanonicalIsoDate(value, fieldName) {
+  if (value === void 0) return void 0;
+  return validateCanonicalIsoDate(value, fieldName);
+}
+function statedBoundMatchesStored(stated, stored) {
+  return stated === canonicalizeDatabaseTimestamp(stored);
+}
+function isInvertedValidityWindow(validFrom, validTo) {
+  if (validFrom === void 0 || validTo === void 0) return false;
+  return validFrom > validTo;
+}
+function assertEffectiveValidityLowerBound(subject, effectiveValidFrom, validTo) {
+  if (!isInvertedValidityWindow(effectiveValidFrom, validTo)) return;
+  throw new chunkNI72YOJB_cjs.ValidationError(
+    `Inverted validity window for ${subject}: the effective validFrom "${effectiveValidFrom}" is after validTo "${validTo}".`,
+    {
+      issues: [
+        {
+          path: "validTo",
+          code: chunkNI72YOJB_cjs.INVERTED_VALIDITY_WINDOW_CODE,
+          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.`
+        }
+      ]
+    },
+    {
+      suggestion: "Provide both validFrom and validTo for a historical window, or drop validTo to keep the row current."
+    }
+  );
+}
+function assertOrderedValidityWindow(subject, validFrom, validTo) {
+  if (!isInvertedValidityWindow(validFrom, validTo)) return;
+  throw new chunkNI72YOJB_cjs.ValidationError(
+    `Inverted validity window for ${subject}: validFrom "${validFrom}" is after validTo "${validTo}".`,
+    {
+      issues: [
+        {
+          path: "validFrom",
+          code: chunkNI72YOJB_cjs.INVERTED_VALIDITY_WINDOW_CODE,
+          message: `Expected validFrom <= validTo, got "${validFrom}" > "${validTo}"`
+        }
+      ]
+    },
+    {
+      suggestion: "Pass a validFrom at or before validTo, or omit validTo to leave the window open."
+    }
+  );
+}
+function preservesImmutableLowerBound(policy) {
+  return policy === "preserve";
+}
+function assertStatedLowerBoundIsApplicable(subject, statedValidFrom, storedValidFrom) {
+  if (statedBoundMatchesStored(statedValidFrom, storedValidFrom)) return;
+  const storedDescription = storedValidFrom === void 0 ? "the row has no lower bound" : `the row's stored lower bound is "${storedValidFrom}"`;
+  throw new chunkNI72YOJB_cjs.ValidationError(
+    `Unappliable validFrom for ${subject}: stated "${statedValidFrom}", but ${storedDescription} and the row is live.`,
+    {
+      issues: [
+        {
+          path: "validFrom",
+          code: chunkNI72YOJB_cjs.IMMUTABLE_VALIDITY_LOWER_BOUND_CODE,
+          message: `A live row's lower bound is history and an in-place update never rewrites it, so "${statedValidFrom}" could not be applied.`
+        }
+      ]
+    },
+    {
+      suggestion: storedValidFrom === void 0 ? "Omit validFrom: this row has no lower bound to restate, and only a resurrection can give it one." : `Restate the stored bound ("${storedValidFrom}") or omit validFrom.`
+    }
+  );
+}
+function assertWritableValidityWindow(subject, validFrom, lowerBound, validTo) {
+  assertOrderedValidityWindow(subject, validFrom, validTo);
+  const comparedStatedBound = validFrom !== void 0 && !lowerBound.appliesStatedValidFrom;
+  if (comparedStatedBound) {
+    assertStatedLowerBoundIsApplicable(
+      subject,
+      validFrom,
+      lowerBound.effectiveValidFrom
+    );
+  }
+  assertEffectiveValidityLowerBound(
+    subject,
+    validFrom ?? lowerBound.effectiveValidFrom,
+    validTo
+  );
+  const comparedStoredBoundAgainstEnd = validFrom === void 0 && validTo !== void 0;
+  const readEffectiveLowerBound = comparedStatedBound || comparedStoredBoundAgainstEnd;
+  return {
+    storedLowerBoundFence: readEffectiveLowerBound && lowerBound.effectiveBoundIsStored ? (
+      // eslint-disable-next-line unicorn/no-null -- `expectedValidFrom` distinguishes "assert IS NULL" (null) from "assert nothing" (an absent key); see UpdateNodeParams.
+      { expectedValidFrom: lowerBound.effectiveValidFrom ?? null }
+    ) : {}
+  };
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+
+// src/core/temporal.ts
+var RECORDED_INSTANT_VERSION = "r1";
+var RECORDED_REVISION_WIDTH = 16;
+var RECORDED_MAX_REVISION = Number.MAX_SAFE_INTEGER;
+var RECORDED_INSTANT_PATTERN = /^r1:(\d{16}):(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)$/;
+function invalidRecordedInstant(value, path) {
+  return new chunkNI72YOJB_cjs.ValidationError(
+    `${path} must be a canonical versioned recorded instant.`,
+    {
+      issues: [
+        {
+          path,
+          message: `Expected ${RECORDED_INSTANT_VERSION}:<${RECORDED_REVISION_WIDTH}-digit revision>:YYYY-MM-DDTHH:mm:ss.sssZ, got "${value}"`
+        }
+      ]
+    },
+    {
+      suggestion: "Persist the exact string returned by store.recordedNow(); migrate preview-schema checkpoints with migrateLegacyRecordedTime() and migrateRecordedAnchor()."
+    }
+  );
+}
+function parseRecordedInstant(value, path = "RecordedInstant") {
+  const match = RECORDED_INSTANT_PATTERN.exec(value);
+  if (match === null) throw invalidRecordedInstant(value, path);
+  const revisionText = match[1];
+  const recordedAt = match[2];
+  if (revisionText === void 0 || recordedAt === void 0) {
+    throw invalidRecordedInstant(value, path);
+  }
+  const revision = Number(revisionText);
+  if (!Number.isSafeInteger(revision) || revision < 1 || revision >= RECORDED_MAX_REVISION) {
+    throw invalidRecordedInstant(value, path);
+  }
+  validateCanonicalIsoDate(recordedAt, path);
+  return { revision, recordedAt };
+}
+function assertValidRecordedInstant(value, path) {
+  parseRecordedInstant(value, path);
+}
+function optionalRecordedInstantParts(value, path = "RecordedInstant") {
+  return value === void 0 ? void 0 : parseRecordedInstant(value, path);
+}
+function createRecordedInstant(revision, recordedAt) {
+  if (!Number.isSafeInteger(revision) || revision < 1 || revision >= RECORDED_MAX_REVISION) {
+    throw new chunkNI72YOJB_cjs.ValidationError(
+      "createRecordedInstant revision must be a valid recorded revision.",
+      {
+        issues: [
+          {
+            path: "createRecordedInstant.revision",
+            message: `Expected a safe integer from 1 through ${String(RECORDED_MAX_REVISION - 1)}, got ${String(revision)}`
+          }
+        ]
+      }
+    );
+  }
+  const revisionText = revision.toString().padStart(RECORDED_REVISION_WIDTH, "0");
+  return asRecordedInstant(
+    `${RECORDED_INSTANT_VERSION}:${revisionText}:${recordedAt}`
+  );
+}
+function recordedInstantWallTime(instant) {
+  return parseRecordedInstant(instant).recordedAt;
+}
+function recordedInstantRevision(instant) {
+  return parseRecordedInstant(instant).revision;
+}
+function compareRecordedInstants(left, right) {
+  const leftRevision = recordedInstantRevision(left);
+  const rightRevision = recordedInstantRevision(right);
+  if (leftRevision < rightRevision) return -1;
+  if (leftRevision > rightRevision) return 1;
+  return 0;
+}
+function asRecordedInstant(value) {
+  assertValidRecordedInstant(value, "asRecordedInstant");
+  return value;
+}
+function resolveReadCoordinate(mode, asOf, suggestion) {
+  if (mode !== "asOf" && asOf !== void 0) {
+    throw new chunkNI72YOJB_cjs.ValidationError(
+      `Temporal mode "${mode}" does not take an asOf timestamp.`,
+      {
+        issues: [
+          {
+            path: "asOf",
+            message: `asOf is only valid with mode "asOf", not "${mode}"`
+          }
+        ]
+      },
+      {
+        suggestion: 'Pin an instant with store.asOf(timestamp) or store.view({ mode: "asOf", asOf }); drop asOf for other modes.'
+      }
+    );
+  }
+  assertValidAsOf(
+    mode,
+    asOf,
+    suggestion === void 0 ? void 0 : { suggestion }
+  );
+  return { valid: asOf === void 0 ? { mode } : { mode, asOf } };
+}
+function withRecordedCoordinate(coordinate, recordedAsOf) {
+  assertValidRecordedInstant(recordedAsOf, "asOfRecorded");
+  return {
+    ...coordinate,
+    recorded: { asOf: recordedAsOf }
+  };
+}
+function assertValidAsOf(mode, asOf, options) {
+  if (mode === "asOf" && asOf === void 0) {
+    throw new chunkNI72YOJB_cjs.ValidationError(
+      'Temporal mode "asOf" requires a timestamp',
+      {
+        issues: [
+          { path: "asOf", message: "Timestamp is required for asOf mode" }
+        ]
+      },
+      {
+        suggestion: options?.suggestion ?? 'Provide an ISO-8601 timestamp for asOf mode, e.g. "2026-01-01T00:00:00.000Z".'
+      }
+    );
+  }
+  if (asOf !== void 0) {
+    validateCanonicalIsoDate(asOf, "asOf");
+  }
+}
+function describeCoordinate(coordinate) {
+  const { mode, asOf } = coordinate.valid;
+  const valid = asOf === void 0 ? `mode "${mode}"` : `mode "${mode}" asOf ${asOf}`;
+  return coordinate.recorded === void 0 ? valid : `${valid}, recorded asOf ${coordinate.recorded.asOf}`;
+}
+function coordinateContext(coordinate) {
+  const { mode, asOf } = coordinate.valid;
+  return {
+    temporalMode: mode,
+    ...asOf !== void 0 && { asOf },
+    ...coordinate.recorded === void 0 ? {} : { recordedAsOf: coordinate.recorded.asOf }
+  };
+}
+
+exports.RECORDED_MAX_REVISION = RECORDED_MAX_REVISION;
+exports.asRecordedInstant = asRecordedInstant;
+exports.assertOrderedValidityWindow = assertOrderedValidityWindow;
+exports.assertValidRecordedInstant = assertValidRecordedInstant;
+exports.assertWritableValidityWindow = assertWritableValidityWindow;
+exports.canonicalizeDatabaseTimestamp = canonicalizeDatabaseTimestamp;
+exports.compareRecordedInstants = compareRecordedInstants;
+exports.coordinateContext = coordinateContext;
+exports.createRecordedInstant = createRecordedInstant;
+exports.describeCoordinate = describeCoordinate;
+exports.isCanonicalIsoDate = isCanonicalIsoDate;
+exports.isInvertedValidityWindow = isInvertedValidityWindow;
+exports.nowIso = nowIso;
+exports.optionalRecordedInstantParts = optionalRecordedInstantParts;
+exports.parseRecordedInstant = parseRecordedInstant;
+exports.preservesImmutableLowerBound = preservesImmutableLowerBound;
+exports.recordedInstantRevision = recordedInstantRevision;
+exports.recordedInstantWallTime = recordedInstantWallTime;
+exports.resolveReadCoordinate = resolveReadCoordinate;
+exports.statedBoundMatchesStored = statedBoundMatchesStored;
+exports.validateOptionalCanonicalIsoDate = validateOptionalCanonicalIsoDate;
+exports.withRecordedCoordinate = withRecordedCoordinate;
+//# sourceMappingURL=chunk-MCLYU6BN.cjs.map
+//# sourceMappingURL=chunk-MCLYU6BN.cjs.map

package/dist/chunk-MCLYU6BN.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/date.ts","../src/core/temporal.ts"],"names":["ValidationError","INVERTED_VALIDITY_WINDOW_CODE","IMMUTABLE_VALIDITY_LOWER_BOUND_CODE"],"mappings":"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","file":"chunk-MCLYU6BN.cjs","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 a node 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","/**\n * Shared temporal coordinate + validation.\n */\nimport { ValidationError } from \"../errors\";\nimport { validateCanonicalIsoDate } from \"../utils/date\";\nimport { type TemporalMode } from \"./types\";\n\nconst RECORDED_INSTANT_VERSION = \"r1\";\nconst RECORDED_REVISION_WIDTH = 16;\n/** Open interval ceiling for numeric recorded-revision columns. */\nexport const RECORDED_MAX_REVISION = Number.MAX_SAFE_INTEGER;\nconst RECORDED_INSTANT_PATTERN =\n  /^r1:(\\d{16}):(\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z)$/;\n\ndeclare const RECORDED_INSTANT_BRAND: unique symbol;\n\n/**\n * A versioned recorded-time anchor containing a fixed-width logical revision\n * and a canonical UTC physical timestamp:\n * `r1:0000000000000001:YYYY-MM-DDTHH:mm:ss.sssZ`.\n *\n * Logical revisions are strictly monotonic per graph and make every commit\n * addressable even when many commits share one wall-clock millisecond. The\n * timestamp is a non-decreasing physical wall-time high-water mark used by\n * diagonal valid-time reads. Same-millisecond commits repeat it; backward clock\n * corrections hold it at the previous value until wall time catches up. The\n * string is canonical and lexicographically ordered by revision, so it can\n * round-trip through plain string checkpoint columns without a custom\n * serializer.\n */\nexport type RecordedInstant = string & {\n  readonly [RECORDED_INSTANT_BRAND]: \"RecordedInstant\";\n};\n\nexport type RecordedInstantParts = Readonly<{\n  revision: number;\n  recordedAt: string;\n}>;\n\nfunction invalidRecordedInstant(value: string, path: string): ValidationError {\n  return new ValidationError(\n    `${path} must be a canonical versioned recorded instant.`,\n    {\n      issues: [\n        {\n          path,\n          message: `Expected ${RECORDED_INSTANT_VERSION}:<${RECORDED_REVISION_WIDTH}-digit revision>:YYYY-MM-DDTHH:mm:ss.sssZ, got \"${value}\"`,\n        },\n      ],\n    },\n    {\n      suggestion:\n        \"Persist the exact string returned by store.recordedNow(); migrate preview-schema checkpoints with migrateLegacyRecordedTime() and migrateRecordedAnchor().\",\n    },\n  );\n}\n\nexport function parseRecordedInstant(\n  value: string,\n  path = \"RecordedInstant\",\n): RecordedInstantParts {\n  const match = RECORDED_INSTANT_PATTERN.exec(value);\n  if (match === null) throw invalidRecordedInstant(value, path);\n  const revisionText = match[1];\n  const recordedAt = match[2];\n  if (revisionText === undefined || recordedAt === undefined) {\n    throw invalidRecordedInstant(value, path);\n  }\n  const revision = Number(revisionText);\n  if (\n    !Number.isSafeInteger(revision) ||\n    revision < 1 ||\n    revision >= RECORDED_MAX_REVISION\n  ) {\n    throw invalidRecordedInstant(value, path);\n  }\n  validateCanonicalIsoDate(recordedAt, path);\n  return { revision, recordedAt };\n}\n\nexport function assertValidRecordedInstant(value: string, path: string): void {\n  parseRecordedInstant(value, path);\n}\n\n/**\n * Splits an optional recorded anchor into the numeric revision that recorded\n * relations store their `recorded_from`/`recorded_to` boundaries as, and the\n * wall time that valid-time windows are measured against. Compilers that\n * consult both halves parse once through this instead of per predicate.\n */\nexport function optionalRecordedInstantParts(\n  value: string | undefined,\n  path = \"RecordedInstant\",\n): RecordedInstantParts | undefined {\n  return value === undefined ? undefined : parseRecordedInstant(value, path);\n}\n\nexport function createRecordedInstant(\n  revision: number,\n  recordedAt: string,\n): RecordedInstant {\n  if (\n    !Number.isSafeInteger(revision) ||\n    revision < 1 ||\n    revision >= RECORDED_MAX_REVISION\n  ) {\n    throw new ValidationError(\n      \"createRecordedInstant revision must be a valid recorded revision.\",\n      {\n        issues: [\n          {\n            path: \"createRecordedInstant.revision\",\n            message: `Expected a safe integer from 1 through ${String(RECORDED_MAX_REVISION - 1)}, got ${String(revision)}`,\n          },\n        ],\n      },\n    );\n  }\n  const revisionText = revision\n    .toString()\n    .padStart(RECORDED_REVISION_WIDTH, \"0\");\n  return asRecordedInstant(\n    `${RECORDED_INSTANT_VERSION}:${revisionText}:${recordedAt}`,\n  );\n}\n\n/**\n * Returns the canonical UTC wall-time component of a recorded anchor.\n *\n * The value is non-decreasing per graph, but it is not the commit-order key;\n * use the complete {@link RecordedInstant} when ordering or replaying commits.\n */\nexport function recordedInstantWallTime(instant: RecordedInstant): string {\n  return parseRecordedInstant(instant).recordedAt;\n}\n\n/** Returns the strict per-graph logical revision carried by an anchor. */\nexport function recordedInstantRevision(instant: RecordedInstant): number {\n  return parseRecordedInstant(instant).revision;\n}\n\n/**\n * Compares two recorded anchors by logical revision.\n *\n * Revisions are local to a graph, so only compare anchors produced by the same\n * graph. The physical wall-time component deliberately does not participate.\n */\nexport function compareRecordedInstants(\n  left: RecordedInstant,\n  right: RecordedInstant,\n): -1 | 0 | 1 {\n  const leftRevision = recordedInstantRevision(left);\n  const rightRevision = recordedInstantRevision(right);\n  if (leftRevision < rightRevision) return -1;\n  if (leftRevision > rightRevision) return 1;\n  return 0;\n}\n\n/**\n * Brands a canonical versioned anchor string as a {@link RecordedInstant}.\n *\n * The escape hatch for an instant that round-trips through untyped storage:\n * captured from {@link Store.recordedNow}, persisted as a plain string, read\n * back, and replayed into `asOfRecorded`. Validates the canonical form eagerly —\n * the same check `asOfRecorded` applies — so a malformed value fails here, at the\n * brand site, rather than deeper in a read. Does *not* assert the instant is a\n * real captured commit; it only guarantees the value is well-formed enough to\n * compare correctly against the recorded relations.\n *\n * @throws {ValidationError} when `value` is not a canonical versioned anchor.\n */\nexport function asRecordedInstant(value: string): RecordedInstant {\n  assertValidRecordedInstant(value, \"asRecordedInstant\");\n  return value as RecordedInstant;\n}\n\n/**\n * The single opaque temporal coordinate every pinned read is resolved\n * against. It carries the valid-time axis plus an optional recorded/system-time\n * axis, so every surface can inject one coordinate object instead of threading\n * each temporal dimension separately.\n */\nexport type ReadCoordinate = Readonly<{\n  /**\n   * The valid-time axis: a resolved temporal mode and (only for `\"asOf\"`) the\n   * instant it is pinned to.\n   */\n  valid: Readonly<{\n    mode: TemporalMode;\n    /** Defined only when `mode` is `\"asOf\"`. */\n    asOf?: string;\n  }>;\n  /** The recorded/system-time axis. Defined only for recorded-pinned views. */\n  recorded?: Readonly<{ asOf: RecordedInstant }>;\n}>;\n\n/**\n * Resolves and validates a `(mode, asOf)` pair into a {@link ReadCoordinate}.\n * Rejects an `asOf` paired with any non-`\"asOf\"` mode rather than silently\n * dropping it — pinning an instant is only meaningful in `\"asOf\"` mode, so a\n * `view({ mode: \"current\", asOf })` is a caller mistake, not a coordinate to\n * quietly discard. Then validates via {@link assertValidAsOf}.\n *\n * @param mode - The temporal mode to pin.\n * @param asOf - The supplied timestamp. Required for `\"asOf\"`; rejected for\n *   every other mode.\n * @param suggestion - Caller-specific remediation hint for the\n *   missing/invalid-timestamp case.\n */\nexport function resolveReadCoordinate(\n  mode: TemporalMode,\n  asOf: string | undefined,\n  suggestion?: string,\n): ReadCoordinate {\n  if (mode !== \"asOf\" && asOf !== undefined) {\n    throw new ValidationError(\n      `Temporal mode \"${mode}\" does not take an asOf timestamp.`,\n      {\n        issues: [\n          {\n            path: \"asOf\",\n            message: `asOf is only valid with mode \"asOf\", not \"${mode}\"`,\n          },\n        ],\n      },\n      {\n        suggestion:\n          'Pin an instant with store.asOf(timestamp) or store.view({ mode: \"asOf\", asOf }); drop asOf for other modes.',\n      },\n    );\n  }\n  assertValidAsOf(\n    mode,\n    asOf,\n    suggestion === undefined ? undefined : { suggestion },\n  );\n  return { valid: asOf === undefined ? { mode } : { mode, asOf } };\n}\n\n/**\n * Adds a recorded/system-time pin to an existing valid-time coordinate.\n * Direct `store.asOfRecorded(T)` passes the diagonal valid-time coordinate\n * (`mode: \"asOf\", asOf: T`); `store.asOf(vt).asOfRecorded(rt)` passes the\n * already-resolved valid coordinate and adds the recorded sibling.\n */\nexport function withRecordedCoordinate(\n  coordinate: ReadCoordinate,\n  recordedAsOf: RecordedInstant,\n): ReadCoordinate {\n  assertValidRecordedInstant(recordedAsOf, \"asOfRecorded\");\n  return {\n    ...coordinate,\n    recorded: { asOf: recordedAsOf },\n  };\n}\n\n/**\n * Validates the `asOf` coordinate of a temporal read: `\"asOf\"` mode\n * requires a timestamp, and any supplied timestamp must be a canonical\n * fixed-width UTC ISO-8601 string (`YYYY-MM-DDTHH:mm:ss.sssZ`). The latter\n * is load-bearing — temporal filters compare `asOf` against `valid_from` /\n * `valid_to` as text on SQLite, so a non-canonical value (date-only, an\n * offset, natural language, or variable-width / missing milliseconds like\n * `.1Z`) would sort and compare wrong rather than error. Reached only through\n * {@link resolveReadCoordinate}, which every temporal read entry point routes\n * through (direct reads, queries, subgraphs, algorithms, and StoreView), so\n * they all fail identically.\n *\n * @param mode - The resolved temporal mode.\n * @param asOf - The supplied timestamp (may be `undefined`).\n * @param options.suggestion - A caller-specific remediation hint for the\n *   missing-timestamp case.\n *\n * @throws {ValidationError} when `mode` is `\"asOf\"` and `asOf` is missing, or\n *   when any supplied `asOf` is not a canonical UTC ISO-8601 timestamp. The\n *   canonical check runs for *every* mode that consumes `asOf`, so a\n *   non-canonical value can never reach a text comparison.\n */\nfunction assertValidAsOf(\n  mode: TemporalMode,\n  asOf: string | undefined,\n  options?: Readonly<{ suggestion?: string }>,\n): void {\n  if (mode === \"asOf\" && asOf === undefined) {\n    throw new ValidationError(\n      'Temporal mode \"asOf\" requires a timestamp',\n      {\n        issues: [\n          { path: \"asOf\", message: \"Timestamp is required for asOf mode\" },\n        ],\n      },\n      {\n        suggestion:\n          options?.suggestion ??\n          'Provide an ISO-8601 timestamp for asOf mode, e.g. \"2026-01-01T00:00:00.000Z\".',\n      },\n    );\n  }\n  if (asOf !== undefined) {\n    validateCanonicalIsoDate(asOf, \"asOf\");\n  }\n}\n\n/**\n * A human-readable description of a coordinate for error messages, e.g.\n * `mode \"current\"` or `mode \"asOf\" asOf 2026-01-01T00:00:00.000Z`. Shared by\n * every refusal path (the `StoreView` read-only / current-only / search facades\n * and the sealed-query builder) so they describe a coordinate identically — and\n * a future axis (recorded time) is reflected everywhere from one place.\n */\nexport function describeCoordinate(coordinate: ReadCoordinate): string {\n  const { mode, asOf } = coordinate.valid;\n  const valid =\n    asOf === undefined ? `mode \"${mode}\"` : `mode \"${mode}\" asOf ${asOf}`;\n  return coordinate.recorded === undefined ?\n      valid\n    : `${valid}, recorded asOf ${coordinate.recorded.asOf}`;\n}\n\n/**\n * The structured error-context fields describing a coordinate, shared by the\n * same refusal paths as {@link describeCoordinate}.\n */\nexport function coordinateContext(\n  coordinate: ReadCoordinate,\n): Record<string, unknown> {\n  const { mode, asOf } = coordinate.valid;\n  return {\n    temporalMode: mode,\n    ...(asOf !== undefined && { asOf }),\n    ...(coordinate.recorded === undefined ?\n      {}\n    : { recordedAsOf: coordinate.recorded.asOf }),\n  };\n}\n"]}

package/dist/{chunk-MIJKEVV7.js → chunk-MSY7FSX4.js}

@@ -1,6 +1,6 @@
 import { MAX_PG_IDENTIFIER_LENGTH } from './chunk-2EBMPJBO.js';
-import { typeGraphGlobalSymbol, sql, isSqlFragment } from './chunk-6DCB664D.js';
-import { ConfigurationError } from './chunk-4MB3AQAQ.js';
+import { typeGraphGlobalSymbol, sql, isSqlFragment } from './chunk-PQBQG7IM.js';
+import { ConfigurationError } from './chunk-J3WZ3FA2.js';
 
 // src/query/compiler/schema.ts
 var SQL_SCHEMA_BRAND = typeGraphGlobalSymbol("sql-schema-v1");
@@ -14,6 +14,10 @@ var SqlSchemaDescriptor = class extends SqlSchema {
   recordedEdgesTable;
   recordedClockTable;
   revisionOriginsTable;
+  identityAssertionsTable;
+  recordedIdentityAssertionsTable;
+  identityClosureTable;
+  identitySeparationTable;
   fulltextTable;
   constructor(fields) {
     super();
@@ -30,6 +34,10 @@ var SqlSchemaDescriptor = class extends SqlSchema {
     this.recordedEdgesTable = fields.recordedEdgesTable;
     this.recordedClockTable = fields.recordedClockTable;
     this.revisionOriginsTable = fields.revisionOriginsTable;
+    this.identityAssertionsTable = fields.identityAssertionsTable;
+    this.recordedIdentityAssertionsTable = fields.recordedIdentityAssertionsTable;
+    this.identityClosureTable = fields.identityClosureTable;
+    this.identitySeparationTable = fields.identitySeparationTable;
     this.fulltextTable = fields.fulltextTable;
     Object.freeze(this);
   }
@@ -41,6 +49,10 @@ var DEFAULT_TABLE_NAMES = {
   recordedEdges: "typegraph_recorded_edges",
   recordedClock: "typegraph_recorded_clock",
   revisionOrigins: "typegraph_revision_origins",
+  identityAssertions: "typegraph_identity_assertions",
+  recordedIdentityAssertions: "typegraph_recorded_identity_assertions",
+  identityClosure: "typegraph_identity_closure",
+  identitySeparation: "typegraph_identity_separation",
   fulltext: "typegraph_node_fulltext",
   uniques: "typegraph_node_uniques"
 };
@@ -52,6 +64,10 @@ function resolveTableNames(names) {
     recordedEdges: names.recordedEdges ?? DEFAULT_TABLE_NAMES.recordedEdges,
     recordedClock: names.recordedClock ?? DEFAULT_TABLE_NAMES.recordedClock,
     revisionOrigins: names.revisionOrigins ?? DEFAULT_TABLE_NAMES.revisionOrigins,
+    identityAssertions: names.identityAssertions ?? DEFAULT_TABLE_NAMES.identityAssertions,
+    recordedIdentityAssertions: names.recordedIdentityAssertions ?? DEFAULT_TABLE_NAMES.recordedIdentityAssertions,
+    identityClosure: names.identityClosure ?? DEFAULT_TABLE_NAMES.identityClosure,
+    identitySeparation: names.identitySeparation ?? DEFAULT_TABLE_NAMES.identitySeparation,
     fulltext: names.fulltext ?? DEFAULT_TABLE_NAMES.fulltext,
     uniques: names.uniques ?? DEFAULT_TABLE_NAMES.uniques
   };
@@ -98,6 +114,13 @@ function createSqlSchema(names = {}) {
   validateTableName(tables.recordedEdges, "recordedEdges");
   validateTableName(tables.recordedClock, "recordedClock");
   validateTableName(tables.revisionOrigins, "revisionOrigins");
+  validateTableName(tables.identityAssertions, "identityAssertions");
+  validateTableName(
+    tables.recordedIdentityAssertions,
+    "recordedIdentityAssertions"
+  );
+  validateTableName(tables.identityClosure, "identityClosure");
+  validateTableName(tables.identitySeparation, "identitySeparation");
   validateTableName(tables.fulltext, "fulltext");
   validateTableName(tables.uniques, "uniques");
   return freezeSqlSchema({
@@ -108,6 +131,12 @@ function createSqlSchema(names = {}) {
     recordedEdgesTable: sql.identifier(tables.recordedEdges),
     recordedClockTable: sql.identifier(tables.recordedClock),
     revisionOriginsTable: sql.identifier(tables.revisionOrigins),
+    identityAssertionsTable: sql.identifier(tables.identityAssertions),
+    recordedIdentityAssertionsTable: sql.identifier(
+      tables.recordedIdentityAssertions
+    ),
+    identityClosureTable: sql.identifier(tables.identityClosure),
+    identitySeparationTable: sql.identifier(tables.identitySeparation),
     fulltextTable: sql.identifier(tables.fulltext)
   });
 }
@@ -189,6 +218,10 @@ function recordedReadSqlSchema(binding) {
     recordedEdgesTable: schema.recordedEdgesTable,
     recordedClockTable: schema.recordedClockTable,
     revisionOriginsTable: schema.revisionOriginsTable,
+    identityAssertionsTable: schema.identityAssertionsTable,
+    recordedIdentityAssertionsTable: schema.recordedIdentityAssertionsTable,
+    identityClosureTable: schema.identityClosureTable,
+    identitySeparationTable: schema.identitySeparationTable,
     fulltextTable: schema.fulltextTable
   });
 }
@@ -207,5 +240,5 @@ var FULLTEXT_CTE_ALIAS = "cte_fulltext";
 var HYBRID_CANDIDATES_CTE_ALIAS = "cte_relevance_candidates";
 
 export { ALIAS_CTE_PREFIX, DEFAULT_SQL_SCHEMA, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS, createRecordedReadBinding, createSqlSchema, recordedReadSchemaFor, recordedReadSqlSchema, recordedRelation, requireExternalRecordedReadSource, requireRecordedReadBinding, requireSqlSchema, vectorSlotKey };
-//# sourceMappingURL=chunk-MIJKEVV7.js.map
-//# sourceMappingURL=chunk-MIJKEVV7.js.map
+//# sourceMappingURL=chunk-MSY7FSX4.js.map
+//# sourceMappingURL=chunk-MSY7FSX4.js.map

package/dist/chunk-MSY7FSX4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/query/compiler/schema.ts"],"names":[],"mappings":";;;;;AAaA,IAAM,gBAAA,GAAkC,sBAAsB,eAAe,CAAA;AAiGtE,IAAe,YAAf,MAAoD;AAc3D,CAAA;AAEA,IAAM,mBAAA,GAAN,cAAkC,SAAA,CAAU;AAAA,EAEjC,MAAA;AAAA,EACA,UAAA;AAAA,EACA,UAAA;AAAA,EACA,kBAAA;AAAA,EACA,kBAAA;AAAA,EACA,kBAAA;AAAA,EACA,oBAAA;AAAA,EACA,uBAAA;AAAA,EACA,+BAAA;AAAA,EACA,oBAAA;AAAA,EACA,uBAAA;AAAA,EACA,aAAA;AAAA,EAET,YAAY,MAAA,EAAyB;AACnC,IAAA,KAAA,EAAM;AACN,IAAA,MAAA,CAAO,cAAA,CAAe,MAAM,gBAAA,EAAkB;AAAA,MAC5C,YAAA,EAAc,KAAA;AAAA,MACd,UAAA,EAAY,KAAA;AAAA,MACZ,KAAA,EAAO,IAAA;AAAA,MACP,QAAA,EAAU;AAAA,KACX,CAAA;AACD,IAAA,IAAA,CAAK,SAAS,MAAA,CAAO,MAAA;AACrB,IAAA,IAAA,CAAK,aAAa,MAAA,CAAO,UAAA;AACzB,IAAA,IAAA,CAAK,aAAa,MAAA,CAAO,UAAA;AACzB,IAAA,IAAA,CAAK,qBAAqB,MAAA,CAAO,kBAAA;AACjC,IAAA,IAAA,CAAK,qBAAqB,MAAA,CAAO,kBAAA;AACjC,IAAA,IAAA,CAAK,qBAAqB,MAAA,CAAO,kBAAA;AACjC,IAAA,IAAA,CAAK,uBAAuB,MAAA,CAAO,oBAAA;AACnC,IAAA,IAAA,CAAK,0BAA0B,MAAA,CAAO,uBAAA;AACtC,IAAA,IAAA,CAAK,kCACH,MAAA,CAAO,+BAAA;AACT,IAAA,IAAA,CAAK,uBAAuB,MAAA,CAAO,oBAAA;AACnC,IAAA,IAAA,CAAK,0BAA0B,MAAA,CAAO,uBAAA;AACtC,IAAA,IAAA,CAAK,gBAAgB,MAAA,CAAO,aAAA;AAC5B,IAAA,MAAA,CAAO,OAAO,IAAI,CAAA;AAAA,EACpB;AACF,CAAA;AAKA,IAAM,mBAAA,GAA6C;AAAA,EACjD,KAAA,EAAO,iBAAA;AAAA,EACP,KAAA,EAAO,iBAAA;AAAA,EACP,aAAA,EAAe,0BAAA;AAAA,EACf,aAAA,EAAe,0BAAA;AAAA,EACf,aAAA,EAAe,0BAAA;AAAA,EACf,eAAA,EAAiB,4BAAA;AAAA,EACjB,kBAAA,EAAoB,+BAAA;AAAA,EACpB,0BAAA,EAA4B,wCAAA;AAAA,EAC5B,eAAA,EAAiB,4BAAA;AAAA,EACjB,kBAAA,EAAoB,+BAAA;AAAA,EACpB,QAAA,EAAU,yBAAA;AAAA,EACV,OAAA,EAAS;AACX,CAAA;AAEA,SAAS,kBACP,KAAA,EACuB;AACvB,EAAA,OAAO;AAAA,IACL,KAAA,EAAO,KAAA,CAAM,KAAA,IAAS,mBAAA,CAAoB,KAAA;AAAA,IAC1C,KAAA,EAAO,KAAA,CAAM,KAAA,IAAS,mBAAA,CAAoB,KAAA;AAAA,IAC1C,aAAA,EAAe,KAAA,CAAM,aAAA,IAAiB,mBAAA,CAAoB,aAAA;AAAA,IAC1D,aAAA,EAAe,KAAA,CAAM,aAAA,IAAiB,mBAAA,CAAoB,aAAA;AAAA,IAC1D,aAAA,EAAe,KAAA,CAAM,aAAA,IAAiB,mBAAA,CAAoB,aAAA;AAAA,IAC1D,eAAA,EACE,KAAA,CAAM,eAAA,IAAmB,mBAAA,CAAoB,eAAA;AAAA,IAC/C,kBAAA,EACE,KAAA,CAAM,kBAAA,IAAsB,mBAAA,CAAoB,kBAAA;AAAA,IAClD,0BAAA,EACE,KAAA,CAAM,0BAAA,IACN,mBAAA,CAAoB,0BAAA;AAAA,IACtB,eAAA,EACE,KAAA,CAAM,eAAA,IAAmB,mBAAA,CAAoB,eAAA;AAAA,IAC/C,kBAAA,EACE,KAAA,CAAM,kBAAA,IAAsB,mBAAA,CAAoB,kBAAA;AAAA,IAClD,QAAA,EAAU,KAAA,CAAM,QAAA,IAAY,mBAAA,CAAoB,QAAA;AAAA,IAChD,OAAA,EAAS,KAAA,CAAM,OAAA,IAAW,mBAAA,CAAoB;AAAA,GAChD;AACF;AAQA,IAAM,wBAAA,GAA2B,sBAAA;AAOjC,SAAS,iBAAA,CAAkB,MAAc,KAAA,EAAqB;AAC5D,EAAA,IAAI,CAAC,IAAA,IAAQ,IAAA,CAAK,MAAA,KAAW,CAAA,EAAG;AAC9B,IAAA,MAAM,IAAI,kBAAA,CAAmB,CAAA,EAAG,KAAK,CAAA,2BAAA,CAA6B,CAAA;AAAA,EACpE;AACA,EAAA,IAAI,IAAA,CAAK,SAAS,wBAAA,EAA0B;AAC1C,IAAA,MAAM,IAAI,kBAAA;AAAA,MACR,CAAA,EAAG,KAAK,CAAA,sCAAA,EAAyC,wBAAwB,CAAA,WAAA;AAAA,KAC3E;AAAA,EACF;AACA,EAAA,IAAI,CAAC,wBAAA,CAAyB,IAAA,CAAK,IAAI,CAAA,EAAG;AACxC,IAAA,MAAM,IAAI,kBAAA;AAAA,MACR,CAAA,EAAG,KAAK,CAAA,aAAA,EAAgB,IAAI,CAAA,mJAAA;AAAA,KAE9B;AAAA,EACF;AACF;AAEA,SAAS,gBAAgB,MAAA,EAAoC;AAC3D,EAAA,OAAO,IAAI,oBAAoB,MAAM,CAAA;AACvC;AAEA,SAAS,YAAY,MAAA,EAAsC;AACzD,EAAA,IAAI,OAAO,MAAA,KAAW,QAAA,IAAY,MAAA,KAAW,MAAM,OAAO,KAAA;AAC1D,EAAA,MAAM,SAAA,GAAY,MAAA;AAClB,EAAA,OACE,SAAA,CAAU,gBAAgB,CAAA,KAAM,IAAA,IAChC,OAAO,SAAA,CAAU,QAAQ,CAAA,KAAM,QAAA,IAC/B,SAAA,CAAU,QAAQ,CAAA,KAAM,IAAA,IACxB,OAAO,QAAA,CAAS,SAAA,CAAU,QAAQ,CAAC,CAAA,IACnC,aAAA,CAAc,SAAA,CAAU,YAAY,CAAC,CAAA,IACrC,aAAA,CAAc,SAAA,CAAU,YAAY,CAAC,KACrC,aAAA,CAAc,SAAA,CAAU,oBAAoB,CAAC,CAAA,IAC7C,aAAA,CAAc,SAAA,CAAU,oBAAoB,CAAC,CAAA,IAC7C,aAAA,CAAc,SAAA,CAAU,oBAAoB,CAAC,KAC7C,aAAA,CAAc,SAAA,CAAU,sBAAsB,CAAC,CAAA,IAC/C,aAAA,CAAc,SAAA,CAAU,eAAe,CAAC,CAAA,IACxC,MAAA,CAAO,QAAA,CAAS,SAAS,CAAA;AAE7B;AAEO,SAAS,gBAAA,CACd,MAAA,EACA,OAAA,GAAU,WAAA,EACC;AACX,EAAA,IAAI,WAAA,CAAY,MAAM,CAAA,EAAG,OAAO,MAAA;AAChC,EAAA,MAAM,IAAI,kBAAA;AAAA,IACR,GAAG,OAAO,CAAA,2CAAA,CAAA;AAAA,IACV,EAAE,IAAA,EAAM,oBAAA,EAAsB,OAAA,EAAQ;AAAA,IACtC;AAAA,MACE,UAAA,EACE;AAAA;AACJ,GACF;AACF;AAyBO,SAAS,eAAA,CAAgB,KAAA,GAAgC,EAAC,EAAc;AAC7E,EAAA,MAAM,MAAA,GAAS,kBAAkB,KAAK,CAAA;AAGtC,EAAA,iBAAA,CAAkB,MAAA,CAAO,OAAO,OAAO,CAAA;AACvC,EAAA,iBAAA,CAAkB,MAAA,CAAO,OAAO,OAAO,CAAA;AACvC,EAAA,iBAAA,CAAkB,MAAA,CAAO,eAAe,eAAe,CAAA;AACvD,EAAA,iBAAA,CAAkB,MAAA,CAAO,eAAe,eAAe,CAAA;AACvD,EAAA,iBAAA,CAAkB,MAAA,CAAO,eAAe,eAAe,CAAA;AACvD,EAAA,iBAAA,CAAkB,MAAA,CAAO,iBAAiB,iBAAiB,CAAA;AAC3D,EAAA,iBAAA,CAAkB,MAAA,CAAO,oBAAoB,oBAAoB,CAAA;AACjE,EAAA,iBAAA;AAAA,IACE,MAAA,CAAO,0BAAA;AAAA,IACP;AAAA,GACF;AACA,EAAA,iBAAA,CAAkB,MAAA,CAAO,iBAAiB,iBAAiB,CAAA;AAC3D,EAAA,iBAAA,CAAkB,MAAA,CAAO,oBAAoB,oBAAoB,CAAA;AACjE,EAAA,iBAAA,CAAkB,MAAA,CAAO,UAAU,UAAU,CAAA;AAC7C,EAAA,iBAAA,CAAkB,MAAA,CAAO,SAAS,SAAS,CAAA;AAE3C,EAAA,OAAO,eAAA,CAAgB;AAAA,IACrB,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,MAAM,CAAA;AAAA,IAC5B,UAAA,EAAY,GAAA,CAAI,UAAA,CAAW,MAAA,CAAO,KAAK,CAAA;AAAA,IACvC,UAAA,EAAY,GAAA,CAAI,UAAA,CAAW,MAAA,CAAO,KAAK,CAAA;AAAA,IACvC,kBAAA,EAAoB,GAAA,CAAI,UAAA,CAAW,MAAA,CAAO,aAAa,CAAA;AAAA,IACvD,kBAAA,EAAoB,GAAA,CAAI,UAAA,CAAW,MAAA,CAAO,aAAa,CAAA;AAAA,IACvD,kBAAA,EAAoB,GAAA,CAAI,UAAA,CAAW,MAAA,CAAO,aAAa,CAAA;AAAA,IACvD,oBAAA,EAAsB,GAAA,CAAI,UAAA,CAAW,MAAA,CAAO,eAAe,CAAA;AAAA,IAC3D,uBAAA,EAAyB,GAAA,CAAI,UAAA,CAAW,MAAA,CAAO,kBAAkB,CAAA;AAAA,IACjE,iCAAiC,GAAA,CAAI,UAAA;AAAA,MACnC,MAAA,CAAO;AAAA,KACT;AAAA,IACA,oBAAA,EAAsB,GAAA,CAAI,UAAA,CAAW,MAAA,CAAO,eAAe,CAAA;AAAA,IAC3D,uBAAA,EAAyB,GAAA,CAAI,UAAA,CAAW,MAAA,CAAO,kBAAkB,CAAA;AAAA,IACjE,aAAA,EAAe,GAAA,CAAI,UAAA,CAAW,MAAA,CAAO,QAAQ;AAAA,GAC9C,CAAA;AACH;AAYA,IAAM,6BAAA,GAA+C,qBAAA;AAAA,EACnD;AACF,CAAA;AAcA,IAAM,8BAAA,GAAgD,qBAAA;AAAA,EACpD;AACF,CAAA;AAiBO,SAAS,iBACd,OAAA,EAC4B;AAC5B,EAAA,MAAM,MAAA,GAAS,gBAAA,CAAiB,OAAA,CAAQ,MAAA,EAAQ,yBAAyB,CAAA;AACzE,EAAA,OAAO,OAAO,MAAA,CAAO;AAAA,IACnB,MAAA,EAAQ,UAAA;AAAA,IACR,MAAA;AAAA,IACA,CAAC,6BAA6B,GAAG;AAAA,GAClC,CAAA;AACH;AAEO,SAAS,kCACd,MAAA,EACwC;AACxC,EAAA,IAAI,MAAA,KAAW,QAAW,OAAO,MAAA;AACjC,EAAA,IAAI,4BAAA,CAA6B,MAAM,CAAA,EAAG,OAAO,MAAA;AACjD,EAAA,MAAM,IAAI,kBAAA;AAAA,IACR,iEAAA;AAAA,IACA,EAAE,MAAM,8BAAA,EAA+B;AAAA,IACvC;AAAA,MACE,UAAA,EACE;AAAA;AACJ,GACF;AACF;AAEA,SAAS,6BACP,MAAA,EACsC;AACtC,EAAA,IAAI,OAAO,MAAA,KAAW,QAAA,IAAY,MAAA,KAAW,MAAM,OAAO,KAAA;AAC1D,EAAA,MAAM,SAAA,GAAY,MAAA;AAClB,EAAA,OACE,SAAA,CAAU,MAAA,KAAW,UAAA,IACrB,SAAA,CAAU,6BAA6B,CAAA,KAAM,IAAA,IAC7C,WAAA,CAAY,SAAA,CAAU,MAAM,CAAA,IAC5B,MAAA,CAAO,SAAS,SAAS,CAAA;AAE7B;AAEO,SAAS,0BACd,MAAA,EAC6B;AAC7B,EAAA,MAAM,UAAA,GAAa,gBAAA,CAAiB,MAAA,EAAQ,8BAA8B,CAAA;AAC1E,EAAA,OAAO,OAAO,MAAA,CAAO;AAAA,IACnB,MAAA,EAAQ,mBAAA;AAAA,IACR,MAAA,EAAQ,UAAA;AAAA,IACR,CAAC,8BAA8B,GAAG;AAAA,GACnC,CAAA;AACH;AAEO,SAAS,0BAAA,CACd,SACA,OAAA,EACqB;AACrB,EAAA,IAAI,qBAAA,CAAsB,OAAO,CAAA,EAAG,OAAO,OAAA;AAC3C,EAAA,IAAI,YAAY,MAAA,EAAW;AACzB,IAAA,MAAM,IAAI,kBAAA;AAAA,MACR,4EAAA;AAAA,MACA,EAAE,IAAA,EAAM,+BAAA,EAAiC,OAAA,EAAQ;AAAA,MACjD;AAAA,QACE,UAAA,EACE;AAAA;AACJ,KACF;AAAA,EACF;AACA,EAAA,MAAM,IAAI,kBAAA;AAAA,IACR,uDAAA;AAAA,IACA,EAAE,IAAA,EAAM,gCAAA,EAAkC,OAAA,EAAQ;AAAA,IAClD;AAAA,MACE,UAAA,EACE;AAAA;AACJ,GACF;AACF;AAQA,SAAS,8BACP,MAAA,EACuC;AACvC,EAAA,IAAI,OAAO,MAAA,KAAW,QAAA,IAAY,MAAA,KAAW,MAAM,OAAO,KAAA;AAC1D,EAAA,MAAM,SAAA,GAAY,MAAA;AAClB,EAAA,OACE,SAAA,CAAU,MAAA,KAAW,mBAAA,IACrB,SAAA,CAAU,8BAA8B,CAAA,KAAM,IAAA,IAC9C,WAAA,CAAY,SAAA,CAAU,MAAM,CAAA,IAC5B,MAAA,CAAO,SAAS,SAAS,CAAA;AAE7B;AAEA,SAAS,sBACP,OAAA,EACgC;AAChC,EAAA,OACE,4BAAA,CAA6B,OAAO,CAAA,IACpC,6BAAA,CAA8B,OAAO,CAAA;AAEzC;AAQO,SAAS,sBAAsB,OAAA,EAAyC;AAC7E,EAAA,MAAM,EAAE,QAAO,GAAI,0BAAA;AAAA,IACjB,OAAA;AAAA,IACA;AAAA,GACF;AACA,EAAA,OAAO,eAAA,CAAgB;AAAA,IACrB,QAAQ,MAAA,CAAO,MAAA;AAAA,IACf,YAAY,MAAA,CAAO,kBAAA;AAAA,IACnB,YAAY,MAAA,CAAO,kBAAA;AAAA,IACnB,oBAAoB,MAAA,CAAO,kBAAA;AAAA,IAC3B,oBAAoB,MAAA,CAAO,kBAAA;AAAA,IAC3B,oBAAoB,MAAA,CAAO,kBAAA;AAAA,IAC3B,sBAAsB,MAAA,CAAO,oBAAA;AAAA,IAC7B,yBAAyB,MAAA,CAAO,uBAAA;AAAA,IAChC,iCAAiC,MAAA,CAAO,+BAAA;AAAA,IACxC,sBAAsB,MAAA,CAAO,oBAAA;AAAA,IAC7B,yBAAyB,MAAA,CAAO,uBAAA;AAAA,IAChC,eAAe,MAAA,CAAO;AAAA,GACvB,CAAA;AACH;AAOO,SAAS,qBAAA,CACd,MAAA,EACA,YAAA,EACA,OAAA,EACA,OAAA,EACW;AACX,EAAA,MAAM,UAAA,GAAa,gBAAA,CAAiB,MAAA,EAAQ,CAAA,EAAG,OAAO,CAAA,OAAA,CAAS,CAAA;AAC/D,EAAA,IAAI,YAAA,KAAiB,QAAW,OAAO,UAAA;AACvC,EAAA,OAAO,qBAAA,CAAsB,0BAAA,CAA2B,OAAA,EAAS,OAAO,CAAC,CAAA;AAC3E;AAKO,IAAM,qBAAgC,eAAA;AA0BtC,SAAS,aAAA,CAAc,UAAkB,SAAA,EAA2B;AACzE,EAAA,OAAO,CAAA,EAAG,QAAQ,CAAA,EAAA,EAAS,SAAS,CAAA,CAAA;AACtC;AAOO,IAAM,gBAAA,GAAmB;AACzB,IAAM,oBAAA,GAAuB;AAC7B,IAAM,kBAAA,GAAqB;AAC3B,IAAM,2BAAA,GAA8B","file":"chunk-MSY7FSX4.js","sourcesContent":["/**\n * SQL Schema Configuration for Query Compilation\n *\n * Provides table and column identifiers that the query compiler uses.\n * This allows the compiler to work with custom table names instead of\n * hard-coded defaults.\n */\nimport { type VectorIndexType, type VectorMetric } from \"../../backend/types\";\nimport { MAX_PG_IDENTIFIER_LENGTH } from \"../../constants\";\nimport { ConfigurationError } from \"../../errors\";\nimport { typeGraphGlobalSymbol } from \"../../utils/global-symbol\";\nimport { isSqlFragment, sql, type SqlFragment } from \"../sql-fragment\";\n\nconst SQL_SCHEMA_BRAND: unique symbol = typeGraphGlobalSymbol(\"sql-schema-v1\");\n\n/**\n * Table names for TypeGraph SQL schema.\n *\n * Carries every customizable physical-table name the backend exposes,\n * including the secondary tables (`uniques`) that the query compiler\n * itself doesn't reference but `materializeRemovals` and other\n * cleanup paths need to address by name. Backends without a\n * `uniques` table (custom embeddings-only stores) leave it as the\n * default — the cleanup path is a no-op for kinds with no unique\n * rows.\n */\nexport type SqlTableNames = Readonly<{\n  /** Nodes table name (default: \"typegraph_nodes\") */\n  nodes: string;\n  /** Edges table name (default: \"typegraph_edges\") */\n  edges: string;\n  /** Recorded node relation table name (default: \"typegraph_recorded_nodes\") */\n  recordedNodes?: string | undefined;\n  /** Recorded edge relation table name (default: \"typegraph_recorded_edges\") */\n  recordedEdges?: string | undefined;\n  /** Recorded-time commit clock table name (default: \"typegraph_recorded_clock\") */\n  recordedClock?: string | undefined;\n  /** Durable per-graph revision-origin table name (default: \"typegraph_revision_origins\") */\n  revisionOrigins?: string | undefined;\n  /** Identity assertion ledger (default: \"typegraph_identity_assertions\") */\n  identityAssertions?: string | undefined;\n  /** Recorded identity assertion relation */\n  recordedIdentityAssertions?: string | undefined;\n  /** Derived current identity closure */\n  identityClosure?: string | undefined;\n  /** Derived separation relation over identity classes */\n  identitySeparation?: string | undefined;\n  /** Node fulltext table name (default: \"typegraph_node_fulltext\") */\n  fulltext: string;\n  /** Node uniques table name (default: \"typegraph_node_uniques\") */\n  uniques: string;\n}>;\n\nexport type ResolvedSqlTableNames = Readonly<{\n  /** Nodes table name */\n  nodes: string;\n  /** Edges table name */\n  edges: string;\n  /** Recorded node relation table name */\n  recordedNodes: string;\n  /** Recorded edge relation table name */\n  recordedEdges: string;\n  /** Recorded-time commit clock table name */\n  recordedClock: string;\n  /** Durable per-graph revision-origin table name */\n  revisionOrigins: string;\n  identityAssertions: string;\n  recordedIdentityAssertions: string;\n  identityClosure: string;\n  identitySeparation: string;\n  /** Node fulltext table name */\n  fulltext: string;\n  /** Node uniques table name */\n  uniques: string;\n}>;\n\ntype SqlSchemaFields = Readonly<{\n  /** Table names */\n  tables: ResolvedSqlTableNames;\n  /** Get a `SqlFragment` reference to the nodes table. */\n  nodesTable: SqlFragment;\n  /** Get a `SqlFragment` reference to the edges table. */\n  edgesTable: SqlFragment;\n  /** Get a `SqlFragment` reference to the recorded node relation. */\n  recordedNodesTable: SqlFragment;\n  /** Get a `SqlFragment` reference to the recorded edge relation. */\n  recordedEdgesTable: SqlFragment;\n  /** Get a `SqlFragment` reference to the recorded-time commit clock. */\n  recordedClockTable: SqlFragment;\n  /** Get a `SqlFragment` reference to the durable per-graph revision origins. */\n  revisionOriginsTable: SqlFragment;\n  /** Get a `SqlFragment` reference to the identity assertion ledger. */\n  identityAssertionsTable: SqlFragment;\n  /** Get a `SqlFragment` reference to the recorded identity assertion relation. */\n  recordedIdentityAssertionsTable: SqlFragment;\n  /** Get a `SqlFragment` reference to the derived identity closure. */\n  identityClosureTable: SqlFragment;\n  /** Get a `SqlFragment` reference to the derived identity separation relation. */\n  identitySeparationTable: SqlFragment;\n  /** Get a `SqlFragment` reference to the fulltext table. */\n  fulltextTable: SqlFragment;\n}>;\n\n/**\n * SQL schema configuration for query compilation.\n * Contains table identifiers and utility methods for generating `SqlFragment` references.\n *\n * Branded and frozen by {@link createSqlSchema}; callers should not construct\n * schema-shaped objects by hand.\n */\nexport abstract class SqlSchema implements SqlSchemaFields {\n  declare private readonly typeGraphSqlSchemaBrand: true;\n  abstract readonly tables: ResolvedSqlTableNames;\n  abstract readonly nodesTable: SqlFragment;\n  abstract readonly edgesTable: SqlFragment;\n  abstract readonly recordedNodesTable: SqlFragment;\n  abstract readonly recordedEdgesTable: SqlFragment;\n  abstract readonly recordedClockTable: SqlFragment;\n  abstract readonly revisionOriginsTable: SqlFragment;\n  abstract readonly identityAssertionsTable: SqlFragment;\n  abstract readonly recordedIdentityAssertionsTable: SqlFragment;\n  abstract readonly identityClosureTable: SqlFragment;\n  abstract readonly identitySeparationTable: SqlFragment;\n  abstract readonly fulltextTable: SqlFragment;\n}\n\nclass SqlSchemaDescriptor extends SqlSchema {\n  declare readonly [SQL_SCHEMA_BRAND]: true;\n  readonly tables: ResolvedSqlTableNames;\n  readonly nodesTable: SqlFragment;\n  readonly edgesTable: SqlFragment;\n  readonly recordedNodesTable: SqlFragment;\n  readonly recordedEdgesTable: SqlFragment;\n  readonly recordedClockTable: SqlFragment;\n  readonly revisionOriginsTable: SqlFragment;\n  readonly identityAssertionsTable: SqlFragment;\n  readonly recordedIdentityAssertionsTable: SqlFragment;\n  readonly identityClosureTable: SqlFragment;\n  readonly identitySeparationTable: SqlFragment;\n  readonly fulltextTable: SqlFragment;\n\n  constructor(fields: SqlSchemaFields) {\n    super();\n    Object.defineProperty(this, SQL_SCHEMA_BRAND, {\n      configurable: false,\n      enumerable: false,\n      value: true,\n      writable: false,\n    });\n    this.tables = fields.tables;\n    this.nodesTable = fields.nodesTable;\n    this.edgesTable = fields.edgesTable;\n    this.recordedNodesTable = fields.recordedNodesTable;\n    this.recordedEdgesTable = fields.recordedEdgesTable;\n    this.recordedClockTable = fields.recordedClockTable;\n    this.revisionOriginsTable = fields.revisionOriginsTable;\n    this.identityAssertionsTable = fields.identityAssertionsTable;\n    this.recordedIdentityAssertionsTable =\n      fields.recordedIdentityAssertionsTable;\n    this.identityClosureTable = fields.identityClosureTable;\n    this.identitySeparationTable = fields.identitySeparationTable;\n    this.fulltextTable = fields.fulltextTable;\n    Object.freeze(this);\n  }\n}\n\n/**\n * Default table names matching the standard TypeGraph schema.\n */\nconst DEFAULT_TABLE_NAMES: ResolvedSqlTableNames = {\n  nodes: \"typegraph_nodes\",\n  edges: \"typegraph_edges\",\n  recordedNodes: \"typegraph_recorded_nodes\",\n  recordedEdges: \"typegraph_recorded_edges\",\n  recordedClock: \"typegraph_recorded_clock\",\n  revisionOrigins: \"typegraph_revision_origins\",\n  identityAssertions: \"typegraph_identity_assertions\",\n  recordedIdentityAssertions: \"typegraph_recorded_identity_assertions\",\n  identityClosure: \"typegraph_identity_closure\",\n  identitySeparation: \"typegraph_identity_separation\",\n  fulltext: \"typegraph_node_fulltext\",\n  uniques: \"typegraph_node_uniques\",\n};\n\nfunction resolveTableNames(\n  names: Partial<SqlTableNames>,\n): ResolvedSqlTableNames {\n  return {\n    nodes: names.nodes ?? DEFAULT_TABLE_NAMES.nodes,\n    edges: names.edges ?? DEFAULT_TABLE_NAMES.edges,\n    recordedNodes: names.recordedNodes ?? DEFAULT_TABLE_NAMES.recordedNodes,\n    recordedEdges: names.recordedEdges ?? DEFAULT_TABLE_NAMES.recordedEdges,\n    recordedClock: names.recordedClock ?? DEFAULT_TABLE_NAMES.recordedClock,\n    revisionOrigins:\n      names.revisionOrigins ?? DEFAULT_TABLE_NAMES.revisionOrigins,\n    identityAssertions:\n      names.identityAssertions ?? DEFAULT_TABLE_NAMES.identityAssertions,\n    recordedIdentityAssertions:\n      names.recordedIdentityAssertions ??\n      DEFAULT_TABLE_NAMES.recordedIdentityAssertions,\n    identityClosure:\n      names.identityClosure ?? DEFAULT_TABLE_NAMES.identityClosure,\n    identitySeparation:\n      names.identitySeparation ?? DEFAULT_TABLE_NAMES.identitySeparation,\n    fulltext: names.fulltext ?? DEFAULT_TABLE_NAMES.fulltext,\n    uniques: names.uniques ?? DEFAULT_TABLE_NAMES.uniques,\n  };\n}\n\n/**\n * Regex for valid SQL identifiers.\n * Must start with a letter or underscore.\n * Can contain letters, digits, underscores, and dollar signs.\n * Dollar signs are a PostgreSQL extension but commonly supported.\n */\nconst VALID_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_$]*$/i;\n\n/**\n * Validates that a table name is a valid SQL identifier.\n *\n * @throws Error if the table name is invalid\n */\nfunction validateTableName(name: string, label: string): void {\n  if (!name || name.length === 0) {\n    throw new ConfigurationError(`${label} table name cannot be empty`);\n  }\n  if (name.length > MAX_PG_IDENTIFIER_LENGTH) {\n    throw new ConfigurationError(\n      `${label} table name exceeds maximum length of ${MAX_PG_IDENTIFIER_LENGTH} characters`,\n    );\n  }\n  if (!VALID_IDENTIFIER_PATTERN.test(name)) {\n    throw new ConfigurationError(\n      `${label} table name \"${name}\" is not a valid SQL identifier. ` +\n        `Table names must start with a letter or underscore and contain only letters, digits, underscores, or dollar signs.`,\n    );\n  }\n}\n\nfunction freezeSqlSchema(fields: SqlSchemaFields): SqlSchema {\n  return new SqlSchemaDescriptor(fields);\n}\n\nfunction isSqlSchema(schema: unknown): schema is SqlSchema {\n  if (typeof schema !== \"object\" || schema === null) return false;\n  const candidate = schema as Record<PropertyKey, unknown>;\n  return (\n    candidate[SQL_SCHEMA_BRAND] === true &&\n    typeof candidate[\"tables\"] === \"object\" &&\n    candidate[\"tables\"] !== null &&\n    Object.isFrozen(candidate[\"tables\"]) &&\n    isSqlFragment(candidate[\"nodesTable\"]) &&\n    isSqlFragment(candidate[\"edgesTable\"]) &&\n    isSqlFragment(candidate[\"recordedNodesTable\"]) &&\n    isSqlFragment(candidate[\"recordedEdgesTable\"]) &&\n    isSqlFragment(candidate[\"recordedClockTable\"]) &&\n    isSqlFragment(candidate[\"revisionOriginsTable\"]) &&\n    isSqlFragment(candidate[\"fulltextTable\"]) &&\n    Object.isFrozen(candidate)\n  );\n}\n\nexport function requireSqlSchema(\n  schema: unknown,\n  surface = \"SqlSchema\",\n): SqlSchema {\n  if (isSqlSchema(schema)) return schema;\n  throw new ConfigurationError(\n    `${surface} must be created with createSqlSchema(...).`,\n    { code: \"INVALID_SQL_SCHEMA\", surface },\n    {\n      suggestion:\n        \"Pass the result of createSqlSchema(...) instead of a plain schema-shaped object.\",\n    },\n  );\n}\n\n/**\n * Creates a SqlSchema configuration from table names.\n *\n * Table names are validated to ensure they are valid SQL identifiers.\n * This prevents SQL injection and ensures compatibility across databases.\n *\n * @param names - Optional custom table names (defaults to standard names)\n * @returns SqlSchema configuration for query compilation\n * @throws Error if any table name is invalid\n *\n * @example\n * ```typescript\n * // Use default table names\n * const schema = createSqlSchema();\n *\n * // Use custom table names\n * const schema = createSqlSchema({\n *   nodes: \"myapp_nodes\",\n *   edges: \"myapp_edges\",\n *   fulltext: \"myapp_fulltext\",\n * });\n * ```\n */\nexport function createSqlSchema(names: Partial<SqlTableNames> = {}): SqlSchema {\n  const tables = resolveTableNames(names);\n\n  // Validate all table names\n  validateTableName(tables.nodes, \"nodes\");\n  validateTableName(tables.edges, \"edges\");\n  validateTableName(tables.recordedNodes, \"recordedNodes\");\n  validateTableName(tables.recordedEdges, \"recordedEdges\");\n  validateTableName(tables.recordedClock, \"recordedClock\");\n  validateTableName(tables.revisionOrigins, \"revisionOrigins\");\n  validateTableName(tables.identityAssertions, \"identityAssertions\");\n  validateTableName(\n    tables.recordedIdentityAssertions,\n    \"recordedIdentityAssertions\",\n  );\n  validateTableName(tables.identityClosure, \"identityClosure\");\n  validateTableName(tables.identitySeparation, \"identitySeparation\");\n  validateTableName(tables.fulltext, \"fulltext\");\n  validateTableName(tables.uniques, \"uniques\");\n\n  return freezeSqlSchema({\n    tables: Object.freeze(tables),\n    nodesTable: sql.identifier(tables.nodes),\n    edgesTable: sql.identifier(tables.edges),\n    recordedNodesTable: sql.identifier(tables.recordedNodes),\n    recordedEdgesTable: sql.identifier(tables.recordedEdges),\n    recordedClockTable: sql.identifier(tables.recordedClock),\n    revisionOriginsTable: sql.identifier(tables.revisionOrigins),\n    identityAssertionsTable: sql.identifier(tables.identityAssertions),\n    recordedIdentityAssertionsTable: sql.identifier(\n      tables.recordedIdentityAssertions,\n    ),\n    identityClosureTable: sql.identifier(tables.identityClosure),\n    identitySeparationTable: sql.identifier(tables.identitySeparation),\n    fulltextTable: sql.identifier(tables.fulltext),\n  });\n}\n\n/**\n * The recorded/system-time relation a read coordinate may reconstruct from.\n *\n * TypeGraph's built-in capture relation is bound by `createStore(..., {\n * history: true })`. Hosts can also bind externally populated row-compatible\n * recorded relations through `recordedRelation({ schema })`. Keeping both as\n * explicit values separates the read contract from the write-capture mechanism\n * so future external/TMS-owned recorded relations can feed the same query\n * machinery without changing StoreView or ReadCoordinate.\n */\nconst EXTERNAL_RECORDED_READ_SOURCE: unique symbol = typeGraphGlobalSymbol(\n  \"external-recorded-read-source-v1\",\n);\n\nexport type ExternalRecordedReadSource = Readonly<{\n  source: \"external\";\n  schema: SqlSchema;\n  [EXTERNAL_RECORDED_READ_SOURCE]: true;\n}>;\n\ntype ExternalRecordedReadSourceCandidate = Readonly<{\n  source?: unknown;\n  schema?: unknown;\n  [EXTERNAL_RECORDED_READ_SOURCE]?: unknown;\n}>;\n\nconst TYPEGRAPH_RECORDED_READ_SOURCE: unique symbol = typeGraphGlobalSymbol(\n  \"typegraph-recorded-read-source-v1\",\n);\n\nexport type TypeGraphRecordedReadSource = Readonly<{\n  source: \"typegraph-capture\";\n  schema: SqlSchema;\n  [TYPEGRAPH_RECORDED_READ_SOURCE]: true;\n}>;\n\ntype RecordedReadSource =\n  ExternalRecordedReadSource | TypeGraphRecordedReadSource;\n\nexport type RecordedReadBinding = RecordedReadSource;\n\nexport type RecordedRelationOptions = Readonly<{\n  schema: SqlSchema;\n}>;\n\nexport function recordedRelation(\n  options: RecordedRelationOptions,\n): ExternalRecordedReadSource {\n  const schema = requireSqlSchema(options.schema, \"recordedRelation schema\");\n  return Object.freeze({\n    source: \"external\",\n    schema,\n    [EXTERNAL_RECORDED_READ_SOURCE]: true as const,\n  });\n}\n\nexport function requireExternalRecordedReadSource(\n  source: unknown,\n): ExternalRecordedReadSource | undefined {\n  if (source === undefined) return undefined;\n  if (isExternalRecordedReadSource(source)) return source;\n  throw new ConfigurationError(\n    \"recordedRead must be created with recordedRelation({ schema }).\",\n    { code: \"INVALID_RECORDED_READ_SOURCE\" },\n    {\n      suggestion:\n        \"Pass { recordedRead: recordedRelation({ schema }) } for an externally populated recorded relation. Use { history: true } when TypeGraph should capture writes.\",\n    },\n  );\n}\n\nfunction isExternalRecordedReadSource(\n  source: unknown,\n): source is ExternalRecordedReadSource {\n  if (typeof source !== \"object\" || source === null) return false;\n  const candidate = source as ExternalRecordedReadSourceCandidate;\n  return (\n    candidate.source === \"external\" &&\n    candidate[EXTERNAL_RECORDED_READ_SOURCE] === true &&\n    isSqlSchema(candidate.schema) &&\n    Object.isFrozen(candidate)\n  );\n}\n\nexport function createRecordedReadBinding(\n  schema: SqlSchema,\n): TypeGraphRecordedReadSource {\n  const readSchema = requireSqlSchema(schema, \"recorded read binding schema\");\n  return Object.freeze({\n    source: \"typegraph-capture\",\n    schema: readSchema,\n    [TYPEGRAPH_RECORDED_READ_SOURCE]: true as const,\n  });\n}\n\nexport function requireRecordedReadBinding(\n  binding: unknown,\n  surface: string,\n): RecordedReadBinding {\n  if (isRecordedReadBinding(binding)) return binding;\n  if (binding !== undefined) {\n    throw new ConfigurationError(\n      \"Recorded-time reads require a recorded read relation created by TypeGraph.\",\n      { code: \"INVALID_RECORDED_READ_BINDING\", surface },\n      {\n        suggestion:\n          \"Use createStore(graph, backend, { history: true }) or { recordedRead: recordedRelation({ schema }) } instead of passing a plain object.\",\n      },\n    );\n  }\n  throw new ConfigurationError(\n    \"Recorded-time reads require a recorded read relation.\",\n    { code: \"RECORDED_READ_REQUIRES_BINDING\", surface },\n    {\n      suggestion:\n        \"Create the store with createStore(graph, backend, { history: true }) to bind TypeGraph's built-in captured relation, or pass { recordedRead: recordedRelation({ schema }) } for an externally populated recorded relation.\",\n    },\n  );\n}\n\ntype TypeGraphRecordedReadSourceCandidate = Readonly<{\n  source?: unknown;\n  schema?: unknown;\n  [TYPEGRAPH_RECORDED_READ_SOURCE]?: unknown;\n}>;\n\nfunction isTypeGraphRecordedReadSource(\n  source: unknown,\n): source is TypeGraphRecordedReadSource {\n  if (typeof source !== \"object\" || source === null) return false;\n  const candidate = source as TypeGraphRecordedReadSourceCandidate;\n  return (\n    candidate.source === \"typegraph-capture\" &&\n    candidate[TYPEGRAPH_RECORDED_READ_SOURCE] === true &&\n    isSqlSchema(candidate.schema) &&\n    Object.isFrozen(candidate)\n  );\n}\n\nfunction isRecordedReadBinding(\n  binding: unknown,\n): binding is RecordedReadBinding {\n  return (\n    isExternalRecordedReadSource(binding) ||\n    isTypeGraphRecordedReadSource(binding)\n  );\n}\n\n/**\n * Returns a schema view whose primary node/edge sources are the recorded-time\n * relations. The recorded relations are row-compatible with the live tables\n * for every column the query compiler, subgraph extractor, and algorithms\n * already read; the temporal filter adds the `recorded_from/to` predicate.\n */\nexport function recordedReadSqlSchema(binding: RecordedReadBinding): SqlSchema {\n  const { schema } = requireRecordedReadBinding(\n    binding,\n    \"recorded-read-schema\",\n  );\n  return freezeSqlSchema({\n    tables: schema.tables,\n    nodesTable: schema.recordedNodesTable,\n    edgesTable: schema.recordedEdgesTable,\n    recordedNodesTable: schema.recordedNodesTable,\n    recordedEdgesTable: schema.recordedEdgesTable,\n    recordedClockTable: schema.recordedClockTable,\n    revisionOriginsTable: schema.revisionOriginsTable,\n    identityAssertionsTable: schema.identityAssertionsTable,\n    recordedIdentityAssertionsTable: schema.recordedIdentityAssertionsTable,\n    identityClosureTable: schema.identityClosureTable,\n    identitySeparationTable: schema.identitySeparationTable,\n    fulltextTable: schema.fulltextTable,\n  });\n}\n\n/**\n * Resolves the read schema for a coordinate: the live schema when no recorded\n * pin is set, or the recorded-relation view when `recordedAsOf` is present. The\n * single place every read path decides whether to source the recorded tables.\n */\nexport function recordedReadSchemaFor(\n  schema: SqlSchema,\n  recordedAsOf: string | undefined,\n  binding: RecordedReadBinding | undefined,\n  surface: string,\n): SqlSchema {\n  const baseSchema = requireSqlSchema(schema, `${surface} schema`);\n  if (recordedAsOf === undefined) return baseSchema;\n  return recordedReadSqlSchema(requireRecordedReadBinding(binding, surface));\n}\n\n/**\n * Default SqlSchema using standard TypeGraph table names.\n */\nexport const DEFAULT_SQL_SCHEMA: SqlSchema = createSqlSchema();\n\n/**\n * The compiler's resolved view of one declared embedding field — the\n * `(dimensions, metric, indexType)` a {@link VectorStrategy} needs to\n * name and scan the field's typed per-`(kind, field)` storage. Sourced\n * from the registered node schema's `embedding()` declaration when the\n * store builds its compile options.\n */\nexport type VectorSlotDescriptor = Readonly<{\n  dimensions: number;\n  metric: VectorMetric;\n  indexType: VectorIndexType;\n}>;\n\n/**\n * Map of declared embedding slots keyed by {@link vectorSlotKey} -\n * `\"<nodeKind>\\0<fieldPath>\"` (NUL-separated). Carries every `(concrete kind,\n * fieldPath)` that declares an embedding field, so the compiler's\n * `field.similarTo(...)` CTE can UNION ALL the per-field tables for the\n * kinds in an alias that actually declare the field (only\n * `includeSubClasses` yields more than one).\n */\nexport type VectorSlotMap = ReadonlyMap<string, VectorSlotDescriptor>;\n\n/** NUL-delimited composite key for {@link VectorSlotMap}. */\nexport function vectorSlotKey(nodeKind: string, fieldPath: string): string {\n  return `${nodeKind}\\u0000${fieldPath}`;\n}\n\n/**\n * CTE aliases used by the standard query emitter. Joining on these names\n * across multiple builder files is fragile when typed as raw strings —\n * import these constants instead.\n */\nexport const ALIAS_CTE_PREFIX = \"cte_\" as const;\nexport const EMBEDDINGS_CTE_ALIAS = \"cte_embeddings\" as const;\nexport const FULLTEXT_CTE_ALIAS = \"cte_fulltext\" as const;\nexport const HYBRID_CANDIDATES_CTE_ALIAS = \"cte_relevance_candidates\" as const;\n"]}