@nicia-ai/typegraph 0.37.1 → 0.39.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-A42GCBGX.cjs → chunk-TRF4EBJT.cjs}

@@ -1,5 +1,7 @@
 'use strict';
 
+var chunk764JHTLT_cjs = require('./chunk-764JHTLT.cjs');
+
 // src/utils/compare.ts
 function compareStrings(left, right) {
   if (left < right) return -1;
@@ -10,8 +12,8 @@ function compareCodePoints(left, right) {
   let leftIndex = 0;
   let rightIndex = 0;
   while (leftIndex < left.length && rightIndex < right.length) {
-    const leftPoint = left.codePointAt(leftIndex);
-    const rightPoint = right.codePointAt(rightIndex);
+    const leftPoint = chunk764JHTLT_cjs.requireDefined(left.codePointAt(leftIndex));
+    const rightPoint = chunk764JHTLT_cjs.requireDefined(right.codePointAt(rightIndex));
     if (leftPoint !== rightPoint) return leftPoint < rightPoint ? -1 : 1;
     leftIndex += leftPoint > 65535 ? 2 : 1;
     rightIndex += rightPoint > 65535 ? 2 : 1;
@@ -24,5 +26,5 @@ function compareCodePoints(left, right) {
 
 exports.compareCodePoints = compareCodePoints;
 exports.compareStrings = compareStrings;
-//# sourceMappingURL=chunk-A42GCBGX.cjs.map
-//# sourceMappingURL=chunk-A42GCBGX.cjs.map
+//# sourceMappingURL=chunk-TRF4EBJT.cjs.map
+//# sourceMappingURL=chunk-TRF4EBJT.cjs.map

package/dist/chunk-TRF4EBJT.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/compare.ts"],"names":["requireDefined"],"mappings":";;;;;AAgBO,SAAS,cAAA,CAAe,MAAc,KAAA,EAAuB;AAClE,EAAA,IAAI,IAAA,GAAO,OAAO,OAAO,EAAA;AACzB,EAAA,OAAO,IAAA,GAAO,QAAQ,CAAA,GAAI,CAAA;AAC5B;AAiBO,SAAS,iBAAA,CAAkB,MAAc,KAAA,EAAuB;AACrE,EAAA,IAAI,IAAA,KAAS,OAAO,OAAO,CAAA;AAG3B,EAAA,IAAI,SAAA,GAAY,CAAA;AAChB,EAAA,IAAI,UAAA,GAAa,CAAA;AACjB,EAAA,OAAO,SAAA,GAAY,IAAA,CAAK,MAAA,IAAU,UAAA,GAAa,MAAM,MAAA,EAAQ;AAC3D,IAAA,MAAM,SAAA,GAAYA,gCAAA,CAAe,IAAA,CAAK,WAAA,CAAY,SAAS,CAAC,CAAA;AAC5D,IAAA,MAAM,UAAA,GAAaA,gCAAA,CAAe,KAAA,CAAM,WAAA,CAAY,UAAU,CAAC,CAAA;AAC/D,IAAA,IAAI,SAAA,KAAc,UAAA,EAAY,OAAO,SAAA,GAAY,aAAa,EAAA,GAAK,CAAA;AACnE,IAAA,SAAA,IAAa,SAAA,GAAY,QAAU,CAAA,GAAI,CAAA;AACvC,IAAA,UAAA,IAAc,UAAA,GAAa,QAAU,CAAA,GAAI,CAAA;AAAA,EAC3C;AACA,EAAA,MAAM,aAAA,GAAgB,aAAa,IAAA,CAAK,MAAA;AACxC,EAAA,MAAM,cAAA,GAAiB,cAAc,KAAA,CAAM,MAAA;AAC3C,EAAA,IAAI,aAAA,IAAiB,gBAAgB,OAAO,CAAA;AAC5C,EAAA,OAAO,gBAAgB,EAAA,GAAK,CAAA;AAC9B","file":"chunk-TRF4EBJT.cjs","sourcesContent":["import { requireDefined } from \"./presence\";\n/**\n * Deterministic UTF-16 code-unit string comparison.\n *\n * `localeCompare` (and any `Intl`-backed collation) varies with the host's\n * ICU configuration, so two processes can order the same strings differently\n * — which turns \"sorted\" lock-acquisition sequences into cross-process\n * deadlocks and makes result/report ordering flap between environments.\n * Code-unit order is identical everywhere, matches SQLite's BINARY collation\n * for ASCII identifiers, and sorts NUL below every other character, so\n * NUL-separated composite keys compare as true tuples.\n *\n * Use this (or `Array.prototype.toSorted()` with no comparator, which is the\n * same order) for every internal ordering; locale-aware collation belongs\n * only in user-facing presentation code, which this library does not have.\n */\nexport function compareStrings(left: string, right: string): number {\n  if (left < right) return -1;\n  return left > right ? 1 : 0;\n}\n\n/**\n * Deterministic code-point string comparison — the order a SQL engine uses.\n *\n * {@link compareStrings} compares UTF-16 code *units*, which disagrees with\n * SQL byte order for astral characters: `\"\\u{10000}\"` is stored as the\n * surrogate pair `𐀀`, so code-unit order sorts it below `\"\"`\n * even though its code point (and its UTF-8 encoding) is far above. SQLite's\n * `BINARY` collation, Postgres's `C` collation, and UTF-8 byte order all agree\n * with code-point order.\n *\n * Use this wherever a JS-side ordering must reproduce an ORDER BY the database\n * could equally have performed — notably the hybrid-search fusion fallback,\n * whose ranks and page boundary must match the single-statement SQL path row\n * for row. Everywhere else {@link compareStrings} is cheaper and sufficient.\n */\nexport function compareCodePoints(left: string, right: string): number {\n  if (left === right) return 0;\n  // Walks by code point, stepping over the low surrogate of an astral pair.\n  // `codePointAt` at a valid index always yields a number.\n  let leftIndex = 0;\n  let rightIndex = 0;\n  while (leftIndex < left.length && rightIndex < right.length) {\n    const leftPoint = requireDefined(left.codePointAt(leftIndex));\n    const rightPoint = requireDefined(right.codePointAt(rightIndex));\n    if (leftPoint !== rightPoint) return leftPoint < rightPoint ? -1 : 1;\n    leftIndex += leftPoint > 0xff_ff ? 2 : 1;\n    rightIndex += rightPoint > 0xff_ff ? 2 : 1;\n  }\n  const leftExhausted = leftIndex >= left.length;\n  const rightExhausted = rightIndex >= right.length;\n  if (leftExhausted && rightExhausted) return 0;\n  return leftExhausted ? -1 : 1;\n}\n"]}

package/dist/{chunk-KQJ54OG5.js → chunk-U4JDJKPD.js}

@@ -1,7 +1,12 @@
-import { compileNodeIndexKeys, compileEdgeIndexKeys, compileIndexWhere, getDialect } from './chunk-EXU3RASM.js';
-import { sql } from 'drizzle-orm';
-import { CasingCache } from 'drizzle-orm/casing';
+import { compileNodeIndexKeys, compileEdgeIndexKeys, compileIndexWhere, getDialect } from './chunk-G3CSQLLT.js';
+import { sql, renderSqlInline } from './chunk-6XDBRDZE.js';
+import { requireDefined } from './chunk-QMQLUA66.js';
 
+// src/indexes/ddl.ts
+var INDEX_DDL_BEHAVIOR = {
+  postgres: { concurrentBuilds: true, supportsGinFamily: true },
+  sqlite: { concurrentBuilds: false, supportsGinFamily: false }
+};
 function generateIndexDDL(index, dialect, options = {}) {
   if (index.entity === "node") {
     return generateNodeIndexDDL(index, dialect, options);
@@ -21,10 +26,10 @@ function generateTableIndexDDL(index, dialect, tableName, options) {
     return generateGinFamilyIndexDDL(index, dialect, tableName, options);
   }
   const ifNotExists = options.ifNotExists ?? true;
-  const propsColumn = sql.raw('"props"');
-  const systemColumn = (column) => sql.raw(quoteIdentifier(column));
+  const propsColumn = sql.identifier("props");
+  const systemColumn = (column) => sql.identifier(column);
   const keys = index.entity === "node" ? compileNodeIndexKeys(index, dialect, propsColumn, systemColumn).keys : compileEdgeIndexKeys(index, dialect, propsColumn, systemColumn).keys;
-  const whereSql = index.where ? sqlToInlineString(
+  const whereSql = index.where ? renderSqlInline(
     compileIndexWhere(
       {
         dialect,
@@ -35,74 +40,32 @@ function generateTableIndexDDL(index, dialect, tableName, options) {
     ),
     dialect
   ) : void 0;
-  const keySql = keys.map((k) => sqlToInlineString(k, dialect)).join(", ");
+  const keySql = keys.map((key) => renderSqlInline(key, dialect)).join(", ");
   const unique = index.unique ? "UNIQUE " : "";
-  const concurrent = options.concurrent === true && dialect === "postgres" ? "CONCURRENTLY " : "";
+  const concurrent = options.concurrent === true && INDEX_DDL_BEHAVIOR[dialect].concurrentBuilds ? "CONCURRENTLY " : "";
   const ifNotExistsSql = ifNotExists ? "IF NOT EXISTS " : "";
   const whereClause = whereSql ? ` WHERE ${whereSql}` : "";
   return `CREATE ${unique}INDEX ${concurrent}${ifNotExistsSql}${quoteIdentifier(index.name)} ON ${quoteIdentifier(tableName)} (${keySql})${whereClause};`;
 }
 function generateGinFamilyIndexDDL(index, dialect, tableName, options) {
-  if (dialect !== "postgres") {
+  if (!INDEX_DDL_BEHAVIOR[dialect].supportsGinFamily) {
     throw new Error(
       `Index "${index.name}" declares method "${index.method}", which requires PostgreSQL. materializeIndexes() reports such declarations as skipped on SQLite instead of calling this.`
     );
   }
   const adapter = getDialect(dialect);
-  const propsColumn = sql.raw('"props"');
-  const pointer = index.fields[0];
+  const propsColumn = sql.identifier("props");
+  const pointer = requireDefined(index.fields[0]);
   const expression = index.method === "gin" ? adapter.jsonExtract(propsColumn, pointer) : adapter.jsonExtractText(propsColumn, pointer);
   const operatorClass = index.method === "gin" ? "jsonb_path_ops" : "gin_trgm_ops";
   const concurrent = options.concurrent === true ? "CONCURRENTLY " : "";
   const ifNotExistsSql = options.ifNotExists ?? true ? "IF NOT EXISTS " : "";
-  return `CREATE INDEX ${concurrent}${ifNotExistsSql}${quoteIdentifier(index.name)} ON ${quoteIdentifier(tableName)} USING GIN ((${sqlToInlineString(expression, dialect)}) ${operatorClass});`;
+  return `CREATE INDEX ${concurrent}${ifNotExistsSql}${quoteIdentifier(index.name)} ON ${quoteIdentifier(tableName)} USING GIN ((${renderSqlInline(expression, dialect)}) ${operatorClass});`;
 }
 function quoteIdentifier(identifier) {
   return `"${identifier.replaceAll('"', '""')}"`;
 }
-function sqlToInlineString(object, dialect) {
-  const query = object.toQuery({
-    casing: new CasingCache(),
-    escapeName: (name) => name,
-    escapeParam: (_number, value) => inlineParam(value, dialect),
-    escapeString: (value) => escapeStringLiteral(value),
-    inlineParams: true,
-    invokeSource: "indexes"
-  });
-  if (query.params.length > 0) {
-    throw new Error(
-      "Index DDL generation produced parameters; expected fully inlined SQL"
-    );
-  }
-  return query.sql;
-}
-function inlineParam(value, dialect) {
-  if (value === null || value === void 0) {
-    return "NULL";
-  }
-  if (value instanceof Date) {
-    return escapeStringLiteral(value.toISOString());
-  }
-  if (typeof value === "string") {
-    return escapeStringLiteral(value);
-  }
-  if (typeof value === "number") {
-    return value.toString();
-  }
-  if (typeof value === "boolean") {
-    return getDialect(dialect).booleanLiteralString(value);
-  }
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-  throw new TypeError(
-    "Index DDL generation received an unsupported SQL parameter value"
-  );
-}
-function escapeStringLiteral(value) {
-  return `'${value.replaceAll("'", "''")}'`;
-}
 
 export { generateEdgeIndexDDL, generateIndexDDL, generateNodeIndexDDL };
-//# sourceMappingURL=chunk-KQJ54OG5.js.map
-//# sourceMappingURL=chunk-KQJ54OG5.js.map
+//# sourceMappingURL=chunk-U4JDJKPD.js.map
+//# sourceMappingURL=chunk-U4JDJKPD.js.map

package/dist/chunk-U4JDJKPD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/indexes/ddl.ts"],"names":[],"mappings":"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","file":"chunk-U4JDJKPD.js","sourcesContent":["import { getDialect } from \"../query/dialect\";\nimport { type SqlDialect } from \"../query/dialect/types\";\nimport { renderSqlInline, sql, type SqlFragment } from \"../query/sql-fragment\";\nimport { requireDefined } from \"../utils/presence\";\nimport {\n  compileEdgeIndexKeys,\n  compileIndexWhere,\n  compileNodeIndexKeys,\n  type IndexCompilationContext,\n} from \"./compiler\";\nimport {\n  type EdgeIndexDeclaration,\n  type NodeIndexDeclaration,\n  type RelationalIndexDeclaration,\n  type SystemColumnName,\n} from \"./types\";\n\nexport type GenerateIndexDdlOptions = Readonly<{\n  nodesTableName?: string | undefined;\n  edgesTableName?: string | undefined;\n  ifNotExists?: boolean | undefined;\n  /**\n   * Emit `CREATE INDEX CONCURRENTLY` (Postgres only). Required for\n   * `store.materializeIndexes()` so live tables don't take an\n   * `AccessExclusiveLock`. Ignored on SQLite (no equivalent; SQLite is\n   * single-writer regardless). When true on Postgres, the resulting\n   * statement cannot be executed inside a transaction.\n   */\n  concurrent?: boolean | undefined;\n}>;\n\nconst INDEX_DDL_BEHAVIOR = {\n  postgres: { concurrentBuilds: true, supportsGinFamily: true },\n  sqlite: { concurrentBuilds: false, supportsGinFamily: false },\n} as const satisfies Record<\n  SqlDialect,\n  Readonly<{ concurrentBuilds: boolean; supportsGinFamily: boolean }>\n>;\n\n/**\n * Generate `CREATE INDEX` DDL for a single relational index declaration.\n *\n * Vector index declarations (`entity: \"vector\"`) are NOT handled here —\n * they go through `backend.createVectorIndex` instead because the DDL\n * is dialect-specific (`USING hnsw (...) WITH (m=..., ef_construction=...)`\n * on Postgres) and operates on the strategy's per-`(kind, field)` embedding\n * tables, not `typegraph_nodes` / `typegraph_edges`. Callers narrow to the\n * relational subset before calling this function.\n */\nexport function generateIndexDDL(\n  index: RelationalIndexDeclaration,\n  dialect: SqlDialect,\n  options: GenerateIndexDdlOptions = {},\n): string {\n  if (index.entity === \"node\") {\n    return generateNodeIndexDDL(index, dialect, options);\n  }\n  return generateEdgeIndexDDL(index, dialect, options);\n}\n\nexport function generateNodeIndexDDL(\n  index: NodeIndexDeclaration,\n  dialect: SqlDialect,\n  options: GenerateIndexDdlOptions = {},\n): string {\n  const tableName = options.nodesTableName ?? \"typegraph_nodes\";\n  return generateTableIndexDDL(index, dialect, tableName, options);\n}\n\nexport function generateEdgeIndexDDL(\n  index: EdgeIndexDeclaration,\n  dialect: SqlDialect,\n  options: GenerateIndexDdlOptions = {},\n): string {\n  const tableName = options.edgesTableName ?? \"typegraph_edges\";\n  return generateTableIndexDDL(index, dialect, tableName, options);\n}\n\nfunction generateTableIndexDDL(\n  index: RelationalIndexDeclaration,\n  dialect: SqlDialect,\n  tableName: string,\n  options: GenerateIndexDdlOptions,\n): string {\n  if (index.method !== undefined) {\n    return generateGinFamilyIndexDDL(index, dialect, tableName, options);\n  }\n  const ifNotExists = options.ifNotExists ?? true;\n  const propsColumn = sql.identifier(\"props\");\n  const systemColumn = (column: SystemColumnName): SqlFragment =>\n    sql.identifier(column);\n\n  const keys =\n    index.entity === \"node\" ?\n      compileNodeIndexKeys(index, dialect, propsColumn, systemColumn).keys\n    : compileEdgeIndexKeys(index, dialect, propsColumn, systemColumn).keys;\n\n  const whereSql =\n    index.where ?\n      renderSqlInline(\n        compileIndexWhere(\n          {\n            dialect,\n            propsColumn,\n            systemColumn,\n          } satisfies IndexCompilationContext,\n          index.where,\n        ),\n        dialect,\n      )\n    : undefined;\n\n  const keySql = keys.map((key) => renderSqlInline(key, dialect)).join(\", \");\n  const unique = index.unique ? \"UNIQUE \" : \"\";\n  const concurrent =\n    (\n      options.concurrent === true &&\n      INDEX_DDL_BEHAVIOR[dialect].concurrentBuilds\n    ) ?\n      \"CONCURRENTLY \"\n    : \"\";\n  const ifNotExistsSql = ifNotExists ? \"IF NOT EXISTS \" : \"\";\n\n  const whereClause = whereSql ? ` WHERE ${whereSql}` : \"\";\n\n  return `CREATE ${unique}INDEX ${concurrent}${ifNotExistsSql}${quoteIdentifier(index.name)} ON ${quoteIdentifier(tableName)} (${keySql})${whereClause};`;\n}\n\n/**\n * DDL for the GIN-family methods (`\"gin\"` / `\"trigram\"`) — a PostgreSQL\n * expression GIN over the declaration's single field.\n *\n * The indexed expression is built from the SAME dialect extraction the\n * query compiler emits for the field (`jsonExtract` → `\"props\" #> ARRAY[…]`\n * for containment, `jsonExtractText` → `#>>` for text), because Postgres\n * matches expression indexes structurally: `(props #> ARRAY['tags']) @> $1`\n * and `(props #>> ARRAY['name']) ILIKE $1 ESCAPE '\\'` both hit their GIN\n * (verified against parameterized prepared statements). No scope prefix\n * columns, uniqueness, or partial clause: a GIN indexes one expression, and\n * the query's `graph_id` / `kind` equality filters apply as residual\n * conditions over the candidate rows.\n */\nfunction generateGinFamilyIndexDDL(\n  index: RelationalIndexDeclaration,\n  dialect: SqlDialect,\n  tableName: string,\n  options: GenerateIndexDdlOptions,\n): string {\n  if (!INDEX_DDL_BEHAVIOR[dialect].supportsGinFamily) {\n    throw new Error(\n      `Index \"${index.name}\" declares method \"${index.method}\", which ` +\n        \"requires PostgreSQL. materializeIndexes() reports such \" +\n        \"declarations as skipped on SQLite instead of calling this.\",\n    );\n  }\n  const adapter = getDialect(dialect);\n  const propsColumn = sql.identifier(\"props\");\n  const pointer = requireDefined(index.fields[0]);\n  const expression =\n    index.method === \"gin\" ?\n      adapter.jsonExtract(propsColumn, pointer)\n    : adapter.jsonExtractText(propsColumn, pointer);\n  const operatorClass =\n    index.method === \"gin\" ? \"jsonb_path_ops\" : \"gin_trgm_ops\";\n  const concurrent = options.concurrent === true ? \"CONCURRENTLY \" : \"\";\n  const ifNotExistsSql = (options.ifNotExists ?? true) ? \"IF NOT EXISTS \" : \"\";\n  return `CREATE INDEX ${concurrent}${ifNotExistsSql}${quoteIdentifier(index.name)} ON ${quoteIdentifier(tableName)} USING GIN ((${renderSqlInline(expression, dialect)}) ${operatorClass});`;\n}\n\nfunction quoteIdentifier(identifier: string): string {\n  return `\"${identifier.replaceAll('\"', '\"\"')}\"`;\n}\n"]}