@nicia-ai/typegraph 0.45.0 → 0.46.1

package/dist/chunk-DYATYRY4.js

@@ -0,0 +1,47 @@
+// src/utils/object.ts
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function hasOwnKey(bag, key) {
+  return Object.hasOwn(bag, key);
+}
+function readOwnProperty(bag, key) {
+  return hasOwnKey(bag, key) ? bag[key] : void 0;
+}
+function createDataKeyedBag() {
+  return /* @__PURE__ */ Object.create(null);
+}
+var INTEROP_PROBE_KEYS = /* @__PURE__ */ new Set(["then", "toJSON"]);
+function isInteropProbeKey(key) {
+  return INTEROP_PROBE_KEYS.has(key);
+}
+function compactUndefined(value) {
+  const result = {};
+  for (const [key, fieldValue] of Object.entries(value)) {
+    if (fieldValue !== void 0) result[key] = fieldValue;
+  }
+  return result;
+}
+function freezeDeep(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Object.isFrozen(value)) return value;
+  for (const nested of Object.values(value)) {
+    freezeDeep(nested);
+  }
+  return Object.freeze(value);
+}
+
+// src/utils/presence.ts
+function isPresent(value) {
+  return value !== null && value !== void 0;
+}
+function requireDefined(value, message = "Expected a defined value.") {
+  if (value === void 0 || value === null) throw new TypeError(message);
+  return value;
+}
+
+export { compactUndefined, createDataKeyedBag, freezeDeep, hasOwnKey, isInteropProbeKey, isPlainObject, isPresent, readOwnProperty, requireDefined };
+//# sourceMappingURL=chunk-DYATYRY4.js.map
+//# sourceMappingURL=chunk-DYATYRY4.js.map

package/dist/chunk-DYATYRY4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/object.ts","../src/utils/presence.ts"],"names":[],"mappings":";AAMO,SAAS,cACd,KAAA,EACkC;AAClC,EAAA,IAAI,OAAO,KAAA,KAAU,QAAA,IAAY,KAAA,KAAU,MAAM,OAAO,KAAA;AACxD,EAAA,MAAM,SAAA,GAAqB,MAAA,CAAO,cAAA,CAAe,KAAK,CAAA;AACtD,EAAA,OAAO,SAAA,KAAc,MAAA,CAAO,SAAA,IAAa,SAAA,KAAc,IAAA;AACzD;AAyBO,SAAS,SAAA,CACd,KACA,GAAA,EACS;AACT,EAAA,OAAO,MAAA,CAAO,MAAA,CAAO,GAAA,EAAK,GAAG,CAAA;AAC/B;AASO,SAAS,eAAA,CACd,KACA,GAAA,EACS;AACT,EAAA,OAAO,UAAU,GAAA,EAAK,GAAG,CAAA,GAAI,GAAA,CAAI,GAAG,CAAA,GAAI,MAAA;AAC1C;AAqCO,SAAS,kBAAA,GAA2C;AACzD,EAAA,uBAAO,MAAA,CAAO,OAAO,IAAI,CAAA;AAC3B;AASA,IAAM,qCAA0C,IAAI,GAAA,CAAI,CAAC,MAAA,EAAQ,QAAQ,CAAC,CAAA;AAuBnE,SAAS,kBAAkB,GAAA,EAAsB;AACtD,EAAA,OAAO,kBAAA,CAAmB,IAAI,GAAG,CAAA;AACnC;AAWO,SAAS,iBAAmC,KAAA,EAE7C;AACJ,EAAA,MAAM,SAAkC,EAAC;AACzC,EAAA,KAAA,MAAW,CAAC,GAAA,EAAK,UAAU,KAAK,MAAA,CAAO,OAAA,CAAQ,KAAK,CAAA,EAAG;AACrD,IAAA,IAAI,UAAA,KAAe,MAAA,EAAW,MAAA,CAAO,GAAG,CAAA,GAAI,UAAA;AAAA,EAC9C;AACA,EAAA,OAAO,MAAA;AACT;AAUO,SAAS,WAAc,KAAA,EAAa;AACzC,EAAA,IAAI,KAAA,KAAU,IAAA,IAAQ,OAAO,KAAA,KAAU,UAAU,OAAO,KAAA;AACxD,EAAA,IAAI,MAAA,CAAO,QAAA,CAAS,KAAK,CAAA,EAAG,OAAO,KAAA;AACnC,EAAA,KAAA,MAAW,MAAA,IAAU,MAAA,CAAO,MAAA,CAAO,KAAgC,CAAA,EAAG;AACpE,IAAA,UAAA,CAAW,MAAM,CAAA;AAAA,EACnB;AACA,EAAA,OAAO,MAAA,CAAO,OAAO,KAAK,CAAA;AAC5B;;;AClKO,SAAS,UAAU,KAAA,EAAyB;AACjD,EAAA,OAAO,KAAA,KAAU,QAAQ,KAAA,KAAU,MAAA;AACrC;AAOO,SAAS,cAAA,CACd,KAAA,EACA,OAAA,GAAU,2BAAA,EACM;AAChB,EAAA,IAAI,UAAU,MAAA,IAAa,KAAA,KAAU,MAAM,MAAM,IAAI,UAAU,OAAO,CAAA;AACtE,EAAA,OAAO,KAAA;AACT","file":"chunk-DYATYRY4.js","sourcesContent":["/**\n * Plain-object predicate. Excludes class instances (Date, Map, Set,\n * RegExp, Buffer, …) and arrays. Used wherever the caller needs to\n * distinguish a literal `{}` from anything else — e.g. JSON-value\n * validation and runtime-document structural checks.\n */\nexport function isPlainObject(\n  value: unknown,\n): value is Record<string, unknown> {\n  if (typeof value !== \"object\" || value === null) return false;\n  const prototype: unknown = Object.getPrototypeOf(value);\n  return prototype === Object.prototype || prototype === null;\n}\n\n/**\n * Own-key membership for a bag whose KEYS ARE DATA — a props record parsed out\n * of a JSON column, a JSON-Schema `properties` map, a serialized-schema kind\n * table. The single owner of that question; every path asking it calls here.\n *\n * `in` is the wrong operator for these bags because it also finds inherited\n * members: `\"toString\" in {}` is `true`, as are `\"constructor\"`, `\"valueOf\"`,\n * `\"__proto__\"`, and the rest of `Object.prototype`. A bag that does NOT carry\n * the key therefore reads as if it does, and the `bag[key]` read that follows\n * yields the inherited member instead of stored data.\n *\n * Reachable, and not through anything exotic: a schema may DECLARE a field named\n * after a prototype member — `z.object({ toString: z.string() })` is an ordinary\n * schema — and such a field survives validation, storage, and the JSON round-trip\n * as normal data. (`__proto__` is the narrower case: Zod drops an own `__proto__`\n * key and `bag[\"__proto__\"] = value` assigns a prototype rather than creating one,\n * so no validated write produces it — but the unvalidated trusted import writes a\n * caller's bag verbatim, and JSON parses `__proto__` back as an own key.)\n *\n * `in` remains correct — and stays in use — where the key set is statically\n * known: a discriminated union's tag, a capability probe, a brand check. The\n * distinction is whether the key came from data or from the code.\n */\nexport function hasOwnKey(\n  bag: Readonly<Record<string, unknown>>,\n  key: string,\n): boolean {\n  return Object.hasOwn(bag, key);\n}\n\n/**\n * Own-key read of a data-keyed bag: an absent key reads `undefined`, never an\n * inherited `Object.prototype` member. The read companion to {@link hasOwnKey}\n * (see its doc for why `bag[key]` alone is wrong for these bags), and like it\n * the single owner — every path reading a data-keyed bag by a data-supplied\n * key calls here rather than re-spelling the guard.\n */\nexport function readOwnProperty(\n  bag: Readonly<Record<string, unknown>>,\n  key: string,\n): unknown {\n  return hasOwnKey(bag, key) ? bag[key] : undefined;\n}\n\n/**\n * Creates an accumulator whose KEYS ARE DATA — a kind name, a property name, a\n * JSON-Schema keyword, an entity's property bag. The write-side companion to\n * {@link hasOwnKey} / {@link readOwnProperty}, and like them the single owner\n * of the question: every accumulator keyed by data is built here.\n *\n * Null-prototype, because `bag[key] = value` on a `{}` literal does NOT create\n * an entry when `key` is `__proto__`: it invokes `Object.prototype`'s\n * `__proto__` SETTER, which either reparents the bag (object value) or does\n * nothing at all (primitive value). Either way the value is silently dropped,\n * and every later own-key read answers as if the writer never wrote it — the\n * write-side mirror of the inherited-member read `hasOwnKey` exists to prevent.\n *\n * Reachable, and not through anything exotic: kind names are validated against\n * `/^[A-Za-z_][A-Za-z0-9_]*$/`, which admits `__proto__` (as it does\n * `toString` and `constructor`); extension property names are unrestricted\n * apart from a reserved list; and `JSON.parse` yields `__proto__` as an\n * ordinary own key, so any document read off disk or the wire can carry one.\n *\n * A plain `{}` remains correct — and stays in use — for records whose keys are\n * statically known: an options object, a discriminated-union member, a fixed\n * lookup table.\n *\n * ## Spread it at the boundary\n *\n * The null prototype is an INTERNAL write-side protection, not something a\n * caller asked for. A bag that escapes into a value this library RETURNS must\n * be copied with a spread — `return { ...bag }` — at that boundary: returned\n * as-is it has no `toString`, no `hasOwnProperty`, and answers `false` to\n * `instanceof Object`, which is a public behavior change against every other\n * object the library hands back. The spread is safe precisely where a\n * key-by-key rebuild would not be: it copies own properties with\n * CreateDataProperty rather than Set, so an own `__proto__` key survives the\n * copy while `Object.prototype` is restored.\n */\nexport function createDataKeyedBag<T>(): Record<string, T> {\n  return Object.create(null) as Record<string, T>;\n}\n\n/**\n * The two property names JavaScript itself probes on an arbitrary object:\n * `then` (the thenable check promise adoption performs) and `toJSON` (the hook\n * `JSON.stringify` looks for). A proxy standing in for data resolves them to\n * `undefined` so it is not mistaken for a promise and does not break\n * serialization.\n */\nconst INTEROP_PROBE_KEYS: ReadonlySet<string> = new Set([\"then\", \"toJSON\"]);\n\n/**\n * True if `key` is a name the language probes for a protocol rather than a name\n * a caller asked for. The single owner of WHICH names those are — the companion\n * to, not a substitute for, the question of whether the name is data\n * (`hasOwnKey` for a materialized bag, `SchemaIntrospector.hasDeclaredField`\n * for a proxy whose key set is the schema).\n *\n * **This predicate is a fallback, never a short-circuit.** `then` and `toJSON`\n * are ordinary identifiers: `z.object({ toJSON: z.string() })` is a legal\n * schema, and such a field is stored, validated, and round-tripped as data like\n * any other. A trap that answers `undefined` for these names BEFORE consulting\n * the data it fronts therefore drops a declared field — the read side of the\n * same mistake `hasOwnKey` fixes on the write side. Ask the data question\n * first; reach for this only once the answer is \"not data\", where resolving to\n * `undefined` keeps `await` and `JSON.stringify` working on a partial object.\n *\n * Returning stored data for an own `then` is safe as well as correct: props\n * come from a JSON column, so the value can never be callable, and the thenable\n * check ignores a non-callable `then` exactly as it does on the plain objects\n * the non-selective path returns.\n */\nexport function isInteropProbeKey(key: string): boolean {\n  return INTEROP_PROBE_KEYS.has(key);\n}\n\n/**\n * Builds an object dropping any keys whose value is `undefined`.\n *\n * Lets callers construct discriminated-union members and `defineNode` /\n * `defineEdge` option objects without tripping over\n * `exactOptionalPropertyTypes: true` — which forbids setting `optional:\n * undefined` on a type that declares `optional?: boolean`. The cast keeps\n * call sites readable; this helper is the single typed seam.\n */\nexport function compactUndefined<T extends object>(value: {\n  [K in keyof T]: T[K] | undefined;\n}): T {\n  const result: Record<string, unknown> = {};\n  for (const [key, fieldValue] of Object.entries(value)) {\n    if (fieldValue !== undefined) result[key] = fieldValue;\n  }\n  return result as T;\n}\n\n/**\n * Recursively `Object.freeze` every plain object / array reachable from\n * `value`. Already-frozen branches are skipped. Returns the input for\n * convenient chaining; the freeze is in-place.\n *\n * Class instances and other non-plain values are left alone — only their\n * containers freeze.\n */\nexport function freezeDeep<T>(value: T): T {\n  if (value === null || typeof value !== \"object\") return value;\n  if (Object.isFrozen(value)) return value;\n  for (const nested of Object.values(value as Record<string, unknown>)) {\n    freezeDeep(nested);\n  }\n  return Object.freeze(value);\n}\n","/**\n * Predicate for values that are materially present in database rows.\n */\nexport function isPresent(value: unknown): boolean {\n  return value !== null && value !== undefined;\n}\n\n/**\n * Narrows a value after a runtime presence check. Prefer this to a non-null\n * assertion: an invalid invariant fails at the point where it is assumed,\n * with a stable error instead of propagating `undefined` into unrelated code.\n */\nexport function requireDefined<T>(\n  value: T,\n  message = \"Expected a defined value.\",\n): NonNullable<T> {\n  if (value === undefined || value === null) throw new TypeError(message);\n  return value;\n}\n"]}

package/dist/chunk-E4WNQBEF.cjs

@@ -0,0 +1,217 @@
+'use strict';
+
+var chunkNI72YOJB_cjs = require('./chunk-NI72YOJB.cjs');
+var chunkN66HCGCY_cjs = require('./chunk-N66HCGCY.cjs');
+
+// src/constraints/index.ts
+var UNIQUE_KEY_SEPARATOR = "";
+var UNIQUE_KEY_NULL_MARKER = "";
+function computeUniqueKey(props, fields, collation) {
+  const values = fields.map((field) => {
+    const value = chunkN66HCGCY_cjs.readOwnProperty(props, field);
+    if (value === void 0 || value === null) {
+      return UNIQUE_KEY_NULL_MARKER;
+    }
+    const stringValue = typeof value === "string" ? value : typeof value === "number" || typeof value === "boolean" ? value.toString() : JSON.stringify(value);
+    return collation === "caseInsensitive" ? stringValue.toLowerCase() : stringValue;
+  });
+  return values.join(UNIQUE_KEY_SEPARATOR);
+}
+function checkWherePredicate(constraint, props) {
+  if (!constraint.where) {
+    return true;
+  }
+  const predicate = captureWherePredicate(constraint.where);
+  if (predicate === void 0) {
+    throw new chunkNI72YOJB_cjs.ConfigurationError(
+      `Unique constraint "${constraint.name}" has a \`where\` callback that does not return a predicate.`,
+      { constraintName: constraint.name, fields: [...constraint.fields] },
+      {
+        suggestion: `Return a field predicate, e.g. \`where: (fields) => fields.${constraint.fields[0] ?? "someField"}.isNotNull()\`. A constraint built outside \`defineGraph\` bypasses the definition-time check that normally reports this.`
+      }
+    );
+  }
+  return evaluatePredicate(predicate, props);
+}
+function captureWherePredicate(where) {
+  const predicate = where(buildPredicateContext());
+  if (typeof predicate !== "object" || predicate === null || !("__type" in predicate)) {
+    return void 0;
+  }
+  const candidate = predicate;
+  if (candidate.__type !== "unique_predicate" || typeof candidate.field !== "string" || candidate.op !== "isNull" && candidate.op !== "isNotNull") {
+    return void 0;
+  }
+  return {
+    __type: "unique_predicate",
+    field: candidate.field,
+    op: candidate.op
+  };
+}
+function assertWhereFieldDeclared(kind, constraint, shape) {
+  if (!constraint.where) return;
+  const predicate = captureWherePredicate(constraint.where);
+  if (predicate === void 0) {
+    throw new chunkNI72YOJB_cjs.ConfigurationError(
+      `Unique constraint "${constraint.name}" on node kind "${kind}" has a \`where\` callback that does not return a predicate.`,
+      { kind, constraintName: constraint.name },
+      {
+        suggestion: `Return a field predicate, e.g. \`where: (fields) => fields.${Object.keys(shape)[0] ?? "someField"}.isNotNull()\`.`
+      }
+    );
+  }
+  if (!chunkN66HCGCY_cjs.hasOwnKey(shape, predicate.field)) {
+    throw new chunkNI72YOJB_cjs.ConfigurationError(
+      `Unique constraint "${constraint.name}" on node kind "${kind}" has a \`where\` clause on field "${predicate.field}", which is not declared in the kind's schema.`,
+      {
+        kind,
+        constraintName: constraint.name,
+        field: predicate.field,
+        declaredFields: Object.keys(shape)
+      },
+      {
+        suggestion: `Name a declared field (${Object.keys(shape).join(", ")}) or add "${predicate.field}" to the schema.`
+      }
+    );
+  }
+}
+function buildPredicateContext() {
+  return new Proxy(
+    {},
+    {
+      get(_target, property) {
+        if (typeof property === "symbol") return;
+        return {
+          isNull: () => ({
+            __type: "unique_predicate",
+            field: property,
+            op: "isNull"
+          }),
+          isNotNull: () => ({
+            __type: "unique_predicate",
+            field: property,
+            op: "isNotNull"
+          })
+        };
+      }
+    }
+  );
+}
+function evaluatePredicate(pred, props) {
+  const value = chunkN66HCGCY_cjs.readOwnProperty(props, pred.field);
+  if (pred.op === "isNull") {
+    return value === null || value === void 0;
+  }
+  return chunkN66HCGCY_cjs.isPresent(value);
+}
+function getKindsForUniquenessCheck(baseKind, scope, registry) {
+  if (scope === "kind") {
+    return [baseKind];
+  }
+  const root = findRootAncestor(baseKind, registry);
+  return registry.expandSubClasses(root);
+}
+function findRootAncestor(kind, registry) {
+  const ancestors = registry.getAncestors(kind);
+  if (ancestors.size === 0) {
+    return kind;
+  }
+  for (const ancestor of ancestors) {
+    if (registry.getAncestors(ancestor).size === 0) {
+      return ancestor;
+    }
+  }
+  const firstAncestor = [...ancestors][0];
+  return firstAncestor ? findRootAncestor(firstAncestor, registry) : kind;
+}
+function checkCardinality(edgeKind, fromKind, fromId, cardinality, existingEdgeCount, hasActiveEdge) {
+  switch (cardinality) {
+    case "many": {
+      return void 0;
+    }
+    case "one": {
+      if (existingEdgeCount > 0) {
+        return new chunkNI72YOJB_cjs.CardinalityError({
+          edgeKind,
+          fromKind,
+          fromId,
+          cardinality: "one",
+          existingCount: existingEdgeCount
+        });
+      }
+      return void 0;
+    }
+    case "unique": {
+      return void 0;
+    }
+    case "oneActive": {
+      if (hasActiveEdge) {
+        return new chunkNI72YOJB_cjs.CardinalityError({
+          edgeKind,
+          fromKind,
+          fromId,
+          cardinality: "oneActive",
+          existingCount: 1
+        });
+      }
+      return void 0;
+    }
+  }
+}
+function checkUniqueEdge(edgeKind, fromKind, fromId, _toKind, _toId, existingCount) {
+  if (existingCount > 0) {
+    return new chunkNI72YOJB_cjs.CardinalityError({
+      edgeKind,
+      fromKind,
+      fromId,
+      cardinality: "unique",
+      existingCount
+    });
+  }
+  return void 0;
+}
+function validateEdgeEndpoints(edgeKind, fromKind, toKind, registration, registry) {
+  const validFromKinds = registration.from.map((node) => node.kind);
+  if (!registry.isAssignableToAny(fromKind, validFromKinds)) {
+    return new chunkNI72YOJB_cjs.EndpointError({
+      edgeKind,
+      endpoint: "from",
+      actualKind: fromKind,
+      expectedKinds: validFromKinds
+    });
+  }
+  const validToKinds = registration.to.map((node) => node.kind);
+  if (!registry.isAssignableToAny(toKind, validToKinds)) {
+    return new chunkNI72YOJB_cjs.EndpointError({
+      edgeKind,
+      endpoint: "to",
+      actualKind: toKind,
+      expectedKinds: validToKinds
+    });
+  }
+  return void 0;
+}
+function checkDisjointness(nodeId, nodeKind, existingKinds, registry) {
+  for (const existingKind of existingKinds) {
+    if (registry.areDisjoint(nodeKind, existingKind)) {
+      return new chunkNI72YOJB_cjs.DisjointError({
+        nodeId,
+        attemptedKind: nodeKind,
+        conflictingKind: existingKind
+      });
+    }
+  }
+  return void 0;
+}
+
+exports.assertWhereFieldDeclared = assertWhereFieldDeclared;
+exports.captureWherePredicate = captureWherePredicate;
+exports.checkCardinality = checkCardinality;
+exports.checkDisjointness = checkDisjointness;
+exports.checkUniqueEdge = checkUniqueEdge;
+exports.checkWherePredicate = checkWherePredicate;
+exports.computeUniqueKey = computeUniqueKey;
+exports.getKindsForUniquenessCheck = getKindsForUniquenessCheck;
+exports.validateEdgeEndpoints = validateEdgeEndpoints;
+//# sourceMappingURL=chunk-E4WNQBEF.cjs.map
+//# sourceMappingURL=chunk-E4WNQBEF.cjs.map

package/dist/chunk-E4WNQBEF.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/constraints/index.ts"],"names":["readOwnProperty","ConfigurationError","hasOwnKey","isPresent","CardinalityError","EndpointError","DisjointError"],"mappings":"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","file":"chunk-E4WNQBEF.cjs","sourcesContent":["/**\n * Constraint validation module.\n *\n * Provides validation functions for enforcing graph constraints:\n * - Uniqueness constraints on node properties\n * - Cardinality constraints on edges\n * - Endpoint type constraints on edges\n * - Disjointness constraints between node kinds\n */\n\n/**\n * Separator used between field values in composite unique keys.\n * Uses ASCII Record Separator (0x1E) — valid UTF-8 and safe for PostgreSQL\n * TEXT columns (unlike \\0 which PostgreSQL rejects).\n */\nconst UNIQUE_KEY_SEPARATOR = \"\\u001E\";\n\n/** Marker for undefined/null field values in unique keys. */\nconst UNIQUE_KEY_NULL_MARKER = \"\\u001F\"; // ASCII Unit Separator\nimport {\n  type Cardinality,\n  type Collation,\n  type EdgeRegistration,\n  type NullCheckOp,\n  type UniqueConstraint,\n  type UniquenessScope,\n} from \"../core/types\";\nimport {\n  CardinalityError,\n  ConfigurationError,\n  DisjointError,\n  EndpointError,\n  UniquenessError,\n} from \"../errors\";\nimport { type KindRegistry } from \"../registry/kind-registry\";\nimport { hasOwnKey, readOwnProperty } from \"../utils/object\";\nimport { isPresent } from \"../utils/presence\";\n\n// ============================================================\n// Uniqueness Validation\n// ============================================================\n\n/**\n * Computes the unique key for a node's uniqueness constraint.\n *\n * The key is built by concatenating the specified field values,\n * optionally normalized for case-insensitive comparison.\n *\n * Field values are read by declared OWN key ({@link readOwnProperty}): a\n * constraint may name a field that a props bag does not carry (an absent\n * optional field), and a plain `props[field]` read would answer such a field\n * with the inherited `Object.prototype` member when the field is named after\n * one. A constraint over a field named `toString` then keyed on the inherited\n * function — `\"\"` under `binary` (the function stringified and dropped by\n * `JSON.stringify`) and a `TypeError` under `caseInsensitive` — instead of the\n * null marker every other absent value gets.\n */\nexport function computeUniqueKey(\n  props: Record<string, unknown>,\n  fields: readonly string[],\n  collation: Collation,\n): string {\n  const values = fields.map((field) => {\n    const value = readOwnProperty(props, field);\n    if (value === undefined || value === null) {\n      return UNIQUE_KEY_NULL_MARKER;\n    }\n    // Convert to string, handling primitives safely\n    const stringValue =\n      typeof value === \"string\" ? value\n      : typeof value === \"number\" || typeof value === \"boolean\" ?\n        value.toString()\n      : JSON.stringify(value);\n    return collation === \"caseInsensitive\" ?\n        stringValue.toLowerCase()\n      : stringValue;\n  });\n  return values.join(UNIQUE_KEY_SEPARATOR);\n}\n\n/**\n * Checks if a uniqueness constraint's where predicate passes.\n *\n * A `where` callback that does not return a predicate is REFUSED here, not\n * treated as \"the constraint always applies\". The same malformed clause is a\n * hard `ConfigurationError` at definition time ({@link assertWhereFieldDeclared})\n * and at persistence time (`serializeWherePredicate`); a third reading that\n * silently widened a partial constraint to a total one would let the three\n * sites disagree about the same clause — the divergence\n * {@link captureWherePredicate} exists to prevent.\n *\n * The arm SHOULD be unreachable: `defineGraph` refuses a non-predicate callback\n * before any write can evaluate it, `validateGraphExtension` refuses the\n * document form, and a constraint reconstructed from a persisted schema carries\n * a callback this module built itself. It is reachable only by handing the\n * store a constraint object that never passed a definition gate — for which\n * failing loudly is the correct answer, since the alternative is enforcing\n * uniqueness over rows the author meant to exclude.\n */\nexport function checkWherePredicate(\n  constraint: UniqueConstraint,\n  props: Record<string, unknown>,\n): boolean {\n  if (!constraint.where) {\n    return true; // No where clause, always applies\n  }\n\n  const predicate = captureWherePredicate(constraint.where);\n  if (predicate === undefined) {\n    throw new ConfigurationError(\n      `Unique constraint \"${constraint.name}\" has a \\`where\\` callback that does not return a predicate.`,\n      { constraintName: constraint.name, fields: [...constraint.fields] },\n      {\n        suggestion: `Return a field predicate, e.g. \\`where: (fields) => fields.${constraint.fields[0] ?? \"someField\"}.isNotNull()\\`. A constraint built outside \\`defineGraph\\` bypasses the definition-time check that normally reports this.`,\n      },\n    );\n  }\n\n  return evaluatePredicate(predicate, props);\n}\n\ntype UniquePredicate = Readonly<{\n  __type: \"unique_predicate\";\n  field: string;\n  op: NullCheckOp;\n}>;\n\n/**\n * The `where` callback as every caller of {@link captureWherePredicate} sees it:\n * a per-field builder in, whatever the author returned out.\n *\n * Deliberately looser than `UniqueConstraint[\"where\"]`, whose builder type is\n * generic in the kind's schema — the capture is the same operation whether the\n * callback came from a typed `defineGraph` registration, a compiled\n * graph-extension document, or an untyped JavaScript caller.\n */\ntype UniqueWhereCallback = (\n  builder: Readonly<\n    Record<\n      string,\n      Readonly<{\n        isNull: () => UniquePredicate;\n        isNotNull: () => UniquePredicate;\n      }>\n    >\n  >,\n) => unknown;\n\n/**\n * Runs a `where` callback against the shared builder and returns the predicate\n * it named, or `undefined` when the callback returned something that is not a\n * predicate.\n *\n * The single owner of \"what does this `where` clause say\": constraint\n * EVALUATION ({@link checkWherePredicate}), definition-time VALIDATION\n * ({@link assertWhereFieldDeclared}), and persistence-time CAPTURE\n * (`serializeWherePredicate` in src/schema/serializer.ts) all read the clause\n * through this one function, so a persisted `where`, a validated `where`, and\n * an evaluated `where` cannot disagree about which field the author named.\n */\nexport function captureWherePredicate(\n  where: UniqueWhereCallback,\n): UniquePredicate | undefined {\n  const predicate = where(buildPredicateContext());\n  if (\n    typeof predicate !== \"object\" ||\n    predicate === null ||\n    !(\"__type\" in predicate)\n  ) {\n    return undefined;\n  }\n\n  const candidate = predicate as {\n    __type: unknown;\n    field: unknown;\n    op: unknown;\n  };\n  if (\n    candidate.__type !== \"unique_predicate\" ||\n    typeof candidate.field !== \"string\" ||\n    (candidate.op !== \"isNull\" && candidate.op !== \"isNotNull\")\n  ) {\n    return undefined;\n  }\n\n  return {\n    __type: \"unique_predicate\",\n    field: candidate.field,\n    op: candidate.op,\n  };\n}\n\n/**\n * Refuses a uniqueness constraint whose `where` clause names a field the kind\n * does not declare.\n *\n * The runtime half of the builder's guard. {@link buildPredicateContext} is\n * total by design — it must answer for a DECLARED-but-absent field, which is\n * the whole point of a partial constraint — so a typo'd name cannot be caught\n * there, and the type system catches it only for typed callers\n * (`UniqueConstraintPredicateBuilder` declares exactly the schema's fields and\n * has no index signature). An untyped caller naming an undeclared field\n * otherwise gets a predicate that quietly never applies.\n *\n * Called once per constraint at graph-definition time — the single point every\n * constraint passes through before any write can evaluate it — rather than at\n * each of the write paths' `checkWherePredicate` call sites, so the refusal\n * covers every path uniformly and costs nothing per write. Mirrors\n * `validateGraphExtension`'s `UNKNOWN_UNIQUE_WHERE_FIELD` refusal, which\n * already holds the same invariant for kinds declared as JSON documents.\n */\nexport function assertWhereFieldDeclared(\n  kind: string,\n  constraint: UniqueConstraint,\n  shape: Readonly<Record<string, unknown>>,\n): void {\n  if (!constraint.where) return;\n\n  const predicate = captureWherePredicate(constraint.where);\n  if (predicate === undefined) {\n    throw new ConfigurationError(\n      `Unique constraint \"${constraint.name}\" on node kind \"${kind}\" has a \\`where\\` callback that does not return a predicate.`,\n      { kind, constraintName: constraint.name },\n      {\n        suggestion: `Return a field predicate, e.g. \\`where: (fields) => fields.${Object.keys(shape)[0] ?? \"someField\"}.isNotNull()\\`.`,\n      },\n    );\n  }\n\n  if (!hasOwnKey(shape, predicate.field)) {\n    throw new ConfigurationError(\n      `Unique constraint \"${constraint.name}\" on node kind \"${kind}\" has a \\`where\\` clause on field \"${predicate.field}\", which is not declared in the kind's schema.`,\n      {\n        kind,\n        constraintName: constraint.name,\n        field: predicate.field,\n        declaredFields: Object.keys(shape),\n      },\n      {\n        suggestion: `Name a declared field (${Object.keys(shape).join(\", \")}) or add \"${predicate.field}\" to the schema.`,\n      },\n    );\n  }\n}\n\ntype PredicateContext = Readonly<\n  Record<\n    string,\n    Readonly<{\n      isNull: () => UniquePredicate;\n      isNotNull: () => UniquePredicate;\n    }>\n  >\n>;\n\n/**\n * Builds the context a constraint's `where` callback names fields on.\n *\n * EVERY field name gets a member, because the builder type declares every\n * schema field as required (`-?` in `UniqueConstraintPredicateBuilder`) —\n * precisely so a partial constraint can ask whether an OPTIONAL field is\n * present. Populating the context from the props bag's own keys instead left a\n * declared-but-absent field with no member, and the callback's access then hit\n * whatever the context's prototype offered: `Object.prototype.toString` for a\n * field named `toString` (so naming it threw \"isNull is not a function\"), and\n * `undefined` for an ordinary field (so the everyday partial constraint over\n * `externalId` threw — \"Cannot read properties of undefined\", or \"Expected a\n * defined value\" through `requireDefined` — for every node written without it).\n *\n * Answering every name is safe because a name comes from the predicate author\n * (the code), never from data, and the field's VALUE is still read from the\n * props bag by own key when the predicate is evaluated — so an absent field\n * evaluates as null, which is what a partial constraint means by absent. Every\n * reader of a `where` clause goes through {@link captureWherePredicate}, which\n * builds this one context, so a persisted `where`, a validated `where`, and an\n * evaluated `where` cannot see different builders.\n *\n * The guard against a TYPO'D field name is NOT this Proxy — it must stay total\n * or a declared-but-absent field loses its member. It is\n * {@link assertWhereFieldDeclared}, which every constraint passes at\n * graph-definition time: an undeclared name is refused there with a typed\n * `ConfigurationError`, so no `where` clause naming one ever reaches\n * evaluation, from a typed or an untyped caller.\n */\nfunction buildPredicateContext(): PredicateContext {\n  return new Proxy<PredicateContext>(\n    {},\n    {\n      get(_target, property) {\n        if (typeof property === \"symbol\") return;\n        return {\n          isNull: () => ({\n            __type: \"unique_predicate\" as const,\n            field: property,\n            op: \"isNull\" as const,\n          }),\n          isNotNull: () => ({\n            __type: \"unique_predicate\" as const,\n            field: property,\n            op: \"isNotNull\" as const,\n          }),\n        };\n      },\n    },\n  );\n}\n\n/**\n * Evaluates a uniqueness predicate.\n *\n * Takes a CAPTURED predicate, not an `unknown`: the \"is this really a\n * predicate?\" question belongs to {@link captureWherePredicate}, which is its\n * single owner. The defensive `return true` arms this function used to carry\n * were a second, quieter answer to that question — and they answered it the\n * opposite way, widening a partial constraint into a total one where the owner\n * refuses.\n */\nfunction evaluatePredicate(\n  pred: UniquePredicate,\n  props: Record<string, unknown>,\n): boolean {\n  // Own-key read: `pred.field` is a schema field name, and a props bag that\n  // does not carry it must read as absent rather than as the inherited\n  // `Object.prototype` member a field named after one would otherwise find\n  // (which reads as present, inverting both `isNull` and `isNotNull`).\n  const value = readOwnProperty(props, pred.field);\n  if (pred.op === \"isNull\") {\n    return value === null || value === undefined;\n  }\n  return isPresent(value);\n}\n\n/**\n * Gets all kinds that should be checked for a uniqueness constraint.\n *\n * For \"kindWithSubClasses\" scope, includes the entire subclass hierarchy:\n * - The kind itself\n * - All ancestors (parent classes)\n * - All descendants of those ancestors (sibling classes)\n *\n * For \"kind\" scope, only the specific kind.\n */\nexport function getKindsForUniquenessCheck(\n  baseKind: string,\n  scope: UniquenessScope,\n  registry: KindRegistry,\n): readonly string[] {\n  if (scope === \"kind\") {\n    return [baseKind];\n  }\n\n  // Get the entire connected subclass hierarchy by finding the root ancestor\n  const root = findRootAncestor(baseKind, registry);\n\n  // Return the root and all its descendants (which includes baseKind and siblings)\n  return registry.expandSubClasses(root);\n}\n\n/**\n * Finds the topmost ancestor of a kind, or the kind itself if it has no ancestors.\n */\nfunction findRootAncestor(kind: string, registry: KindRegistry): string {\n  const ancestors = registry.getAncestors(kind);\n\n  if (ancestors.size === 0) {\n    return kind;\n  }\n\n  // Find an ancestor with no ancestors (the root)\n  for (const ancestor of ancestors) {\n    if (registry.getAncestors(ancestor).size === 0) {\n      return ancestor;\n    }\n  }\n\n  // If all ancestors have ancestors, recurse up\n  const firstAncestor = [...ancestors][0];\n  return firstAncestor ? findRootAncestor(firstAncestor, registry) : kind;\n}\n\n/**\n * Creates a uniqueness error.\n */\nexport function createUniquenessError(\n  constraintName: string,\n  kind: string,\n  existingId: string,\n  newId: string,\n  fields: readonly string[],\n): UniquenessError {\n  return new UniquenessError({\n    constraintName,\n    kind,\n    existingId,\n    newId,\n    fields: [...fields],\n  });\n}\n\n// ============================================================\n// Cardinality Validation\n// ============================================================\n\n/**\n * Checks if adding an edge would violate cardinality constraints.\n *\n * @param edgeKind - The edge kind being added\n * @param fromKind - The source node kind\n * @param fromId - The source node ID\n * @param cardinality - The cardinality constraint\n * @param existingEdgeCount - Number of existing edges of this kind from this source\n * @param hasActiveEdge - Whether there's an active (valid_to IS NULL) edge\n * @returns Error if violation, undefined if valid\n */\nexport function checkCardinality(\n  edgeKind: string,\n  fromKind: string,\n  fromId: string,\n  cardinality: Cardinality,\n  existingEdgeCount: number,\n  hasActiveEdge: boolean,\n): CardinalityError | undefined {\n  switch (cardinality) {\n    case \"many\": {\n      // No constraint\n      return undefined;\n    }\n    case \"one\": {\n      // At most one edge of this kind from any source node\n      if (existingEdgeCount > 0) {\n        return new CardinalityError({\n          edgeKind,\n          fromKind,\n          fromId,\n          cardinality: \"one\",\n          existingCount: existingEdgeCount,\n        });\n      }\n      return undefined;\n    }\n    case \"unique\": {\n      // unique is checked separately per (source, target) pair\n      return undefined;\n    }\n    case \"oneActive\": {\n      // At most one edge with valid_to IS NULL from any source\n      if (hasActiveEdge) {\n        return new CardinalityError({\n          edgeKind,\n          fromKind,\n          fromId,\n          cardinality: \"oneActive\",\n          existingCount: 1,\n        });\n      }\n      return undefined;\n    }\n  }\n}\n\n/**\n * Checks unique edge constraint (at most one edge between any source-target pair).\n */\nexport function checkUniqueEdge(\n  edgeKind: string,\n  fromKind: string,\n  fromId: string,\n  _toKind: string,\n  _toId: string,\n  existingCount: number,\n): CardinalityError | undefined {\n  if (existingCount > 0) {\n    return new CardinalityError({\n      edgeKind,\n      fromKind,\n      fromId,\n      cardinality: \"unique\",\n      existingCount,\n    });\n  }\n  return undefined;\n}\n\n// ============================================================\n// Endpoint Validation\n// ============================================================\n\n/**\n * Validates that an edge's endpoints are valid node kinds.\n */\nexport function validateEdgeEndpoints(\n  edgeKind: string,\n  fromKind: string,\n  toKind: string,\n  registration: EdgeRegistration,\n  registry: KindRegistry,\n): EndpointError | undefined {\n  // Check from kinds\n  const validFromKinds = registration.from.map((node) => node.kind);\n  if (!registry.isAssignableToAny(fromKind, validFromKinds)) {\n    return new EndpointError({\n      edgeKind,\n      endpoint: \"from\",\n      actualKind: fromKind,\n      expectedKinds: validFromKinds,\n    });\n  }\n\n  // Check to kinds\n  const validToKinds = registration.to.map((node) => node.kind);\n  if (!registry.isAssignableToAny(toKind, validToKinds)) {\n    return new EndpointError({\n      edgeKind,\n      endpoint: \"to\",\n      actualKind: toKind,\n      expectedKinds: validToKinds,\n    });\n  }\n\n  return undefined;\n}\n\n// ============================================================\n// Disjointness Validation\n// ============================================================\n\n/**\n * Checks if creating a node would violate disjointness constraints.\n *\n * @param nodeId - The node ID being created\n * @param nodeKind - The kind of the new node\n * @param existingKinds - Kinds of existing nodes with the same ID\n * @param registry - The kind registry for disjointness checks\n * @returns Error if disjoint violation, undefined if valid\n */\nexport function checkDisjointness(\n  nodeId: string,\n  nodeKind: string,\n  existingKinds: readonly string[],\n  registry: KindRegistry,\n): DisjointError | undefined {\n  for (const existingKind of existingKinds) {\n    if (registry.areDisjoint(nodeKind, existingKind)) {\n      return new DisjointError({\n        nodeId,\n        attemptedKind: nodeKind,\n        conflictingKind: existingKind,\n      });\n    }\n  }\n  return undefined;\n}\n\n/**\n * Gets all disjoint kinds for a given kind.\n */\nexport function getDisjointKinds(\n  kind: string,\n  registry: KindRegistry,\n): readonly string[] {\n  return registry.getDisjointKinds(kind);\n}\n"]}

package/dist/{chunk-G6Q5UM7U.js → chunk-FWJKWH6U.js}

@@ -1,3 +1,5 @@
+import { readOwnProperty } from './chunk-DYATYRY4.js';
+
 // src/query/json-pointer.ts
 var MAX_JSON_POINTER_DEPTH = 5;
 function jsonPointer(segments) {
@@ -48,7 +50,7 @@ function resolveJsonPointer(value, pointer) {
   for (const segment of parseJsonPointer(pointer)) {
     if (current === null || current === void 0) return void 0;
     if (typeof current !== "object") return void 0;
-    current = current[segment];
+    current = readOwnProperty(current, segment);
   }
   return current;
 }
@@ -110,5 +112,5 @@ function isValidPointerEncoding(segment) {
 }
 
 export { MAX_JSON_POINTER_DEPTH, encodeJsonPointerSegment, joinJsonPointers, jsonPointer, normalizeJsonPointer, parseJsonPointer, resolveJsonPointer };
-//# sourceMappingURL=chunk-G6Q5UM7U.js.map
-//# sourceMappingURL=chunk-G6Q5UM7U.js.map
+//# sourceMappingURL=chunk-FWJKWH6U.js.map
+//# sourceMappingURL=chunk-FWJKWH6U.js.map

package/dist/chunk-FWJKWH6U.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/query/json-pointer.ts"],"names":[],"mappings":"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","file":"chunk-FWJKWH6U.js","sourcesContent":["// JSON Pointer utilities and types.\n\nimport { readOwnProperty } from \"../utils/object\";\n\nexport const MAX_JSON_POINTER_DEPTH = 5 as const;\n\nexport type JsonPointer = string & { readonly __jsonPointer: unique symbol };\nexport type JsonPointerSegment = string | number;\nexport type JsonPointerSegments = readonly JsonPointerSegment[];\n\ntype Depth = 0 | 1 | 2 | 3 | 4 | 5;\n\ninterface DepthDecrementMap {\n  0: 0;\n  1: 0;\n  2: 1;\n  3: 2;\n  4: 3;\n  5: 4;\n}\n\ntype Decrement<Current extends Depth> = DepthDecrementMap[Current];\n\ntype NonNegativeIntegerString = Exclude<`${bigint}`, `-${string}`>;\ntype ObjectPointerKey<T> = Exclude<\n  Extract<keyof T, string>,\n  NonNegativeIntegerString\n>;\n\ntype EncodeTilde<S extends string> =\n  S extends `${infer Head}~${infer Tail}` ?\n    `${EncodeTilde<Head>}~0${EncodeTilde<Tail>}`\n  : S;\n\ntype EncodeSlash<S extends string> =\n  S extends `${infer Head}/${infer Tail}` ?\n    `${EncodeSlash<Head>}~1${EncodeSlash<Tail>}`\n  : S;\n\ntype EncodePointerSegment<S extends string> = EncodeSlash<EncodeTilde<S>>;\n\ntype DecodePointerSegment<S extends string> =\n  S extends `${infer Head}~1${infer Tail}` ?\n    `${DecodePointerSegment<Head>}/${DecodePointerSegment<Tail>}`\n  : S extends `${infer Head}~0${infer Tail}` ?\n    `${DecodePointerSegment<Head>}~${DecodePointerSegment<Tail>}`\n  : S;\n\ntype PointerForArray<T, Current extends Depth> =\n  | `/${NonNegativeIntegerString}`\n  | (Current extends 1 ? never\n    : `/${NonNegativeIntegerString}${JsonPointerFor<T, Decrement<Current>>}`);\n\ntype PointerForObject<T, Current extends Depth> = {\n  [K in ObjectPointerKey<T>]:\n    | `/${EncodePointerSegment<K>}`\n    | (Current extends 1 ? never\n      : `/${EncodePointerSegment<K>}${JsonPointerFor<T[K], Decrement<Current>>}`);\n}[ObjectPointerKey<T>];\n\nexport type JsonPointerFor<T, Current extends Depth = 5> =\n  | \"\"\n  | (Current extends 0 ? \"\"\n    : T extends readonly (infer U)[] ? PointerForArray<U, Current>\n    : never)\n  | (Current extends 0 ? \"\"\n    : T extends Record<string, unknown> ? PointerForObject<T, Current>\n    : never);\n\ntype PointerSegmentsForArray<T, Current extends Depth> =\n  | readonly [number]\n  | (Current extends 1 ? readonly [number]\n    : readonly [number, ...JsonPointerSegmentsFor<T, Decrement<Current>>]);\n\ntype PointerSegmentsForObject<T, Current extends Depth> = {\n  [K in ObjectPointerKey<T>]:\n    | readonly [K]\n    | (Current extends 1 ? readonly [K]\n      : readonly [K, ...JsonPointerSegmentsFor<T[K], Decrement<Current>>]);\n}[ObjectPointerKey<T>];\n\nexport type JsonPointerSegmentsFor<T, Current extends Depth = 5> =\n  | readonly []\n  | (Current extends 0 ? readonly []\n    : T extends readonly (infer U)[] ? PointerSegmentsForArray<U, Current>\n    : never)\n  | (Current extends 0 ? readonly []\n    : T extends Record<string, unknown> ? PointerSegmentsForObject<T, Current>\n    : never);\n\nexport type JsonPointerInput<T> =\n  JsonPointerFor<T> | JsonPointerSegmentsFor<T> | JsonPointer;\n\nexport type ResolveJsonPointer<T, Pointer extends string> =\n  Pointer extends \"\" ? T\n  : Pointer extends `/${infer Head}/${infer Tail}` ?\n    ResolveJsonPointer<\n      ResolvePointerSegment<T, DecodePointerSegment<Head>>,\n      `/${Tail}`\n    >\n  : Pointer extends `/${infer Head}` ?\n    ResolvePointerSegment<T, DecodePointerSegment<Head>>\n  : unknown;\n\ntype ResolvePointerSegment<T, Segment extends string> =\n  T extends readonly (infer U)[] ?\n    Segment extends NonNegativeIntegerString ?\n      U\n    : unknown\n  : T extends Record<string, unknown> ?\n    Segment extends keyof T ?\n      Segment extends NonNegativeIntegerString ?\n        unknown\n      : T[Segment]\n    : unknown\n  : unknown;\n\nexport type ResolveJsonPointerSegments<\n  T,\n  Segments extends readonly JsonPointerSegment[],\n> =\n  Segments extends readonly [] ? T\n  : Segments extends readonly [infer Head, ...infer Tail] ?\n    ResolveJsonPointerSegments<\n      ResolvePointerSegment<T, SegmentToString<Head>>,\n      Extract<Tail, readonly JsonPointerSegment[]>\n    >\n  : unknown;\n\ntype SegmentToString<Segment> =\n  Segment extends number ? `${Segment}`\n  : Segment extends string ? Segment\n  : string;\n\nexport function jsonPointer(segments: JsonPointerSegments): JsonPointer {\n  if (segments.length > MAX_JSON_POINTER_DEPTH) {\n    throw new Error(\n      `JSON Pointer exceeds max depth ${MAX_JSON_POINTER_DEPTH}: ${segments.length}`,\n    );\n  }\n\n  if (segments.length === 0) {\n    return \"\" as JsonPointer;\n  }\n\n  const encoded = segments.map((segment) => {\n    if (segment === \"-\") {\n      throw new Error(\n        \"JSON Pointer '-' segment is not allowed for query access\",\n      );\n    }\n    if (typeof segment === \"number\") {\n      if (!Number.isInteger(segment) || segment < 0) {\n        throw new Error(\n          `JSON Pointer index must be a non-negative integer: ${segment}`,\n        );\n      }\n      return segment.toString();\n    }\n    return encodeJsonPointerSegment(segment);\n  });\n\n  return `/${encoded.join(\"/\")}` as JsonPointer;\n}\n\nfunction isJsonPointerSegments(\n  input: unknown,\n): input is readonly JsonPointerSegment[] {\n  return Array.isArray(input);\n}\n\nexport function normalizeJsonPointer<T>(\n  input: JsonPointerInput<T>,\n): JsonPointer {\n  if (isJsonPointerSegments(input)) {\n    return jsonPointer(input);\n  }\n\n  return assertJsonPointer(input);\n}\n\nexport function parseJsonPointer(pointer: JsonPointer): readonly string[] {\n  if (pointer === \"\") {\n    return [];\n  }\n\n  const rawSegments = pointer.slice(1).split(\"/\");\n  return rawSegments.map((segment) => decodeJsonPointerSegment(segment));\n}\n\n/**\n * Resolves the value at a JSON pointer within a plain JS value, returning\n * `undefined` if any segment is missing or traverses a non-object.\n *\n * Segments are read by OWN key: the values walked here are data (a props bag\n * parsed out of a JSON column, a caller's probe record) and the segments are\n * data too — they come from schema field names. A raw read would answer a\n * segment named after an `Object.prototype` member (\"toString\") with the\n * inherited member instead of `undefined`, so a missing field would resolve to\n * a function for every value.\n */\nexport function resolveJsonPointer(\n  value: unknown,\n  pointer: JsonPointer,\n): unknown {\n  let current = value;\n  for (const segment of parseJsonPointer(pointer)) {\n    if (current === null || current === undefined) return undefined;\n    if (typeof current !== \"object\") return undefined;\n    current = readOwnProperty(current as Record<string, unknown>, segment);\n  }\n  return current;\n}\n\nexport function joinJsonPointers(\n  base: JsonPointer | undefined,\n  relative: JsonPointer,\n): JsonPointer {\n  if (!base || base === \"\") {\n    return relative;\n  }\n  if (relative === \"\") {\n    return base;\n  }\n\n  const combinedSegments = [\n    ...parseJsonPointer(base),\n    ...parseJsonPointer(relative),\n  ];\n  return jsonPointer(combinedSegments);\n}\n\nfunction assertJsonPointer(pointer: string): JsonPointer {\n  if (pointer !== \"\" && !pointer.startsWith(\"/\")) {\n    throw new Error(\"JSON Pointer must be empty or start with '/'\");\n  }\n\n  const segments = pointer === \"\" ? [] : pointer.slice(1).split(\"/\");\n  if (segments.length > MAX_JSON_POINTER_DEPTH) {\n    throw new Error(\n      `JSON Pointer exceeds max depth ${MAX_JSON_POINTER_DEPTH}: ${segments.length}`,\n    );\n  }\n\n  for (const segment of segments) {\n    if (segment === \"-\") {\n      throw new Error(\n        \"JSON Pointer '-' segment is not allowed for query access\",\n      );\n    }\n    if (!isValidPointerEncoding(segment)) {\n      throw new Error(\n        `Invalid JSON Pointer escape sequence in segment: ${segment}`,\n      );\n    }\n  }\n\n  return pointer as JsonPointer;\n}\n\n/**\n * Escape a single JSON Pointer reference segment per RFC 6901: `~`\n * becomes `~0`, `/` becomes `~1`. Callers join the result with `/`.\n */\nexport function encodeJsonPointerSegment(segment: string): string {\n  return segment.replaceAll(\"~\", \"~0\").replaceAll(\"/\", \"~1\");\n}\n\nfunction decodeJsonPointerSegment(segment: string): string {\n  return segment.replaceAll(\"~1\", \"/\").replaceAll(\"~0\", \"~\");\n}\n\nfunction isValidPointerEncoding(segment: string): boolean {\n  for (let index = 0; index < segment.length; index += 1) {\n    if (segment[index] !== \"~\") {\n      continue;\n    }\n    const next = segment[index + 1];\n    if (next !== \"0\" && next !== \"1\") {\n      return false;\n    }\n    index += 1;\n  }\n  return true;\n}\n"]}