@nicia-ai/typegraph 0.37.0 → 0.38.0

package/dist/chunk-SVJ5GEXW.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+// src/ontology/constants.ts
+var META_EDGE_SUB_CLASS_OF = "subClassOf";
+var META_EDGE_BROADER = "broader";
+var META_EDGE_NARROWER = "narrower";
+var META_EDGE_RELATED_TO = "relatedTo";
+var META_EDGE_EQUIVALENT_TO = "equivalentTo";
+var META_EDGE_SAME_AS = "sameAs";
+var META_EDGE_DIFFERENT_FROM = "differentFrom";
+var META_EDGE_DISJOINT_WITH = "disjointWith";
+var META_EDGE_PART_OF = "partOf";
+var META_EDGE_HAS_PART = "hasPart";
+var META_EDGE_INVERSE_OF = "inverseOf";
+var META_EDGE_IMPLIES = "implies";
+var ALL_META_EDGE_NAMES = [
+  META_EDGE_SUB_CLASS_OF,
+  META_EDGE_BROADER,
+  META_EDGE_NARROWER,
+  META_EDGE_RELATED_TO,
+  META_EDGE_EQUIVALENT_TO,
+  META_EDGE_SAME_AS,
+  META_EDGE_DIFFERENT_FROM,
+  META_EDGE_DISJOINT_WITH,
+  META_EDGE_PART_OF,
+  META_EDGE_HAS_PART,
+  META_EDGE_INVERSE_OF,
+  META_EDGE_IMPLIES
+];
+
+exports.ALL_META_EDGE_NAMES = ALL_META_EDGE_NAMES;
+exports.META_EDGE_BROADER = META_EDGE_BROADER;
+exports.META_EDGE_DIFFERENT_FROM = META_EDGE_DIFFERENT_FROM;
+exports.META_EDGE_DISJOINT_WITH = META_EDGE_DISJOINT_WITH;
+exports.META_EDGE_EQUIVALENT_TO = META_EDGE_EQUIVALENT_TO;
+exports.META_EDGE_HAS_PART = META_EDGE_HAS_PART;
+exports.META_EDGE_IMPLIES = META_EDGE_IMPLIES;
+exports.META_EDGE_INVERSE_OF = META_EDGE_INVERSE_OF;
+exports.META_EDGE_NARROWER = META_EDGE_NARROWER;
+exports.META_EDGE_PART_OF = META_EDGE_PART_OF;
+exports.META_EDGE_RELATED_TO = META_EDGE_RELATED_TO;
+exports.META_EDGE_SAME_AS = META_EDGE_SAME_AS;
+exports.META_EDGE_SUB_CLASS_OF = META_EDGE_SUB_CLASS_OF;
+//# sourceMappingURL=chunk-SVJ5GEXW.cjs.map
+//# sourceMappingURL=chunk-SVJ5GEXW.cjs.map

package/dist/chunk-SVJ5GEXW.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/ontology/constants.ts"],"names":[],"mappings":";;;AAYO,IAAM,sBAAA,GAAyB;AAG/B,IAAM,iBAAA,GAAoB;AAG1B,IAAM,kBAAA,GAAqB;AAG3B,IAAM,oBAAA,GAAuB;AAG7B,IAAM,uBAAA,GAA0B;AAGhC,IAAM,iBAAA,GAAoB;AAG1B,IAAM,wBAAA,GAA2B;AAGjC,IAAM,uBAAA,GAA0B;AAGhC,IAAM,iBAAA,GAAoB;AAG1B,IAAM,kBAAA,GAAqB;AAG3B,IAAM,oBAAA,GAAuB;AAG7B,IAAM,iBAAA,GAAoB;AAM1B,IAAM,mBAAA,GAAsB;AAAA,EACjC,sBAAA;AAAA,EACA,iBAAA;AAAA,EACA,kBAAA;AAAA,EACA,oBAAA;AAAA,EACA,uBAAA;AAAA,EACA,iBAAA;AAAA,EACA,wBAAA;AAAA,EACA,uBAAA;AAAA,EACA,iBAAA;AAAA,EACA,kBAAA;AAAA,EACA,oBAAA;AAAA,EACA;AACF","file":"chunk-SVJ5GEXW.cjs","sourcesContent":["/**\n * Named constants for ontology meta-edge names.\n *\n * Use these constants instead of string literals for type safety\n * and IDE support.\n */\n\n// ============================================================\n// Meta-Edge Names\n// ============================================================\n\n/** Type inheritance (Podcast subClassOf Media) */\nexport const META_EDGE_SUB_CLASS_OF = \"subClassOf\" as const;\n\n/** Broader concept (ML broader AI) */\nexport const META_EDGE_BROADER = \"broader\" as const;\n\n/** Narrower concept (AI narrower ML) */\nexport const META_EDGE_NARROWER = \"narrower\" as const;\n\n/** Non-hierarchical association */\nexport const META_EDGE_RELATED_TO = \"relatedTo\" as const;\n\n/** Same class, different representation */\nexport const META_EDGE_EQUIVALENT_TO = \"equivalentTo\" as const;\n\n/** Same individual (for deduplication) */\nexport const META_EDGE_SAME_AS = \"sameAs\" as const;\n\n/** Explicitly different individuals */\nexport const META_EDGE_DIFFERENT_FROM = \"differentFrom\" as const;\n\n/** Mutually exclusive types */\nexport const META_EDGE_DISJOINT_WITH = \"disjointWith\" as const;\n\n/** X is part of Y */\nexport const META_EDGE_PART_OF = \"partOf\" as const;\n\n/** Y has part X */\nexport const META_EDGE_HAS_PART = \"hasPart\" as const;\n\n/** Edge A is inverse of edge B */\nexport const META_EDGE_INVERSE_OF = \"inverseOf\" as const;\n\n/** Edge A implies edge B exists */\nexport const META_EDGE_IMPLIES = \"implies\" as const;\n\n// ============================================================\n// All Meta-Edge Names (for validation)\n// ============================================================\n\nexport const ALL_META_EDGE_NAMES = [\n  META_EDGE_SUB_CLASS_OF,\n  META_EDGE_BROADER,\n  META_EDGE_NARROWER,\n  META_EDGE_RELATED_TO,\n  META_EDGE_EQUIVALENT_TO,\n  META_EDGE_SAME_AS,\n  META_EDGE_DIFFERENT_FROM,\n  META_EDGE_DISJOINT_WITH,\n  META_EDGE_PART_OF,\n  META_EDGE_HAS_PART,\n  META_EDGE_INVERSE_OF,\n  META_EDGE_IMPLIES,\n] as const;\n\nexport type MetaEdgeName = (typeof ALL_META_EDGE_NAMES)[number];\n"]}

package/dist/chunk-SVUKGWSN.cjs

@@ -0,0 +1,102 @@
+'use strict';
+
+var chunkDDCYVIVV_cjs = require('./chunk-DDCYVIVV.cjs');
+var chunkSAFZ6JTI_cjs = require('./chunk-SAFZ6JTI.cjs');
+
+// src/core/temporal.ts
+var RECORDED_MAX = "9999-12-31T23:59:59.999Z";
+function assertValidRecordedInstant(value, path) {
+  chunkDDCYVIVV_cjs.validateCanonicalIsoDate(value, path);
+  if (value >= RECORDED_MAX) {
+    throw new chunkSAFZ6JTI_cjs.ValidationError(
+      `${path} must be before the recorded-time open sentinel ${RECORDED_MAX}.`,
+      {
+        issues: [
+          {
+            path,
+            message: `Expected a timestamp before ${RECORDED_MAX}, got "${value}"`
+          }
+        ]
+      },
+      {
+        suggestion: "Use a real recorded-time commit instant, not the open-interval sentinel."
+      }
+    );
+  }
+}
+function asRecordedInstant(value) {
+  assertValidRecordedInstant(value, "asRecordedInstant");
+  return value;
+}
+function resolveReadCoordinate(mode, asOf, suggestion) {
+  if (mode !== "asOf" && asOf !== void 0) {
+    throw new chunkSAFZ6JTI_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 chunkSAFZ6JTI_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) {
+    chunkDDCYVIVV_cjs.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 = RECORDED_MAX;
+exports.asRecordedInstant = asRecordedInstant;
+exports.assertValidRecordedInstant = assertValidRecordedInstant;
+exports.coordinateContext = coordinateContext;
+exports.describeCoordinate = describeCoordinate;
+exports.resolveReadCoordinate = resolveReadCoordinate;
+exports.withRecordedCoordinate = withRecordedCoordinate;
+//# sourceMappingURL=chunk-SVUKGWSN.cjs.map
+//# sourceMappingURL=chunk-SVUKGWSN.cjs.map

package/dist/chunk-SVUKGWSN.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/temporal.ts"],"names":["validateCanonicalIsoDate","ValidationError"],"mappings":"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","file":"chunk-SVUKGWSN.cjs","sourcesContent":["/**\n * Shared temporal coordinate + validation.\n */\nimport { ValidationError } from \"../errors\";\nimport { validateCanonicalIsoDate } from \"../utils/date\";\nimport { type TemporalMode } from \"./types\";\n\n/**\n * Open-ended recorded-time sentinel. Chosen so SQLite text ordering and\n * PostgreSQL `timestamptz` ordering both put every real commit instant before\n * the open interval end.\n */\nexport const RECORDED_MAX = \"9999-12-31T23:59:59.999Z\";\n\ndeclare const RECORDED_INSTANT_BRAND: unique symbol;\n\n/**\n * A canonical UTC ISO-8601 recorded-time instant (`YYYY-MM-DDTHH:mm:ss.sssZ`),\n * nominally branded so it can only originate from a recorded-time source —\n * {@link Store.recordedNow} or an explicit {@link asRecordedInstant} — never an\n * ad-hoc wall-clock string.\n *\n * The recorded commit clock is a logical, monotonic per-graph instant that can\n * run briefly ahead of wall time under bursty same-millisecond writes, so a raw\n * `new Date().toISOString()` may sort *before* the most recent commits and\n * silently omit them. The brand turns that footgun into a compile error:\n * `store.asOfRecorded` accepts only a `RecordedInstant`, so a bare wall-clock\n * string no longer type-checks — callers reach for `await store.recordedNow()`\n * (the monotonic high-water mark) or {@link asRecordedInstant} instead.\n */\nexport type RecordedInstant = string & {\n  readonly [RECORDED_INSTANT_BRAND]: \"RecordedInstant\";\n};\n\nexport function assertValidRecordedInstant(value: string, path: string): void {\n  validateCanonicalIsoDate(value, path);\n  if (value >= RECORDED_MAX) {\n    throw new ValidationError(\n      `${path} must be before the recorded-time open sentinel ${RECORDED_MAX}.`,\n      {\n        issues: [\n          {\n            path,\n            message: `Expected a timestamp before ${RECORDED_MAX}, got \"${value}\"`,\n          },\n        ],\n      },\n      {\n        suggestion:\n          \"Use a real recorded-time commit instant, not the open-interval sentinel.\",\n      },\n    );\n  }\n}\n\n/**\n * Brands a canonical UTC ISO-8601 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 UTC ISO-8601 string.\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-TAUGGLNQ.js

@@ -0,0 +1,59 @@
+import { isPlainObject } from './chunk-ITE4IXAK.js';
+import { ConfigurationError } from './chunk-DPNA466P.js';
+
+// src/core/json-value.ts
+function assertJsonValue(value, rootLabel, ownerKind) {
+  walk(value, rootLabel, ownerKind);
+}
+function walk(value, path, ownerKind) {
+  if (value === null) return;
+  const valueType = typeof value;
+  if (valueType === "number") {
+    if (!Number.isFinite(value)) {
+      throwInvalid(path, describeNonFinite(value), ownerKind);
+    }
+    return;
+  }
+  if (valueType === "string" || valueType === "boolean") return;
+  if (valueType === "bigint" || valueType === "function" || valueType === "symbol" || valueType === "undefined") {
+    throwInvalid(path, valueType, ownerKind);
+  }
+  if (Array.isArray(value)) {
+    for (const [index, element] of value.entries()) {
+      walk(element, `${path}[${index}]`, ownerKind);
+    }
+    return;
+  }
+  if (!isPlainObject(value)) {
+    throwInvalid(path, describeNonPlain(value), ownerKind);
+  }
+  for (const [key, nested] of Object.entries(value)) {
+    walk(nested, `${path}.${key}`, ownerKind);
+  }
+}
+function describeNonFinite(value) {
+  if (Number.isNaN(value)) return "NaN";
+  if (value === Number.POSITIVE_INFINITY) return "Infinity";
+  if (value === Number.NEGATIVE_INFINITY) return "-Infinity";
+  return "non-finite number";
+}
+function describeNonPlain(value) {
+  const constructorName = value?.constructor?.name;
+  if (typeof constructorName === "string" && constructorName.length > 0) {
+    return `${constructorName} instance`;
+  }
+  return "non-plain object";
+}
+function throwInvalid(path, kind, ownerKind) {
+  throw new ConfigurationError(
+    `${ownerKind} ${path} contains a non-JSON value (${kind}). Annotations must be JSON-serializable.`,
+    { path, valueKind: kind },
+    {
+      suggestion: "Use only strings, numbers, booleans, null, arrays, and plain objects in annotations."
+    }
+  );
+}
+
+export { assertJsonValue };
+//# sourceMappingURL=chunk-TAUGGLNQ.js.map
+//# sourceMappingURL=chunk-TAUGGLNQ.js.map

package/dist/chunk-TAUGGLNQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/json-value.ts"],"names":[],"mappings":";;;;AAyBO,SAAS,eAAA,CACd,KAAA,EACA,SAAA,EACA,SAAA,EACM;AACN,EAAA,IAAA,CAAK,KAAA,EAAO,WAAW,SAAS,CAAA;AAClC;AAEA,SAAS,IAAA,CAAK,KAAA,EAAgB,IAAA,EAAc,SAAA,EAAyB;AACnE,EAAA,IAAI,UAAU,IAAA,EAAM;AACpB,EAAA,MAAM,YAAY,OAAO,KAAA;AACzB,EAAA,IAAI,cAAc,QAAA,EAAU;AAI1B,IAAA,IAAI,CAAC,MAAA,CAAO,QAAA,CAAS,KAAK,CAAA,EAAG;AAC3B,MAAA,YAAA,CAAa,IAAA,EAAM,iBAAA,CAAkB,KAAe,CAAA,EAAG,SAAS,CAAA;AAAA,IAClE;AACA,IAAA;AAAA,EACF;AACA,EAAA,IAAI,SAAA,KAAc,QAAA,IAAY,SAAA,KAAc,SAAA,EAAW;AACvD,EAAA,IACE,cAAc,QAAA,IACd,SAAA,KAAc,cACd,SAAA,KAAc,QAAA,IACd,cAAc,WAAA,EACd;AACA,IAAA,YAAA,CAAa,IAAA,EAAM,WAAW,SAAS,CAAA;AAAA,EACzC;AACA,EAAA,IAAI,KAAA,CAAM,OAAA,CAAQ,KAAK,CAAA,EAAG;AACxB,IAAA,KAAA,MAAW,CAAC,KAAA,EAAO,OAAO,CAAA,IAAK,KAAA,CAAM,SAAQ,EAAG;AAC9C,MAAA,IAAA,CAAK,SAAS,CAAA,EAAG,IAAI,CAAA,CAAA,EAAI,KAAK,KAAK,SAAS,CAAA;AAAA,IAC9C;AACA,IAAA;AAAA,EACF;AACA,EAAA,IAAI,CAAC,aAAA,CAAc,KAAK,CAAA,EAAG;AACzB,IAAA,YAAA,CAAa,IAAA,EAAM,gBAAA,CAAiB,KAAK,CAAA,EAAG,SAAS,CAAA;AAAA,EACvD;AACA,EAAA,KAAA,MAAW,CAAC,GAAA,EAAK,MAAM,KAAK,MAAA,CAAO,OAAA,CAAQ,KAAK,CAAA,EAAG;AACjD,IAAA,IAAA,CAAK,QAAQ,CAAA,EAAG,IAAI,CAAA,CAAA,EAAI,GAAG,IAAI,SAAS,CAAA;AAAA,EAC1C;AACF;AAEA,SAAS,kBAAkB,KAAA,EAAuB;AAChD,EAAA,IAAI,MAAA,CAAO,KAAA,CAAM,KAAK,CAAA,EAAG,OAAO,KAAA;AAChC,EAAA,IAAI,KAAA,KAAU,MAAA,CAAO,iBAAA,EAAmB,OAAO,UAAA;AAC/C,EAAA,IAAI,KAAA,KAAU,MAAA,CAAO,iBAAA,EAAmB,OAAO,WAAA;AAC/C,EAAA,OAAO,mBAAA;AACT;AAEA,SAAS,iBAAiB,KAAA,EAAwB;AAChD,EAAA,MAAM,eAAA,GAAmB,OACrB,WAAA,EAAa,IAAA;AACjB,EAAA,IAAI,OAAO,eAAA,KAAoB,QAAA,IAAY,eAAA,CAAgB,SAAS,CAAA,EAAG;AACrE,IAAA,OAAO,GAAG,eAAe,CAAA,SAAA,CAAA;AAAA,EAC3B;AACA,EAAA,OAAO,kBAAA;AACT;AAEA,SAAS,YAAA,CAAa,IAAA,EAAc,IAAA,EAAc,SAAA,EAA0B;AAC1E,EAAA,MAAM,IAAI,kBAAA;AAAA,IACR,CAAA,EAAG,SAAS,CAAA,CAAA,EAAI,IAAI,+BAA+B,IAAI,CAAA,yCAAA,CAAA;AAAA,IACvD,EAAE,IAAA,EAAM,SAAA,EAAW,IAAA,EAAK;AAAA,IACxB;AAAA,MACE,UAAA,EACE;AAAA;AACJ,GACF;AACF","file":"chunk-TAUGGLNQ.js","sourcesContent":["/**\n * Runtime validation for JSON-serializable values.\n *\n * Used at definition-time boundaries (e.g., `defineNode`/`defineEdge` annotations)\n * to reject values that would silently break `JSON.stringify` round-trips or\n * throw at hash time. Catches accidental violations from untyped JS callers\n * and `as any` escape hatches that bypass the `JsonValue` type.\n */\nimport { ConfigurationError } from \"../errors\";\nimport { isPlainObject } from \"../utils/object\";\n\n/**\n * Asserts that `value` is JSON-serializable.\n *\n * Throws `ConfigurationError` with a dotted path identifying the offending\n * field. Rejects `bigint`, `function`, `symbol`, `undefined`, and class\n * instances such as `Date`, `Map`, `Set`, regex literals, and Buffers — all\n * of which either throw or silently coerce under `JSON.stringify`.\n *\n * @param value - The value to validate\n * @param rootLabel - Label for the root of the value (e.g., `\"annotations\"`)\n *   used as the prefix of the error path\n * @param ownerKind - Human-readable owner identifier for the error message\n *   (e.g., `'Node \"Person\"'`)\n */\nexport function assertJsonValue(\n  value: unknown,\n  rootLabel: string,\n  ownerKind: string,\n): void {\n  walk(value, rootLabel, ownerKind);\n}\n\nfunction walk(value: unknown, path: string, ownerKind: string): void {\n  if (value === null) return;\n  const valueType = typeof value;\n  if (valueType === \"number\") {\n    // NaN/Infinity/-Infinity are not JSON values; JSON.stringify silently\n    // coerces them to `null`, which would change the canonical hash input\n    // without the consumer noticing.\n    if (!Number.isFinite(value)) {\n      throwInvalid(path, describeNonFinite(value as number), ownerKind);\n    }\n    return;\n  }\n  if (valueType === \"string\" || valueType === \"boolean\") return;\n  if (\n    valueType === \"bigint\" ||\n    valueType === \"function\" ||\n    valueType === \"symbol\" ||\n    valueType === \"undefined\"\n  ) {\n    throwInvalid(path, valueType, ownerKind);\n  }\n  if (Array.isArray(value)) {\n    for (const [index, element] of value.entries()) {\n      walk(element, `${path}[${index}]`, ownerKind);\n    }\n    return;\n  }\n  if (!isPlainObject(value)) {\n    throwInvalid(path, describeNonPlain(value), ownerKind);\n  }\n  for (const [key, nested] of Object.entries(value)) {\n    walk(nested, `${path}.${key}`, ownerKind);\n  }\n}\n\nfunction describeNonFinite(value: number): string {\n  if (Number.isNaN(value)) return \"NaN\";\n  if (value === Number.POSITIVE_INFINITY) return \"Infinity\";\n  if (value === Number.NEGATIVE_INFINITY) return \"-Infinity\";\n  return \"non-finite number\";\n}\n\nfunction describeNonPlain(value: unknown): string {\n  const constructorName = (value as { constructor?: { name?: unknown } } | null)\n    ?.constructor?.name;\n  if (typeof constructorName === \"string\" && constructorName.length > 0) {\n    return `${constructorName} instance`;\n  }\n  return \"non-plain object\";\n}\n\nfunction throwInvalid(path: string, kind: string, ownerKind: string): never {\n  throw new ConfigurationError(\n    `${ownerKind} ${path} contains a non-JSON value (${kind}). Annotations must be JSON-serializable.`,\n    { path, valueKind: kind },\n    {\n      suggestion:\n        \"Use only strings, numbers, booleans, null, arrays, and plain objects in annotations.\",\n    },\n  );\n}\n"]}

package/dist/{chunk-J4IUSYFF.js → chunk-TE5ZA4VX.js}

@@ -1,10 +1,13 @@
-import { createSqliteOperationStrategy, createContributionMaterializer, gateFulltextMethods, assertTrustedImportDatabaseEmpty, suspendSqliteSecondaryIndexes, createSqliteTrustedImportSession, restoreSecondaryIndexes, analyzeImportedTables, generateSqliteCreateTableSQL, mapContributionMaterializationRow, SQLITE_CONTRIBUTION_MAT_TIMESTAMPS, buildContributionInsertValues, buildContributionOnConflictSet, assertAdoptedDialect, buildKindRemovalInsertValues, SQLITE_KIND_REMOVAL_TIMESTAMPS, buildKindRemovalOnConflictSet, mapKindRemovalRow, buildMaterializationInsertValues, SQLITE_INDEX_MAT_TIMESTAMPS, buildMaterializationOnConflictSet, mapMaterializationRow, generateSqliteDDL, createCommonOperationBackend, vectorSlotFromParams, hybridCandidatesRef, mapVectorWriteError, mapHybridSearchRow, gateFulltext, compileQueryWithDialect, EMBEDDING_UPSERT_PARAM_COUNT, vectorSlotFromDropIndexParams, vectorSlotFromCreateIndexParams, getOrCreateLru } from './chunk-K3Q3LJY3.js';
-import { tables } from './chunk-UXLSNRYL.js';
-import { createNodeRowMapper, SQLITE_ROW_MAPPER_CONFIG, createEdgeRowMapper, createUniqueRowMapper, createSchemaVersionRowMapper, quoteIdentifier, nowIso, coerceNumericScore } from './chunk-M6VES7V6.js';
-import { fts5Strategy, buildVectorCapabilities, buildFulltextCapabilities, assertVectorSearchLimit } from './chunk-EXU3RASM.js';
-import { normalizeGraphAnalyticsCapabilities, INTERNAL_TEMPORARY_WRITES, SQLITE_CAPABILITIES, SQLITE_MAX_BIND_PARAMETERS, MODERN_SQLITE_MAX_BIND_PARAMETERS, chunk, DURABLE_OBJECT_MAX_BIND_PARAMETERS, D1_MAX_BIND_PARAMETERS } from './chunk-44TA22QT.js';
-import { isMissingTableError } from './chunk-XGPUQ56G.js';
-import { ConfigurationError, BackendDisposedError } from './chunk-5PNMDJ7J.js';
+import { createSqliteOperationStrategy, createContributionMaterializer, gateFulltextMethods, assertTrustedImportDatabaseEmpty, suspendSqliteSecondaryIndexes, createSqliteTrustedImportSession, restoreSecondaryIndexes, analyzeImportedTables, generateSqliteCreateTableSQL, mapContributionMaterializationRow, SQLITE_CONTRIBUTION_MAT_TIMESTAMPS, buildContributionInsertValues, buildContributionOnConflictSet, assertAdoptedDialect, buildKindRemovalInsertValues, SQLITE_KIND_REMOVAL_TIMESTAMPS, buildKindRemovalOnConflictSet, mapKindRemovalRow, buildMaterializationInsertValues, SQLITE_INDEX_MAT_TIMESTAMPS, buildMaterializationOnConflictSet, mapMaterializationRow, generateSqliteDDL, createCommonOperationBackend, vectorSlotFromParams, buildLiveNodeCandidates, mapVectorWriteError, mapHybridSearchRow, gateFulltext, EMBEDDING_UPSERT_PARAM_COUNT, vectorSlotFromDropIndexParams, vectorSlotFromCreateIndexParams, getOrCreateLru } from './chunk-G32AO634.js';
+import { tables } from './chunk-MTNEGGM2.js';
+import { createNodeRowMapper, SQLITE_ROW_MAPPER_CONFIG, createEdgeRowMapper, createUniqueRowMapper, createSchemaVersionRowMapper, nowIso, coerceNumericScore } from './chunk-AOL64O4Z.js';
+import { toDrizzleSql, compileQueryWithDialect } from './chunk-Z2PPIVOO.js';
+import { chunk } from './chunk-35S6P5ZU.js';
+import { normalizeGraphAnalyticsCapabilities, INTERNAL_TEMPORARY_WRITES, SQLITE_CAPABILITIES, SQLITE_MAX_BIND_PARAMETERS, MODERN_SQLITE_MAX_BIND_PARAMETERS, DURABLE_OBJECT_MAX_BIND_PARAMETERS, D1_MAX_BIND_PARAMETERS } from './chunk-PZHC5GCD.js';
+import { isMissingTableError } from './chunk-KFLXWVUJ.js';
+import { fts5Strategy, buildVectorCapabilities, buildFulltextCapabilities, assertVectorSearchLimit } from './chunk-Y7M44XEK.js';
+import { sql as sql$1, isSqlFragment } from './chunk-6XDBRDZE.js';
+import { ConfigurationError, BackendDisposedError } from './chunk-DPNA466P.js';
 import { getTableName, sql, eq, and, isNull, inArray } from 'drizzle-orm';
 import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
 
@@ -27,8 +30,8 @@ function isDurableObjectBySessionName(db) {
 function isDurableObjectStorageClient(value) {
   if (typeof value !== "object" || value === null) return false;
   const candidate = value;
-  const sqlApi = candidate.sql;
-  return typeof candidate.transaction === "function" && typeof candidate.transactionSync === "function" && typeof sqlApi === "object" && sqlApi !== null && typeof sqlApi.exec === "function";
+  const sqlApi = candidate["sql"];
+  return typeof candidate["transaction"] === "function" && typeof candidate["transactionSync"] === "function" && typeof sqlApi === "object" && sqlApi !== null && typeof sqlApi["exec"] === "function";
 }
 function getDurableObjectStorageClient(db) {
   const client = db.$client;
@@ -77,7 +80,7 @@ var FIRST_MODERN_BIND_LIMIT_MINOR = 32;
 function parseCompiledMaxVariableNumber(rows) {
   for (const row of rows) {
     if (typeof row !== "object" || row === null) continue;
-    const option = row.compile_options;
+    const option = row["compile_options"];
     if (typeof option !== "string") continue;
     const match = MAX_VARIABLE_NUMBER_COMPILE_OPTION.exec(option);
     if (match !== null) return Number(match[1]);
@@ -87,7 +90,7 @@ function parseCompiledMaxVariableNumber(rows) {
 function hasModernBindLimitByVersion(rows) {
   const first = rows[0];
   if (typeof first !== "object" || first === null) return false;
-  const version = first.version;
+  const version = first["version"];
   if (typeof version !== "string") return false;
   const [major = 0, minor = 0] = version.split(".").map(Number);
   if (!Number.isFinite(major) || !Number.isFinite(minor)) return false;
@@ -120,7 +123,7 @@ function resolveSqliteClient(db) {
   const sqliteClient = db.$client;
   if (typeof sqliteClient !== "object" || sqliteClient === null) return;
   const candidate = sqliteClient;
-  if (typeof candidate.prepare !== "function") return;
+  if (typeof candidate["prepare"] !== "function") return;
   return sqliteClient;
 }
 function getOrCreatePreparedStatement(cache, sqliteClient, sqlText, cacheMax) {
@@ -247,7 +250,10 @@ function createSqliteExecutionAdapter(db, statementCacheMaxOrOptions = {}) {
     },
     compile,
     execute(query) {
-      return executeDrizzleQuery(db, query);
+      return executeDrizzleQuery(
+        db,
+        isSqlFragment(query) ? toDrizzleSql(query, "sqlite") : query
+      );
     },
     profile
   };
@@ -403,6 +409,16 @@ function resolveMaxBindParametersCapability(profile, override) {
   const requested = override ?? profile.maxBindParameters;
   return profile.hardMaxBindParameters === void 0 ? requested : Math.min(requested, profile.hardMaxBindParameters);
 }
+function resolveSqliteGraphAnalyticsCapabilities(profile, override) {
+  const requested = override ?? SQLITE_CAPABILITIES.graphAnalytics ?? {
+    supported: false,
+    mathFunctions: false
+  };
+  if (profile.transactionMode !== "do-sqlite" && profile.transactionMode !== "none") {
+    return requested;
+  }
+  return { ...requested, supported: false };
+}
 function createSqliteOperationBackend(options) {
   const {
     capabilities,
@@ -420,7 +436,7 @@ function createSqliteOperationBackend(options) {
   function execGet(query) {
     return runWithSerializedQueue(serializedQueue, async () => {
       if (compiledExecute === void 0) {
-        const rows2 = await db.all(query);
+        const rows2 = await executionAdapter.execute(query);
         return rows2[0];
       }
       const rows = await compiledExecute(executionAdapter.compile(query));
@@ -430,7 +446,7 @@ function createSqliteOperationBackend(options) {
   function execAll(query) {
     return runWithSerializedQueue(serializedQueue, async () => {
       if (compiledExecute === void 0) {
-        return await db.all(query);
+        return [...await executionAdapter.execute(query)];
       }
       return [...await compiledExecute(executionAdapter.compile(query))];
     });
@@ -438,7 +454,9 @@ function createSqliteOperationBackend(options) {
   function execRun(query) {
     return runWithSerializedQueue(serializedQueue, async () => {
       if (compiledRun === void 0) {
-        await db.run(query);
+        await db.run(
+          isSqlFragment(query) ? toDrizzleSql(query, "sqlite") : query
+        );
         return;
       }
       await compiledRun(executionAdapter.compile(query));
@@ -543,9 +561,11 @@ function createSqliteOperationBackend(options) {
         params,
         // Store-compiled candidates (predicates + subclass + currency)
         // take precedence; the live-node default covers direct backend use.
-        params.candidates ?? operationStrategy.buildLiveNodeIds(
+        params.candidates ?? buildLiveNodeCandidates(
+          tableNames.nodes,
           params.graphId,
-          params.nodeKind
+          params.nodeKind,
+          nowIso()
         )
       );
       let rows;
@@ -574,9 +594,11 @@ function createSqliteOperationBackend(options) {
           metric: params.vector.metric,
           indexType: params.vector.indexType
         });
-        const candidates = params.candidates ?? operationStrategy.buildLiveNodeIds(
+        const candidates = params.candidates ?? buildLiveNodeCandidates(
+          tableNames.nodes,
           params.graphId,
-          params.nodeKind
+          params.nodeKind,
+          nowIso()
         );
         const vectorParams = {
           graphId: params.graphId,
@@ -592,11 +614,11 @@ function createSqliteOperationBackend(options) {
         const vectorSql = vectorStrategy.buildSearch(
           slot,
           vectorParams,
-          hybridCandidatesRef()
+          sql$1.raw("SELECT node_id FROM tg_hybrid_cand")
         );
         const statement = operationStrategy.buildHybridSearch(
           { ...params, candidates },
-          vectorSql,
+          toDrizzleSql(vectorSql, "sqlite"),
           params.vector.metric === "cosine"
         );
         let raw;
@@ -728,6 +750,10 @@ function createSqliteBackend(db, options = {}) {
     maxBindParameters: resolveMaxBindParametersCapability(
       executionAdapter.profile,
       capabilityOverrides.maxBindParameters
+    ),
+    graphAnalytics: resolveSqliteGraphAnalyticsCapabilities(
+      executionAdapter.profile,
+      capabilityOverrides.graphAnalytics
     )
   });
   const tableNames = {
@@ -1102,14 +1128,27 @@ function createSqliteBackend(db, options = {}) {
     },
     async refreshStatistics() {
       await db.run(
-        sql`PRAGMA analysis_limit = ${sql.raw(String(SQLITE_ANALYZE_ROW_LIMIT))}`
+        toDrizzleSql(
+          sql$1`PRAGMA analysis_limit = ${sql$1.raw(String(SQLITE_ANALYZE_ROW_LIMIT))}`,
+          "sqlite"
+        )
       );
       for (const tableName of coreAnalyzeTables) {
-        await db.run(sql`ANALYZE ${quoteIdentifier(tableName)}`);
+        await db.run(
+          toDrizzleSql(
+            sql$1`ANALYZE ${sql$1.identifier(tableName)}`,
+            "sqlite"
+          )
+        );
       }
       for (const tableName of recordedAnalyzeTables) {
         try {
-          await db.run(sql`ANALYZE ${quoteIdentifier(tableName)}`);
+          await db.run(
+            toDrizzleSql(
+              sql$1`ANALYZE ${sql$1.identifier(tableName)}`,
+              "sqlite"
+            )
+          );
         } catch (error) {
           if (!isMissingTableError(error)) throw error;
         }
@@ -1126,6 +1165,9 @@ function createSqliteBackend(db, options = {}) {
       );
     },
     async transaction(fn, options2) {
+      return backend.transactionWithNative((tx) => fn(tx), options2);
+    },
+    async transactionWithNative(fn, options2) {
       const temporaryWrites = options2?.temporaryWrites === INTERNAL_TEMPORARY_WRITES;
       if (temporaryWrites && options2.accessMode !== "read_only") {
         throw new ConfigurationError(
@@ -1219,5 +1261,5 @@ function createTransactionBackend(options) {
 }
 
 export { createSqliteBackend };
-//# sourceMappingURL=chunk-J4IUSYFF.js.map
-//# sourceMappingURL=chunk-J4IUSYFF.js.map
+//# sourceMappingURL=chunk-TE5ZA4VX.js.map
+//# sourceMappingURL=chunk-TE5ZA4VX.js.map