@nicia-ai/typegraph 0.48.0 → 0.50.0

package/dist/{chunk-XVWOYKIK.js → chunk-FZHF5UWR.js}

@@ -1,4 +1,4 @@
-import { ConfigurationError } from './chunk-ZLONH2UD.js';
+import { ConfigurationError } from './chunk-YDEJQWOL.js';
 import { createDataKeyedBag, isPlainObject } from './chunk-DYATYRY4.js';
 import { z } from 'zod';
 
@@ -244,5 +244,5 @@ function throwInvalid(path, kind, ownerKind) {
 }
 
 export { RESERVED_EDGE_KEYS, RESERVED_NODE_KEYS, UNSTORABLE_PROPERTY_NAME_REASON, assertJsonValue, assertSchemaKeysAreFree, filterReservedKeys, isUnstorablePropertyName, validateProjectionField };
-//# sourceMappingURL=chunk-XVWOYKIK.js.map
-//# sourceMappingURL=chunk-XVWOYKIK.js.map
+//# sourceMappingURL=chunk-FZHF5UWR.js.map
+//# sourceMappingURL=chunk-FZHF5UWR.js.map

package/dist/{chunk-XVWOYKIK.js.map → chunk-FZHF5UWR.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/store/reserved-keys.ts","../src/core/json-value.ts"],"names":[],"mappings":"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","file":"chunk-XVWOYKIK.js","sourcesContent":["/**\n * Reserved Keys for Store Entities\n *\n * Structural keys that cannot be overwritten by user-defined properties.\n * Shared across row-mappers, subgraph projection, and schema validation.\n */\nimport { z } from \"zod\";\n\nimport type { KindEntity } from \"../core/types\";\nimport { ConfigurationError } from \"../errors\";\nimport { createDataKeyedBag, isPlainObject } from \"../utils/object\";\n\nexport const RESERVED_NODE_KEYS: ReadonlySet<string> = new Set([\n  \"id\",\n  \"kind\",\n  \"meta\",\n]);\n\nexport const RESERVED_EDGE_KEYS: ReadonlySet<string> = new Set([\n  \"id\",\n  \"kind\",\n  \"meta\",\n  \"fromKind\",\n  \"fromId\",\n  \"toKind\",\n  \"toId\",\n]);\n\nconst PROTOTYPE_POLLUTION_KEYS: ReadonlySet<string> = new Set([\n  \"__proto__\",\n  \"constructor\",\n  \"prototype\",\n]);\n\n/**\n * The property name the SCHEMA LAYER cannot carry, and the single owner of that\n * question — every authoring path asks here rather than re-spelling the literal.\n *\n * Zod accepts `__proto__` in a shape but drops it from every parse result, and\n * reports success even when the field is required, so a value written to such a\n * field is silently lost. A declaration naming it is therefore refused rather\n * than accepted as a field the storage layer can never honor.\n *\n * TWO authoring paths ask, and they stay separate walkers by necessity — one\n * traverses Zod schemas (`defineNode` / `defineEdge`, below), the other JSON\n * property descriptors (`validateGraphExtension`, in\n * ./../graph-extension/validation.ts) — but the VERDICT and the reason they give\n * for it are shared from here, because a name unstorable on one path is\n * unstorable on the other: both compile to the same `z.object(...)`.\n */\nconst UNSTORABLE_PROPERTY_NAME = \"__proto__\";\n\n/**\n * The shared explanation both authoring paths give when they refuse\n * {@link UNSTORABLE_PROPERTY_NAME}, so the two refusals read as one rule.\n */\nexport const UNSTORABLE_PROPERTY_NAME_REASON =\n  \"schema validation cannot carry it\";\n\n/** See {@link UNSTORABLE_PROPERTY_NAME}. */\nexport function isUnstorablePropertyName(name: string): boolean {\n  return name === UNSTORABLE_PROPERTY_NAME;\n}\n\n/**\n * Renders a nested property path for a refusal message: object field names\n * joined by `.`, with the wrappers between them (optional, array, union, …)\n * contributing no segment because they name nothing.\n */\nfunction formatSchemaPath(segments: readonly string[]): string {\n  return segments.join(\".\");\n}\n\n/** How a refusal names a location that is the schema itself, not a field. */\nconst SCHEMA_ROOT_PATH_LABEL = \"(schema root)\";\n\n/**\n * Every schema reachable one step down from `value` — a schema, an array of\n * them, or a plain object holding them.\n *\n * Deliberately STRUCTURAL rather than a per-Zod-type enumeration: every\n * composite (`array`, `record`, `map`, `set`, `tuple`, `union`, `intersection`,\n * `pipe`) and every wrapper (`optional`, `nullable`, `default`, `prefault`,\n * `catch`, `readonly`, `nonoptional`, `promise`) stores its inner schemas as\n * ordinary values of the public {@link z.ZodType.def} record, so one walk covers\n * all of them — including any Zod adds later. An enumeration would silently\n * stop covering the type it forgot, which is precisely how this defect class\n * survived a depth-0-only fix.\n */\nfunction collectNestedSchemas(value: unknown, found: z.ZodType[]): void {\n  if (value instanceof z.ZodType) {\n    found.push(value);\n    return;\n  }\n  if (Array.isArray(value)) {\n    for (const item of value) collectNestedSchemas(item, found);\n    return;\n  }\n  if (isPlainObject(value)) {\n    for (const nested of Object.values(value)) {\n      collectNestedSchemas(nested, found);\n    }\n  }\n}\n\n/** A `z.lazy` whose getter could not run, and where in the schema it sits. */\ntype UnresolvableLazy = Readonly<{ path: string; cause: unknown }>;\n\n/** What one walk of a schema found. */\ntype SchemaFindings = Readonly<{\n  unstorable: string[];\n  unresolvableLazy: UnresolvableLazy[];\n}>;\n\n/**\n * The inner schema of a `z.lazy`, or the reason its getter could not run.\n *\n * `z.lazy` is the one shape the structural walk cannot see — its inner schema\n * hangs off a `getter` FUNCTION rather than a `def` value — so it is unwrapped\n * through the public `unwrap()`, which RUNS that getter. Running it is the only\n * way to inspect what it wraps, and the `visited` set in the caller makes the\n * resulting recursion safe for a self-referential schema.\n *\n * The failure is REPORTED rather than swallowed, and that is the whole contract\n * of this function. `unwrap()` throws when the getter names a binding still in\n * its temporal dead zone — a mutually recursive pair whose second `z.object`\n * const is declared AFTER the `defineNode` call that walks the first. Returning\n * `undefined` there made the walk fail OPEN: the subtree was never judged, and\n * because a definition is validated exactly once, it was never judged later\n * either — so a nested `__proto__` under that subtree was accepted at\n * definition time and then silently dropped by every parse, which is the exact\n * defect this validation exists to prevent. A branch that cannot be looked at\n * is refused, not waved through.\n */\nfunction resolveLazySchema(schema: z.ZodLazy<z.core.SomeType>):\n  | Readonly<{ resolved: true; inner: unknown }>\n  | Readonly<{\n      resolved: false;\n      cause: unknown;\n    }> {\n  try {\n    return { resolved: true, inner: schema.unwrap() };\n  } catch (error) {\n    return { resolved: false, cause: error };\n  }\n}\n\n/**\n * The schemas nested directly inside `schema`, recording an unrunnable `z.lazy`\n * getter in `findings` instead of quietly yielding nothing for it.\n */\nfunction nestedSchemasOf(\n  schema: z.ZodType,\n  path: readonly string[],\n  findings: SchemaFindings,\n): readonly z.ZodType[] {\n  const found: z.ZodType[] = [];\n  if (schema instanceof z.ZodLazy) {\n    const resolution = resolveLazySchema(schema);\n    if (!resolution.resolved) {\n      findings.unresolvableLazy.push({\n        path: formatSchemaPath(path),\n        cause: resolution.cause,\n      });\n      return found;\n    }\n    collectNestedSchemas(resolution.inner, found);\n    return found;\n  }\n  collectNestedSchemas(Object.values(schema.def), found);\n  return found;\n}\n\n/**\n * Collects the path of every property named {@link UNSTORABLE_PROPERTY_NAME}\n * anywhere in `schema`, at any depth and behind any wrapper — and the path of\n * every `z.lazy` that stopped the walk from getting there.\n *\n * `visited` both terminates recursive schemas and keeps a schema reused under\n * several fields from being re-walked; a name is reported once, which is enough\n * to refuse the definition.\n */\nfunction collectSchemaFindings(\n  schema: z.ZodType,\n  path: readonly string[],\n  visited: Set<z.ZodType>,\n  findings: SchemaFindings,\n): void {\n  if (visited.has(schema)) return;\n  visited.add(schema);\n\n  if (schema instanceof z.ZodObject) {\n    // A ZodObject is the only schema that NAMES anything, so its fields are\n    // walked here, by name, rather than through the structural pass below.\n    for (const [propertyName, field] of Object.entries(schema.shape)) {\n      const fieldPath = [...path, propertyName];\n      if (isUnstorablePropertyName(propertyName)) {\n        findings.unstorable.push(formatSchemaPath(fieldPath));\n      }\n      if (field instanceof z.ZodType) {\n        collectSchemaFindings(field, fieldPath, visited, findings);\n      }\n    }\n  }\n\n  // Runs for a ZodObject too, so its `catchall` is covered; the shape schemas it\n  // re-reaches are already in `visited` and cost one set lookup each.\n  for (const nested of nestedSchemasOf(schema, path, findings)) {\n    collectSchemaFindings(nested, path, visited, findings);\n  }\n}\n\n/**\n * Properties starting with `$` are reserved for TypeGraph-owned accessors\n * on the query-builder node/edge proxies (today: `$fulltext`). Reserving\n * the whole prefix — not just the currently-used names — keeps future\n * accessors (e.g. `$vector`, `$json`) from colliding with user fields.\n */\nconst RESERVED_PROPERTY_PREFIX = \"$\";\n\n/**\n * True if a user-defined field name is reserved by TypeGraph's accessor\n * namespace. `defineNode` / `defineEdge` call this against schema keys so\n * the collision fails fast at graph-definition time rather than silently\n * at query time.\n */\nfunction isReservedPropertyName(name: string): boolean {\n  return name.startsWith(RESERVED_PROPERTY_PREFIX);\n}\n\n/**\n * Validates that a node or edge schema does not use any reserved property\n * name. Covers the unstorable name (at ANY depth), the structural keys (`id`,\n * `kind`, etc.) and the `$`-prefix accessor namespace. Throws a single\n * `ConfigurationError` per conflict class so the user sees all collisions in\n * one pass.\n *\n * A FOURTH class is refused here, and it is about the verdict rather than about\n * a name: a `z.lazy` whose getter cannot run yet. The walk must be able to see\n * the whole schema to answer at all, this is the only moment it ever runs, and\n * a branch it could not enter is a branch nothing will ever check. Refusing is\n * the fail-CLOSED reading of \"cannot judge\"; returning a clean verdict for a\n * subtree that was never looked at is the fail-open one.\n *\n * Takes the SCHEMA rather than its top-level key list: the unstorable-name\n * check is recursive, and a caller that could only hand over `Object.keys(\n * schema.shape)` could not express that.\n *\n * The structural and `$`-prefix classes stay top-level-only, and that is a\n * decision rather than an omission: both are about names TypeGraph itself\n * occupies on the node/edge OBJECT it hands back (`id`, `kind`, `meta`,\n * `$fulltext`), and nothing is projected onto a nested object, so a nested\n * field may legitimately be called `id`. Only unstorability is a property of\n * the schema layer at every depth.\n */\nexport function assertSchemaKeysAreFree(\n  entityKind: \"Node\" | \"Edge\",\n  name: string,\n  schema: z.ZodObject<z.ZodRawShape>,\n  reservedStructuralKeys: ReadonlySet<string>,\n): void {\n  // A field named `__proto__` is UNSTORABLE, not merely reserved: Zod accepts\n  // it in a shape but drops it from every parse result — and reports success\n  // even when the field is required — so a write to it is silently lost.\n  //\n  // `validateGraphExtension` already refuses exactly this declaration for a\n  // kind authored as a JSON document (`RESERVED_PROPERTY_NAME`), AT ANY DEPTH.\n  // Checking only the top-level shape here left the two authoring paths\n  // disagreeing again one level down: `z.object({ payload: z.object({\n  // [\"__proto__\"]: z.string() }) })` was accepted, and the nested write was\n  // dropped at parse exactly as the top-level one had been.\n  //\n  // Reachable only through a COMPUTED key — `z.object({ __proto__: … })`\n  // written literally sets the shape object's prototype instead of creating\n  // the entry — but `z.object({ [\"__proto__\"]: z.string() })` yields a shape\n  // whose `Object.keys` really does contain it.\n  const findings: SchemaFindings = { unstorable: [], unresolvableLazy: [] };\n  collectSchemaFindings(schema, [], new Set(), findings);\n\n  // Refused FIRST, because it is the reason the rest of the verdict may be\n  // incomplete: an unrunnable `z.lazy` getter hides everything beneath it, and\n  // a definition is validated exactly once, so \"judge it later\" is not on\n  // offer. See `resolveLazySchema`.\n  if (findings.unresolvableLazy.length > 0) {\n    const label = entityKind.toLowerCase();\n    const locations = findings.unresolvableLazy.map((lazy) =>\n      lazy.path === \"\" ? SCHEMA_ROOT_PATH_LABEL : lazy.path,\n    );\n    throw new ConfigurationError(\n      `${entityKind} \"${name}\" schema contains a z.lazy() whose schema is not available yet at ${label}-definition time: ${locations.join(\", \")}`,\n      {\n        [`${label}Type`]: name,\n        conflicts: locations,\n      },\n      {\n        cause: findings.unresolvableLazy[0]?.cause,\n        suggestion:\n          `Declare every schema the lazy getter references BEFORE this ` +\n          `define${entityKind} call — a mutually recursive pair works when ` +\n          `both z.object() consts are initialized first, and the getters then ` +\n          `resolve. TypeGraph must read through the whole schema at definition ` +\n          `time to refuse property names it cannot store, and a getter that ` +\n          `throws leaves that subtree unchecked forever.`,\n      },\n    );\n  }\n\n  const unstorableConflicts = findings.unstorable;\n  if (unstorableConflicts.length > 0) {\n    const label = entityKind.toLowerCase();\n    throw new ConfigurationError(\n      `${entityKind} \"${name}\" schema declares a property named \"${UNSTORABLE_PROPERTY_NAME}\", which ${UNSTORABLE_PROPERTY_NAME_REASON}: ${unstorableConflicts.join(\", \")}`,\n      {\n        [`${label}Type`]: name,\n        conflicts: unstorableConflicts,\n      },\n      {\n        suggestion: `Rename the property at ${unstorableConflicts.join(\", \")}. Zod drops \"${UNSTORABLE_PROPERTY_NAME}\" from every parse result, so a value written to it would be silently lost.`,\n      },\n    );\n  }\n\n  const keys = Object.keys(schema.shape);\n  const structuralConflicts = keys.filter((key) =>\n    reservedStructuralKeys.has(key),\n  );\n  if (structuralConflicts.length > 0) {\n    const label = entityKind.toLowerCase();\n    throw new ConfigurationError(\n      `${entityKind} \"${name}\" schema contains reserved property names: ${structuralConflicts.join(\", \")}`,\n      {\n        [`${label}Type`]: name,\n        conflicts: structuralConflicts,\n        reservedKeys: [...reservedStructuralKeys],\n      },\n      {\n        suggestion: `Rename the conflicting properties. Reserved names (${[...reservedStructuralKeys].join(\", \")}) are added automatically to all ${label}s.`,\n      },\n    );\n  }\n\n  const prefixConflicts = keys.filter((key) => isReservedPropertyName(key));\n  if (prefixConflicts.length > 0) {\n    const label = entityKind.toLowerCase();\n    throw new ConfigurationError(\n      `${entityKind} \"${name}\" schema uses the reserved \"${RESERVED_PROPERTY_PREFIX}\" prefix on: ${prefixConflicts.join(\", \")}`,\n      {\n        [`${label}Type`]: name,\n        conflicts: prefixConflicts,\n        reservedPrefix: RESERVED_PROPERTY_PREFIX,\n      },\n      {\n        suggestion: `Property names starting with \"${RESERVED_PROPERTY_PREFIX}\" are reserved for TypeGraph accessors (e.g. $fulltext). Rename each field.`,\n      },\n    );\n  }\n}\n\n/**\n * Validates that a projection field name is safe to assign onto a result object.\n * Rejects reserved structural keys and prototype-pollution vectors.\n *\n * @throws ConfigurationError if the field is reserved or dangerous\n */\nexport function validateProjectionField(\n  field: string,\n  entityType: KindEntity,\n  kind: string,\n): void {\n  const reserved =\n    entityType === \"node\" ? RESERVED_NODE_KEYS : RESERVED_EDGE_KEYS;\n\n  if (reserved.has(field)) {\n    throw new ConfigurationError(\n      `Projection field \"${field}\" on ${entityType} kind \"${kind}\" conflicts with a reserved structural key`,\n      { field, kind, entityType, reservedKeys: [...reserved] },\n      {\n        suggestion: `Remove \"${field}\" from the projection. Structural fields (${[...reserved].join(\", \")}) are included automatically when relevant.`,\n      },\n    );\n  }\n\n  if (PROTOTYPE_POLLUTION_KEYS.has(field)) {\n    throw new ConfigurationError(\n      `Projection field \"${field}\" on ${entityType} kind \"${kind}\" is not allowed`,\n      { field, kind, entityType },\n      {\n        suggestion: `\"${field}\" cannot be used as a projection field name.`,\n      },\n    );\n  }\n}\n\n/**\n * Filters out reserved keys from a props object to prevent runtime collisions.\n */\nexport function filterReservedKeys(\n  props: Record<string, unknown>,\n  reservedKeys: ReadonlySet<string>,\n): Record<string, unknown> {\n  // Props keys are DATA (a trusted import writes a caller's bag verbatim, and\n  // `JSON.parse` yields `__proto__` as an own key), so the accumulator must be\n  // null-prototype — a `{}` literal would answer `filtered[\"__proto__\"] = v`\n  // with the prototype setter and silently drop the value.\n  const filtered = createDataKeyedBag<unknown>();\n  for (const [key, value] of Object.entries(props)) {\n    if (!reservedKeys.has(key)) {\n      filtered[key] = value;\n    }\n  }\n  return filtered;\n}\n","/**\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"]}
+{"version":3,"sources":["../src/store/reserved-keys.ts","../src/core/json-value.ts"],"names":[],"mappings":"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","file":"chunk-FZHF5UWR.js","sourcesContent":["/**\n * Reserved Keys for Store Entities\n *\n * Structural keys that cannot be overwritten by user-defined properties.\n * Shared across row-mappers, subgraph projection, and schema validation.\n */\nimport { z } from \"zod\";\n\nimport type { KindEntity } from \"../core/types\";\nimport { ConfigurationError } from \"../errors\";\nimport { createDataKeyedBag, isPlainObject } from \"../utils/object\";\n\nexport const RESERVED_NODE_KEYS: ReadonlySet<string> = new Set([\n  \"id\",\n  \"kind\",\n  \"meta\",\n]);\n\nexport const RESERVED_EDGE_KEYS: ReadonlySet<string> = new Set([\n  \"id\",\n  \"kind\",\n  \"meta\",\n  \"fromKind\",\n  \"fromId\",\n  \"toKind\",\n  \"toId\",\n]);\n\nconst PROTOTYPE_POLLUTION_KEYS: ReadonlySet<string> = new Set([\n  \"__proto__\",\n  \"constructor\",\n  \"prototype\",\n]);\n\n/**\n * The property name the SCHEMA LAYER cannot carry, and the single owner of that\n * question — every authoring path asks here rather than re-spelling the literal.\n *\n * Zod accepts `__proto__` in a shape but drops it from every parse result, and\n * reports success even when the field is required, so a value written to such a\n * field is silently lost. A declaration naming it is therefore refused rather\n * than accepted as a field the storage layer can never honor.\n *\n * TWO authoring paths ask, and they stay separate walkers by necessity — one\n * traverses Zod schemas (`defineNode` / `defineEdge`, below), the other JSON\n * property descriptors (`validateGraphExtension`, in\n * ./../graph-extension/validation.ts) — but the VERDICT and the reason they give\n * for it are shared from here, because a name unstorable on one path is\n * unstorable on the other: both compile to the same `z.object(...)`.\n */\nconst UNSTORABLE_PROPERTY_NAME = \"__proto__\";\n\n/**\n * The shared explanation both authoring paths give when they refuse\n * {@link UNSTORABLE_PROPERTY_NAME}, so the two refusals read as one rule.\n */\nexport const UNSTORABLE_PROPERTY_NAME_REASON =\n  \"schema validation cannot carry it\";\n\n/** See {@link UNSTORABLE_PROPERTY_NAME}. */\nexport function isUnstorablePropertyName(name: string): boolean {\n  return name === UNSTORABLE_PROPERTY_NAME;\n}\n\n/**\n * Renders a nested property path for a refusal message: object field names\n * joined by `.`, with the wrappers between them (optional, array, union, …)\n * contributing no segment because they name nothing.\n */\nfunction formatSchemaPath(segments: readonly string[]): string {\n  return segments.join(\".\");\n}\n\n/** How a refusal names a location that is the schema itself, not a field. */\nconst SCHEMA_ROOT_PATH_LABEL = \"(schema root)\";\n\n/**\n * Every schema reachable one step down from `value` — a schema, an array of\n * them, or a plain object holding them.\n *\n * Deliberately STRUCTURAL rather than a per-Zod-type enumeration: every\n * composite (`array`, `record`, `map`, `set`, `tuple`, `union`, `intersection`,\n * `pipe`) and every wrapper (`optional`, `nullable`, `default`, `prefault`,\n * `catch`, `readonly`, `nonoptional`, `promise`) stores its inner schemas as\n * ordinary values of the public {@link z.ZodType.def} record, so one walk covers\n * all of them — including any Zod adds later. An enumeration would silently\n * stop covering the type it forgot, which is precisely how this defect class\n * survived a depth-0-only fix.\n */\nfunction collectNestedSchemas(value: unknown, found: z.ZodType[]): void {\n  if (value instanceof z.ZodType) {\n    found.push(value);\n    return;\n  }\n  if (Array.isArray(value)) {\n    for (const item of value) collectNestedSchemas(item, found);\n    return;\n  }\n  if (isPlainObject(value)) {\n    for (const nested of Object.values(value)) {\n      collectNestedSchemas(nested, found);\n    }\n  }\n}\n\n/** A `z.lazy` whose getter could not run, and where in the schema it sits. */\ntype UnresolvableLazy = Readonly<{ path: string; cause: unknown }>;\n\n/** What one walk of a schema found. */\ntype SchemaFindings = Readonly<{\n  unstorable: string[];\n  unresolvableLazy: UnresolvableLazy[];\n}>;\n\n/**\n * The inner schema of a `z.lazy`, or the reason its getter could not run.\n *\n * `z.lazy` is the one shape the structural walk cannot see — its inner schema\n * hangs off a `getter` FUNCTION rather than a `def` value — so it is unwrapped\n * through the public `unwrap()`, which RUNS that getter. Running it is the only\n * way to inspect what it wraps, and the `visited` set in the caller makes the\n * resulting recursion safe for a self-referential schema.\n *\n * The failure is REPORTED rather than swallowed, and that is the whole contract\n * of this function. `unwrap()` throws when the getter names a binding still in\n * its temporal dead zone — a mutually recursive pair whose second `z.object`\n * const is declared AFTER the `defineNode` call that walks the first. Returning\n * `undefined` there made the walk fail OPEN: the subtree was never judged, and\n * because a definition is validated exactly once, it was never judged later\n * either — so a nested `__proto__` under that subtree was accepted at\n * definition time and then silently dropped by every parse, which is the exact\n * defect this validation exists to prevent. A branch that cannot be looked at\n * is refused, not waved through.\n */\nfunction resolveLazySchema(schema: z.ZodLazy<z.core.SomeType>):\n  | Readonly<{ resolved: true; inner: unknown }>\n  | Readonly<{\n      resolved: false;\n      cause: unknown;\n    }> {\n  try {\n    return { resolved: true, inner: schema.unwrap() };\n  } catch (error) {\n    return { resolved: false, cause: error };\n  }\n}\n\n/**\n * The schemas nested directly inside `schema`, recording an unrunnable `z.lazy`\n * getter in `findings` instead of quietly yielding nothing for it.\n */\nfunction nestedSchemasOf(\n  schema: z.ZodType,\n  path: readonly string[],\n  findings: SchemaFindings,\n): readonly z.ZodType[] {\n  const found: z.ZodType[] = [];\n  if (schema instanceof z.ZodLazy) {\n    const resolution = resolveLazySchema(schema);\n    if (!resolution.resolved) {\n      findings.unresolvableLazy.push({\n        path: formatSchemaPath(path),\n        cause: resolution.cause,\n      });\n      return found;\n    }\n    collectNestedSchemas(resolution.inner, found);\n    return found;\n  }\n  collectNestedSchemas(Object.values(schema.def), found);\n  return found;\n}\n\n/**\n * Collects the path of every property named {@link UNSTORABLE_PROPERTY_NAME}\n * anywhere in `schema`, at any depth and behind any wrapper — and the path of\n * every `z.lazy` that stopped the walk from getting there.\n *\n * `visited` both terminates recursive schemas and keeps a schema reused under\n * several fields from being re-walked; a name is reported once, which is enough\n * to refuse the definition.\n */\nfunction collectSchemaFindings(\n  schema: z.ZodType,\n  path: readonly string[],\n  visited: Set<z.ZodType>,\n  findings: SchemaFindings,\n): void {\n  if (visited.has(schema)) return;\n  visited.add(schema);\n\n  if (schema instanceof z.ZodObject) {\n    // A ZodObject is the only schema that NAMES anything, so its fields are\n    // walked here, by name, rather than through the structural pass below.\n    for (const [propertyName, field] of Object.entries(schema.shape)) {\n      const fieldPath = [...path, propertyName];\n      if (isUnstorablePropertyName(propertyName)) {\n        findings.unstorable.push(formatSchemaPath(fieldPath));\n      }\n      if (field instanceof z.ZodType) {\n        collectSchemaFindings(field, fieldPath, visited, findings);\n      }\n    }\n  }\n\n  // Runs for a ZodObject too, so its `catchall` is covered; the shape schemas it\n  // re-reaches are already in `visited` and cost one set lookup each.\n  for (const nested of nestedSchemasOf(schema, path, findings)) {\n    collectSchemaFindings(nested, path, visited, findings);\n  }\n}\n\n/**\n * Properties starting with `$` are reserved for TypeGraph-owned accessors\n * on the query-builder node/edge proxies (today: `$fulltext`). Reserving\n * the whole prefix — not just the currently-used names — keeps future\n * accessors (e.g. `$vector`, `$json`) from colliding with user fields.\n */\nconst RESERVED_PROPERTY_PREFIX = \"$\";\n\n/**\n * True if a user-defined field name is reserved by TypeGraph's accessor\n * namespace. `defineNode` / `defineEdge` call this against schema keys so\n * the collision fails fast at graph-definition time rather than silently\n * at query time.\n */\nfunction isReservedPropertyName(name: string): boolean {\n  return name.startsWith(RESERVED_PROPERTY_PREFIX);\n}\n\n/**\n * Validates that a node or edge schema does not use any reserved property\n * name. Covers the unstorable name (at ANY depth), the structural keys (`id`,\n * `kind`, etc.) and the `$`-prefix accessor namespace. Throws a single\n * `ConfigurationError` per conflict class so the user sees all collisions in\n * one pass.\n *\n * A FOURTH class is refused here, and it is about the verdict rather than about\n * a name: a `z.lazy` whose getter cannot run yet. The walk must be able to see\n * the whole schema to answer at all, this is the only moment it ever runs, and\n * a branch it could not enter is a branch nothing will ever check. Refusing is\n * the fail-CLOSED reading of \"cannot judge\"; returning a clean verdict for a\n * subtree that was never looked at is the fail-open one.\n *\n * Takes the SCHEMA rather than its top-level key list: the unstorable-name\n * check is recursive, and a caller that could only hand over `Object.keys(\n * schema.shape)` could not express that.\n *\n * The structural and `$`-prefix classes stay top-level-only, and that is a\n * decision rather than an omission: both are about names TypeGraph itself\n * occupies on the node/edge OBJECT it hands back (`id`, `kind`, `meta`,\n * `$fulltext`), and nothing is projected onto a nested object, so a nested\n * field may legitimately be called `id`. Only unstorability is a property of\n * the schema layer at every depth.\n */\nexport function assertSchemaKeysAreFree(\n  entityKind: \"Node\" | \"Edge\",\n  name: string,\n  schema: z.ZodObject<z.ZodRawShape>,\n  reservedStructuralKeys: ReadonlySet<string>,\n): void {\n  // A field named `__proto__` is UNSTORABLE, not merely reserved: Zod accepts\n  // it in a shape but drops it from every parse result — and reports success\n  // even when the field is required — so a write to it is silently lost.\n  //\n  // `validateGraphExtension` already refuses exactly this declaration for a\n  // kind authored as a JSON document (`RESERVED_PROPERTY_NAME`), AT ANY DEPTH.\n  // Checking only the top-level shape here left the two authoring paths\n  // disagreeing again one level down: `z.object({ payload: z.object({\n  // [\"__proto__\"]: z.string() }) })` was accepted, and the nested write was\n  // dropped at parse exactly as the top-level one had been.\n  //\n  // Reachable only through a COMPUTED key — `z.object({ __proto__: … })`\n  // written literally sets the shape object's prototype instead of creating\n  // the entry — but `z.object({ [\"__proto__\"]: z.string() })` yields a shape\n  // whose `Object.keys` really does contain it.\n  const findings: SchemaFindings = { unstorable: [], unresolvableLazy: [] };\n  collectSchemaFindings(schema, [], new Set(), findings);\n\n  // Refused FIRST, because it is the reason the rest of the verdict may be\n  // incomplete: an unrunnable `z.lazy` getter hides everything beneath it, and\n  // a definition is validated exactly once, so \"judge it later\" is not on\n  // offer. See `resolveLazySchema`.\n  if (findings.unresolvableLazy.length > 0) {\n    const label = entityKind.toLowerCase();\n    const locations = findings.unresolvableLazy.map((lazy) =>\n      lazy.path === \"\" ? SCHEMA_ROOT_PATH_LABEL : lazy.path,\n    );\n    throw new ConfigurationError(\n      `${entityKind} \"${name}\" schema contains a z.lazy() whose schema is not available yet at ${label}-definition time: ${locations.join(\", \")}`,\n      {\n        [`${label}Type`]: name,\n        conflicts: locations,\n      },\n      {\n        cause: findings.unresolvableLazy[0]?.cause,\n        suggestion:\n          `Declare every schema the lazy getter references BEFORE this ` +\n          `define${entityKind} call — a mutually recursive pair works when ` +\n          `both z.object() consts are initialized first, and the getters then ` +\n          `resolve. TypeGraph must read through the whole schema at definition ` +\n          `time to refuse property names it cannot store, and a getter that ` +\n          `throws leaves that subtree unchecked forever.`,\n      },\n    );\n  }\n\n  const unstorableConflicts = findings.unstorable;\n  if (unstorableConflicts.length > 0) {\n    const label = entityKind.toLowerCase();\n    throw new ConfigurationError(\n      `${entityKind} \"${name}\" schema declares a property named \"${UNSTORABLE_PROPERTY_NAME}\", which ${UNSTORABLE_PROPERTY_NAME_REASON}: ${unstorableConflicts.join(\", \")}`,\n      {\n        [`${label}Type`]: name,\n        conflicts: unstorableConflicts,\n      },\n      {\n        suggestion: `Rename the property at ${unstorableConflicts.join(\", \")}. Zod drops \"${UNSTORABLE_PROPERTY_NAME}\" from every parse result, so a value written to it would be silently lost.`,\n      },\n    );\n  }\n\n  const keys = Object.keys(schema.shape);\n  const structuralConflicts = keys.filter((key) =>\n    reservedStructuralKeys.has(key),\n  );\n  if (structuralConflicts.length > 0) {\n    const label = entityKind.toLowerCase();\n    throw new ConfigurationError(\n      `${entityKind} \"${name}\" schema contains reserved property names: ${structuralConflicts.join(\", \")}`,\n      {\n        [`${label}Type`]: name,\n        conflicts: structuralConflicts,\n        reservedKeys: [...reservedStructuralKeys],\n      },\n      {\n        suggestion: `Rename the conflicting properties. Reserved names (${[...reservedStructuralKeys].join(\", \")}) are added automatically to all ${label}s.`,\n      },\n    );\n  }\n\n  const prefixConflicts = keys.filter((key) => isReservedPropertyName(key));\n  if (prefixConflicts.length > 0) {\n    const label = entityKind.toLowerCase();\n    throw new ConfigurationError(\n      `${entityKind} \"${name}\" schema uses the reserved \"${RESERVED_PROPERTY_PREFIX}\" prefix on: ${prefixConflicts.join(\", \")}`,\n      {\n        [`${label}Type`]: name,\n        conflicts: prefixConflicts,\n        reservedPrefix: RESERVED_PROPERTY_PREFIX,\n      },\n      {\n        suggestion: `Property names starting with \"${RESERVED_PROPERTY_PREFIX}\" are reserved for TypeGraph accessors (e.g. $fulltext). Rename each field.`,\n      },\n    );\n  }\n}\n\n/**\n * Validates that a projection field name is safe to assign onto a result object.\n * Rejects reserved structural keys and prototype-pollution vectors.\n *\n * @throws ConfigurationError if the field is reserved or dangerous\n */\nexport function validateProjectionField(\n  field: string,\n  entityType: KindEntity,\n  kind: string,\n): void {\n  const reserved =\n    entityType === \"node\" ? RESERVED_NODE_KEYS : RESERVED_EDGE_KEYS;\n\n  if (reserved.has(field)) {\n    throw new ConfigurationError(\n      `Projection field \"${field}\" on ${entityType} kind \"${kind}\" conflicts with a reserved structural key`,\n      { field, kind, entityType, reservedKeys: [...reserved] },\n      {\n        suggestion: `Remove \"${field}\" from the projection. Structural fields (${[...reserved].join(\", \")}) are included automatically when relevant.`,\n      },\n    );\n  }\n\n  if (PROTOTYPE_POLLUTION_KEYS.has(field)) {\n    throw new ConfigurationError(\n      `Projection field \"${field}\" on ${entityType} kind \"${kind}\" is not allowed`,\n      { field, kind, entityType },\n      {\n        suggestion: `\"${field}\" cannot be used as a projection field name.`,\n      },\n    );\n  }\n}\n\n/**\n * Filters out reserved keys from a props object to prevent runtime collisions.\n */\nexport function filterReservedKeys(\n  props: Record<string, unknown>,\n  reservedKeys: ReadonlySet<string>,\n): Record<string, unknown> {\n  // Props keys are DATA (a trusted import writes a caller's bag verbatim, and\n  // `JSON.parse` yields `__proto__` as an own key), so the accumulator must be\n  // null-prototype — a `{}` literal would answer `filtered[\"__proto__\"] = v`\n  // with the prototype setter and silently drop the value.\n  const filtered = createDataKeyedBag<unknown>();\n  for (const [key, value] of Object.entries(props)) {\n    if (!reservedKeys.has(key)) {\n      filtered[key] = value;\n    }\n  }\n  return filtered;\n}\n","/**\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-BFUOME67.cjs → chunk-G2TLHH6T.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
-var chunkFQPEMEWX_cjs = require('./chunk-FQPEMEWX.cjs');
+var chunkLLVOQOWE_cjs = require('./chunk-LLVOQOWE.cjs');
 var chunkHAHNRASW_cjs = require('./chunk-HAHNRASW.cjs');
-var chunkMRDBBHIZ_cjs = require('./chunk-MRDBBHIZ.cjs');
+var chunkX4GDXBOP_cjs = require('./chunk-X4GDXBOP.cjs');
 var chunkN66HCGCY_cjs = require('./chunk-N66HCGCY.cjs');
 
 // src/core/types.ts
@@ -12,7 +12,7 @@ function assertNonEmptyId(value, path) {
   if (value.length > 0) {
     return;
   }
-  throw new chunkMRDBBHIZ_cjs.ValidationError(
+  throw new chunkX4GDXBOP_cjs.ValidationError(
     `${path} must be a non-empty string.`,
     {
       issues: [
@@ -138,7 +138,7 @@ function validateConstraintNarrowing(name, edgeType, registration) {
   const builtInFromNames = new Set(edgeType.from.map((node) => node.kind));
   for (const fromNode of registration.from) {
     if (!builtInFromNames.has(fromNode.kind)) {
-      throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+      throw new chunkX4GDXBOP_cjs.ConfigurationError(
         `Edge "${name}" registration has 'from' kind "${fromNode.kind}" not in edge's built-in domain: [${[...builtInFromNames].join(", ")}]`,
         {
           edgeName: name,
@@ -154,7 +154,7 @@ function validateConstraintNarrowing(name, edgeType, registration) {
   const builtInToNames = new Set(edgeType.to.map((node) => node.kind));
   for (const toNode of registration.to) {
     if (!builtInToNames.has(toNode.kind)) {
-      throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+      throw new chunkX4GDXBOP_cjs.ConfigurationError(
         `Edge "${name}" registration has 'to' kind "${toNode.kind}" not in edge's built-in range: [${[...builtInToNames].join(", ")}]`,
         {
           edgeName: name,
@@ -197,6 +197,7 @@ function defineGraphUnchecked(config) {
   };
   const allNodeTypes = Object.values(config.nodes).map((reg) => reg.type);
   const normalizedEdges = normalizeEdges(config.edges, allNodeTypes);
+  assertClaimNamesAreSafe(config.nodes);
   assertUniqueConstraintsAreDeclared(config.nodes);
   const autoVectorIndexes = autoDeriveVectorIndexes(config.nodes);
   const explicitProvided = config.indexes !== void 0;
@@ -224,6 +225,14 @@ function defineInternalGraph(config) {
 var EMPTY_DEPRECATED_KINDS = Object.freeze(
   /* @__PURE__ */ new Set()
 );
+function assertClaimNamesAreSafe(nodes) {
+  for (const registration of Object.values(nodes)) {
+    chunkLLVOQOWE_cjs.assertClaimAxisSafe(registration.type.kind, "Node kind");
+    for (const constraint of registration.unique ?? []) {
+      chunkLLVOQOWE_cjs.assertClaimAxisSafe(constraint.name, "Unique constraint");
+    }
+  }
+}
 function assertUniqueConstraintsAreDeclared(nodes) {
   for (const registration of Object.values(nodes)) {
     const constraints = registration.unique;
@@ -233,7 +242,7 @@ function assertUniqueConstraintsAreDeclared(nodes) {
     for (const constraint of constraints) {
       if (shape === void 0) {
         if (constraint.where === void 0) continue;
-        throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+        throw new chunkX4GDXBOP_cjs.ConfigurationError(
           `Unique constraint "${constraint.name}" on node kind "${registration.type.kind}" has a \`where\` clause, but the kind's schema is not an object schema, so its declared fields cannot be checked.`,
           {
             kind: registration.type.kind,
@@ -244,7 +253,7 @@ function assertUniqueConstraintsAreDeclared(nodes) {
           }
         );
       }
-      chunkFQPEMEWX_cjs.assertWhereFieldDeclared(registration.type.kind, constraint, shape);
+      chunkLLVOQOWE_cjs.assertWhereFieldDeclared(registration.type.kind, constraint, shape);
     }
   }
 }
@@ -262,7 +271,7 @@ function normalizeIndexes(inputs, nodes, edges) {
       assertKindRegistered(declaration, edgeKinds, "edge");
     }
     if (seenNames.has(declaration.name)) {
-      throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+      throw new chunkX4GDXBOP_cjs.ConfigurationError(
         `Duplicate index name "${declaration.name}" in defineGraph({ indexes }). Index names must be unique within a graph.`,
         { indexName: declaration.name },
         {
@@ -285,7 +294,7 @@ function assertKindRegistered(declaration, registeredKinds, entity) {
   if (registeredKinds.has(declaration.kind)) return;
   const slot = entity === "node" ? "nodes" : "edges";
   const suggestion = entity === "node" ? `Add { ${declaration.kind}: { type: ${declaration.kind} } } to defineGraph({ nodes }) or remove the index from "indexes".` : `Register the edge in defineGraph({ edges }) or remove the index from "indexes".`;
-  throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+  throw new chunkX4GDXBOP_cjs.ConfigurationError(
     `Index "${declaration.name}" references ${entity} kind "${declaration.kind}" which is not registered in this graph's "${slot}".`,
     {
       indexName: declaration.name,
@@ -323,5 +332,5 @@ exports.isGraphDef = isGraphDef;
 exports.isKnownKind = isKnownKind;
 exports.isNodeType = isNodeType;
 exports.mergeVectorIndexes = mergeVectorIndexes;
-//# sourceMappingURL=chunk-BFUOME67.cjs.map
-//# sourceMappingURL=chunk-BFUOME67.cjs.map
+//# sourceMappingURL=chunk-G2TLHH6T.cjs.map
+//# sourceMappingURL=chunk-G2TLHH6T.cjs.map

package/dist/chunk-G2TLHH6T.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/types.ts","../src/indexes/auto-derive.ts","../src/core/define-graph.ts"],"names":["ValidationError","getEmbeddingIndex","isEmbeddingSchema","ConfigurationError","createDataKeyedBag","assertClaimAxisSafe","assertWhereFieldDeclared"],"mappings":"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","file":"chunk-G2TLHH6T.cjs","sourcesContent":["import { type z } from \"zod\";\n\nimport { ValidationError } from \"../errors\";\n\n// ============================================================\n// Cross-cutting Discriminators\n// ============================================================\n\n/**\n * Which side of the bipartite graph a kind lives on. Used everywhere a\n * function takes \"the entity that owns a kind\" — error metadata,\n * extension classifiers, removal queues, schema diffs.\n */\nexport type KindEntity = \"node\" | \"edge\";\n\n/**\n * Which physical surface an index targets. Vector indexes don't own a\n * kind directly (they back a per-`(kind, field)` typed embedding table\n * owned by the active `VectorStrategy`), but they participate in the same\n * materialization and diff pipelines, so they share this discriminator.\n *\n * `\"system\"` marks TypeGraph's own base-relation indexes\n * (`SYSTEM_INDEX_DECLARATIONS`) — graph-independent, but materialized and\n * status-tracked through the same pipeline; their status rows carry the\n * relation key (e.g. `\"recordedNodes\"`) in the `kind` column.\n */\nexport type IndexEntity = \"node\" | \"edge\" | \"vector\" | \"system\";\n\n/**\n * Field-level null-check operations that round-trip through persisted\n * documents (unique-constraint where clauses, index where clauses,\n * graph-extension where clauses, IsNullPredicate). Consolidated so a\n * single rename or extension touches one site.\n */\nexport type NullCheckOp = \"isNull\" | \"isNotNull\";\n\n// ============================================================\n// Brand Keys for Nominal Typing\n// ============================================================\n\n/** Brand key for NodeType */\nexport const NODE_TYPE_BRAND = \"__nodeType\" as const;\n\n/** Brand key for EdgeType */\nexport const EDGE_TYPE_BRAND = \"__edgeType\" as const;\n\n/** Brand symbol for NodeId */\ndeclare const __nodeId: unique symbol;\n\n/** Brand symbol for EdgeId */\ndeclare const __edgeId: unique symbol;\n\nfunction assertNonEmptyId(value: string, path: string): void {\n  if (value.length > 0) {\n    return;\n  }\n\n  throw new ValidationError(\n    `${path} must be a non-empty string.`,\n    {\n      issues: [\n        {\n          path,\n          message: \"Expected a non-empty string.\",\n        },\n      ],\n    },\n    {\n      suggestion:\n        \"Use a persisted node or edge id value, or let TypeGraph generate an id on create.\",\n    },\n  );\n}\n\n// ============================================================\n// Node Type\n// ============================================================\n\n/**\n * Any JSON-serializable value.\n *\n * Mirrors the JSON wire format: primitives, arrays, and string-keyed objects.\n * `null` is included because the JSON spec requires it for \"no value here\";\n * this is the one place in the public API that uses `null` over `undefined`.\n */\nexport type JsonValue =\n  | null\n  | string\n  | number\n  | boolean\n  | readonly JsonValue[]\n  | Readonly<{ [key: string]: JsonValue }>;\n\n/**\n * Consumer-owned per-kind annotations.\n *\n * Stable labels attached to a node or edge kind at definition time — UI hints,\n * audit policy, provenance pointers, tooling annotations.\n *\n * **Consumer-owned, fully.** TypeGraph never reads, validates, or interprets\n * values in this field. Consumers own the entire namespace; there are no\n * reserved keys or extension prefixes. Future library-owned per-kind state,\n * if needed, will use a separate sibling field rather than carving out keys\n * here.\n *\n * **Annotations participate in schema hashing.** Any change to an annotation\n * value (or adding/removing an annotation key) bumps the canonical schema\n * hash and is reported as a `safe`-severity diff by `getSchemaChanges`. If\n * you don't want versioning for a piece of state, do not put it here.\n *\n * Values must be JSON-serializable — `bigint`, `function`, `symbol`, `undefined`,\n * `Date`, and other class instances are rejected at definition time so they can\n * never silently break schema hashing or storage round-trips.\n */\nexport type KindAnnotations = Readonly<Record<string, JsonValue>>;\n\n/**\n * A node type definition.\n *\n * Created via `defineNode()`. Represents a type of node in the graph\n * with an associated Zod schema for properties.\n */\nexport type NodeType<\n  K extends string = string,\n  S extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>,\n> = Readonly<{\n  [NODE_TYPE_BRAND]: true;\n  kind: K;\n  schema: S;\n  description: string | undefined;\n  annotations: KindAnnotations | undefined;\n}>;\n\n/**\n * Branded node ID type.\n *\n * Prevents mixing IDs from different node types at compile time.\n */\nexport type NodeId<N extends NodeType> = string &\n  Readonly<{\n    [__nodeId]: N;\n  }>;\n\n/**\n * Brands a non-empty string as a {@link NodeId}.\n *\n * Use this when a persisted node id has round-tripped through untyped storage\n * or an external boundary and must be passed back to read/update/delete\n * surfaces such as `getById`, `getByIds`, `update`, or `delete`.\n * Write surfaces that mint or claim ids, such as `create({ id })` and\n * `upsertById`, intentionally accept plain strings.\n *\n * @throws {ValidationError} when `value` is empty.\n */\nexport function asNodeId<N extends NodeType = NodeType>(\n  value: string,\n): NodeId<N> {\n  assertNonEmptyId(value, \"asNodeId\");\n  return value as NodeId<N>;\n}\n\n/**\n * Infer the props type from a NodeType.\n */\nexport type NodeProps<N extends NodeType> = z.infer<N[\"schema\"]>;\n\n// ============================================================\n// Edge Type\n// ============================================================\n\n/**\n * An edge type definition.\n *\n * Created via `defineEdge()`. Represents a type of edge in the graph\n * with an optional Zod schema for properties.\n *\n * Optionally includes `from` and `to` arrays that define the allowed\n * source and target node types (domain and range constraints).\n */\nexport type EdgeType<\n  K extends string = string,\n  S extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>,\n  From extends readonly NodeType[] | undefined = undefined,\n  To extends readonly NodeType[] | undefined = undefined,\n> = Readonly<{\n  [EDGE_TYPE_BRAND]: true;\n  kind: K;\n  schema: S;\n  description: string | undefined;\n  annotations: KindAnnotations | undefined;\n  from: From;\n  to: To;\n}>;\n\n/**\n * Base edge type for use in constraints - accepts any from/to configuration.\n */\nexport type AnyEdgeType = EdgeType<\n  string,\n  z.ZodObject<z.ZodRawShape>,\n  readonly NodeType[] | undefined,\n  readonly NodeType[] | undefined\n>;\n\n/**\n * An edge type that has both from and to constraints defined.\n * Can be used directly in defineGraph without an EdgeRegistration wrapper.\n */\nexport type EdgeTypeWithEndpoints = EdgeType<\n  string,\n  z.ZodObject<z.ZodRawShape>,\n  readonly NodeType[],\n  readonly NodeType[]\n>;\n\n/**\n * Branded edge ID type.\n *\n * Prevents mixing IDs from different edge types at compile time.\n */\nexport type EdgeId<E extends AnyEdgeType = AnyEdgeType> = string &\n  Readonly<{\n    [__edgeId]: E;\n  }>;\n\n/**\n * Brands a non-empty string as an {@link EdgeId}.\n *\n * Use this when a persisted edge id has round-tripped through untyped storage\n * or an external boundary and must be passed back to read/update/delete\n * surfaces such as `getById`, `getByIds`, `update`, or `delete`.\n * Write surfaces that mint ids intentionally accept plain strings.\n *\n * @throws {ValidationError} when `value` is empty.\n */\nexport function asEdgeId<E extends AnyEdgeType = AnyEdgeType>(\n  value: string,\n): EdgeId<E> {\n  assertNonEmptyId(value, \"asEdgeId\");\n  return value as EdgeId<E>;\n}\n\n/**\n * Infer the props type from an EdgeType.\n */\nexport type EdgeProps<E extends AnyEdgeType> = z.infer<E[\"schema\"]>;\n\n// ============================================================\n// Configuration Types\n// ============================================================\n\n/**\n * Delete behaviors for nodes.\n */\nexport type DeleteBehavior = \"restrict\" | \"cascade\" | \"disconnect\";\n\n/**\n * Edge cardinality constraints.\n */\nexport type Cardinality =\n  | \"many\" // No constraint (default)\n  | \"one\" // At most one edge of this kind from any source node\n  | \"unique\" // At most one edge of this kind between any (source, target) pair\n  | \"oneActive\"; // At most one edge with valid_to IS NULL from any source\n\n/**\n * Endpoint existence modes for edge validation.\n */\nexport type EndpointExistence =\n  | \"notDeleted\" // Endpoint deleted_at IS NULL (default)\n  | \"currentlyValid\" // Endpoint not deleted AND temporally valid\n  | \"ever\"; // Endpoint exists in any state\n\n/**\n * Temporal query modes.\n */\nexport type TemporalMode =\n  | \"current\" // Valid now AND not deleted\n  | \"asOf\" // Valid at specific date AND not deleted\n  | \"includeEnded\" // All validity periods AND not deleted\n  | \"includeTombstones\"; // Everything including soft-deleted\n\n/**\n * Uniqueness constraint scope.\n */\nexport type UniquenessScope =\n  | \"kind\" // Unique within this exact kind only\n  | \"kindWithSubClasses\"; // Unique across this kind and all subclasses\n\n/**\n * Collation for uniqueness constraints.\n */\nexport type Collation = \"binary\" | \"caseInsensitive\";\n\n// ============================================================\n// Uniqueness Constraint\n// ============================================================\n\n/**\n * Uniqueness constraint definition.\n */\nexport type UniqueConstraint<\n  S extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>,\n> = Readonly<{\n  name: string;\n  fields: readonly (keyof z.infer<S> & string)[];\n  where?: (\n    props: UniqueConstraintPredicateBuilder<S>,\n  ) => UniqueConstraintPredicate;\n  scope: UniquenessScope;\n  collation: Collation;\n}>;\n\n/**\n * Predicate builder for uniqueness constraint where clause.\n * Uses -? to make all fields required in the builder, even if optional in the schema.\n */\ntype UniqueConstraintPredicateBuilder<S extends z.ZodObject<z.ZodRawShape>> =\n  Readonly<{\n    [K in keyof z.infer<S>]-?: UniqueConstraintField;\n  }>;\n\n/**\n * Field operations for uniqueness constraint predicates.\n */\ntype UniqueConstraintField = Readonly<{\n  isNull: () => UniqueConstraintPredicate;\n  isNotNull: () => UniqueConstraintPredicate;\n}>;\n\n/**\n * A uniqueness constraint predicate (internal representation).\n */\ntype UniqueConstraintPredicate = Readonly<{\n  __type: \"unique_predicate\";\n  field: string;\n  op: NullCheckOp;\n}>;\n\n// ============================================================\n// Node Registration\n// ============================================================\n\n/**\n * Node registration in a graph definition.\n */\nexport type NodeRegistration<N extends NodeType = NodeType> = Readonly<{\n  type: N;\n  unique?: readonly UniqueConstraint<N[\"schema\"]>[];\n  onDelete?: DeleteBehavior;\n}>;\n\n// ============================================================\n// Edge Registration\n// ============================================================\n\n/**\n * Edge registration in a graph definition.\n */\nexport type EdgeRegistration<\n  E extends AnyEdgeType = AnyEdgeType,\n  FromTypes extends NodeType = NodeType,\n  ToTypes extends NodeType = NodeType,\n> = Readonly<{\n  type: E;\n  from: readonly FromTypes[];\n  to: readonly ToTypes[];\n  cardinality?: Cardinality;\n  endpointExistence?: EndpointExistence;\n}>;\n\n// ============================================================\n// Graph Defaults\n// ============================================================\n\n/**\n * Default settings for a graph.\n */\nexport type GraphDefaults = Readonly<{\n  onNodeDelete?: DeleteBehavior;\n  temporalMode?: TemporalMode;\n}>;\n\n// ============================================================\n// Type Helpers\n// ============================================================\n\n/**\n * Checks if a value is a NodeType.\n */\nexport function isNodeType(value: unknown): value is NodeType {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    NODE_TYPE_BRAND in value &&\n    (value as Record<string, unknown>)[NODE_TYPE_BRAND] === true\n  );\n}\n\n/**\n * Checks if a value is an EdgeType.\n */\nexport function isEdgeType(value: unknown): value is AnyEdgeType {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    EDGE_TYPE_BRAND in value &&\n    (value as Record<string, unknown>)[EDGE_TYPE_BRAND] === true\n  );\n}\n\n/**\n * Checks if a value is an EdgeType with both from and to constraints defined.\n * Such edges can be used directly in defineGraph without an EdgeRegistration wrapper.\n */\nexport function isEdgeTypeWithEndpoints(\n  value: unknown,\n): value is EdgeTypeWithEndpoints {\n  return (\n    isEdgeType(value) &&\n    Array.isArray(value.from) &&\n    value.from.length > 0 &&\n    Array.isArray(value.to) &&\n    value.to.length > 0\n  );\n}\n","/**\n * Auto-derive vector index declarations from `embedding()` brands on\n * node schemas.\n *\n * Walks each node's top-level Zod shape, finds fields wrapped in\n * `embedding(dimensions, opts)` (including `.optional()` /\n * `.nullable()` wrappers), and emits one `VectorIndexDeclaration` per\n * (kind, field) pair. The declaration carries the resolved index\n * configuration from the embedding brand — metric, indexType, HNSW /\n * IVFFlat params — so the materializer doesn't need to reach back into\n * the Zod schema.\n *\n * Auto-derivation is intentionally limited to TOP-LEVEL embedding\n * fields. Embeddings nested inside object properties are out of scope\n * for v1 — vector slots are materialized as flat `(kind, fieldPath)`\n * storage units, and top-level fields keep that contract explicit.\n *\n * Explicit `defineVectorIndex(node, fieldPath, opts)` declarations\n * passed via `defineGraph({ indexes })` take precedence — when an\n * explicit declaration matches the same (kind, fieldPath) as an\n * auto-derived one, the explicit version wins. This lets consumers\n * override defaults without losing auto-derivation for other fields.\n */\n\nimport { type z } from \"zod\";\n\nimport {\n  getEmbeddingIndex,\n  isEmbeddingSchema,\n  type ResolvedEmbeddingIndex,\n} from \"../core/embedding\";\nimport { type NodeRegistration } from \"../core/types\";\nimport { type IndexDeclaration, type VectorIndexDeclaration } from \"./types\";\n\n/**\n * Auto-derive vector index declarations from embedding brands on a\n * map of node registrations. Returns one declaration per\n * (kind, top-level field) pair. Empty array when no embeddings found.\n *\n * Cross-graph status-table disambiguation does NOT happen here — the\n * declaration name stays clean (`tg_vec_{kind}_{field}_{metric}`) so\n * `pg_indexes` and result-entry inspection are readable. The\n * materializer composes a graph-scoped key (`${graphId}::${name}`)\n * for status-table identity, applied uniformly to both auto-derived\n * and explicit `VectorIndexDeclaration` entries — see\n * `vectorStatusKey` in `store/materialize-indexes.ts`. This keeps\n * the disambiguation rule in one place that BOTH paths go through,\n * rather than depending on the auto-derive caller to produce a\n * graph-scoped name.\n */\nexport function autoDeriveVectorIndexes(\n  nodes: Record<string, NodeRegistration>,\n): readonly VectorIndexDeclaration[] {\n  const out: VectorIndexDeclaration[] = [];\n  for (const registration of Object.values(nodes)) {\n    const node = registration.type;\n    const shape = readObjectShape(node.schema);\n    if (shape === undefined) continue;\n    for (const [fieldName, fieldSchema] of Object.entries(shape)) {\n      const config = readEmbeddingIndex(fieldSchema);\n      if (config === undefined) continue;\n      const dimensions = readEmbeddingDimensions(fieldSchema);\n      if (dimensions === undefined) continue;\n      out.push(buildAutoDerived(node.kind, fieldName, dimensions, config));\n    }\n  }\n  return out;\n}\n\n/**\n * Merge auto-derived declarations with explicit ones, preferring\n * explicit on (kind, fieldPath) collisions. Returns a flat list of all\n * indexes; non-vector entries from `explicit` pass through unchanged.\n */\nexport function mergeVectorIndexes(\n  explicit: readonly IndexDeclaration[],\n  autoDerived: readonly VectorIndexDeclaration[],\n): readonly IndexDeclaration[] {\n  if (autoDerived.length === 0) return explicit;\n  const explicitVectorKeys = new Set<string>();\n  for (const declaration of explicit) {\n    if (declaration.entity === \"vector\") {\n      explicitVectorKeys.add(`${declaration.kind}|${declaration.fieldPath}`);\n    }\n  }\n  const filteredAuto = autoDerived.filter(\n    (entry) => !explicitVectorKeys.has(`${entry.kind}|${entry.fieldPath}`),\n  );\n  return [...explicit, ...filteredAuto];\n}\n\n/**\n * Generate the deterministic vector index name. The visible prefix\n * `tg_vec_<kind>_<field>_<metric>` keeps it scannable in result-entry\n * inspection and the `typegraph_index_materializations` table.\n *\n * Cross-graph disambiguation is handled separately at the\n * materialization boundary (see `vectorStatusKey`) so the declaration\n * name doesn't need to carry `graphId` — the same auto-derived name\n * is reusable across graphs and the materializer composes a\n * graph-scoped status key for both auto-derived and explicit entries\n * uniformly.\n */\nfunction buildAutoDerived(\n  kind: string,\n  fieldName: string,\n  dimensions: number,\n  config: ResolvedEmbeddingIndex,\n): VectorIndexDeclaration {\n  const fieldPath = fieldName;\n  return Object.freeze({\n    entity: \"vector\" as const,\n    name: `tg_vec_${sanitize(kind)}_${sanitize(fieldName)}_${config.metric}`,\n    kind,\n    fieldPath,\n    dimensions,\n    metric: config.metric,\n    indexType: config.indexType,\n    indexParams: Object.freeze({\n      m: config.m,\n      efConstruction: config.efConstruction,\n      lists: config.lists,\n    }),\n  });\n}\n\nfunction sanitize(value: string): string {\n  return value.replaceAll(/[^a-zA-Z0-9]/g, \"_\").toLowerCase();\n}\n\nfunction readObjectShape(\n  schema: z.ZodType,\n): Record<string, z.ZodType> | undefined {\n  if ((schema as { type?: string }).type !== \"object\") return undefined;\n  const shape = (schema.def as { shape?: Record<string, z.ZodType> }).shape;\n  return shape;\n}\n\nfunction readEmbeddingIndex(\n  schema: z.ZodType,\n): ResolvedEmbeddingIndex | undefined {\n  for (const candidate of unwrapChain(schema)) {\n    const config = getEmbeddingIndex(candidate);\n    if (config !== undefined) return config;\n  }\n  return undefined;\n}\n\nfunction readEmbeddingDimensions(schema: z.ZodType): number | undefined {\n  for (const candidate of unwrapChain(schema)) {\n    if (isEmbeddingSchema(candidate)) {\n      return (candidate as unknown as Record<string, number>)[\n        \"_embeddingDimensions\"\n      ];\n    }\n  }\n  return undefined;\n}\n\n/**\n * Yield the schema and every reachable inner schema by repeatedly\n * applying `.unwrap()` (Zod 4 optional/nullable/default) and\n * `.def.innerType` (some wrappers). Cycle-guarded by depth and\n * reference identity. Generators stop at the first non-unwrappable\n * schema OR after 8 levels — deeper wrapping is pathological and not\n * worth supporting.\n */\nfunction* unwrapChain(schema: z.ZodType): Generator<z.ZodType, void, void> {\n  const seen = new Set<z.ZodType>();\n  let current: z.ZodType | undefined = schema;\n  let depth = 0;\n  while (current !== undefined && !seen.has(current) && depth < 8) {\n    seen.add(current);\n    yield current;\n    current = unwrapOnce(current);\n    depth++;\n  }\n}\n\nfunction unwrapOnce(schema: z.ZodType): z.ZodType | undefined {\n  // Zod 4 wrappers expose `.unwrap()` on optional/nullable/default.\n  const candidate = schema as unknown as { unwrap?: () => z.ZodType };\n  if (typeof candidate.unwrap === \"function\") return candidate.unwrap();\n  // Some wrappers expose the inner schema via `.def.innerType`.\n  return (schema as unknown as { def?: { innerType?: z.ZodType } }).def\n    ?.innerType;\n}\n","import { assertWhereFieldDeclared } from \"../constraints\";\nimport { ConfigurationError } from \"../errors/index\";\nimport { type GraphExtension } from \"../graph-extension/extension-types\";\nimport {\n  autoDeriveVectorIndexes,\n  mergeVectorIndexes,\n} from \"../indexes/auto-derive\";\nimport { type IndexDeclaration } from \"../indexes/types\";\nimport { type OntologyRelation } from \"../ontology/types\";\nimport { assertClaimAxisSafe } from \"../store/claims/axis\";\nimport { createDataKeyedBag } from \"../utils/object\";\nimport {\n  type AnyEdgeType,\n  type DeleteBehavior,\n  type EdgeRegistration,\n  type EdgeTypeWithEndpoints,\n  type GraphDefaults,\n  isEdgeType,\n  isEdgeTypeWithEndpoints,\n  type KindEntity,\n  type NodeRegistration,\n  type NodeType,\n  type TemporalMode,\n} from \"./types\";\n\n// ============================================================\n// Graph Definition Brand Symbol\n// ============================================================\n\n/** Brand key for GraphDef */\nconst GRAPH_DEF_BRAND = \"__graphDef\" as const;\n\n// ============================================================\n// Edge Entry Types\n// ============================================================\n\n/**\n * An edge entry in the graph definition.\n * Can be:\n * - EdgeType directly (constrained or unconstrained)\n * - EdgeRegistration object (always works, can override/narrow defaults)\n */\ntype EdgeEntry = EdgeRegistration | AnyEdgeType;\n\n/**\n * Normalized edge map type - all entries become EdgeRegistration.\n * For bare EdgeTypes, constrained endpoints are extracted from the type;\n * unconstrained edges fall back to all node types in the graph.\n */\ntype NormalizedEdges<\n  TNodes extends Record<string, NodeRegistration>,\n  TEdges extends Record<string, EdgeEntry>,\n> = {\n  [K in keyof TEdges]: TEdges[K] extends EdgeRegistration ? TEdges[K]\n  : TEdges[K] extends AnyEdgeType ?\n    EdgeRegistration<\n      TEdges[K],\n      TEdges[K][\"from\"] extends readonly (infer N extends NodeType)[] ? N\n      : TNodes[keyof TNodes][\"type\"],\n      TEdges[K][\"to\"] extends readonly (infer N extends NodeType)[] ? N\n      : TNodes[keyof TNodes][\"type\"]\n    >\n  : never;\n};\n\n// ============================================================\n// Edge Normalization Functions\n// ============================================================\n\n/**\n * Validates that an EdgeRegistration's constraints don't widen beyond\n * the edge type's built-in domain/range constraints.\n */\nfunction validateConstraintNarrowing(\n  name: string,\n  edgeType: EdgeTypeWithEndpoints,\n  registration: EdgeRegistration,\n): void {\n  const builtInFromNames = new Set(edgeType.from.map((node) => node.kind));\n  for (const fromNode of registration.from) {\n    if (!builtInFromNames.has(fromNode.kind)) {\n      throw new ConfigurationError(\n        `Edge \"${name}\" registration has 'from' kind \"${fromNode.kind}\" ` +\n          `not in edge's built-in domain: [${[...builtInFromNames].join(\", \")}]`,\n        {\n          edgeName: name,\n          invalidFrom: fromNode.kind,\n          allowedFrom: [...builtInFromNames],\n        },\n        {\n          suggestion: `Edge registration can only narrow, not widen, the edge type's built-in constraints.`,\n        },\n      );\n    }\n  }\n\n  const builtInToNames = new Set(edgeType.to.map((node) => node.kind));\n  for (const toNode of registration.to) {\n    if (!builtInToNames.has(toNode.kind)) {\n      throw new ConfigurationError(\n        `Edge \"${name}\" registration has 'to' kind \"${toNode.kind}\" ` +\n          `not in edge's built-in range: [${[...builtInToNames].join(\", \")}]`,\n        {\n          edgeName: name,\n          invalidTo: toNode.kind,\n          allowedTo: [...builtInToNames],\n        },\n        {\n          suggestion: `Edge registration can only narrow, not widen, the edge type's built-in constraints.`,\n        },\n      );\n    }\n  }\n}\n\n/**\n * Normalizes a single edge entry to EdgeRegistration.\n */\nfunction normalizeEdgeEntry(\n  name: string,\n  entry: EdgeEntry,\n  allNodeTypes: readonly NodeType[],\n): EdgeRegistration {\n  if (isEdgeType(entry)) {\n    if (isEdgeTypeWithEndpoints(entry)) {\n      // EdgeType with from/to — convert to EdgeRegistration\n      return { type: entry, from: entry.from, to: entry.to };\n    }\n    // Unconstrained EdgeType — allow any→any\n    return { type: entry, from: allNodeTypes, to: allNodeTypes };\n  }\n\n  // Already EdgeRegistration — validate narrowing if edge has built-in constraints\n  if (isEdgeTypeWithEndpoints(entry.type)) {\n    validateConstraintNarrowing(name, entry.type, entry);\n  }\n\n  return entry;\n}\n\n/**\n * Normalizes all edge entries to EdgeRegistration.\n *\n * The accumulator is a {@link createDataKeyedBag}: its keys are EDGE KIND\n * NAMES, which are data. `isValidKindName` admits `__proto__` exactly as it\n * admits `toString`, and a graph literal written with a computed key\n * (`edges: { [\"__proto__\"]: knows }`) carries it as an own key — so\n * `result[name] = …` into a `{}` literal would reach `Object.prototype`'s\n * `__proto__` setter, reparent the accumulator, and drop the declared edge.\n * `config.nodes` needs no such treatment: it is passed through by reference,\n * never re-accumulated.\n */\nfunction normalizeEdges(\n  edges: Record<string, EdgeEntry>,\n  allNodeTypes: readonly NodeType[],\n): Record<string, EdgeRegistration> {\n  const result = createDataKeyedBag<EdgeRegistration>();\n  for (const [name, entry] of Object.entries(edges)) {\n    result[name] = normalizeEdgeEntry(name, entry, allNodeTypes);\n  }\n  // Spread at the boundary: this becomes `graph.edges` on the returned (and\n  // publicly reachable) `GraphDef`. See `createDataKeyedBag` in\n  // ../utils/object.ts.\n  return { ...result };\n}\n\n// ============================================================\n// Graph Definition Configuration\n// ============================================================\n\n/** Durable graph-level configuration for the TypeGraph Identity Profile. */\nexport type GraphIdentityConfig = Readonly<{\n  /** Whether equal ids in different kinds implicitly join one identity class. */\n  sameIdAcrossKinds: \"fold\" | \"ignore\";\n}>;\n\n/**\n * Configuration for defineGraph.\n */\ntype GraphDefConfig<\n  TNodes extends Record<string, NodeRegistration>,\n  TEdges extends Record<string, EdgeEntry>,\n  TOntology extends readonly OntologyRelation[],\n  TIdentity extends GraphIdentityConfig | undefined,\n> = Readonly<{\n  /** Unique identifier for this graph */\n  id: string;\n  /** Node registrations */\n  nodes: TNodes;\n  /** Edge registrations or EdgeTypes with built-in domain/range */\n  edges: TEdges;\n  /** Ontology relations */\n  ontology?: TOntology;\n  /** Graph-wide defaults */\n  defaults?: GraphDefaults;\n  /** Enables the TypeGraph Identity Profile for this graph. */\n  identity?: TIdentity;\n  /**\n   * Index declarations attached to this graph.\n   *\n   * Accepts the outputs of `defineNodeIndex` / `defineEdgeIndex` (which\n   * already return `IndexDeclaration` values) or pre-built declarations\n   * reconstructed from a stored schema or graph extension.\n   *\n   * Validated at definition time: every index must reference a `kind`\n   * that exists in `nodes` / `edges`, and index `name`s must be unique\n   * within the graph.\n   *\n   * Index DDL is **not** generated by `defineGraph`. Indexes flow into\n   * `SerializedSchema.indexes` so they can later be materialized via\n   * `store.materializeIndexes()` — lifting the storage concern out of\n   * the schema-version commit path.\n   */\n  indexes?: readonly IndexDeclaration[];\n}>;\n\n// ============================================================\n// Graph Definition Type\n// ============================================================\n\n/**\n * A graph definition.\n *\n * This is a compile-time artifact that describes the structure of a graph.\n * Use `createStore()` to create a runtime store from this definition.\n */\nexport type GraphDef<\n  TNodes extends Record<string, NodeRegistration> = Record<\n    string,\n    NodeRegistration\n  >,\n  TEdges extends Record<string, EdgeRegistration> = Record<\n    string,\n    EdgeRegistration\n  >,\n  TOntology extends readonly OntologyRelation[] = readonly OntologyRelation[],\n  TIdentity extends GraphIdentityConfig | undefined =\n    GraphIdentityConfig | undefined,\n> = Readonly<{\n  [GRAPH_DEF_BRAND]: true;\n  id: string;\n  nodes: TNodes;\n  edges: TEdges;\n  ontology: TOntology;\n  /** Durable graph-level opt-in to the TypeGraph Identity Profile. */\n  identity: TIdentity;\n  defaults: Readonly<{\n    onNodeDelete: DeleteBehavior;\n    temporalMode: TemporalMode;\n  }>;\n  /**\n   * Index declarations attached to this graph. Preserves whatever the\n   * caller passed to `defineGraph` (including an explicit empty array)\n   * for introspection purposes.\n   *\n   * The serialized canonical form is order-canonicalized (sorted by\n   * `name`) and treats `undefined` and `[]` as the same \"no slice\" form\n   * — an empty array does not bump the schema hash, since indexes are\n   * an unordered set keyed by name and `[]` carries no semantic meaning\n   * that an absent slice doesn't.\n   */\n  indexes: readonly IndexDeclaration[] | undefined;\n  /**\n   * Graph extension this graph was merged with, if any. Set by\n   * `mergeGraphExtension`; never set by `defineGraph` directly.\n   * Exists solely so re-serialization is stable — the rest of the\n   * system reads the merged kinds through `nodes` / `edges` /\n   * `ontology` and never inspects this field. Absent on graphs that\n   * have never been extended; legacy graphs hash byte-identically.\n   */\n  extension: GraphExtension | undefined;\n  /**\n   * Soft-deprecated kind names attached to this graph. Set by the\n   * loader from the persisted schema and by `store.deprecateKinds(...)`\n   * / `store.undeprecateKinds(...)`. A purely informational signal\n   * surfaced for introspection — does not gate reads, writes, or\n   * queries. Defaults to the empty set on freshly-defined graphs.\n   */\n  deprecatedKinds: ReadonlySet<string>;\n}>;\n\n// ============================================================\n// Type Helpers\n// ============================================================\n\n/**\n * Extract node kind names from a GraphDef.\n */\nexport type NodeKinds<G extends GraphDef> = keyof G[\"nodes\"] & string;\n\n/**\n * Extract edge kind names from a GraphDef.\n */\nexport type EdgeKinds<G extends GraphDef> = keyof G[\"edges\"] & string;\n\n/**\n * Get a NodeType from a GraphDef by kind name.\n */\nexport type GetNodeType<\n  G extends GraphDef,\n  K extends NodeKinds<G>,\n> = G[\"nodes\"][K][\"type\"];\n\n/**\n * Get an EdgeType from a GraphDef by kind name.\n */\nexport type GetEdgeType<\n  G extends GraphDef,\n  K extends EdgeKinds<G>,\n> = G[\"edges\"][K][\"type\"];\n\n/**\n * Get all NodeTypes from a GraphDef.\n */\nexport type AllNodeTypes<G extends GraphDef> = {\n  [K in NodeKinds<G>]: G[\"nodes\"][K][\"type\"];\n}[NodeKinds<G>];\n\n/**\n * Get all EdgeTypes from a GraphDef.\n */\nexport type AllEdgeTypes<G extends GraphDef> = {\n  [K in EdgeKinds<G>]: G[\"edges\"][K][\"type\"];\n}[EdgeKinds<G>];\n\n// ============================================================\n// Define Graph Function\n// ============================================================\n\n/**\n * Creates a graph definition.\n *\n * @example\n * ```typescript\n * const graph = defineGraph({\n *   id: \"my_graph\",\n *   nodes: {\n *     Person: { type: Person },\n *     Company: { type: Company },\n *   },\n *   edges: {\n *     // Traditional EdgeRegistration syntax\n *     worksAt: {\n *       type: worksAt,\n *       from: [Person],\n *       to: [Company],\n *       cardinality: \"many\",\n *     },\n *     // Or use EdgeType directly if it has from/to defined\n *     knows,  // EdgeType with built-in domain/range\n *   },\n *   ontology: [\n *     subClassOf(Company, Organization),\n *     disjointWith(Person, Organization),\n *   ],\n *   defaults: {\n *     onNodeDelete: \"restrict\",\n *     temporalMode: \"current\",\n *   },\n * });\n * ```\n */\nexport function defineGraph<\n  const TNodes extends Record<string, NodeRegistration<NodeType>>,\n  const TEdges extends Record<string, EdgeEntry>,\n  const TOntology extends readonly OntologyRelation[],\n  const TIdentity extends GraphIdentityConfig | undefined = undefined,\n>(\n  config: GraphDefConfig<TNodes, TEdges, TOntology, TIdentity>,\n): GraphDef<TNodes, NormalizedEdges<TNodes, TEdges>, TOntology, TIdentity> {\n  return defineGraphUnchecked(config);\n}\n\nfunction defineGraphUnchecked<\n  const TNodes extends Record<string, NodeRegistration<NodeType>>,\n  const TEdges extends Record<string, EdgeEntry>,\n  const TOntology extends readonly OntologyRelation[],\n  const TIdentity extends GraphIdentityConfig | undefined = undefined,\n>(\n  config: GraphDefConfig<TNodes, TEdges, TOntology, TIdentity>,\n): GraphDef<TNodes, NormalizedEdges<TNodes, TEdges>, TOntology, TIdentity> {\n  const defaults = {\n    onNodeDelete: config.defaults?.onNodeDelete ?? \"restrict\",\n    temporalMode: config.defaults?.temporalMode ?? \"current\",\n  } as const;\n\n  const allNodeTypes = Object.values(config.nodes).map((reg) => reg.type);\n  const normalizedEdges = normalizeEdges(config.edges, allNodeTypes);\n  assertClaimNamesAreSafe(config.nodes);\n  assertUniqueConstraintsAreDeclared(config.nodes);\n  // Vector indexes are auto-derived from `embedding()` brands on node\n  // schemas (see `autoDeriveVectorIndexes`). Explicit declarations\n  // passed via `defineGraph({ indexes })` win on (kind, fieldPath)\n  // collisions so consumers can override defaults — see\n  // `mergeVectorIndexes`. The merged list flows through\n  // `normalizeIndexes` for the standard kind-registered + unique-name\n  // checks.\n  //\n  // Preservation rule: if the consumer never passed `indexes` at all\n  // AND no embedding brands exist, leave `graph.indexes` undefined to\n  // keep the introspection surface stable for legacy graphs. If the\n  // consumer passed an explicit `[]`, surface it as `[]` (not\n  // `undefined`) to match the contract pinned by the\n  // \"preserves an explicit empty indexes array\" test.\n  const autoVectorIndexes = autoDeriveVectorIndexes(config.nodes);\n  const explicitProvided = config.indexes !== undefined;\n  const mergedIndexes = mergeVectorIndexes(\n    config.indexes ?? [],\n    autoVectorIndexes,\n  );\n  const indexes =\n    !explicitProvided && mergedIndexes.length === 0 ?\n      undefined\n    : normalizeIndexes(mergedIndexes, config.nodes, normalizedEdges);\n\n  return Object.freeze({\n    [GRAPH_DEF_BRAND]: true as const,\n    id: config.id,\n    nodes: config.nodes,\n    edges: normalizedEdges,\n    ontology: config.ontology ?? ([] as unknown as TOntology),\n    identity: config.identity as TIdentity,\n    defaults,\n    indexes,\n    extension: undefined,\n    deprecatedKinds: EMPTY_DEPRECATED_KINDS,\n  }) as GraphDef<TNodes, NormalizedEdges<TNodes, TEdges>, TOntology, TIdentity>;\n}\n\n/**\n * @internal Marks a graph definition as framework-owned rather than\n * application-authored.\n *\n * It builds exactly what {@link defineGraph} builds — the name records the\n * caller, it does not reserve anything. There is NO reserved id namespace and\n * no id validation anywhere: an application may define a graph at any id a\n * framework-owned graph uses, the merge-provenance sidecar's\n * `<target>::merge-provenance` convention included. That convention is\n * protected at RUNTIME instead, by the ownership checks in the single gateway\n * that opens a sidecar (`openProvenanceStore`), which refuses an id occupied by\n * anything it cannot prove it owns.\n */\nexport function defineInternalGraph<\n  const TNodes extends Record<string, NodeRegistration<NodeType>>,\n  const TEdges extends Record<string, EdgeEntry>,\n  const TOntology extends readonly OntologyRelation[],\n  const TIdentity extends GraphIdentityConfig | undefined = undefined,\n>(\n  config: GraphDefConfig<TNodes, TEdges, TOntology, TIdentity>,\n): GraphDef<TNodes, NormalizedEdges<TNodes, TEdges>, TOntology, TIdentity> {\n  return defineGraphUnchecked(config);\n}\n\n// Sharing one frozen empty Set keeps the canonical-form hash stable\n// across graphs that never deprecate any kinds.\nconst EMPTY_DEPRECATED_KINDS: ReadonlySet<string> = Object.freeze(\n  new Set<string>(),\n);\n\n// ============================================================\n// Unique Constraint Validation\n// ============================================================\n\n/**\n * Refuses any kind name or constraint name that could spell a reserved claim\n * axis.\n *\n * A node kind and a unique constraint name are both written verbatim into the\n * claim rows a write of that kind reserves, and the axes that are NOT kinds —\n * the disjoint pair axis, and the reserved constraint name its rows carry — are\n * built from a code point neither may contain. `defineGraph` is where that is\n * enforced for the whole graph: `defineNode` already refuses it for kinds it\n * builds, but the graph-extension compiler builds registrations without going\n * through it, and constraint names never pass `defineNode` at all.\n */\nfunction assertClaimNamesAreSafe(\n  nodes: Record<string, NodeRegistration>,\n): void {\n  for (const registration of Object.values(nodes)) {\n    assertClaimAxisSafe(registration.type.kind, \"Node kind\");\n    for (const constraint of registration.unique ?? []) {\n      assertClaimAxisSafe(constraint.name, \"Unique constraint\");\n    }\n  }\n}\n\n/**\n * Refuses any uniqueness constraint whose `where` clause names a field its kind\n * does not declare.\n *\n * `defineGraph` is the one gate every constraint passes before a write can\n * evaluate it — the store reads constraints off `registration.unique`, and the\n * only other way a registration is built is `mergeGraphExtension`, whose\n * documents `validateGraphExtension` already refuses on the same grounds\n * (`UNKNOWN_UNIQUE_WHERE_FIELD`). Validating here therefore covers every write\n * path at once, instead of at each `checkWherePredicate` call site.\n *\n * Typed callers are already guarded by `UniqueConstraintPredicateBuilder`,\n * which declares exactly the schema's fields; this is the runtime half, for\n * untyped callers whose typo would otherwise produce a constraint that quietly\n * never applies.\n */\nfunction assertUniqueConstraintsAreDeclared(\n  nodes: Record<string, NodeRegistration>,\n): void {\n  for (const registration of Object.values(nodes)) {\n    const constraints = registration.unique;\n    if (constraints === undefined || constraints.length === 0) continue;\n\n    const rawShape = (registration.type.schema as { shape?: unknown }).shape;\n    const shape =\n      typeof rawShape === \"object\" && rawShape !== null ?\n        (rawShape as Readonly<Record<string, unknown>>)\n      : undefined;\n\n    for (const constraint of constraints) {\n      // A schema exposing no `.shape` is not an object schema, so there is no\n      // declared-field set to check the clause against. Skipping the check\n      // silently would disable this guard for exactly the callers it was\n      // written for — untyped ones, who are also the only callers who can put\n      // a non-`ZodObject` here (`defineNode` / `defineEdge` and the\n      // graph-extension compiler all produce `z.object(...)`). So the clause is\n      // REFUSED rather than left unvalidated.\n      //\n      // Narrowly: only a constraint that actually carries a `where` is refused.\n      // A plain `unique: [{ fields }]` needs no shape to be meaningful — it\n      // names props by key and evaluates fine against a non-object schema — and\n      // refusing it would break a working, if unusual, untyped graph for no\n      // safety gain.\n      if (shape === undefined) {\n        if (constraint.where === undefined) continue;\n        throw new ConfigurationError(\n          `Unique constraint \"${constraint.name}\" on node kind \"${registration.type.kind}\" has a \\`where\\` clause, but the kind's schema is not an object schema, so its declared fields cannot be checked.`,\n          {\n            kind: registration.type.kind,\n            constraintName: constraint.name,\n          },\n          {\n            suggestion: `Declare the kind with an object schema (\\`z.object({ ... })\\`) so the \\`where\\` clause can be validated, or drop the \\`where\\` clause.`,\n          },\n        );\n      }\n\n      assertWhereFieldDeclared(registration.type.kind, constraint, shape);\n    }\n  }\n}\n\n// ============================================================\n// Index Normalization\n// ============================================================\n\n/**\n * Validates the `indexes` config slice:\n *\n * - Every index references a kind that exists in the graph's `nodes`\n *   (for node indexes) or `edges` (for edge indexes).\n * - Index `name`s are unique within the graph.\n */\nfunction normalizeIndexes(\n  inputs: readonly IndexDeclaration[],\n  nodes: Record<string, NodeRegistration>,\n  edges: Record<string, EdgeRegistration>,\n): readonly IndexDeclaration[] {\n  if (inputs.length === 0) {\n    return [];\n  }\n\n  const nodeKinds = collectKinds(nodes);\n  const edgeKinds = collectKinds(edges);\n  const seenNames = new Set<string>();\n\n  for (const declaration of inputs) {\n    if (declaration.entity === \"node\" || declaration.entity === \"vector\") {\n      // Vector indexes attach to node kinds (the embedding lives on a\n      // node field). Validation reuses the node-kind check.\n      assertKindRegistered(declaration, nodeKinds, \"node\");\n    } else {\n      assertKindRegistered(declaration, edgeKinds, \"edge\");\n    }\n\n    if (seenNames.has(declaration.name)) {\n      throw new ConfigurationError(\n        `Duplicate index name \"${declaration.name}\" in defineGraph({ indexes }). ` +\n          `Index names must be unique within a graph.`,\n        { indexName: declaration.name },\n        {\n          suggestion: `Pass an explicit { name: \"...\" } to disambiguate.`,\n        },\n      );\n    }\n    seenNames.add(declaration.name);\n  }\n\n  return inputs;\n}\n\nfunction collectKinds(\n  registrations: Record<string, { type: { kind: string } }>,\n): ReadonlySet<string> {\n  const kinds = new Set<string>();\n  for (const registration of Object.values(registrations)) {\n    kinds.add(registration.type.kind);\n  }\n  return kinds;\n}\n\nfunction assertKindRegistered(\n  declaration: IndexDeclaration,\n  registeredKinds: ReadonlySet<string>,\n  entity: KindEntity,\n): void {\n  if (registeredKinds.has(declaration.kind)) return;\n\n  const slot = entity === \"node\" ? \"nodes\" : \"edges\";\n  const suggestion =\n    entity === \"node\" ?\n      `Add { ${declaration.kind}: { type: ${declaration.kind} } } to defineGraph({ nodes }) ` +\n      `or remove the index from \"indexes\".`\n    : `Register the edge in defineGraph({ edges }) or remove the index from \"indexes\".`;\n\n  throw new ConfigurationError(\n    `Index \"${declaration.name}\" references ${entity} kind \"${declaration.kind}\" ` +\n      `which is not registered in this graph's \"${slot}\".`,\n    {\n      indexName: declaration.name,\n      referencedKind: declaration.kind,\n      availableKinds: [...registeredKinds],\n    },\n    { suggestion },\n  );\n}\n\n// ============================================================\n// Graph Definition Utilities\n// ============================================================\n\n/**\n * Checks if a value is a GraphDef.\n */\nexport function isGraphDef(value: unknown): value is GraphDef {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    GRAPH_DEF_BRAND in value &&\n    (value as Record<string, unknown>)[GRAPH_DEF_BRAND] === true\n  );\n}\n\n/**\n * Gets all node kind names from a GraphDef.\n */\nexport function getNodeKinds<G extends GraphDef>(\n  graph: G,\n): readonly (keyof G[\"nodes\"] & string)[] {\n  return Object.keys(graph.nodes);\n}\n\n/**\n * Gets all edge kind names from a GraphDef.\n */\nexport function getEdgeKinds<G extends GraphDef>(\n  graph: G,\n): readonly (keyof G[\"edges\"] & string)[] {\n  return Object.keys(graph.edges);\n}\n\n/**\n * Returns true when `name` is registered as either a node or edge kind\n * on the given graph.\n */\nexport function isKnownKind(graph: GraphDef, name: string): boolean {\n  return Object.hasOwn(graph.nodes, name) || Object.hasOwn(graph.edges, name);\n}\n"]}

package/dist/{chunk-5PRKMB24.cjs → chunk-GHZPZNFC.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkEDN4Y4ZG_cjs = require('./chunk-EDN4Y4ZG.cjs');
+var chunkOJHD3LXJ_cjs = require('./chunk-OJHD3LXJ.cjs');
 
 // src/backend/types.ts
 function normalizeGraphAnalyticsCapabilities(capabilities) {
@@ -24,9 +24,10 @@ function isLiveNodeRow(row) {
 function isTombstonedNodeRow(row) {
   return row.deleted_at !== void 0;
 }
-var INTERNAL_TEMPORARY_WRITES = chunkEDN4Y4ZG_cjs.typeGraphGlobalSymbol(
+var INTERNAL_TEMPORARY_WRITES = chunkOJHD3LXJ_cjs.typeGraphGlobalSymbol(
   "internal-temporary-writes-v1"
 );
+var DATABASE_EXTENSION_NAMES = ["pg_trgm", "vector"];
 function createTransactionReadBackend(backend) {
   const getNodes = backend.getNodes;
   const getEdges = backend.getEdges;
@@ -87,6 +88,9 @@ var SQLITE_CAPABILITIES = Object.freeze({
   clearValidTo: true,
   returning: true,
   // SQLite has supported RETURNING since 3.35.0
+  // The bundled schema ships both claim relations and the shared operation
+  // backend implements every claim member.
+  constraintClaims: true,
   maxBindParameters: SQLITE_MAX_BIND_PARAMETERS,
   // Generic SQLite builds do not guarantee ENABLE_MATH_FUNCTIONS. The local
   // better-sqlite3 factory overrides this flag for its bundled build contract.
@@ -100,11 +104,15 @@ var POSTGRES_CAPABILITIES = Object.freeze({
   clearValidTo: true,
   returning: true,
   // PostgreSQL has supported RETURNING since 8.2
+  // The bundled schema ships both claim relations and the shared operation
+  // backend implements every claim member.
+  constraintClaims: true,
   maxBindParameters: POSTGRES_MAX_BIND_PARAMETERS,
   graphAnalytics: Object.freeze({ supported: true, mathFunctions: true })
 });
 
 exports.D1_MAX_BIND_PARAMETERS = D1_MAX_BIND_PARAMETERS;
+exports.DATABASE_EXTENSION_NAMES = DATABASE_EXTENSION_NAMES;
 exports.DURABLE_OBJECT_MAX_BIND_PARAMETERS = DURABLE_OBJECT_MAX_BIND_PARAMETERS;
 exports.INTERNAL_TEMPORARY_WRITES = INTERNAL_TEMPORARY_WRITES;
 exports.MODERN_SQLITE_MAX_BIND_PARAMETERS = MODERN_SQLITE_MAX_BIND_PARAMETERS;
@@ -120,5 +128,5 @@ exports.normalizeGraphAnalyticsCapabilities = normalizeGraphAnalyticsCapabilitie
 exports.rowPropsToJsonText = rowPropsToJsonText;
 exports.rowPropsToObject = rowPropsToObject;
 exports.runOptionallyInTransaction = runOptionallyInTransaction;
-//# sourceMappingURL=chunk-5PRKMB24.cjs.map
-//# sourceMappingURL=chunk-5PRKMB24.cjs.map
+//# sourceMappingURL=chunk-GHZPZNFC.cjs.map
+//# sourceMappingURL=chunk-GHZPZNFC.cjs.map