@nicia-ai/typegraph 0.46.2 → 0.48.0

package/dist/{chunk-S7WIRFNS.cjs → chunk-TKZXMWQF.cjs}

@@ -1,9 +1,10 @@
 'use strict';
 
-var chunkC2ZP5YS6_cjs = require('./chunk-C2ZP5YS6.cjs');
-var chunkA7NMUYEL_cjs = require('./chunk-A7NMUYEL.cjs');
-var chunkANKOXPCC_cjs = require('./chunk-ANKOXPCC.cjs');
-var chunkKCH7WQA5_cjs = require('./chunk-KCH7WQA5.cjs');
+var chunkPFBRJBUL_cjs = require('./chunk-PFBRJBUL.cjs');
+var chunkHDL2ARHX_cjs = require('./chunk-HDL2ARHX.cjs');
+var chunkSIT26LAZ_cjs = require('./chunk-SIT26LAZ.cjs');
+var chunk5PRKMB24_cjs = require('./chunk-5PRKMB24.cjs');
+var chunkMRDBBHIZ_cjs = require('./chunk-MRDBBHIZ.cjs');
 var pglite = require('@electric-sql/pglite');
 var pglite$1 = require('drizzle-orm/pglite');
 
@@ -12,7 +13,7 @@ async function loadDefaultPgvectorExtension() {
     const module_ = await import('@electric-sql/pglite-pgvector');
     return module_.vector;
   } catch (error) {
-    throw new chunkKCH7WQA5_cjs.ConfigurationError(
+    throw new chunkMRDBBHIZ_cjs.ConfigurationError(
       "createLocalPgliteBackend needs the pgvector extension but `@electric-sql/pglite-pgvector` could not be loaded. Install it (`pnpm add @electric-sql/pglite-pgvector`), pass your own `vector` extension, or set `vector: false` to disable vector support.",
       { backend: "pglite", dependency: "@electric-sql/pglite-pgvector" },
       { cause: error }
@@ -20,7 +21,7 @@ async function loadDefaultPgvectorExtension() {
   }
 }
 async function createLocalPgliteBackend(options = {}) {
-  const tables2 = options.tables ?? chunkA7NMUYEL_cjs.tables;
+  const tables2 = options.tables ?? chunkHDL2ARHX_cjs.tables;
   const vectorExtension = options.vector === false ? void 0 : options.vector ?? await loadDefaultPgvectorExtension();
   const vectorEnabled = vectorExtension !== void 0;
   const client = await pglite.PGlite.create({
@@ -28,22 +29,22 @@ async function createLocalPgliteBackend(options = {}) {
     ...vectorExtension === void 0 ? {} : { extensions: { vector: vectorExtension } }
   });
   try {
-    const migrationSql = vectorEnabled ? chunkA7NMUYEL_cjs.generatePostgresMigrationSQL(tables2) : chunkA7NMUYEL_cjs.generatePostgresDDL(tables2).join("\n\n");
+    const migrationSql = vectorEnabled ? chunkHDL2ARHX_cjs.generatePostgresMigrationSQL(tables2) : chunkHDL2ARHX_cjs.generatePostgresDDL(tables2).join("\n\n");
     await client.exec(migrationSql);
     const db = pglite$1.drizzle(client);
-    const backend = chunkC2ZP5YS6_cjs.createPostgresBackend(db, {
+    const backend = chunkPFBRJBUL_cjs.createPostgresBackend(db, {
       tables: tables2,
       ...vectorEnabled ? {} : { vector: false }
     });
-    const managedBackend = chunkANKOXPCC_cjs.wrapWithManagedClose(backend, async () => {
+    const managedBackend = chunkSIT26LAZ_cjs.wrapWithManagedClose(backend, async () => {
       await client.close();
     });
     return { backend: managedBackend, db, client };
   } catch (error) {
-    return chunkANKOXPCC_cjs.closeAfterFailure(client, error);
+    return chunk5PRKMB24_cjs.closeAfterFailure(client, error);
   }
 }
 
 exports.createLocalPgliteBackend = createLocalPgliteBackend;
-//# sourceMappingURL=chunk-S7WIRFNS.cjs.map
-//# sourceMappingURL=chunk-S7WIRFNS.cjs.map
+//# sourceMappingURL=chunk-TKZXMWQF.cjs.map
+//# sourceMappingURL=chunk-TKZXMWQF.cjs.map

package/dist/chunk-TKZXMWQF.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/backend/postgres/pglite.ts"],"names":["ConfigurationError","tables","PGlite","generatePostgresMigrationSQL","generatePostgresDDL","drizzle","createPostgresBackend","wrapWithManagedClose","closeAfterFailure"],"mappings":";;;;;;;;;;AAqIA,eAAe,4BAAA,GAAmD;AAChE,EAAA,IAAI;AACF,IAAA,MAAM,OAAA,GAAU,MAAM,OAAO,+BAA+B,CAAA;AAC5D,IAAA,OAAO,OAAA,CAAQ,MAAA;AAAA,EACjB,SAAS,KAAA,EAAO;AACd,IAAA,MAAM,IAAIA,oCAAA;AAAA,MACR,2PAAA;AAAA,MAIA,EAAE,OAAA,EAAS,QAAA,EAAU,UAAA,EAAY,+BAAA,EAAgC;AAAA,MACjE,EAAE,OAAO,KAAA;AAAM,KACjB;AAAA,EACF;AACF;AAoBA,eAAsB,wBAAA,CACpB,OAAA,GAAqC,EAAC,EACH;AACnC,EAAA,MAAMC,OAAAA,GAAS,QAAQ,MAAA,IAAUA,wBAAA;AAMjC,EAAA,MAAM,eAAA,GACJ,QAAQ,MAAA,KAAW,KAAA,GACjB,SACC,OAAA,CAAQ,MAAA,IAAW,MAAM,4BAAA,EAA6B;AAC3D,EAAA,MAAM,gBAAgB,eAAA,KAAoB,MAAA;AAO1C,EAAA,MAAM,MAAA,GAAS,MAAMC,aAAA,CAAO,MAAA,CAAO;AAAA,IACjC,GAAI,QAAQ,OAAA,KAAY,MAAA,GAAY,EAAC,GAAI,EAAE,OAAA,EAAS,OAAA,CAAQ,OAAA,EAAQ;AAAA,IACpE,GAAI,eAAA,KAAoB,MAAA,GACtB,EAAC,GACD,EAAE,UAAA,EAAY,EAAE,MAAA,EAAQ,eAAA,EAAgB;AAAE,GAC7C,CAAA;AAED,EAAA,IAAI;AAGF,IAAA,MAAM,YAAA,GACJ,gBACEC,8CAAA,CAA6BF,OAAM,IACnCG,qCAAA,CAAoBH,OAAM,CAAA,CAAE,IAAA,CAAK,MAAM,CAAA;AAC3C,IAAA,MAAM,MAAA,CAAO,KAAK,YAAY,CAAA;AAE9B,IAAA,MAAM,EAAA,GAAKI,iBAAQ,MAAM,CAAA;AACzB,IAAA,MAAM,OAAA,GAAUC,wCAAsB,EAAA,EAAI;AAAA,MACxC,MAAA,EAAAL,OAAAA;AAAA,MACA,GAAI,aAAA,GAAgB,EAAC,GAAI,EAAE,QAAQ,KAAA;AAAM,KAC1C,CAAA;AACD,IAAA,MAAM,cAAA,GAAiBM,sCAAA,CAAqB,OAAA,EAAS,YAAY;AAC/D,MAAA,MAAM,OAAO,KAAA,EAAM;AAAA,IACrB,CAAC,CAAA;AAED,IAAA,OAAO,EAAE,OAAA,EAAS,cAAA,EAAgB,EAAA,EAAI,MAAA,EAAO;AAAA,EAC/C,SAAS,KAAA,EAAO;AACd,IAAA,OAAOC,mCAAA,CAAkB,QAAQ,KAAK,CAAA;AAAA,EACxC;AACF","file":"chunk-TKZXMWQF.cjs","sourcesContent":["/**\n * Local PGlite backend — Postgres-in-WASM, running in-process.\n *\n * [PGlite](https://pglite.dev/) is a full Postgres compiled to WebAssembly\n * that runs inside the Node/Bun/Deno/browser process with no server and no\n * native addon. This is the batteries-included Postgres analog of\n * `createLocalSqliteBackend`: it constructs a PGlite instance, loads the\n * pgvector extension, runs the schema DDL, and returns a ready\n * `{ backend, db }` pair whose `close()` disposes the engine.\n *\n * `@electric-sql/pglite` is an optional peer dependency. Vector support\n * additionally needs `@electric-sql/pglite-pgvector` (PGlite ≥ 0.5 ships\n * pgvector as a separate package). Install what you need:\n *\n * ```bash\n * pnpm add @electric-sql/pglite @electric-sql/pglite-pgvector\n * ```\n *\n * @example In-memory database (default, vector enabled)\n * ```typescript\n * import { createLocalPgliteBackend } from \"@nicia-ai/typegraph/adapters/drizzle/postgres/pglite\";\n *\n * const { backend } = await createLocalPgliteBackend();\n * const store = createStore(graph, backend);\n * ```\n *\n * @example Persistent on-disk database\n * ```typescript\n * const { backend, db } = await createLocalPgliteBackend({ dataDir: \"./pgdata\" });\n * ```\n *\n * @example No vector support (skip the pgvector extension)\n * ```typescript\n * const { backend } = await createLocalPgliteBackend({ vector: false });\n * ```\n *\n * PGlite is single-connection and serial: there is no pooling, so concurrent\n * `store.transaction()` calls queue rather than run in parallel.\n */\nimport { type Extension, PGlite } from \"@electric-sql/pglite\";\nimport { drizzle, type PgliteDatabase } from \"drizzle-orm/pglite\";\n\nimport { ConfigurationError } from \"../../errors\";\nimport { wrapWithManagedClose } from \"../derive-backend\";\nexport type { GraphIdentityConfig } from \"../../core/define-graph\";\nimport {\n  generatePostgresDDL,\n  generatePostgresMigrationSQL,\n} from \"../drizzle/ddl\";\nimport { type AnyPgTransaction } from \"../drizzle/execution\";\nexport type { AnyPgDatabase, AnyPgTransaction } from \"../drizzle/execution\";\nimport {\n  createPostgresBackend,\n  type PostgresTables,\n  tables as defaultTables,\n} from \"../drizzle/postgres\";\nimport { type AdapterBackend, closeAfterFailure } from \"../types\";\nexport type {\n  ContributionDiagnostic,\n  ContributionDiagnosticState,\n  ContributionRepairEntry,\n  ContributionRepairResult,\n} from \"../types\";\n\n// ============================================================\n// Types\n// ============================================================\n\n/**\n * Options for creating a local PGlite backend.\n */\nexport type LocalPgliteBackendOptions = Readonly<{\n  /**\n   * PGlite data directory. Omit for an in-memory database (the default).\n   * Accepts any PGlite data-dir spec: a filesystem path (`\"./pgdata\"`),\n   * `\"memory://\"`, or a browser/runtime-specific scheme such as\n   * `\"idb://my-db\"`.\n   */\n  dataDir?: string;\n\n  /**\n   * Custom table definitions. Defaults to standard TypeGraph table names.\n   */\n  tables?: PostgresTables;\n\n  /**\n   * Controls the pgvector stack:\n   *\n   * - **omitted (default)** — load pgvector from `@electric-sql/pglite-pgvector`\n   *   and run `CREATE EXTENSION vector`, so embedding fields work out of the\n   *   box. Throws a {@link ConfigurationError} if the package isn't installed.\n   * - **`false`** — skip the extension entirely; the backend advertises no\n   *   vector capability (mirroring a SQLite connection without sqlite-vec).\n   *   Use when a graph carries no embeddings, or to avoid the extension dep.\n   * - **a PGlite `Extension`** — bring your own pgvector build or custom\n   *   extension packaging. Decouples this helper from a specific pgvector\n   *   package version.\n   */\n  vector?: false | Extension;\n}>;\n\n/**\n * Result of creating a local PGlite backend.\n */\nexport type LocalPgliteBackendResult = Readonly<{\n  /**\n   * The GraphBackend instance for use with createStore. Its `close()`\n   * disposes the underlying PGlite engine.\n   */\n  backend: AdapterBackend<AnyPgTransaction>;\n\n  /**\n   * The underlying Drizzle database instance. Useful for direct SQL access.\n   */\n  db: PgliteDatabase;\n\n  /**\n   * The raw PGlite instance, for engine-specific operations such as\n   * `dumpDataDir()` / `clone()` not surfaced through Drizzle.\n   */\n  client: PGlite;\n}>;\n\n// ============================================================\n// Vector extension loading\n// ============================================================\n\n/**\n * Dynamically loads the default pgvector extension from\n * `@electric-sql/pglite-pgvector`. Kept as a runtime import so the package\n * stays an optional peer dependency — callers using `vector: false` or\n * supplying their own extension never need it installed.\n */\nasync function loadDefaultPgvectorExtension(): Promise<Extension> {\n  try {\n    const module_ = await import(\"@electric-sql/pglite-pgvector\");\n    return module_.vector;\n  } catch (error) {\n    throw new ConfigurationError(\n      \"createLocalPgliteBackend needs the pgvector extension but \" +\n        \"`@electric-sql/pglite-pgvector` could not be loaded. Install it \" +\n        \"(`pnpm add @electric-sql/pglite-pgvector`), pass your own `vector` \" +\n        \"extension, or set `vector: false` to disable vector support.\",\n      { backend: \"pglite\", dependency: \"@electric-sql/pglite-pgvector\" },\n      { cause: error },\n    );\n  }\n}\n\n// ============================================================\n// Factory Function\n// ============================================================\n\n/**\n * Creates a TypeGraph backend backed by an in-process PGlite database.\n *\n * Constructs the PGlite engine (loading pgvector unless disabled), executes\n * the schema DDL, and wires the standard Postgres backend. The returned\n * backend owns the engine: call `backend.close()` to dispose it.\n *\n * For production Postgres, or a PGlite instance you construct yourself,\n * use `createPostgresBackend` directly with your own Drizzle database — the\n * execution fast path detects PGlite and routes it correctly.\n *\n * @param options - Configuration options\n * @returns Backend, Drizzle database, and raw PGlite client\n */\nexport async function createLocalPgliteBackend(\n  options: LocalPgliteBackendOptions = {},\n): Promise<LocalPgliteBackendResult> {\n  const tables = options.tables ?? defaultTables;\n\n  // pgvector lives in the WASM instance, so the extension must be passed at\n  // construction — `CREATE EXTENSION vector` alone can't pull it in. An\n  // explicitly supplied extension wins; `false` disables; otherwise load the\n  // default package.\n  const vectorExtension =\n    options.vector === false ?\n      undefined\n    : (options.vector ?? (await loadDefaultPgvectorExtension()));\n  const vectorEnabled = vectorExtension !== undefined;\n\n  // Construct via the single options-object form (passing `dataDir` as a\n  // field), not the positional `create(dataDir, options)` overload: with a\n  // leading `undefined` dataDir, that overload silently drops `extensions`\n  // (\"extension vector is not available\"). The options form loads them for\n  // both the in-memory and on-disk cases.\n  const client = await PGlite.create({\n    ...(options.dataDir === undefined ? {} : { dataDir: options.dataDir }),\n    ...(vectorExtension === undefined ?\n      {}\n    : { extensions: { vector: vectorExtension } }),\n  });\n\n  try {\n    // `exec` runs a multi-statement batch (DDL + the pgvector `CREATE\n    // EXTENSION` when enabled) in one round trip.\n    const migrationSql =\n      vectorEnabled ?\n        generatePostgresMigrationSQL(tables)\n      : generatePostgresDDL(tables).join(\"\\n\\n\");\n    await client.exec(migrationSql);\n\n    const db = drizzle(client);\n    const backend = createPostgresBackend(db, {\n      tables,\n      ...(vectorEnabled ? {} : { vector: false }),\n    });\n    const managedBackend = wrapWithManagedClose(backend, async () => {\n      await client.close();\n    });\n\n    return { backend: managedBackend, db, client };\n  } catch (error) {\n    return closeAfterFailure(client, error);\n  }\n}\n"]}

package/dist/{chunk-5PDSCELM.cjs → chunk-TQHGE7UC.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkKCH7WQA5_cjs = require('./chunk-KCH7WQA5.cjs');
+var chunkMRDBBHIZ_cjs = require('./chunk-MRDBBHIZ.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$/;
@@ -51,7 +51,7 @@ function isCanonicalIsoDate(value) {
 }
 function validateCanonicalIsoDate(value, fieldName) {
   if (!isCanonicalIsoDate(value)) {
-    throw new chunkKCH7WQA5_cjs.ValidationError(
+    throw new chunkMRDBBHIZ_cjs.ValidationError(
       `Invalid canonical ISO 8601 datetime for "${fieldName}": "${value}". Expected fixed-width UTC: YYYY-MM-DDTHH:mm:ss.sssZ`,
       {
         issues: [
@@ -79,15 +79,30 @@ function isInvertedValidityWindow(validFrom, validTo) {
   if (validFrom === void 0 || validTo === void 0) return false;
   return validFrom > validTo;
 }
+function isEmptyValidityWindow(validFrom, validTo) {
+  if (validFrom === void 0 || validTo === void 0) return false;
+  return validFrom >= validTo;
+}
+function validityWindowContainsInstant(validFrom, validTo, instant) {
+  return (validFrom === void 0 || validFrom <= instant) && (validTo === void 0 || instant < validTo);
+}
+function resolveStampedValidityLowerBound(statedValidFrom, validTo, writeInstant) {
+  if (statedValidFrom === null) return void 0;
+  if (statedValidFrom !== void 0) return statedValidFrom;
+  return isEmptyValidityWindow(writeInstant, validTo) ? void 0 : writeInstant;
+}
+function resolveStatedValidityLowerBound(validFrom) {
+  return validFrom ?? void 0;
+}
 function assertEffectiveValidityLowerBound(subject, effectiveValidFrom, validTo) {
   if (!isInvertedValidityWindow(effectiveValidFrom, validTo)) return;
-  throw new chunkKCH7WQA5_cjs.ValidationError(
+  throw new chunkMRDBBHIZ_cjs.ValidationError(
     `Inverted validity window for ${subject}: the effective validFrom "${effectiveValidFrom}" is after validTo "${validTo}".`,
     {
       issues: [
         {
           path: "validTo",
-          code: chunkKCH7WQA5_cjs.INVERTED_VALIDITY_WINDOW_CODE,
+          code: chunkMRDBBHIZ_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.`
         }
       ]
@@ -99,13 +114,13 @@ function assertEffectiveValidityLowerBound(subject, effectiveValidFrom, validTo)
 }
 function assertOrderedValidityWindow(subject, validFrom, validTo) {
   if (!isInvertedValidityWindow(validFrom, validTo)) return;
-  throw new chunkKCH7WQA5_cjs.ValidationError(
+  throw new chunkMRDBBHIZ_cjs.ValidationError(
     `Inverted validity window for ${subject}: validFrom "${validFrom}" is after validTo "${validTo}".`,
     {
       issues: [
         {
           path: "validFrom",
-          code: chunkKCH7WQA5_cjs.INVERTED_VALIDITY_WINDOW_CODE,
+          code: chunkMRDBBHIZ_cjs.INVERTED_VALIDITY_WINDOW_CODE,
           message: `Expected validFrom <= validTo, got "${validFrom}" > "${validTo}"`
         }
       ]
@@ -121,13 +136,13 @@ function preservesImmutableLowerBound(policy) {
 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 chunkKCH7WQA5_cjs.ValidationError(
+  throw new chunkMRDBBHIZ_cjs.ValidationError(
     `Unappliable validFrom for ${subject}: stated "${statedValidFrom}", but ${storedDescription} and the row is live.`,
     {
       issues: [
         {
           path: "validFrom",
-          code: chunkKCH7WQA5_cjs.IMMUTABLE_VALIDITY_LOWER_BOUND_CODE,
+          code: chunkMRDBBHIZ_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.`
         }
       ]
@@ -165,168 +180,18 @@ 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 chunkKCH7WQA5_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 chunkKCH7WQA5_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 chunkKCH7WQA5_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 chunkKCH7WQA5_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.resolveStampedValidityLowerBound = resolveStampedValidityLowerBound;
+exports.resolveStatedValidityLowerBound = resolveStatedValidityLowerBound;
 exports.statedBoundMatchesStored = statedBoundMatchesStored;
+exports.validateCanonicalIsoDate = validateCanonicalIsoDate;
 exports.validateOptionalCanonicalIsoDate = validateOptionalCanonicalIsoDate;
-exports.withRecordedCoordinate = withRecordedCoordinate;
-//# sourceMappingURL=chunk-5PDSCELM.cjs.map
-//# sourceMappingURL=chunk-5PDSCELM.cjs.map
+exports.validityWindowContainsInstant = validityWindowContainsInstant;
+//# sourceMappingURL=chunk-TQHGE7UC.cjs.map
+//# sourceMappingURL=chunk-TQHGE7UC.cjs.map

package/dist/chunk-TQHGE7UC.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/date.ts"],"names":["ValidationError","INVERTED_VALIDITY_WINDOW_CODE","IMMUTABLE_VALIDITY_LOWER_BOUND_CODE"],"mappings":"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","file":"chunk-TQHGE7UC.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 * Whether a validity window is readable at NO instant — inverted OR zero width.\n * The CHOICE predicate, sibling to {@link isInvertedValidityWindow}'s REFUSAL\n * predicate, and the two answer different questions on purpose:\n *\n *  - a window a caller STATED in full is refused only when it is inverted, because\n *    zero width is what a same-instant retraction produces and the store's own\n *    output must round-trip;\n *  - a bound a write CHOOSES for a caller who stated none must never satisfy this\n *    one, because a row nobody can read at any coordinate is not a window the\n *    caller asked for.\n *\n * `inverted ⇒ empty`, and `empty ∧ ¬inverted ⟺ zero width`. That law is a\n * property in `tests/property/temporal-window.test.ts`, so the pair cannot drift\n * into disagreeing about anything but the boundary they deliberately differ on.\n *\n * PRECONDITION: as {@link isInvertedValidityWindow} — both endpoints canonical\n * fixed-width UTC ISO 8601, so the lexicographic compare is a chronological one.\n */\nexport function isEmptyValidityWindow(\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 * Whether a canonical instant belongs to the half-open validity interval\n * `[validFrom, validTo)`. An omitted bound is unbounded on that side.\n *\n * This is the single JavaScript owner of validity-window membership. SQL read\n * paths express the same decision through the shared temporal compiler.\n */\nexport function validityWindowContainsInstant(\n  validFrom: string | undefined,\n  validTo: string | undefined,\n  instant: string,\n): boolean {\n  return (\n    (validFrom === undefined || validFrom <= instant) &&\n    (validTo === undefined || instant < validTo)\n  );\n}\n\n/**\n * THE lower bound a write that STAMPS its own start stores, decided against the\n * instant it is about to stamp. One owner for every such write, so no two of them\n * can spell the decision differently. Three inputs, three outcomes:\n *\n *  - a stated `null`   → no lower bound (a CONFIRMED open-left window, which is\n *                        how interchange round-trips a row that has none);\n *  - a stated string   → that bound, the caller's own assertion, verbatim;\n *  - nothing stated    → the write instant, UNLESS stamping it would leave the\n *                        window readable at no instant. A row carrying only a\n *                        `validTo` at or before the write instant is \"born already\n *                        ended\": its start is UNKNOWN, not at-or-after its end, so\n *                        it stores no lower bound and reads back at every `asOf`\n *                        before that end (issue #407).\n *\n * The comparison against `validTo` is NON-STRICT: `validTo === writeInstant`\n * stores no bound too. A stamped `[T, T)` is a successful write no coordinate can\n * observe, and the millisecond of skew between a caller's own `Date.now()` and the\n * backend's sample is enough to land there — so the rule is total, and there is no\n * input for which a stamped bound yields an empty window.\n *\n * The write instant is a PARAMETER, not a clock read: the caller passes the very\n * value it binds into `created_at`/`updated_at` (or, for a resurrection, the\n * instant its guard judged), so the decision and the stamp cannot come from two\n * different samples (issue #413's failure mode). This function has no way to\n * sample a clock, which is what makes that structural rather than tested.\n *\n * PRECONDITION: as {@link isEmptyValidityWindow}. This is called BELOW the\n * validation boundary, on a public `GraphBackend` surface, so canonicality is\n * established by whoever reached the backend: store paths through\n * {@link validateOptionalCanonicalIsoDate}, interchange import through its own\n * window validator, trusted import through its per-chunk format check. A direct\n * `GraphBackend` caller establishes it itself — a pre-existing property of that\n * surface, written down here rather than left implicit.\n */\nexport function resolveStampedValidityLowerBound(\n  statedValidFrom: string | null | undefined,\n  validTo: string | undefined,\n  writeInstant: string,\n): string | undefined {\n  if (statedValidFrom === null) return undefined;\n  if (statedValidFrom !== undefined) return statedValidFrom;\n  return isEmptyValidityWindow(writeInstant, validTo) ? undefined : (\n      writeInstant\n    );\n}\n\n/**\n * The lower bound a write that PASSES THROUGH a stated one stores: `null` — the\n * interchange spelling of a confirmed open-left window — becomes \"no bound\", and\n * a string is stored verbatim.\n *\n * Separate from {@link resolveStampedValidityLowerBound} because it answers a\n * different question. Its one caller (`buildUpdateEdge`'s resurrection leg) writes\n * the window only when the caller NAMED a lower bound; an edge resurrection that\n * names none RETAINS the stored window rather than choosing a new one, so there is\n * no instant to judge and none is offered.\n */\nexport function resolveStatedValidityLowerBound(\n  validFrom: string | null,\n): string | undefined {\n  return validFrom ?? undefined;\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, and that is now the\n * COMPLETE stated-pair rule rather than a partial one. An insert carrying a lone\n * historical `validTo` means \"born already ended\", and there is no bound to hold\n * the caller to because the write stamps none:\n * {@link resolveStampedValidityLowerBound} stores no lower bound whenever the\n * instant it would stamp cannot precede the stated end (I1b). So no insert path\n * can store a window readable at no coordinate, on any `GraphBackend` caller —\n * the decision lives in the SQL builders, below the store, below interchange and\n * below trusted import (I5). 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"]}

package/dist/{chunk-XBHRKLZU.cjs → chunk-TUNPBZY3.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkF36KZDFX_cjs = require('./chunk-F36KZDFX.cjs');
+var chunk3FPR224C_cjs = require('./chunk-3FPR224C.cjs');
 var chunkN66HCGCY_cjs = require('./chunk-N66HCGCY.cjs');
 
 // src/schema/deserializer.ts
@@ -33,7 +33,7 @@ function deserializeSchema(schema) {
 function buildRegistryFromRelations(schema) {
   const nodeKinds = /* @__PURE__ */ new Map();
   const edgeKinds = /* @__PURE__ */ new Map();
-  return chunkF36KZDFX_cjs.buildValidatedKindRegistry({
+  return chunk3FPR224C_cjs.buildValidatedKindRegistry({
     nodeKinds,
     edgeKinds,
     ontology: schema.ontology.relations.map(
@@ -56,5 +56,5 @@ function buildEdgeEndpointKinds(edges) {
 }
 
 exports.deserializeSchema = deserializeSchema;
-//# sourceMappingURL=chunk-XBHRKLZU.cjs.map
-//# sourceMappingURL=chunk-XBHRKLZU.cjs.map
+//# sourceMappingURL=chunk-TUNPBZY3.cjs.map
+//# sourceMappingURL=chunk-TUNPBZY3.cjs.map

package/dist/{chunk-XBHRKLZU.cjs.map → chunk-TUNPBZY3.cjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/schema/deserializer.ts"],"names":["hasOwnKey","buildValidatedKindRegistry"],"mappings":";;;;;;AAqFO,SAAS,kBACd,MAAA,EACoB;AACpB,EAAA,MAAM,SAAA,GAAY,MAAA,CAAO,IAAA,CAAK,MAAA,CAAO,KAAK,CAAA;AAC1C,EAAA,MAAM,SAAA,GAAY,MAAA,CAAO,IAAA,CAAK,MAAA,CAAO,KAAK,CAAA;AAC1C,EAAA,MAAM,aAAA,GAAgB,MAAA,CAAO,IAAA,CAAK,MAAA,CAAO,SAAS,SAAS,CAAA;AAE3D,EAAA,OAAO;AAAA,IACL,SAAS,MAAA,CAAO,OAAA;AAAA,IAChB,SAAS,MAAA,CAAO,OAAA;AAAA,IAChB,aAAa,MAAA,CAAO,WAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMpB,OAAA,EAAS,CAAC,IAAA,KACRA,2BAAA,CAAU,MAAA,CAAO,KAAA,EAAO,IAAI,CAAA,GAAI,MAAA,CAAO,KAAA,CAAM,IAAI,CAAA,GAAI,MAAA;AAAA,IACvD,cAAc,MAAM,SAAA;AAAA,IAEpB,OAAA,EAAS,CAAC,IAAA,KACRA,2BAAA,CAAU,MAAA,CAAO,KAAA,EAAO,IAAI,CAAA,GAAI,MAAA,CAAO,KAAA,CAAM,IAAI,CAAA,GAAI,MAAA;AAAA,IACvD,cAAc,MAAM,SAAA;AAAA,IAEpB,WAAA,EAAa,CAAC,IAAA,KACZA,2BAAA,CAAU,MAAA,CAAO,QAAA,CAAS,SAAA,EAAW,IAAI,CAAA,GACvC,MAAA,CAAO,QAAA,CAAS,SAAA,CAAU,IAAI,CAAA,GAC9B,MAAA;AAAA,IACJ,kBAAkB,MAAM,aAAA;AAAA,IAExB,YAAA,EAAc,MAAM,MAAA,CAAO,QAAA,CAAS,SAAA;AAAA,IACpC,WAAA,EAAa,MAAM,MAAA,CAAO,QAAA,CAAS,QAAA;AAAA,IAEnC,WAAA,EAAa,MAAM,MAAA,CAAO,QAAA;AAAA,IAC1B,WAAA,EAAa,MAAM,MAAA,CAAO,QAAA;AAAA,IAC1B,QAAQ,MAAM,MAAA;AAAA,IAEd,aAAA,EAAe,MAAM,0BAAA,CAA2B,MAAM;AAAA,GACxD;AACF;AAYA,SAAS,2BAA2B,MAAA,EAAwC;AAE1E,EAAA,MAAM,SAAA,uBAAgB,GAAA,EAAsB;AAC5C,EAAA,MAAM,SAAA,uBAAgB,GAAA,EAAyB;AAC/C,EAAA,OAAOC,4CAAA,CAA2B;AAAA,IAChC,SAAA;AAAA,IACA,SAAA;AAAA,IACA,QAAA,EAAU,MAAA,CAAO,QAAA,CAAS,SAAA,CAAU,GAAA;AAAA,MAClC,CAAC,QAAA,MAAqC;AAAA,QACpC,UAAU,QAAA,CAAS,QAAA;AAAA,QACnB,MAAM,QAAA,CAAS,IAAA;AAAA,QACf,IAAI,QAAA,CAAS;AAAA,OACf;AAAA,KACF;AAAA,IACA,aAAA,EAAe,sBAAA,CAAuB,MAAA,CAAO,KAAK,CAAA;AAAA,IAClD,GAAI,OAAO,QAAA,KAAa,MAAA,GAAY,EAAC,GAAI,EAAE,QAAA,EAAU,MAAA,CAAO,QAAA;AAAS,GACtE,CAAA;AACH;AASA,SAAS,uBACP,KAAA,EACwC;AACxC,EAAA,MAAM,MAAA,uBAAa,GAAA,EAA+B;AAClD,EAAA,KAAA,MAAW,CAAC,IAAA,EAAM,GAAG,KAAK,MAAA,CAAO,OAAA,CAAQ,KAAK,CAAA,EAAG;AAC/C,IAAA,MAAA,CAAO,GAAA,CAAI,MAAM,EAAE,IAAA,EAAM,IAAI,SAAA,EAAW,EAAA,EAAI,GAAA,CAAI,OAAA,EAAS,CAAA;AAAA,EAC3D;AACA,EAAA,OAAO,MAAA;AACT","file":"chunk-XBHRKLZU.cjs","sourcesContent":["/**\n * Schema deserializer for loading stored schemas.\n *\n * Reconstructs runtime objects from SerializedSchema.\n * Note: Zod schemas cannot be fully reconstructed from JSON Schema,\n * so this provides access to the serialized data for introspection.\n */\nimport { type AnyEdgeType, type NodeType } from \"../core/types\";\nimport { type NamedOntologyRelation } from \"../ontology/validation\";\nimport { buildValidatedKindRegistry } from \"../registry/build-validated\";\nimport type { KindRegistry } from \"../registry/kind-registry\";\nimport { type EdgeEndpointKinds } from \"../registry/validate-implies\";\nimport { hasOwnKey } from \"../utils/object\";\nimport {\n  type SerializedClosures,\n  type SerializedEdgeDef,\n  type SerializedMetaEdge,\n  type SerializedNodeDef,\n  type SerializedOntologyRelation,\n  type SerializedSchema,\n} from \"./types\";\n\n// ============================================================\n// Deserialized Schema\n// ============================================================\n\n/**\n * A deserialized schema provides read-only access to schema metadata.\n *\n * Note: Unlike the original GraphDef, this does not include Zod schemas\n * since those cannot be reconstructed from JSON Schema. Use this for\n * introspection and metadata access only.\n */\nexport type DeserializedSchema = Readonly<{\n  graphId: string;\n  version: number;\n  generatedAt: string;\n\n  /** Get node definition by name */\n  getNode: (name: string) => SerializedNodeDef | undefined;\n\n  /** Get all node names */\n  getNodeNames: () => readonly string[];\n\n  /** Get edge definition by name */\n  getEdge: (name: string) => SerializedEdgeDef | undefined;\n\n  /** Get all edge names */\n  getEdgeNames: () => readonly string[];\n\n  /** Get meta-edge definition by name */\n  getMetaEdge: (name: string) => SerializedMetaEdge | undefined;\n\n  /** Get all meta-edge names */\n  getMetaEdgeNames: () => readonly string[];\n\n  /** Get all ontology relations */\n  getRelations: () => readonly SerializedOntologyRelation[];\n\n  /** Get precomputed closures */\n  getClosures: () => SerializedClosures;\n\n  /** Get graph defaults */\n  getDefaults: () => SerializedSchema[\"defaults\"];\n\n  /** Get the durable TypeGraph Identity Profile configuration. */\n  getIdentity: () => SerializedSchema[\"identity\"];\n\n  /** Get the raw serialized schema */\n  getRaw: () => SerializedSchema;\n\n  /** Build a validated KindRegistry by recomputing closures from relations */\n  buildRegistry: () => KindRegistry;\n}>;\n\n// ============================================================\n// Deserialization\n// ============================================================\n\n/**\n * Deserializes a SerializedSchema into a DeserializedSchema.\n *\n * @param schema - The serialized schema to deserialize\n * @returns A deserialized schema with accessor methods\n */\nexport function deserializeSchema(\n  schema: SerializedSchema,\n): DeserializedSchema {\n  const nodeNames = Object.keys(schema.nodes);\n  const edgeNames = Object.keys(schema.edges);\n  const metaEdgeNames = Object.keys(schema.ontology.metaEdges);\n\n  return {\n    graphId: schema.graphId,\n    version: schema.version,\n    generatedAt: schema.generatedAt,\n\n    // Own-key reads, for the same reason {@link buildEdgeEndpointKinds} below\n    // uses a `Map`: `schema` is parsed out of a stored JSON document and the\n    // caller supplies the name, so a raw read hands back an `Object.prototype`\n    // member typed as a definition for any name no kind is registered under.\n    getNode: (name) =>\n      hasOwnKey(schema.nodes, name) ? schema.nodes[name] : undefined,\n    getNodeNames: () => nodeNames,\n\n    getEdge: (name) =>\n      hasOwnKey(schema.edges, name) ? schema.edges[name] : undefined,\n    getEdgeNames: () => edgeNames,\n\n    getMetaEdge: (name) =>\n      hasOwnKey(schema.ontology.metaEdges, name) ?\n        schema.ontology.metaEdges[name]\n      : undefined,\n    getMetaEdgeNames: () => metaEdgeNames,\n\n    getRelations: () => schema.ontology.relations,\n    getClosures: () => schema.ontology.closures,\n\n    getDefaults: () => schema.defaults,\n    getIdentity: () => schema.identity,\n    getRaw: () => schema,\n\n    buildRegistry: () => buildRegistryFromRelations(schema),\n  };\n}\n\n// ============================================================\n// Registry Building\n// ============================================================\n\n/**\n * Builds a KindRegistry from serialized relations.\n *\n * Persisted closures are a legacy inspection artifact. Relations are validated\n * and closures are recomputed so old schemas gain current hardening rules.\n */\nfunction buildRegistryFromRelations(schema: SerializedSchema): KindRegistry {\n  // Build empty node/edge kind maps (we don't have the actual Zod schemas)\n  const nodeKinds = new Map<string, NodeType>();\n  const edgeKinds = new Map<string, AnyEdgeType>();\n  return buildValidatedKindRegistry({\n    nodeKinds,\n    edgeKinds,\n    ontology: schema.ontology.relations.map(\n      (relation): NamedOntologyRelation => ({\n        metaEdge: relation.metaEdge,\n        from: relation.from,\n        to: relation.to,\n      }),\n    ),\n    edgeEndpoints: buildEdgeEndpointKinds(schema.edges),\n    ...(schema.identity === undefined ? {} : { identity: schema.identity }),\n  });\n}\n\n/**\n * Maps each edge kind's serialized definition to its domain/range kind\n * names, for `validateImpliesEndpointCompatibility`. A `Map` (rather than\n * the plain `schema.edges` object) so a lookup for an edge kind literally\n * named \"toString\" or another `Object.prototype` member can't resolve to\n * an inherited member instead of `undefined`.\n */\nfunction buildEdgeEndpointKinds(\n  edges: Record<string, SerializedEdgeDef>,\n): ReadonlyMap<string, EdgeEndpointKinds> {\n  const result = new Map<string, EdgeEndpointKinds>();\n  for (const [kind, def] of Object.entries(edges)) {\n    result.set(kind, { from: def.fromKinds, to: def.toKinds });\n  }\n  return result;\n}\n"]}
+{"version":3,"sources":["../src/schema/deserializer.ts"],"names":["hasOwnKey","buildValidatedKindRegistry"],"mappings":";;;;;;AAqFO,SAAS,kBACd,MAAA,EACoB;AACpB,EAAA,MAAM,SAAA,GAAY,MAAA,CAAO,IAAA,CAAK,MAAA,CAAO,KAAK,CAAA;AAC1C,EAAA,MAAM,SAAA,GAAY,MAAA,CAAO,IAAA,CAAK,MAAA,CAAO,KAAK,CAAA;AAC1C,EAAA,MAAM,aAAA,GAAgB,MAAA,CAAO,IAAA,CAAK,MAAA,CAAO,SAAS,SAAS,CAAA;AAE3D,EAAA,OAAO;AAAA,IACL,SAAS,MAAA,CAAO,OAAA;AAAA,IAChB,SAAS,MAAA,CAAO,OAAA;AAAA,IAChB,aAAa,MAAA,CAAO,WAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMpB,OAAA,EAAS,CAAC,IAAA,KACRA,2BAAA,CAAU,MAAA,CAAO,KAAA,EAAO,IAAI,CAAA,GAAI,MAAA,CAAO,KAAA,CAAM,IAAI,CAAA,GAAI,MAAA;AAAA,IACvD,cAAc,MAAM,SAAA;AAAA,IAEpB,OAAA,EAAS,CAAC,IAAA,KACRA,2BAAA,CAAU,MAAA,CAAO,KAAA,EAAO,IAAI,CAAA,GAAI,MAAA,CAAO,KAAA,CAAM,IAAI,CAAA,GAAI,MAAA;AAAA,IACvD,cAAc,MAAM,SAAA;AAAA,IAEpB,WAAA,EAAa,CAAC,IAAA,KACZA,2BAAA,CAAU,MAAA,CAAO,QAAA,CAAS,SAAA,EAAW,IAAI,CAAA,GACvC,MAAA,CAAO,QAAA,CAAS,SAAA,CAAU,IAAI,CAAA,GAC9B,MAAA;AAAA,IACJ,kBAAkB,MAAM,aAAA;AAAA,IAExB,YAAA,EAAc,MAAM,MAAA,CAAO,QAAA,CAAS,SAAA;AAAA,IACpC,WAAA,EAAa,MAAM,MAAA,CAAO,QAAA,CAAS,QAAA;AAAA,IAEnC,WAAA,EAAa,MAAM,MAAA,CAAO,QAAA;AAAA,IAC1B,WAAA,EAAa,MAAM,MAAA,CAAO,QAAA;AAAA,IAC1B,QAAQ,MAAM,MAAA;AAAA,IAEd,aAAA,EAAe,MAAM,0BAAA,CAA2B,MAAM;AAAA,GACxD;AACF;AAYA,SAAS,2BAA2B,MAAA,EAAwC;AAE1E,EAAA,MAAM,SAAA,uBAAgB,GAAA,EAAsB;AAC5C,EAAA,MAAM,SAAA,uBAAgB,GAAA,EAAyB;AAC/C,EAAA,OAAOC,4CAAA,CAA2B;AAAA,IAChC,SAAA;AAAA,IACA,SAAA;AAAA,IACA,QAAA,EAAU,MAAA,CAAO,QAAA,CAAS,SAAA,CAAU,GAAA;AAAA,MAClC,CAAC,QAAA,MAAqC;AAAA,QACpC,UAAU,QAAA,CAAS,QAAA;AAAA,QACnB,MAAM,QAAA,CAAS,IAAA;AAAA,QACf,IAAI,QAAA,CAAS;AAAA,OACf;AAAA,KACF;AAAA,IACA,aAAA,EAAe,sBAAA,CAAuB,MAAA,CAAO,KAAK,CAAA;AAAA,IAClD,GAAI,OAAO,QAAA,KAAa,MAAA,GAAY,EAAC,GAAI,EAAE,QAAA,EAAU,MAAA,CAAO,QAAA;AAAS,GACtE,CAAA;AACH;AASA,SAAS,uBACP,KAAA,EACwC;AACxC,EAAA,MAAM,MAAA,uBAAa,GAAA,EAA+B;AAClD,EAAA,KAAA,MAAW,CAAC,IAAA,EAAM,GAAG,KAAK,MAAA,CAAO,OAAA,CAAQ,KAAK,CAAA,EAAG;AAC/C,IAAA,MAAA,CAAO,GAAA,CAAI,MAAM,EAAE,IAAA,EAAM,IAAI,SAAA,EAAW,EAAA,EAAI,GAAA,CAAI,OAAA,EAAS,CAAA;AAAA,EAC3D;AACA,EAAA,OAAO,MAAA;AACT","file":"chunk-TUNPBZY3.cjs","sourcesContent":["/**\n * Schema deserializer for loading stored schemas.\n *\n * Reconstructs runtime objects from SerializedSchema.\n * Note: Zod schemas cannot be fully reconstructed from JSON Schema,\n * so this provides access to the serialized data for introspection.\n */\nimport { type AnyEdgeType, type NodeType } from \"../core/types\";\nimport { type NamedOntologyRelation } from \"../ontology/validation\";\nimport { buildValidatedKindRegistry } from \"../registry/build-validated\";\nimport type { KindRegistry } from \"../registry/kind-registry\";\nimport { type EdgeEndpointKinds } from \"../registry/validate-implies\";\nimport { hasOwnKey } from \"../utils/object\";\nimport {\n  type SerializedClosures,\n  type SerializedEdgeDef,\n  type SerializedMetaEdge,\n  type SerializedNodeDef,\n  type SerializedOntologyRelation,\n  type SerializedSchema,\n} from \"./types\";\n\n// ============================================================\n// Deserialized Schema\n// ============================================================\n\n/**\n * A deserialized schema provides read-only access to schema metadata.\n *\n * Note: Unlike the original GraphDef, this does not include Zod schemas\n * since those cannot be reconstructed from JSON Schema. Use this for\n * introspection and metadata access only.\n */\nexport type DeserializedSchema = Readonly<{\n  graphId: string;\n  version: number;\n  generatedAt: string;\n\n  /** Get node definition by name */\n  getNode: (name: string) => SerializedNodeDef | undefined;\n\n  /** Get all node names */\n  getNodeNames: () => readonly string[];\n\n  /** Get edge definition by name */\n  getEdge: (name: string) => SerializedEdgeDef | undefined;\n\n  /** Get all edge names */\n  getEdgeNames: () => readonly string[];\n\n  /** Get meta-edge definition by name */\n  getMetaEdge: (name: string) => SerializedMetaEdge | undefined;\n\n  /** Get all meta-edge names */\n  getMetaEdgeNames: () => readonly string[];\n\n  /** Get all ontology relations */\n  getRelations: () => readonly SerializedOntologyRelation[];\n\n  /** Get precomputed closures */\n  getClosures: () => SerializedClosures;\n\n  /** Get graph defaults */\n  getDefaults: () => SerializedSchema[\"defaults\"];\n\n  /** Get the durable TypeGraph Identity Profile configuration. */\n  getIdentity: () => SerializedSchema[\"identity\"];\n\n  /** Get the raw serialized schema */\n  getRaw: () => SerializedSchema;\n\n  /** Build a validated KindRegistry by recomputing closures from relations */\n  buildRegistry: () => KindRegistry;\n}>;\n\n// ============================================================\n// Deserialization\n// ============================================================\n\n/**\n * Deserializes a SerializedSchema into a DeserializedSchema.\n *\n * @param schema - The serialized schema to deserialize\n * @returns A deserialized schema with accessor methods\n */\nexport function deserializeSchema(\n  schema: SerializedSchema,\n): DeserializedSchema {\n  const nodeNames = Object.keys(schema.nodes);\n  const edgeNames = Object.keys(schema.edges);\n  const metaEdgeNames = Object.keys(schema.ontology.metaEdges);\n\n  return {\n    graphId: schema.graphId,\n    version: schema.version,\n    generatedAt: schema.generatedAt,\n\n    // Own-key reads, for the same reason {@link buildEdgeEndpointKinds} below\n    // uses a `Map`: `schema` is parsed out of a stored JSON document and the\n    // caller supplies the name, so a raw read hands back an `Object.prototype`\n    // member typed as a definition for any name no kind is registered under.\n    getNode: (name) =>\n      hasOwnKey(schema.nodes, name) ? schema.nodes[name] : undefined,\n    getNodeNames: () => nodeNames,\n\n    getEdge: (name) =>\n      hasOwnKey(schema.edges, name) ? schema.edges[name] : undefined,\n    getEdgeNames: () => edgeNames,\n\n    getMetaEdge: (name) =>\n      hasOwnKey(schema.ontology.metaEdges, name) ?\n        schema.ontology.metaEdges[name]\n      : undefined,\n    getMetaEdgeNames: () => metaEdgeNames,\n\n    getRelations: () => schema.ontology.relations,\n    getClosures: () => schema.ontology.closures,\n\n    getDefaults: () => schema.defaults,\n    getIdentity: () => schema.identity,\n    getRaw: () => schema,\n\n    buildRegistry: () => buildRegistryFromRelations(schema),\n  };\n}\n\n// ============================================================\n// Registry Building\n// ============================================================\n\n/**\n * Builds a KindRegistry from serialized relations.\n *\n * Persisted closures are a legacy inspection artifact. Relations are validated\n * and closures are recomputed so old schemas gain current hardening rules.\n */\nfunction buildRegistryFromRelations(schema: SerializedSchema): KindRegistry {\n  // Build empty node/edge kind maps (we don't have the actual Zod schemas)\n  const nodeKinds = new Map<string, NodeType>();\n  const edgeKinds = new Map<string, AnyEdgeType>();\n  return buildValidatedKindRegistry({\n    nodeKinds,\n    edgeKinds,\n    ontology: schema.ontology.relations.map(\n      (relation): NamedOntologyRelation => ({\n        metaEdge: relation.metaEdge,\n        from: relation.from,\n        to: relation.to,\n      }),\n    ),\n    edgeEndpoints: buildEdgeEndpointKinds(schema.edges),\n    ...(schema.identity === undefined ? {} : { identity: schema.identity }),\n  });\n}\n\n/**\n * Maps each edge kind's serialized definition to its domain/range kind\n * names, for `validateImpliesEndpointCompatibility`. A `Map` (rather than\n * the plain `schema.edges` object) so a lookup for an edge kind literally\n * named \"toString\" or another `Object.prototype` member can't resolve to\n * an inherited member instead of `undefined`.\n */\nfunction buildEdgeEndpointKinds(\n  edges: Record<string, SerializedEdgeDef>,\n): ReadonlyMap<string, EdgeEndpointKinds> {\n  const result = new Map<string, EdgeEndpointKinds>();\n  for (const [kind, def] of Object.entries(edges)) {\n    result.set(kind, { from: def.fromKinds, to: def.toKinds });\n  }\n  return result;\n}\n"]}

package/dist/{chunk-KOAI3KIV.cjs → chunk-TZEGUG6D.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkTCT66A7N_cjs = require('./chunk-TCT66A7N.cjs');
+var chunk26YKDNUD_cjs = require('./chunk-26YKDNUD.cjs');
 var zod = require('zod');
 
 // src/core/meta-edge.ts
@@ -14,7 +14,7 @@ function metaEdge(name, options = {}) {
     description: options.description
   };
   return Object.freeze({
-    [chunkTCT66A7N_cjs.META_EDGE_BRAND]: true,
+    [chunk26YKDNUD_cjs.META_EDGE_BRAND]: true,
     name,
     properties
   });
@@ -52,5 +52,5 @@ exports.externalRef = externalRef;
 exports.getExternalRefTable = getExternalRefTable;
 exports.isExternalRefSchema = isExternalRefSchema;
 exports.metaEdge = metaEdge;
-//# sourceMappingURL=chunk-KOAI3KIV.cjs.map
-//# sourceMappingURL=chunk-KOAI3KIV.cjs.map
+//# sourceMappingURL=chunk-TZEGUG6D.cjs.map
+//# sourceMappingURL=chunk-TZEGUG6D.cjs.map

package/dist/{chunk-KOAI3KIV.cjs.map → chunk-TZEGUG6D.cjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/core/meta-edge.ts","../src/core/external-ref.ts"],"names":["META_EDGE_BRAND","z"],"mappings":";;;;;;AA8CO,SAAS,QAAA,CACd,IAAA,EACA,OAAA,GAA2B,EAAC,EACf;AACb,EAAA,MAAM,UAAA,GAAiC;AAAA,IACrC,UAAA,EAAY,QAAQ,UAAA,IAAc,KAAA;AAAA,IAClC,SAAA,EAAW,QAAQ,SAAA,IAAa,KAAA;AAAA,IAChC,SAAA,EAAW,QAAQ,SAAA,IAAa,KAAA;AAAA,IAChC,SAAS,OAAA,CAAQ,OAAA;AAAA,IACjB,SAAA,EAAW,QAAQ,SAAA,IAAa,MAAA;AAAA,IAChC,aAAa,OAAA,CAAQ;AAAA,GACvB;AAEA,EAAA,OAAO,OAAO,MAAA,CAAO;AAAA,IACnB,CAACA,iCAAe,GAAG,IAAA;AAAA,IACnB,IAAA;AAAA,IACA;AAAA,GACD,CAAA;AACH;AC/CO,IAAM,sBAAA,GAAyB,mBAAA;AA6E/B,SAAS,YAA8B,KAAA,EAAgC;AAC5E,EAAA,IAAI,OAAO,KAAA,KAAU,QAAA,IAAY,KAAA,CAAM,WAAW,CAAA,EAAG;AACnD,IAAA,MAAM,IAAI,KAAA;AAAA,MACR,CAAA,0DAAA,EAA6D,OAAO,KAAA,KAAU,QAAA,GAAW,IAAI,KAAK,CAAA,CAAA,CAAA,GAAM,OAAO,KAAK,CAAA;AAAA,KACtH;AAAA,EACF;AAEA,EAAA,MAAM,MAAA,GAASC,MAAE,MAAA,CAAO;AAAA,IACtB,KAAA,EAAOA,KAAA,CAAE,OAAA,CAAQ,KAAK,CAAA;AAAA,IACtB,IAAIA,KAAA,CAAE,MAAA,EAAO,CAAE,GAAA,CAAI,GAAG,yCAAyC;AAAA,GAChE,CAAA;AAGD,EAAA,OAAO,MAAA,CAAO,OAAO,MAAA,EAAQ;AAAA,IAC3B,CAAC,sBAAsB,GAAG;AAAA,GAC3B,CAAA;AACH;AASO,SAAS,oBACd,KAAA,EAC4B;AAC5B,EAAA,OACE,OAAO,KAAA,KAAU,QAAA,IACjB,KAAA,KAAU,IAAA,IACV,0BAA0B,KAAA,IAC1B,OAAQ,KAAA,CAAkC,sBAAsB,CAAA,KAC9D,QAAA;AAEN;AAMO,SAAS,oBAAoB,MAAA,EAAuC;AACzE,EAAA,IAAI,mBAAA,CAAoB,MAAM,CAAA,EAAG;AAC/B,IAAA,OAAO,OAAO,sBAAsB,CAAA;AAAA,EACtC;AACA,EAAA,OAAO,MAAA;AACT;AAoBO,SAAS,kBACd,KAAA,EACqC;AACrC,EAAA,OAAO,CAAC,EAAA,MAAgB,EAAE,KAAA,EAAO,EAAA,EAAG,CAAA;AACtC","file":"chunk-KOAI3KIV.cjs","sourcesContent":["import {\n  type InferenceType,\n  META_EDGE_BRAND,\n  type MetaEdge,\n  type MetaEdgeProperties,\n} from \"../ontology/types\";\n\n// ============================================================\n// Meta-Edge Factory Options\n// ============================================================\n\n/**\n * Options for creating a meta-edge.\n */\nexport type MetaEdgeOptions = Readonly<{\n  /** Whether the relationship is transitive (A→B, B→C implies A→C) */\n  transitive?: boolean;\n  /** Whether the relationship is symmetric (A→B implies B→A) */\n  symmetric?: boolean;\n  /** Whether the relationship is reflexive (A→A is always true) */\n  reflexive?: boolean;\n  /** Name of the inverse meta-edge */\n  inverse?: string;\n  /** How this meta-edge affects queries and validation */\n  inference?: InferenceType;\n  /** Optional description */\n  description?: string;\n}>;\n\n// ============================================================\n// Meta-Edge Factory\n// ============================================================\n\n/**\n * Creates a custom meta-edge definition.\n *\n * @example\n * ```typescript\n * // Custom meta-edge for regulatory relationships\n * const regulatedBy = metaEdge(\"regulatedBy\", {\n *   description: \"Type X is regulated by authority type Y\",\n *   transitive: false,\n *   symmetric: false,\n * });\n * ```\n */\nexport function metaEdge<K extends string>(\n  name: K,\n  options: MetaEdgeOptions = {},\n): MetaEdge<K> {\n  const properties: MetaEdgeProperties = {\n    transitive: options.transitive ?? false,\n    symmetric: options.symmetric ?? false,\n    reflexive: options.reflexive ?? false,\n    inverse: options.inverse,\n    inference: options.inference ?? \"none\",\n    description: options.description,\n  };\n\n  return Object.freeze({\n    [META_EDGE_BRAND]: true as const,\n    name,\n    properties,\n  });\n}\n","/**\n * External reference type for hybrid overlay patterns.\n *\n * Creates a Zod-compatible schema for referencing entities in external\n * data sources (e.g., existing application tables) from TypeGraph nodes.\n */\nimport { z } from \"zod\";\n\n// ============================================================\n// External Reference Metadata Symbol\n// ============================================================\n\n/**\n * Symbol key for storing external table name on the schema.\n * This allows the schema introspector to detect external reference types\n * and extract source information.\n */\nexport const EXTERNAL_REF_TABLE_KEY = \"_externalRefTable\" as const;\n\n// ============================================================\n// External Reference Value Type\n// ============================================================\n\n/**\n * The shape of an external reference value.\n * Contains the source table identifier and the ID of the referenced record.\n */\nexport type ExternalRefValue<T extends string = string> = Readonly<{\n  table: T;\n  id: string;\n}>;\n\n// ============================================================\n// External Reference Schema Type\n// ============================================================\n\n/**\n * A Zod schema for external references with attached table metadata.\n */\nexport type ExternalRefSchema<T extends string = string> = z.ZodType<\n  ExternalRefValue<T>\n> &\n  Readonly<{\n    [EXTERNAL_REF_TABLE_KEY]: T;\n  }>;\n\n// ============================================================\n// External Reference Factory\n// ============================================================\n\n/**\n * Creates a Zod schema for referencing external data sources.\n *\n * Use this when building a hybrid overlay where TypeGraph stores\n * graph relationships and metadata while your existing tables\n * remain the source of truth for entity data.\n *\n * @param table - The identifier for the external table/source (e.g., \"users\", \"documents\")\n * @returns A Zod schema that validates external reference objects\n *\n * @example\n * ```typescript\n * import { defineNode, externalRef, embedding } from \"@nicia-ai/typegraph\";\n *\n * // Reference documents from your existing application database\n * const Document = defineNode(\"Document\", {\n *   schema: z.object({\n *     source: externalRef(\"documents\"),\n *     embedding: embedding(1536).optional(),\n *     extractedTopics: z.array(z.string()).optional(),\n *   }),\n * });\n *\n * // Create a node referencing an external document\n * await store.nodes.Document.create({\n *   source: { table: \"documents\", id: \"doc_abc123\" },\n *   embedding: await generateEmbedding(docContent),\n * });\n *\n * // Query and hydrate with external data\n * const results = await store\n *   .query()\n *   .from(\"Document\", \"d\")\n *   .whereNode(\"d\", (d) => d.embedding.similarTo(query, 10))\n *   .select((ctx) => ctx.d.source)\n *   .execute();\n *\n * // Fetch full data from your app database\n * const externalIds = results.map((r) => r.id);\n * const fullDocs = await appDb.query.documents.findMany({\n *   where: inArray(documents.id, externalIds),\n * });\n * ```\n */\nexport function externalRef<T extends string>(table: T): ExternalRefSchema<T> {\n  if (typeof table !== \"string\" || table.length === 0) {\n    throw new Error(\n      `External reference table must be a non-empty string, got: ${typeof table === \"string\" ? `\"${table}\"` : typeof table}`,\n    );\n  }\n\n  const schema = z.object({\n    table: z.literal(table),\n    id: z.string().min(1, \"External reference ID must be non-empty\"),\n  });\n\n  // Attach table metadata for introspection\n  return Object.assign(schema, {\n    [EXTERNAL_REF_TABLE_KEY]: table,\n  });\n}\n\n// ============================================================\n// Type Guards\n// ============================================================\n\n/**\n * Checks if a value is an external reference schema.\n */\nexport function isExternalRefSchema(\n  value: unknown,\n): value is ExternalRefSchema {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    EXTERNAL_REF_TABLE_KEY in value &&\n    typeof (value as Record<string, unknown>)[EXTERNAL_REF_TABLE_KEY] ===\n      \"string\"\n  );\n}\n\n/**\n * Gets the table name from an external reference schema.\n * Returns undefined if the schema is not an external reference schema.\n */\nexport function getExternalRefTable(schema: z.ZodType): string | undefined {\n  if (isExternalRefSchema(schema)) {\n    return schema[EXTERNAL_REF_TABLE_KEY];\n  }\n  return undefined;\n}\n\n// ============================================================\n// Helper for creating reference values\n// ============================================================\n\n/**\n * Helper function to create a typed external reference value.\n * Useful when you want to avoid repeating the table name.\n *\n * @example\n * ```typescript\n * const docRef = createExternalRef(\"documents\");\n *\n * await store.nodes.Document.create({\n *   source: docRef(\"doc_123\"),\n *   embedding: [...],\n * });\n * ```\n */\nexport function createExternalRef<T extends string>(\n  table: T,\n): (id: string) => ExternalRefValue<T> {\n  return (id: string) => ({ table, id });\n}\n"]}
+{"version":3,"sources":["../src/core/meta-edge.ts","../src/core/external-ref.ts"],"names":["META_EDGE_BRAND","z"],"mappings":";;;;;;AA8CO,SAAS,QAAA,CACd,IAAA,EACA,OAAA,GAA2B,EAAC,EACf;AACb,EAAA,MAAM,UAAA,GAAiC;AAAA,IACrC,UAAA,EAAY,QAAQ,UAAA,IAAc,KAAA;AAAA,IAClC,SAAA,EAAW,QAAQ,SAAA,IAAa,KAAA;AAAA,IAChC,SAAA,EAAW,QAAQ,SAAA,IAAa,KAAA;AAAA,IAChC,SAAS,OAAA,CAAQ,OAAA;AAAA,IACjB,SAAA,EAAW,QAAQ,SAAA,IAAa,MAAA;AAAA,IAChC,aAAa,OAAA,CAAQ;AAAA,GACvB;AAEA,EAAA,OAAO,OAAO,MAAA,CAAO;AAAA,IACnB,CAACA,iCAAe,GAAG,IAAA;AAAA,IACnB,IAAA;AAAA,IACA;AAAA,GACD,CAAA;AACH;AC/CO,IAAM,sBAAA,GAAyB,mBAAA;AA6E/B,SAAS,YAA8B,KAAA,EAAgC;AAC5E,EAAA,IAAI,OAAO,KAAA,KAAU,QAAA,IAAY,KAAA,CAAM,WAAW,CAAA,EAAG;AACnD,IAAA,MAAM,IAAI,KAAA;AAAA,MACR,CAAA,0DAAA,EAA6D,OAAO,KAAA,KAAU,QAAA,GAAW,IAAI,KAAK,CAAA,CAAA,CAAA,GAAM,OAAO,KAAK,CAAA;AAAA,KACtH;AAAA,EACF;AAEA,EAAA,MAAM,MAAA,GAASC,MAAE,MAAA,CAAO;AAAA,IACtB,KAAA,EAAOA,KAAA,CAAE,OAAA,CAAQ,KAAK,CAAA;AAAA,IACtB,IAAIA,KAAA,CAAE,MAAA,EAAO,CAAE,GAAA,CAAI,GAAG,yCAAyC;AAAA,GAChE,CAAA;AAGD,EAAA,OAAO,MAAA,CAAO,OAAO,MAAA,EAAQ;AAAA,IAC3B,CAAC,sBAAsB,GAAG;AAAA,GAC3B,CAAA;AACH;AASO,SAAS,oBACd,KAAA,EAC4B;AAC5B,EAAA,OACE,OAAO,KAAA,KAAU,QAAA,IACjB,KAAA,KAAU,IAAA,IACV,0BAA0B,KAAA,IAC1B,OAAQ,KAAA,CAAkC,sBAAsB,CAAA,KAC9D,QAAA;AAEN;AAMO,SAAS,oBAAoB,MAAA,EAAuC;AACzE,EAAA,IAAI,mBAAA,CAAoB,MAAM,CAAA,EAAG;AAC/B,IAAA,OAAO,OAAO,sBAAsB,CAAA;AAAA,EACtC;AACA,EAAA,OAAO,MAAA;AACT;AAoBO,SAAS,kBACd,KAAA,EACqC;AACrC,EAAA,OAAO,CAAC,EAAA,MAAgB,EAAE,KAAA,EAAO,EAAA,EAAG,CAAA;AACtC","file":"chunk-TZEGUG6D.cjs","sourcesContent":["import {\n  type InferenceType,\n  META_EDGE_BRAND,\n  type MetaEdge,\n  type MetaEdgeProperties,\n} from \"../ontology/types\";\n\n// ============================================================\n// Meta-Edge Factory Options\n// ============================================================\n\n/**\n * Options for creating a meta-edge.\n */\nexport type MetaEdgeOptions = Readonly<{\n  /** Whether the relationship is transitive (A→B, B→C implies A→C) */\n  transitive?: boolean;\n  /** Whether the relationship is symmetric (A→B implies B→A) */\n  symmetric?: boolean;\n  /** Whether the relationship is reflexive (A→A is always true) */\n  reflexive?: boolean;\n  /** Name of the inverse meta-edge */\n  inverse?: string;\n  /** How this meta-edge affects queries and validation */\n  inference?: InferenceType;\n  /** Optional description */\n  description?: string;\n}>;\n\n// ============================================================\n// Meta-Edge Factory\n// ============================================================\n\n/**\n * Creates a custom meta-edge definition.\n *\n * @example\n * ```typescript\n * // Custom meta-edge for regulatory relationships\n * const regulatedBy = metaEdge(\"regulatedBy\", {\n *   description: \"Type X is regulated by authority type Y\",\n *   transitive: false,\n *   symmetric: false,\n * });\n * ```\n */\nexport function metaEdge<K extends string>(\n  name: K,\n  options: MetaEdgeOptions = {},\n): MetaEdge<K> {\n  const properties: MetaEdgeProperties = {\n    transitive: options.transitive ?? false,\n    symmetric: options.symmetric ?? false,\n    reflexive: options.reflexive ?? false,\n    inverse: options.inverse,\n    inference: options.inference ?? \"none\",\n    description: options.description,\n  };\n\n  return Object.freeze({\n    [META_EDGE_BRAND]: true as const,\n    name,\n    properties,\n  });\n}\n","/**\n * External reference type for hybrid overlay patterns.\n *\n * Creates a Zod-compatible schema for referencing entities in external\n * data sources (e.g., existing application tables) from TypeGraph nodes.\n */\nimport { z } from \"zod\";\n\n// ============================================================\n// External Reference Metadata Symbol\n// ============================================================\n\n/**\n * Symbol key for storing external table name on the schema.\n * This allows the schema introspector to detect external reference types\n * and extract source information.\n */\nexport const EXTERNAL_REF_TABLE_KEY = \"_externalRefTable\" as const;\n\n// ============================================================\n// External Reference Value Type\n// ============================================================\n\n/**\n * The shape of an external reference value.\n * Contains the source table identifier and the ID of the referenced record.\n */\nexport type ExternalRefValue<T extends string = string> = Readonly<{\n  table: T;\n  id: string;\n}>;\n\n// ============================================================\n// External Reference Schema Type\n// ============================================================\n\n/**\n * A Zod schema for external references with attached table metadata.\n */\nexport type ExternalRefSchema<T extends string = string> = z.ZodType<\n  ExternalRefValue<T>\n> &\n  Readonly<{\n    [EXTERNAL_REF_TABLE_KEY]: T;\n  }>;\n\n// ============================================================\n// External Reference Factory\n// ============================================================\n\n/**\n * Creates a Zod schema for referencing external data sources.\n *\n * Use this when building a hybrid overlay where TypeGraph stores\n * graph relationships and metadata while your existing tables\n * remain the source of truth for entity data.\n *\n * @param table - The identifier for the external table/source (e.g., \"users\", \"documents\")\n * @returns A Zod schema that validates external reference objects\n *\n * @example\n * ```typescript\n * import { defineNode, externalRef, embedding } from \"@nicia-ai/typegraph\";\n *\n * // Reference documents from your existing application database\n * const Document = defineNode(\"Document\", {\n *   schema: z.object({\n *     source: externalRef(\"documents\"),\n *     embedding: embedding(1536).optional(),\n *     extractedTopics: z.array(z.string()).optional(),\n *   }),\n * });\n *\n * // Create a node referencing an external document\n * await store.nodes.Document.create({\n *   source: { table: \"documents\", id: \"doc_abc123\" },\n *   embedding: await generateEmbedding(docContent),\n * });\n *\n * // Query and hydrate with external data\n * const results = await store\n *   .query()\n *   .from(\"Document\", \"d\")\n *   .whereNode(\"d\", (d) => d.embedding.similarTo(query, 10))\n *   .select((ctx) => ctx.d.source)\n *   .execute();\n *\n * // Fetch full data from your app database\n * const externalIds = results.map((r) => r.id);\n * const fullDocs = await appDb.query.documents.findMany({\n *   where: inArray(documents.id, externalIds),\n * });\n * ```\n */\nexport function externalRef<T extends string>(table: T): ExternalRefSchema<T> {\n  if (typeof table !== \"string\" || table.length === 0) {\n    throw new Error(\n      `External reference table must be a non-empty string, got: ${typeof table === \"string\" ? `\"${table}\"` : typeof table}`,\n    );\n  }\n\n  const schema = z.object({\n    table: z.literal(table),\n    id: z.string().min(1, \"External reference ID must be non-empty\"),\n  });\n\n  // Attach table metadata for introspection\n  return Object.assign(schema, {\n    [EXTERNAL_REF_TABLE_KEY]: table,\n  });\n}\n\n// ============================================================\n// Type Guards\n// ============================================================\n\n/**\n * Checks if a value is an external reference schema.\n */\nexport function isExternalRefSchema(\n  value: unknown,\n): value is ExternalRefSchema {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    EXTERNAL_REF_TABLE_KEY in value &&\n    typeof (value as Record<string, unknown>)[EXTERNAL_REF_TABLE_KEY] ===\n      \"string\"\n  );\n}\n\n/**\n * Gets the table name from an external reference schema.\n * Returns undefined if the schema is not an external reference schema.\n */\nexport function getExternalRefTable(schema: z.ZodType): string | undefined {\n  if (isExternalRefSchema(schema)) {\n    return schema[EXTERNAL_REF_TABLE_KEY];\n  }\n  return undefined;\n}\n\n// ============================================================\n// Helper for creating reference values\n// ============================================================\n\n/**\n * Helper function to create a typed external reference value.\n * Useful when you want to avoid repeating the table name.\n *\n * @example\n * ```typescript\n * const docRef = createExternalRef(\"documents\");\n *\n * await store.nodes.Document.create({\n *   source: docRef(\"doc_123\"),\n *   embedding: [...],\n * });\n * ```\n */\nexport function createExternalRef<T extends string>(\n  table: T,\n): (id: string) => ExternalRefValue<T> {\n  return (id: string) => ({ table, id });\n}\n"]}