@nicia-ai/typegraph 0.49.0 → 0.50.0

package/dist/{chunk-SHFBB23Q.js → chunk-7OWE7WD6.js}

@@ -1,5 +1,6 @@
-import { NODE_TYPE_BRAND, EDGE_TYPE_BRAND } from './chunk-HEV35TGT.js';
-import { assertJsonValue, assertSchemaKeysAreFree, RESERVED_NODE_KEYS, RESERVED_EDGE_KEYS } from './chunk-XVWOYKIK.js';
+import { NODE_TYPE_BRAND, EDGE_TYPE_BRAND } from './chunk-DI6VC62F.js';
+import { assertClaimAxisSafe } from './chunk-5LKOVCPP.js';
+import { assertJsonValue, assertSchemaKeysAreFree, RESERVED_NODE_KEYS, RESERVED_EDGE_KEYS } from './chunk-FZHF5UWR.js';
 import { z } from 'zod';
 
 // src/core/node.ts
@@ -7,6 +8,7 @@ function validateSchemaKeys(schema, name) {
   assertSchemaKeysAreFree("Node", name, schema, RESERVED_NODE_KEYS);
 }
 function defineNode(name, options) {
+  assertClaimAxisSafe(name, "Node kind");
   validateSchemaKeys(options.schema, name);
   if (options.annotations !== void 0) {
     assertJsonValue(options.annotations, "annotations", `Node "${name}"`);
@@ -53,5 +55,5 @@ function getTypeName(typeOrIri) {
 }
 
 export { META_EDGE_BRAND, defineEdge, defineNode, getTypeName, isMetaEdge };
-//# sourceMappingURL=chunk-SHFBB23Q.js.map
-//# sourceMappingURL=chunk-SHFBB23Q.js.map
+//# sourceMappingURL=chunk-7OWE7WD6.js.map
+//# sourceMappingURL=chunk-7OWE7WD6.js.map

package/dist/chunk-7OWE7WD6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/node.ts","../src/core/edge.ts","../src/ontology/types.ts"],"names":["validateSchemaKeys"],"mappings":";;;;;;AAoCA,SAAS,kBAAA,CACP,QACA,IAAA,EACM;AACN,EAAA,uBAAA,CAAwB,MAAA,EAAQ,IAAA,EAAM,MAAA,EAAQ,kBAAkB,CAAA;AAClE;AAgBO,SAAS,UAAA,CAGd,MAAS,OAAA,EAA+C;AAGxD,EAAA,mBAAA,CAAoB,MAAM,WAAW,CAAA;AACrC,EAAA,kBAAA,CAAmB,OAAA,CAAQ,QAAQ,IAAI,CAAA;AACvC,EAAA,IAAI,OAAA,CAAQ,gBAAgB,MAAA,EAAW;AACrC,IAAA,eAAA,CAAgB,OAAA,CAAQ,WAAA,EAAa,aAAA,EAAe,CAAA,MAAA,EAAS,IAAI,CAAA,CAAA,CAAG,CAAA;AAAA,EACtE;AAEA,EAAA,OAAO,OAAO,MAAA,CAAO;AAAA,IACnB,CAAC,eAAe,GAAG,IAAA;AAAA,IACnB,IAAA,EAAM,IAAA;AAAA,IACN,QAAQ,OAAA,CAAQ,MAAA;AAAA,IAChB,aAAa,OAAA,CAAQ,WAAA;AAAA,IACrB,aAAa,OAAA,CAAQ;AAAA,GACtB,CAAA;AACH;AC5BA,IAAM,YAAA,GAAe,CAAA,CAAE,MAAA,CAAO,EAAE,CAAA;AAOhC,SAASA,mBAAAA,CACP,QACA,IAAA,EACM;AACN,EAAA,uBAAA,CAAwB,MAAA,EAAQ,IAAA,EAAM,MAAA,EAAQ,kBAAkB,CAAA;AAClE;AAgDO,SAAS,UAAA,CAMd,MACA,OAAA,EACqD;AACrD,EAAA,MAAM,MAAA,GAAS,SAAS,MAAA,IAAU,YAAA;AAClC,EAAAA,mBAAAA,CAAmB,QAAQ,IAAI,CAAA;AAC/B,EAAA,IAAI,OAAA,EAAS,gBAAgB,MAAA,EAAW;AACtC,IAAA,eAAA,CAAgB,OAAA,CAAQ,WAAA,EAAa,aAAA,EAAe,CAAA,MAAA,EAAS,IAAI,CAAA,CAAA,CAAG,CAAA;AAAA,EACtE;AAEA,EAAA,OAAO,OAAO,MAAA,CAAO;AAAA,IACnB,CAAC,eAAe,GAAG,IAAA;AAAA,IACnB,IAAA,EAAM,IAAA;AAAA,IACN,MAAA;AAAA,IACA,aAAa,OAAA,EAAS,WAAA;AAAA,IACtB,aAAa,OAAA,EAAS,WAAA;AAAA,IACtB,MAAM,OAAA,EAAS,IAAA;AAAA,IACf,IAAI,OAAA,EAAS;AAAA,GACd,CAAA;AACH;;;AC7HO,IAAM,eAAA,GAAkB;AA+ExB,SAAS,WAAW,KAAA,EAAmC;AAC5D,EAAA,OACE,OAAO,UAAU,QAAA,IACjB,KAAA,KAAU,QACV,eAAA,IAAmB,KAAA,IAClB,KAAA,CAAkC,eAAe,CAAA,KAAM,IAAA;AAE5D;AAKO,SAAS,YAAY,SAAA,EAAiD;AAC3E,EAAA,IAAI,OAAO,cAAc,QAAA,EAAU;AACjC,IAAA,OAAO,SAAA;AAAA,EACT;AACA,EAAA,OAAO,SAAA,CAAU,IAAA;AACnB","file":"chunk-7OWE7WD6.js","sourcesContent":["import { type z } from \"zod\";\n\nimport { assertClaimAxisSafe } from \"../store/claims/axis\";\nimport {\n  assertSchemaKeysAreFree,\n  RESERVED_NODE_KEYS,\n} from \"../store/reserved-keys\";\nimport { assertJsonValue } from \"./json-value\";\nimport { type KindAnnotations, NODE_TYPE_BRAND, type NodeType } from \"./types\";\n\n// ============================================================\n// Node Factory Options\n// ============================================================\n\n/**\n * Options for defining a node type.\n */\nexport type DefineNodeOptions<S extends z.ZodObject<z.ZodRawShape>> = Readonly<{\n  /** Zod schema for node properties */\n  schema: S;\n  /** Optional description for documentation */\n  description?: string;\n  /**\n   * Consumer-owned structured annotations for the kind.\n   *\n   * Stored in the canonical schema and **participates in schema hashing** —\n   * any change bumps the schema version and shows up as a `safe`-severity\n   * diff in `getSchemaChanges`. See `KindAnnotations` for the contract.\n   */\n  annotations?: KindAnnotations;\n}>;\n\n// ============================================================\n// Node Factory\n// ============================================================\n\nfunction validateSchemaKeys(\n  schema: z.ZodObject<z.ZodRawShape>,\n  name: string,\n): void {\n  assertSchemaKeysAreFree(\"Node\", name, schema, RESERVED_NODE_KEYS);\n}\n\n/**\n * Creates a node type definition.\n *\n * @example\n * ```typescript\n * const Person = defineNode(\"Person\", {\n *   schema: z.object({\n *     fullName: z.string().min(1),\n *     email: z.string().email().optional(),\n *   }),\n *   description: \"A person in the system\",\n * });\n * ```\n */\nexport function defineNode<\n  K extends string,\n  S extends z.ZodObject<z.ZodRawShape>,\n>(name: K, options: DefineNodeOptions<S>): NodeType<K, S> {\n  // A kind name is a claim axis, so it may not contain the code point reserved\n  // for building the axes that are not kinds.\n  assertClaimAxisSafe(name, \"Node kind\");\n  validateSchemaKeys(options.schema, name);\n  if (options.annotations !== undefined) {\n    assertJsonValue(options.annotations, \"annotations\", `Node \"${name}\"`);\n  }\n\n  return Object.freeze({\n    [NODE_TYPE_BRAND]: true as const,\n    kind: name,\n    schema: options.schema,\n    description: options.description,\n    annotations: options.annotations,\n  });\n}\n","import { z } from \"zod\";\n\nimport {\n  assertSchemaKeysAreFree,\n  RESERVED_EDGE_KEYS,\n} from \"../store/reserved-keys\";\nimport { assertJsonValue } from \"./json-value\";\nimport {\n  EDGE_TYPE_BRAND,\n  type EdgeType,\n  type KindAnnotations,\n  type NodeType,\n} from \"./types\";\n\n// ============================================================\n// Edge Factory Options\n// ============================================================\n\n/**\n * Options for defining an edge type.\n */\nexport type DefineEdgeOptions<\n  S extends z.ZodObject<z.ZodRawShape>,\n  From extends readonly NodeType[] | undefined = undefined,\n  To extends readonly NodeType[] | undefined = undefined,\n> = Readonly<{\n  /** Zod schema for edge properties (defaults to empty object) */\n  schema?: S;\n  /** Optional description for documentation */\n  description?: string;\n  /**\n   * Consumer-owned structured annotations for the kind.\n   *\n   * Stored in the canonical schema and **participates in schema hashing** —\n   * any change bumps the schema version and shows up as a `safe`-severity\n   * diff in `getSchemaChanges`. See `KindAnnotations` for the contract.\n   */\n  annotations?: KindAnnotations;\n  /** Node types that can be the source of this edge (domain constraint) */\n  from?: From;\n  /** Node types that can be the target of this edge (range constraint) */\n  to?: To;\n}>;\n\n// ============================================================\n// Empty Schema\n// ============================================================\n\nconst EMPTY_SCHEMA = z.object({});\ntype EmptySchema = typeof EMPTY_SCHEMA;\n\n// ============================================================\n// Edge Factory\n// ============================================================\n\nfunction validateSchemaKeys(\n  schema: z.ZodObject<z.ZodRawShape>,\n  name: string,\n): void {\n  assertSchemaKeysAreFree(\"Edge\", name, schema, RESERVED_EDGE_KEYS);\n}\n\n/**\n * Creates an edge type definition.\n *\n * @example\n * ```typescript\n * // Edge with no properties\n * const hasEpisode = defineEdge(\"hasEpisode\");\n *\n * // Edge with properties\n * const employedAt = defineEdge(\"employedAt\", {\n *   schema: z.object({\n *     isPrimary: z.boolean().default(true),\n *     startedAt: z.date(),\n *   }),\n *   description: \"Employment relationship\",\n * });\n *\n * // Edge with domain/range constraints (can be used directly in defineGraph)\n * const worksAt = defineEdge(\"worksAt\", {\n *   schema: z.object({ role: z.string() }),\n *   from: [Person],\n *   to: [Company],\n * });\n * ```\n */\n// Overload: no options - returns edge without domain/range\nexport function defineEdge<K extends string>(name: K): EdgeType<K, EmptySchema>;\n\n// Overload: options with both from and to - returns edge with domain/range\nexport function defineEdge<\n  K extends string,\n  S extends z.ZodObject<z.ZodRawShape>,\n  From extends readonly NodeType[],\n  To extends readonly NodeType[],\n>(\n  name: K,\n  options: DefineEdgeOptions<S, From, To> & { from: From; to: To },\n): EdgeType<K, S, From, To>;\n\n// Overload: options without from/to - returns edge without domain/range\nexport function defineEdge<\n  K extends string,\n  S extends z.ZodObject<z.ZodRawShape>,\n>(name: K, options: DefineEdgeOptions<S>): EdgeType<K, S>;\n\n// Implementation\nexport function defineEdge<\n  K extends string,\n  S extends z.ZodObject<z.ZodRawShape>,\n  From extends readonly NodeType[] | undefined,\n  To extends readonly NodeType[] | undefined,\n>(\n  name: K,\n  options?: DefineEdgeOptions<S, From, To>,\n): EdgeType<K, S, From, To> | EdgeType<K, EmptySchema> {\n  const schema = options?.schema ?? EMPTY_SCHEMA;\n  validateSchemaKeys(schema, name);\n  if (options?.annotations !== undefined) {\n    assertJsonValue(options.annotations, \"annotations\", `Edge \"${name}\"`);\n  }\n\n  return Object.freeze({\n    [EDGE_TYPE_BRAND]: true as const,\n    kind: name,\n    schema,\n    description: options?.description,\n    annotations: options?.annotations,\n    from: options?.from,\n    to: options?.to,\n  }) as EdgeType<K, S, From, To> | EdgeType<K, EmptySchema>;\n}\n","import { type EdgeType, type NodeType } from \"../core/types\";\n\n// ============================================================\n// Brand Key\n// ============================================================\n\n/** Brand key for MetaEdge */\nexport const META_EDGE_BRAND = \"__metaEdge\" as const;\n\n// ============================================================\n// Inference Types\n// ============================================================\n\n/**\n * How a meta-edge affects queries and validation.\n */\nexport type InferenceType =\n  | \"subsumption\" // Query for X includes instances of subclasses\n  | \"hierarchy\" // Enables broader/narrower traversal\n  | \"substitution\" // Can substitute equivalent types\n  | \"constraint\" // Validation rules\n  | \"composition\" // Part-whole navigation\n  | \"association\" // Discovery/recommendation\n  | \"none\"; // No automatic inference\n\n// ============================================================\n// Meta-Edge Properties\n// ============================================================\n\n/**\n * Properties of a meta-edge.\n */\nexport type MetaEdgeProperties = Readonly<{\n  transitive: boolean; // A→B, B→C implies A→C\n  symmetric: boolean; // A→B implies B→A\n  reflexive: boolean; // A→A is always true\n  inverse: string | undefined; // Name of inverse meta-edge\n  inference: InferenceType; // How this affects queries\n  description: string | undefined;\n}>;\n\n// ============================================================\n// Meta-Edge Type\n// ============================================================\n\n/**\n * A meta-edge definition.\n *\n * Meta-edges represent type-level relationships (between kinds),\n * not instance-level relationships (between nodes).\n */\nexport type MetaEdge<K extends string = string> = Readonly<{\n  [META_EDGE_BRAND]: true;\n  name: K;\n  properties: MetaEdgeProperties;\n}>;\n\n// ============================================================\n// Ontology Relation\n// ============================================================\n\n/**\n * A relation in the ontology (instance of meta-edge between types).\n *\n * @example\n * ```typescript\n * // Podcast subClassOf Media\n * subClassOf(Podcast, Media)\n *\n * // Person equivalentTo schema:Person\n * equivalentTo(Person, \"https://schema.org/Person\")\n * ```\n */\nexport type OntologyRelation = Readonly<{\n  metaEdge: MetaEdge;\n  from: NodeType | EdgeType | string; // string for external IRIs\n  to: NodeType | EdgeType | string;\n}>;\n\n// ============================================================\n// Type Guards\n// ============================================================\n\n/**\n * Checks if a value is a MetaEdge.\n */\nexport function isMetaEdge(value: unknown): value is MetaEdge {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    META_EDGE_BRAND in value &&\n    (value as Record<string, unknown>)[META_EDGE_BRAND] === true\n  );\n}\n\n/**\n * Gets the type name from a NodeType, EdgeType, or IRI string.\n */\nexport function getTypeName(typeOrIri: NodeType | EdgeType | string): string {\n  if (typeof typeOrIri === \"string\") {\n    return typeOrIri;\n  }\n  return typeOrIri.kind;\n}\n"]}

package/dist/chunk-7PRMDZIA.cjs

@@ -0,0 +1,182 @@
+'use strict';
+
+var chunkZBFZGLZE_cjs = require('./chunk-ZBFZGLZE.cjs');
+var chunkLLVOQOWE_cjs = require('./chunk-LLVOQOWE.cjs');
+var chunkX4GDXBOP_cjs = require('./chunk-X4GDXBOP.cjs');
+var chunkN66HCGCY_cjs = require('./chunk-N66HCGCY.cjs');
+
+// src/store/claims/backing.ts
+var CLAIM_MEMBER_NAMES = [
+  "claimEdgeCardinality",
+  "claimEdgeCardinalityBatch",
+  "purgeEdgeClaims",
+  "hardDeleteUniquesByConcreteKind"
+];
+function claimSupport(target) {
+  const declared = target.capabilities.constraintClaims === true;
+  const present = CLAIM_MEMBER_NAMES.filter(
+    (name) => target[name] !== void 0
+  );
+  if (declared && present.length === CLAIM_MEMBER_NAMES.length) {
+    return {
+      supported: true,
+      claims: {
+        claimEdgeCardinality: chunkN66HCGCY_cjs.requireDefined(target.claimEdgeCardinality),
+        claimEdgeCardinalityBatch: chunkN66HCGCY_cjs.requireDefined(
+          target.claimEdgeCardinalityBatch
+        ),
+        purgeEdgeClaims: chunkN66HCGCY_cjs.requireDefined(target.purgeEdgeClaims),
+        hardDeleteUniquesByConcreteKind: chunkN66HCGCY_cjs.requireDefined(
+          target.hardDeleteUniquesByConcreteKind
+        )
+      }
+    };
+  }
+  if (!declared && present.length === 0) return { supported: false };
+  const missing = CLAIM_MEMBER_NAMES.filter(
+    (name) => target[name] === void 0
+  );
+  throw new chunkX4GDXBOP_cjs.ConfigurationError(
+    declared ? `This backend declares \`constraintClaims: true\` but does not implement ${missing.join(", ")}. A declared constraint would then be written without the fence the declaration promises.` : `This backend implements ${present.join(", ")} but does not declare \`constraintClaims: true\`. Claim support is read from the declaration, so these members would never be called.`,
+    { code: "CONSTRAINT_CLAIM_SURFACE_MISMATCH", missing, present },
+    {
+      suggestion: declared ? "Implement the missing members, or drop `constraintClaims` from the backend's capabilities." : "Declare `constraintClaims: true` in the backend's capabilities, or drop the claim members."
+    }
+  );
+}
+
+// src/store/claims/edge-claims.ts
+var EDGE_CARDINALITY_SPECS = {
+  one: { keyShape: "from", claimsWhenBornEnded: true, holderLiveness: "live" },
+  unique: {
+    keyShape: "fromAndTo",
+    claimsWhenBornEnded: true,
+    holderLiveness: "live"
+  },
+  oneActive: {
+    keyShape: "from",
+    claimsWhenBornEnded: false,
+    holderLiveness: "liveAndActive"
+  }
+};
+function edgeCardinalityAxesForKind(edgeKind) {
+  return Object.keys(EDGE_CARDINALITY_SPECS).map(
+    (cardinality) => chunkLLVOQOWE_cjs.edgeCardinalityAxis(cardinality, edgeKind)
+  );
+}
+function edgeCardinalityClaimTarget(params) {
+  const spec = EDGE_CARDINALITY_SPECS[params.cardinality];
+  return {
+    relation: "edgeClaims",
+    graphId: params.graphId,
+    axis: chunkLLVOQOWE_cjs.edgeCardinalityAxis(params.cardinality, params.edgeKind),
+    key: spec.keyShape === "from" ? chunkLLVOQOWE_cjs.encodeTupleKey([params.fromKind, params.fromId]) : chunkLLVOQOWE_cjs.encodeTupleKey([
+      params.fromKind,
+      params.fromId,
+      params.toKind,
+      params.toId
+    ])
+  };
+}
+function edgeCardinalityClaim(cardinality, subject) {
+  if (cardinality === "many") return void 0;
+  if (!EDGE_CARDINALITY_SPECS[cardinality].claimsWhenBornEnded && subject.validTo !== void 0) {
+    return void 0;
+  }
+  return {
+    graphId: subject.graphId,
+    cardinality,
+    edgeKind: subject.kind,
+    edgeId: subject.id,
+    fromKind: subject.fromKind,
+    fromId: subject.fromId,
+    toKind: subject.toKind,
+    toId: subject.toId
+  };
+}
+function edgeClaimRefusal(params) {
+  const error = params.cardinality === "unique" ? chunkLLVOQOWE_cjs.checkUniqueEdge(
+    params.edgeKind,
+    params.fromKind,
+    params.fromId,
+    params.toKind,
+    params.toId,
+    1
+  ) : chunkLLVOQOWE_cjs.checkCardinality(
+    params.edgeKind,
+    params.fromKind,
+    params.fromId,
+    params.cardinality,
+    1,
+    true
+  );
+  return error ?? new chunkX4GDXBOP_cjs.CardinalityError({
+    edgeKind: params.edgeKind,
+    fromKind: params.fromKind,
+    fromId: params.fromId,
+    cardinality: params.cardinality,
+    existingCount: 1
+  });
+}
+async function withEdgeClaimRelationPrecondition(graphId, issue) {
+  try {
+    return await issue();
+  } catch (error) {
+    if (!chunkZBFZGLZE_cjs.isMissingTableError(error)) throw error;
+    throw new chunkX4GDXBOP_cjs.ConfigurationError(
+      "Enforcing a declared edge cardinality needs the edge claim relation (typegraph_edge_claims), and this database does not have it. Databases initialized before this relation existed were never sent its CREATE TABLE, because the bootstrap DDL runs only on first boot.",
+      { code: "EDGE_CLAIM_RELATION_MISSING", graphId },
+      {
+        cause: error,
+        suggestion: 'Run the generated migration SQL (generatePostgresMigrationSQL / generateSqliteMigrationSQL) against this database, or declare the edge kind `cardinality: "many"` and enforce the limit in application code.'
+      }
+    );
+  }
+}
+async function claimEdgeCardinality(backend, claim) {
+  const support = claimSupport(backend);
+  if (!support.supported) return;
+  const outcome = await withEdgeClaimRelationPrecondition(
+    claim.graphId,
+    () => support.claims.claimEdgeCardinality(claim)
+  );
+  if (outcome.status === "refused") throw edgeClaimRefusal(claim);
+}
+async function claimEdgeCardinalityBatch(backend, claims) {
+  if (claims.length === 0) return;
+  const support = claimSupport(backend);
+  if (!support.supported) return;
+  const ordered = claims.map((claim) => ({ claim, target: edgeCardinalityClaimTarget(claim) })).toSorted((left, right) => chunkLLVOQOWE_cjs.compareClaimTargets(left.target, right.target));
+  const graphId = ordered[0]?.claim.graphId ?? "";
+  const outcomes = await withEdgeClaimRelationPrecondition(
+    graphId,
+    () => support.claims.claimEdgeCardinalityBatch(
+      ordered.map((entry) => entry.claim)
+    )
+  );
+  for (const [index, outcome] of outcomes.entries()) {
+    const entry = ordered[index];
+    if (entry !== void 0 && outcome.status === "refused") {
+      throw edgeClaimRefusal(entry.claim);
+    }
+  }
+}
+async function purgeEdgeClaims(backend, graphId, edgeIds) {
+  if (edgeIds.length === 0) return;
+  const support = claimSupport(backend);
+  if (!support.supported) return;
+  await withEdgeClaimRelationPrecondition(
+    graphId,
+    () => support.claims.purgeEdgeClaims({ graphId, edgeIds })
+  );
+}
+
+exports.EDGE_CARDINALITY_SPECS = EDGE_CARDINALITY_SPECS;
+exports.claimEdgeCardinality = claimEdgeCardinality;
+exports.claimEdgeCardinalityBatch = claimEdgeCardinalityBatch;
+exports.edgeCardinalityAxesForKind = edgeCardinalityAxesForKind;
+exports.edgeCardinalityClaim = edgeCardinalityClaim;
+exports.edgeCardinalityClaimTarget = edgeCardinalityClaimTarget;
+exports.purgeEdgeClaims = purgeEdgeClaims;
+//# sourceMappingURL=chunk-7PRMDZIA.cjs.map
+//# sourceMappingURL=chunk-7PRMDZIA.cjs.map

package/dist/chunk-7PRMDZIA.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/store/claims/backing.ts","../src/store/claims/edge-claims.ts"],"names":["requireDefined","ConfigurationError","edgeCardinalityAxis","encodeTupleKey","checkUniqueEdge","checkCardinality","CardinalityError","isMissingTableError","compareClaimTargets"],"mappings":";;;;;;;;AAsGA,IAAM,kBAAA,GAAqB;AAAA,EACzB,sBAAA;AAAA,EACA,2BAAA;AAAA,EACA,iBAAA;AAAA,EACA;AACF,CAAA;AAqBO,SAAS,aACd,MAAA,EACc;AACd,EAAA,MAAM,QAAA,GAAW,MAAA,CAAO,YAAA,CAAa,gBAAA,KAAqB,IAAA;AAC1D,EAAA,MAAM,UAAU,kBAAA,CAAmB,MAAA;AAAA,IACjC,CAAC,IAAA,KAAS,MAAA,CAAO,IAAI,CAAA,KAAM;AAAA,GAC7B;AACA,EAAA,IAAI,QAAA,IAAY,OAAA,CAAQ,MAAA,KAAW,kBAAA,CAAmB,MAAA,EAAQ;AAC5D,IAAA,OAAO;AAAA,MACL,SAAA,EAAW,IAAA;AAAA,MACX,MAAA,EAAQ;AAAA,QACN,oBAAA,EAAsBA,gCAAA,CAAe,MAAA,CAAO,oBAAoB,CAAA;AAAA,QAChE,yBAAA,EAA2BA,gCAAA;AAAA,UACzB,MAAA,CAAO;AAAA,SACT;AAAA,QACA,eAAA,EAAiBA,gCAAA,CAAe,MAAA,CAAO,eAAe,CAAA;AAAA,QACtD,+BAAA,EAAiCA,gCAAA;AAAA,UAC/B,MAAA,CAAO;AAAA;AACT;AACF,KACF;AAAA,EACF;AACA,EAAA,IAAI,CAAC,YAAY,OAAA,CAAQ,MAAA,KAAW,GAAG,OAAO,EAAE,WAAW,KAAA,EAAM;AAEjE,EAAA,MAAM,UAAU,kBAAA,CAAmB,MAAA;AAAA,IACjC,CAAC,IAAA,KAAS,MAAA,CAAO,IAAI,CAAA,KAAM;AAAA,GAC7B;AACA,EAAA,MAAM,IAAIC,oCAAA;AAAA,IACR,QAAA,GACE,CAAA,wEAAA,EAA2E,OAAA,CAAQ,IAAA,CAAK,IAAI,CAAC,CAAA,yFAAA,CAAA,GAG7F,CAAA,wBAAA,EAA2B,OAAA,CAAQ,IAAA,CAAK,IAAI,CAAC,CAAA,qIAAA,CAAA;AAAA,IAG/C,EAAE,IAAA,EAAM,mCAAA,EAAqC,OAAA,EAAS,OAAA,EAAQ;AAAA,IAC9D;AAAA,MACE,UAAA,EACE,WACE,4FAAA,GACA;AAAA;AACN,GACF;AACF;;;AC7GO,IAAM,sBAAA,GAAyB;AAAA,EACpC,KAAK,EAAE,QAAA,EAAU,QAAQ,mBAAA,EAAqB,IAAA,EAAM,gBAAgB,MAAA,EAAO;AAAA,EAC3E,MAAA,EAAQ;AAAA,IACN,QAAA,EAAU,WAAA;AAAA,IACV,mBAAA,EAAqB,IAAA;AAAA,IACrB,cAAA,EAAgB;AAAA,GAClB;AAAA,EACA,SAAA,EAAW;AAAA,IACT,QAAA,EAAU,MAAA;AAAA,IACV,mBAAA,EAAqB,KAAA;AAAA,IACrB,cAAA,EAAgB;AAAA;AAEpB;AAGO,SAAS,2BACd,QAAA,EACmB;AACnB,EAAA,OAAO,MAAA,CAAO,IAAA,CAAK,sBAAsB,CAAA,CAAE,GAAA;AAAA,IAAI,CAAC,WAAA,KAC9CC,qCAAA,CAAoB,WAAA,EAAa,QAAQ;AAAA,GAC3C;AACF;AAWO,SAAS,2BACd,MAAA,EACa;AACb,EAAA,MAAM,IAAA,GAAO,sBAAA,CAAuB,MAAA,CAAO,WAAW,CAAA;AACtD,EAAA,OAAO;AAAA,IACL,QAAA,EAAU,YAAA;AAAA,IACV,SAAS,MAAA,CAAO,OAAA;AAAA,IAChB,IAAA,EAAMA,qCAAA,CAAoB,MAAA,CAAO,WAAA,EAAa,OAAO,QAAQ,CAAA;AAAA,IAC7D,GAAA,EACE,IAAA,CAAK,QAAA,KAAa,MAAA,GAChBC,gCAAA,CAAe,CAAC,MAAA,CAAO,QAAA,EAAU,MAAA,CAAO,MAAM,CAAC,CAAA,GAC/CA,gCAAA,CAAe;AAAA,MACb,MAAA,CAAO,QAAA;AAAA,MACP,MAAA,CAAO,MAAA;AAAA,MACP,MAAA,CAAO,MAAA;AAAA,MACP,MAAA,CAAO;AAAA,KACR;AAAA,GACP;AACF;AAwBO,SAAS,oBAAA,CACd,aACA,OAAA,EACwC;AACxC,EAAA,IAAI,WAAA,KAAgB,QAAQ,OAAO,MAAA;AACnC,EAAA,IACE,CAAC,sBAAA,CAAuB,WAAW,EAAE,mBAAA,IACrC,OAAA,CAAQ,YAAY,MAAA,EACpB;AACA,IAAA,OAAO,MAAA;AAAA,EACT;AACA,EAAA,OAAO;AAAA,IACL,SAAS,OAAA,CAAQ,OAAA;AAAA,IACjB,WAAA;AAAA,IACA,UAAU,OAAA,CAAQ,IAAA;AAAA,IAClB,QAAQ,OAAA,CAAQ,EAAA;AAAA,IAChB,UAAU,OAAA,CAAQ,QAAA;AAAA,IAClB,QAAQ,OAAA,CAAQ,MAAA;AAAA,IAChB,QAAQ,OAAA,CAAQ,MAAA;AAAA,IAChB,MAAM,OAAA,CAAQ;AAAA,GAChB;AACF;AAOA,SAAS,iBACP,MAAA,EACkB;AAClB,EAAA,MAAM,KAAA,GACJ,MAAA,CAAO,WAAA,KAAgB,QAAA,GACrBC,iCAAA;AAAA,IACE,MAAA,CAAO,QAAA;AAAA,IACP,MAAA,CAAO,QAAA;AAAA,IACP,MAAA,CAAO,MAAA;AAAA,IACP,MAAA,CAAO,MAAA;AAAA,IACP,MAAA,CAAO,IAAA;AAAA,IACP;AAAA,GACF,GACAC,kCAAA;AAAA,IACE,MAAA,CAAO,QAAA;AAAA,IACP,MAAA,CAAO,QAAA;AAAA,IACP,MAAA,CAAO,MAAA;AAAA,IACP,MAAA,CAAO,WAAA;AAAA,IACP,CAAA;AAAA,IACA;AAAA,GACF;AAIJ,EAAA,OACE,KAAA,IACA,IAAIC,kCAAA,CAAiB;AAAA,IACnB,UAAU,MAAA,CAAO,QAAA;AAAA,IACjB,UAAU,MAAA,CAAO,QAAA;AAAA,IACjB,QAAQ,MAAA,CAAO,MAAA;AAAA,IACf,aAAa,MAAA,CAAO,WAAA;AAAA,IACpB,aAAA,EAAe;AAAA,GAChB,CAAA;AAEL;AAYA,eAAe,iCAAA,CACb,SACA,KAAA,EACY;AACZ,EAAA,IAAI;AACF,IAAA,OAAO,MAAM,KAAA,EAAM;AAAA,EACrB,SAAS,KAAA,EAAO;AACd,IAAA,IAAI,CAACC,qCAAA,CAAoB,KAAK,CAAA,EAAG,MAAM,KAAA;AACvC,IAAA,MAAM,IAAIN,oCAAA;AAAA,MACR,0QAAA;AAAA,MAIA,EAAE,IAAA,EAAM,6BAAA,EAA+B,OAAA,EAAQ;AAAA,MAC/C;AAAA,QACE,KAAA,EAAO,KAAA;AAAA,QACP,UAAA,EACE;AAAA;AAIJ,KACF;AAAA,EACF;AACF;AAcA,eAAsB,oBAAA,CACpB,SACA,KAAA,EACe;AACf,EAAA,MAAM,OAAA,GAAU,aAAa,OAAO,CAAA;AACpC,EAAA,IAAI,CAAC,QAAQ,SAAA,EAAW;AACxB,EAAA,MAAM,UAAU,MAAM,iCAAA;AAAA,IAAkC,KAAA,CAAM,OAAA;AAAA,IAAS,MACrE,OAAA,CAAQ,MAAA,CAAO,oBAAA,CAAqB,KAAK;AAAA,GAC3C;AACA,EAAA,IAAI,OAAA,CAAQ,MAAA,KAAW,SAAA,EAAW,MAAM,iBAAiB,KAAK,CAAA;AAChE;AAYA,eAAsB,yBAAA,CACpB,SACA,MAAA,EACe;AACf,EAAA,IAAI,MAAA,CAAO,WAAW,CAAA,EAAG;AACzB,EAAA,MAAM,OAAA,GAAU,aAAa,OAAO,CAAA;AACpC,EAAA,IAAI,CAAC,QAAQ,SAAA,EAAW;AACxB,EAAA,MAAM,OAAA,GAAU,OACb,GAAA,CAAI,CAAC,WAAW,EAAE,KAAA,EAAO,MAAA,EAAQ,0BAAA,CAA2B,KAAK,CAAA,GAAI,CAAA,CACrE,QAAA,CAAS,CAAC,IAAA,EAAM,KAAA,KAAUO,sCAAoB,IAAA,CAAK,MAAA,EAAQ,KAAA,CAAM,MAAM,CAAC,CAAA;AAC3E,EAAA,MAAM,OAAA,GAAU,OAAA,CAAQ,CAAC,CAAA,EAAG,MAAM,OAAA,IAAW,EAAA;AAC7C,EAAA,MAAM,WAAW,MAAM,iCAAA;AAAA,IAAkC,OAAA;AAAA,IAAS,MAChE,QAAQ,MAAA,CAAO,yBAAA;AAAA,MACb,OAAA,CAAQ,GAAA,CAAI,CAAC,KAAA,KAAU,MAAM,KAAK;AAAA;AACpC,GACF;AACA,EAAA,KAAA,MAAW,CAAC,KAAA,EAAO,OAAO,CAAA,IAAK,QAAA,CAAS,SAAQ,EAAG;AACjD,IAAA,MAAM,KAAA,GAAQ,QAAQ,KAAK,CAAA;AAC3B,IAAA,IAAI,KAAA,KAAU,MAAA,IAAa,OAAA,CAAQ,MAAA,KAAW,SAAA,EAAW;AACvD,MAAA,MAAM,gBAAA,CAAiB,MAAM,KAAK,CAAA;AAAA,IACpC;AAAA,EACF;AACF;AAUA,eAAsB,eAAA,CACpB,OAAA,EACA,OAAA,EACA,OAAA,EACe;AACf,EAAA,IAAI,OAAA,CAAQ,WAAW,CAAA,EAAG;AAC1B,EAAA,MAAM,OAAA,GAAU,aAAa,OAAO,CAAA;AACpC,EAAA,IAAI,CAAC,QAAQ,SAAA,EAAW;AACxB,EAAA,MAAM,iCAAA;AAAA,IAAkC,OAAA;AAAA,IAAS,MAC/C,OAAA,CAAQ,MAAA,CAAO,gBAAgB,EAAE,OAAA,EAAS,SAAS;AAAA,GACrD;AACF","file":"chunk-7PRMDZIA.cjs","sourcesContent":["/**\n * What backs each constraint fence class.\n *\n * A constrained write is fenced by one of two things: a per-graph lock that\n * serializes the probe with the write it guards, or a CLAIM row whose primary\n * key refuses a second claimant outright. The second is strictly stronger — it\n * holds without a lock, which is what an import needs — and this module records\n * which class has reached it, so \"is this fence a lock or a key?\" is answered\n * from one table rather than inferred from whichever module a reader lands in.\n *\n * It also owns the runtime half of the same question — {@link claimSupport},\n * the one reader of \"can THIS object hold a claim?\" — so the declaration and\n * the surface are reconciled in one place rather than at each claim site.\n */\nimport {\n  type GraphBackend,\n  type TransactionBackend,\n} from \"../../backend/types\";\nimport { ConfigurationError } from \"../../errors\";\nimport { requireDefined } from \"../../utils/presence\";\n\n/**\n * The runtime extent of the fence classes. {@link ConstraintFenceReason} is\n * DERIVED from it rather than declared beside it: a union type has no runtime\n * extent, so a totality test over a map keyed by the union could only iterate\n * that map's own keys and would be trivially true.\n */\nexport const CONSTRAINT_FENCE_REASONS = [\n  \"edgeCardinality\",\n  \"edgeMatchKeyConvergence\",\n  \"nodeDisjointness\",\n  \"nodeUniquenessClaim\",\n  \"nodeUniquenessScope\",\n] as const;\n\n/**\n * WHICH declared constraint makes a write constrained.\n *\n * The classification names the reason rather than answering yes/no, because\n * the reason is load-bearing twice over: it is what the fence is taken FOR, and\n * — on a backend that cannot hold the fence — it is what the refusal has to\n * tell the caller. \"This backend cannot fence constrained writes\" is unusable\n * advice; \"your `cardinality: 'one'` edge cannot be enforced here\" is\n * actionable, and only the classifier knows which it was.\n */\nexport type ConstraintFenceReason = (typeof CONSTRAINT_FENCE_REASONS)[number];\n\n/** The relation whose key fences a class, or `lockOnly` when nothing does yet. */\ntype ConstraintFenceBacking = \"uniques\" | \"edgeClaims\" | \"lockOnly\";\n\n/**\n * Which claim relation backs each fence class. The `satisfies` forces totality:\n * a new reason cannot be added without stating what backs it.\n *\n * `nodeUniquenessScope` is `\"uniques\"` because a shared-scope claim is now\n * written at the scope's axis, so two writers of two kinds in one hierarchy\n * contend for one row. `nodeUniquenessClaim` is the same relation seen from the\n * other side: the claim row is the fence, and the class exists because a write\n * that must issue it BEFORE the row it gates needs a transaction to undo the\n * pair together — which is what its refusal names. `nodeDisjointness` is the\n * same relation again, at a third kind of axis: a claim keyed on the declared\n * PAIR and on the node's id, which is the axis disjointness actually declares\n * and the one the nodes primary key `(graph_id, kind, id)` cannot fence.\n * `edgeCardinality` is the other relation: a claim keyed on\n * `(<cardinality>:<edgeKind>, endpoint identity)`, which is the axis the\n * declaration actually spans and the one the edges primary key `(graph_id, id)`\n * cannot fence. The classes still marked `lockOnly` are fenced by the per-graph\n * write lock alone, which is why they are also the classes a non-transactional\n * backend refuses.\n */\nexport const CONSTRAINT_FENCE_BACKING = {\n  edgeCardinality: \"edgeClaims\",\n  edgeMatchKeyConvergence: \"lockOnly\",\n  nodeDisjointness: \"uniques\",\n  nodeUniquenessClaim: \"uniques\",\n  nodeUniquenessScope: \"uniques\",\n} as const satisfies Record<ConstraintFenceReason, ConstraintFenceBacking>;\n\n/**\n * The claim members, narrowed to present. A caller holding this has been told\n * by ONE reader that this object both declares claim support and carries every\n * member that support consists of.\n */\ntype RequiredClaimMembers = Readonly<{\n  claimEdgeCardinality: NonNullable<GraphBackend[\"claimEdgeCardinality\"]>;\n  claimEdgeCardinalityBatch: NonNullable<\n    GraphBackend[\"claimEdgeCardinalityBatch\"]\n  >;\n  purgeEdgeClaims: NonNullable<GraphBackend[\"purgeEdgeClaims\"]>;\n  hardDeleteUniquesByConcreteKind: NonNullable<\n    GraphBackend[\"hardDeleteUniquesByConcreteKind\"]\n  >;\n}>;\n\n/** The decision {@link claimSupport} returns — never a flag a caller re-derives. */\nexport type ClaimSupport =\n  /** Capability declared AND every claim member present: the members, narrowed. */\n  | Readonly<{ supported: true; claims: RequiredClaimMembers }>\n  /** Capability absent or false AND no claim member present: the declared gap. */\n  | Readonly<{ supported: false }>;\n\n/** The members `constraintClaims: true` promises, in one list. */\nconst CLAIM_MEMBER_NAMES = [\n  \"claimEdgeCardinality\",\n  \"claimEdgeCardinalityBatch\",\n  \"purgeEdgeClaims\",\n  \"hardDeleteUniquesByConcreteKind\",\n] as const satisfies readonly (keyof RequiredClaimMembers)[];\n\n/**\n * THE one reader of \"can this object hold a claim?\", asked about the object the\n * claim is about to be written to.\n *\n * It reads BOTH the declaration and the surface, and returns the decision — the\n * narrowed members — rather than a boolean a caller then re-derives the members\n * from. Reading only `capabilities` would let a projection that forwards the\n * capability verbatim while dropping a method produce a verdict about a\n * different object than the write goes to; reading only member presence would\n * be the `undefined`-means-something inference the capability exists to\n * replace.\n *\n * @throws ConfigurationError (`CONSTRAINT_CLAIM_SURFACE_MISMATCH`) when the two\n *   disagree in either direction — a backend or projection declaring\n *   `constraintClaims: true` while missing a member, or one shipping the\n *   members without declaring the capability. Both are defects in the object,\n *   and a silent fallback would unfence exactly the writes the capability\n *   exists to fence.\n */\nexport function claimSupport(\n  target: GraphBackend | TransactionBackend,\n): ClaimSupport {\n  const declared = target.capabilities.constraintClaims === true;\n  const present = CLAIM_MEMBER_NAMES.filter(\n    (name) => target[name] !== undefined,\n  );\n  if (declared && present.length === CLAIM_MEMBER_NAMES.length) {\n    return {\n      supported: true,\n      claims: {\n        claimEdgeCardinality: requireDefined(target.claimEdgeCardinality),\n        claimEdgeCardinalityBatch: requireDefined(\n          target.claimEdgeCardinalityBatch,\n        ),\n        purgeEdgeClaims: requireDefined(target.purgeEdgeClaims),\n        hardDeleteUniquesByConcreteKind: requireDefined(\n          target.hardDeleteUniquesByConcreteKind,\n        ),\n      },\n    };\n  }\n  if (!declared && present.length === 0) return { supported: false };\n\n  const missing = CLAIM_MEMBER_NAMES.filter(\n    (name) => target[name] === undefined,\n  );\n  throw new ConfigurationError(\n    declared ?\n      `This backend declares \\`constraintClaims: true\\` but does not implement ${missing.join(\", \")}. ` +\n        \"A declared constraint would then be written without the fence the \" +\n        \"declaration promises.\"\n    : `This backend implements ${present.join(\", \")} but does not declare \\`constraintClaims: true\\`. ` +\n        \"Claim support is read from the declaration, so these members would \" +\n        \"never be called.\",\n    { code: \"CONSTRAINT_CLAIM_SURFACE_MISMATCH\", missing, present },\n    {\n      suggestion:\n        declared ?\n          \"Implement the missing members, or drop `constraintClaims` from the backend's capabilities.\"\n        : \"Declare `constraintClaims: true` in the backend's capabilities, or drop the claim members.\",\n    },\n  );\n}\n","/**\n * Edge claims — what an edge write reserves on a declared cardinality axis.\n *\n * A declared cardinality is a predicate over `(kind, from)` or\n * `(kind, from, to)`, and the edges relation's only uniqueness is its\n * `(graph_id, id)` primary key, so nothing in the schema re-decides at write\n * time what the probe decided at read time. This module is the reservation that\n * does: one row per `(graph_id, axis, key)` in `typegraph_edge_claims`, whose\n * primary key refuses a second concurrent claimant.\n *\n * The claim needs no release path. A claim whose holder is no longer live (or,\n * for `oneActive`, no longer active) fails the liveness predicate the takeover\n * statement carries and is taken over in place, so the fence never depends on\n * any delete path having run. `purgeEdgeClaims` exists to bound table growth,\n * not to make the fence correct.\n */\nimport {\n  type ClaimEdgeCardinalityParams,\n  type GraphBackend,\n  type InsertEdgeParams,\n  type TransactionBackend,\n} from \"../../backend/types\";\nimport { checkCardinality, checkUniqueEdge } from \"../../constraints\";\nimport { type Cardinality } from \"../../core/types\";\nimport { CardinalityError, ConfigurationError } from \"../../errors\";\nimport { isMissingTableError } from \"../../utils/sql-errors\";\nimport { encodeTupleKey } from \"../../utils/tuple-key\";\nimport {\n  type ClaimTarget,\n  compareClaimTargets,\n  edgeCardinalityAxis,\n} from \"./axis\";\nimport { claimSupport } from \"./backing\";\n\n/** A cardinality that declares something — `many` declares nothing. */\nexport type ConstrainedCardinality = Exclude<Cardinality, \"many\">;\n\n/**\n * What one declared cardinality means to every layer that has to agree about\n * it: which endpoints its axis key covers, whether an edge born already ended\n * claims at all, and what a holder must still BE for its claim to stand.\n */\nexport type EdgeCardinalitySpec = Readonly<{\n  /** Which endpoints the axis key covers. */\n  keyShape: \"from\" | \"fromAndTo\";\n  /** Whether a new edge that is born ENDED makes a claim at all. */\n  claimsWhenBornEnded: boolean;\n  /** What a holder must still be for its claim to stand. */\n  holderLiveness: \"live\" | \"liveAndActive\";\n}>;\n\n/**\n * THE table both renderers of the cardinality predicate read: the TypeScript\n * probe ({@link file://../constraints.ts checkCardinalityConstraint}) and the\n * SQL takeover statement\n * ({@link file://../../backend/drizzle/operations/edge-claims.ts}).\n *\n * Two renderers, one table, exhaustive by type: a new cardinality cannot be\n * added without stating all three facts, and the probe and the fence cannot\n * disagree about any of them — a disagreement is exactly the shape where the\n * probe accepts a write the fence then refuses forever (or the reverse).\n */\nexport const EDGE_CARDINALITY_SPECS = {\n  one: { keyShape: \"from\", claimsWhenBornEnded: true, holderLiveness: \"live\" },\n  unique: {\n    keyShape: \"fromAndTo\",\n    claimsWhenBornEnded: true,\n    holderLiveness: \"live\",\n  },\n  oneActive: {\n    keyShape: \"from\",\n    claimsWhenBornEnded: false,\n    holderLiveness: \"liveAndActive\",\n  },\n} as const satisfies Record<ConstrainedCardinality, EdgeCardinalitySpec>;\n\n/** Every axis an edge kind's claims can sit on, for housekeeping reaps. */\nexport function edgeCardinalityAxesForKind(\n  edgeKind: string,\n): readonly string[] {\n  return Object.keys(EDGE_CARDINALITY_SPECS).map((cardinality) =>\n    edgeCardinalityAxis(cardinality, edgeKind),\n  );\n}\n\n/**\n * THE claim row one edge write reserves: its axis, and the endpoint identity\n * the axis is keyed by.\n *\n * The key is {@link encodeTupleKey}, not a delimiter join: node ids are\n * arbitrary caller data (only kind names pass `assertClaimAxisSafe`), and a\n * delimiter that a value may contain makes two different endpoint tuples\n * collapse onto one key — which would refuse a write no constraint forbids.\n */\nexport function edgeCardinalityClaimTarget(\n  params: ClaimEdgeCardinalityParams,\n): ClaimTarget {\n  const spec = EDGE_CARDINALITY_SPECS[params.cardinality];\n  return {\n    relation: \"edgeClaims\",\n    graphId: params.graphId,\n    axis: edgeCardinalityAxis(params.cardinality, params.edgeKind),\n    key:\n      spec.keyShape === \"from\" ?\n        encodeTupleKey([params.fromKind, params.fromId])\n      : encodeTupleKey([\n          params.fromKind,\n          params.fromId,\n          params.toKind,\n          params.toId,\n        ]),\n  };\n}\n\n/**\n * The fields a claim is decided from: the row's identity and the upper bound\n * that decides whether it joins an active-only population. Narrower than\n * {@link InsertEdgeParams} on purpose — a resurrect has no insert params to\n * hand over, and passing an invented `props` to satisfy a type would be a\n * fabricated value a reader has to check is unread.\n */\nexport type EdgeClaimSubject = Pick<\n  InsertEdgeParams,\n  \"graphId\" | \"id\" | \"kind\" | \"fromKind\" | \"fromId\" | \"toKind\" | \"toId\"\n> &\n  Readonly<{ validTo?: string }>;\n\n/**\n * THE claim an edge insert owes, or `undefined` when it owes none.\n *\n * `many` declares no constraint, and an `oneActive` edge born already ended\n * joins no active population — `claimsWhenBornEnded` is the one place that\n * second exemption is written down, and the probe reads the same field, so the\n * two cannot drift into \"probed but unclaimed\" (a silent hole) or \"claimed but\n * unprobed\" (a refusal with no matching error).\n */\nexport function edgeCardinalityClaim(\n  cardinality: Cardinality,\n  subject: EdgeClaimSubject,\n): ClaimEdgeCardinalityParams | undefined {\n  if (cardinality === \"many\") return undefined;\n  if (\n    !EDGE_CARDINALITY_SPECS[cardinality].claimsWhenBornEnded &&\n    subject.validTo !== undefined\n  ) {\n    return undefined;\n  }\n  return {\n    graphId: subject.graphId,\n    cardinality,\n    edgeKind: subject.kind,\n    edgeId: subject.id,\n    fromKind: subject.fromKind,\n    fromId: subject.fromId,\n    toKind: subject.toKind,\n    toId: subject.toId,\n  };\n}\n\n/**\n * The refusal a lost claim raises — built by the SAME owners the probe calls,\n * so the fence's error is `instanceof` the same class and carries the same\n * payload as the probe's for the same violation (I3).\n */\nfunction edgeClaimRefusal(\n  params: ClaimEdgeCardinalityParams,\n): CardinalityError {\n  const error =\n    params.cardinality === \"unique\" ?\n      checkUniqueEdge(\n        params.edgeKind,\n        params.fromKind,\n        params.fromId,\n        params.toKind,\n        params.toId,\n        1,\n      )\n    : checkCardinality(\n        params.edgeKind,\n        params.fromKind,\n        params.fromId,\n        params.cardinality,\n        1,\n        true,\n      );\n  // Both owners refuse for an incumbent count of one on every constrained\n  // cardinality; the fallback keeps the return type honest without inventing a\n  // second spelling of the message.\n  return (\n    error ??\n    new CardinalityError({\n      edgeKind: params.edgeKind,\n      fromKind: params.fromKind,\n      fromId: params.fromId,\n      cardinality: params.cardinality,\n      existingCount: 1,\n    })\n  );\n}\n\n/**\n * Converts the engine's \"relation does not exist\" into a typed precondition\n * error naming the relation and the way to create it.\n *\n * Checked at FIRST USE rather than at store construction: a graph with no\n * constrained edge kind never issues a claim and must not pay a catalog read\n * for a relation it will never touch. A database bootstrapped before this\n * relation existed reaches it here, on the first constrained edge write, with\n * an error that says what to run instead of an opaque driver failure.\n */\nasync function withEdgeClaimRelationPrecondition<T>(\n  graphId: string,\n  issue: () => Promise<T>,\n): Promise<T> {\n  try {\n    return await issue();\n  } catch (error) {\n    if (!isMissingTableError(error)) throw error;\n    throw new ConfigurationError(\n      \"Enforcing a declared edge cardinality needs the edge claim relation \" +\n        \"(typegraph_edge_claims), and this database does not have it. \" +\n        \"Databases initialized before this relation existed were never sent \" +\n        \"its CREATE TABLE, because the bootstrap DDL runs only on first boot.\",\n      { code: \"EDGE_CLAIM_RELATION_MISSING\", graphId },\n      {\n        cause: error,\n        suggestion:\n          \"Run the generated migration SQL (generatePostgresMigrationSQL / \" +\n          \"generateSqliteMigrationSQL) against this database, or declare the \" +\n          'edge kind `cardinality: \"many\"` and enforce the limit in ' +\n          \"application code.\",\n      },\n    );\n  }\n}\n\n/** The backend an edge claim is written to — the object inside the transaction. */\ntype ClaimTargetBackend = GraphBackend | TransactionBackend;\n\n/**\n * Issues ONE edge cardinality claim against the object the row write goes to,\n * refusing with the declared error when a live incumbent holds the axis.\n *\n * A backend that declares no claim support writes no claim and keeps exactly\n * the fence it has today (the per-graph write lock around the probe) — a\n * declared gap with a parity-matrix row, never a silent unfencing and never a\n * new refusal.\n */\nexport async function claimEdgeCardinality(\n  backend: ClaimTargetBackend,\n  claim: ClaimEdgeCardinalityParams,\n): Promise<void> {\n  const support = claimSupport(backend);\n  if (!support.supported) return;\n  const outcome = await withEdgeClaimRelationPrecondition(claim.graphId, () =>\n    support.claims.claimEdgeCardinality(claim),\n  );\n  if (outcome.status === \"refused\") throw edgeClaimRefusal(claim);\n}\n\n/**\n * Issues a batch's claims as ONE statement, entries sorted by\n * {@link compareClaimTargets}.\n *\n * One statement takes its row locks in a fixed order, so a batch cannot\n * deadlock against itself; sorting is what stops two writers of the same two\n * axes from taking them in opposite orders. In-batch duplicates are refused\n * before this by the batch validation wrapper's pending-cardinality state, so\n * the backend's duplicate-conflict-target guard stays a defensive invariant.\n */\nexport async function claimEdgeCardinalityBatch(\n  backend: ClaimTargetBackend,\n  claims: readonly ClaimEdgeCardinalityParams[],\n): Promise<void> {\n  if (claims.length === 0) return;\n  const support = claimSupport(backend);\n  if (!support.supported) return;\n  const ordered = claims\n    .map((claim) => ({ claim, target: edgeCardinalityClaimTarget(claim) }))\n    .toSorted((left, right) => compareClaimTargets(left.target, right.target));\n  const graphId = ordered[0]?.claim.graphId ?? \"\";\n  const outcomes = await withEdgeClaimRelationPrecondition(graphId, () =>\n    support.claims.claimEdgeCardinalityBatch(\n      ordered.map((entry) => entry.claim),\n    ),\n  );\n  for (const [index, outcome] of outcomes.entries()) {\n    const entry = ordered[index];\n    if (entry !== undefined && outcome.status === \"refused\") {\n      throw edgeClaimRefusal(entry.claim);\n    }\n  }\n}\n\n/**\n * Housekeeping: drops the claim rows named edges held.\n *\n * Never a fence and never load-bearing — a claim whose holder is gone already\n * fails the takeover statement's liveness predicate, so the axis is reusable\n * whether or not this ran. It exists so a hard delete does not leave a row\n * behind forever. A backend without claim support has nothing to purge.\n */\nexport async function purgeEdgeClaims(\n  backend: ClaimTargetBackend,\n  graphId: string,\n  edgeIds: readonly string[],\n): Promise<void> {\n  if (edgeIds.length === 0) return;\n  const support = claimSupport(backend);\n  if (!support.supported) return;\n  await withEdgeClaimRelationPrecondition(graphId, () =>\n    support.claims.purgeEdgeClaims({ graphId, edgeIds }),\n  );\n}\n"]}

package/dist/{chunk-CHAOFCHV.js → chunk-AH2A74OZ.js}

@@ -1,4 +1,4 @@
-import { unwrap, validateGraphExtension } from './chunk-D5R42W5D.js';
+import { unwrap, validateGraphExtension } from './chunk-XZW2CTNO.js';
 
 // src/graph-extension/define-graph-extension.ts
 function defineGraphExtension(input) {
@@ -6,5 +6,5 @@ function defineGraphExtension(input) {
 }
 
 export { defineGraphExtension };
-//# sourceMappingURL=chunk-CHAOFCHV.js.map
-//# sourceMappingURL=chunk-CHAOFCHV.js.map
+//# sourceMappingURL=chunk-AH2A74OZ.js.map
+//# sourceMappingURL=chunk-AH2A74OZ.js.map

package/dist/{chunk-CHAOFCHV.js.map → chunk-AH2A74OZ.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/graph-extension/define-graph-extension.ts"],"names":[],"mappings":";;;AAyDO,SAAS,qBAAqB,KAAA,EAAuC;AAC1E,EAAA,OAAO,OAAO,sBAAA,CAAuB,KAAA,EAAO,EAAE,MAAA,EAAQ,IAAA,EAAM,CAAC,CAAA;AAC/D","file":"chunk-CHAOFCHV.js","sourcesContent":["/**\n * Public entry for declaring a graph extension.\n *\n * Pure value: validates the input, deeply freezes the result, and returns\n * a `GraphExtension`. Invalid documents throw\n * `GraphExtensionValidationError` carrying every issue with a\n * JSON-pointer `path` to the offending field.\n */\nimport { unwrap } from \"../utils/result\";\nimport { type GraphExtension } from \"./extension-types\";\nimport { validateGraphExtension } from \"./validation\";\n\n/**\n * Validates and freezes a graph-extension document.\n *\n * Authoring entry point — runs validation in **strict** mode: unknown\n * top-level keys (e.g. `node` instead of `nodes`) and unsupported\n * string formats (e.g. `\"date-time\"` with a hyphen instead of\n * `\"datetime\"`) fail loudly with `UNKNOWN_DOCUMENT_KEY` /\n * `UNSUPPORTED_STRING_FORMAT`. The persistence-load path leaves both\n * checks off so a document committed by a future v1.x writer with\n * additive fields still parses on an older v1 reader. Callers\n * accepting raw JSON from an untyped source (e.g. an LLM proposal)\n * should validate first via `validateGraphExtension` and surface\n * the structured issues, then pass the validated document here.\n *\n * @param input - Document describing additional node kinds, edge\n *   kinds, and ontology relations. Must satisfy the v1 property-type\n *   subset documented in `ExtensionPropertyType`.\n *\n * @returns The same document, deeply frozen and shape-checked.\n *\n * @throws {GraphExtensionValidationError} when the document violates\n *   the v1 property-type subset, references undeclared kinds, contains\n *   ontology cycles, etc. The thrown error's `details.issues` array\n *   carries every failure with a JSON-pointer path.\n * @throws {GraphExtensionVersionUnsupportedError} when the document\n *   declares a future major version this library cannot safely decode.\n *\n * @example\n * ```typescript\n * const extension = defineGraphExtension({\n *   nodes: {\n *     Paper: {\n *       properties: {\n *         doi:   { type: \"string\" },\n *         title: { type: \"string\", searchable: { language: \"english\" } },\n *       },\n *       unique: [{ name: \"paper_doi\", fields: [\"doi\"] }],\n *     },\n *   },\n * });\n *\n * const evolved = await store.evolve(extension);\n * const papers = evolved.getNodeCollectionOrThrow(\"Paper\");\n * ```\n */\nexport function defineGraphExtension(input: GraphExtension): GraphExtension {\n  return unwrap(validateGraphExtension(input, { strict: true }));\n}\n"]}
+{"version":3,"sources":["../src/graph-extension/define-graph-extension.ts"],"names":[],"mappings":";;;AAyDO,SAAS,qBAAqB,KAAA,EAAuC;AAC1E,EAAA,OAAO,OAAO,sBAAA,CAAuB,KAAA,EAAO,EAAE,MAAA,EAAQ,IAAA,EAAM,CAAC,CAAA;AAC/D","file":"chunk-AH2A74OZ.js","sourcesContent":["/**\n * Public entry for declaring a graph extension.\n *\n * Pure value: validates the input, deeply freezes the result, and returns\n * a `GraphExtension`. Invalid documents throw\n * `GraphExtensionValidationError` carrying every issue with a\n * JSON-pointer `path` to the offending field.\n */\nimport { unwrap } from \"../utils/result\";\nimport { type GraphExtension } from \"./extension-types\";\nimport { validateGraphExtension } from \"./validation\";\n\n/**\n * Validates and freezes a graph-extension document.\n *\n * Authoring entry point — runs validation in **strict** mode: unknown\n * top-level keys (e.g. `node` instead of `nodes`) and unsupported\n * string formats (e.g. `\"date-time\"` with a hyphen instead of\n * `\"datetime\"`) fail loudly with `UNKNOWN_DOCUMENT_KEY` /\n * `UNSUPPORTED_STRING_FORMAT`. The persistence-load path leaves both\n * checks off so a document committed by a future v1.x writer with\n * additive fields still parses on an older v1 reader. Callers\n * accepting raw JSON from an untyped source (e.g. an LLM proposal)\n * should validate first via `validateGraphExtension` and surface\n * the structured issues, then pass the validated document here.\n *\n * @param input - Document describing additional node kinds, edge\n *   kinds, and ontology relations. Must satisfy the v1 property-type\n *   subset documented in `ExtensionPropertyType`.\n *\n * @returns The same document, deeply frozen and shape-checked.\n *\n * @throws {GraphExtensionValidationError} when the document violates\n *   the v1 property-type subset, references undeclared kinds, contains\n *   ontology cycles, etc. The thrown error's `details.issues` array\n *   carries every failure with a JSON-pointer path.\n * @throws {GraphExtensionVersionUnsupportedError} when the document\n *   declares a future major version this library cannot safely decode.\n *\n * @example\n * ```typescript\n * const extension = defineGraphExtension({\n *   nodes: {\n *     Paper: {\n *       properties: {\n *         doi:   { type: \"string\" },\n *         title: { type: \"string\", searchable: { language: \"english\" } },\n *       },\n *       unique: [{ name: \"paper_doi\", fields: [\"doi\"] }],\n *     },\n *   },\n * });\n *\n * const evolved = await store.evolve(extension);\n * const papers = evolved.getNodeCollectionOrThrow(\"Paper\");\n * ```\n */\nexport function defineGraphExtension(input: GraphExtension): GraphExtension {\n  return unwrap(validateGraphExtension(input, { strict: true }));\n}\n"]}

package/dist/{chunk-OORXGFL5.cjs → chunk-BYBDM423.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
-var chunkCICO5GXD_cjs = require('./chunk-CICO5GXD.cjs');
-var chunkL3LQNR34_cjs = require('./chunk-L3LQNR34.cjs');
-var chunkEDN4Y4ZG_cjs = require('./chunk-EDN4Y4ZG.cjs');
+var chunkKWNWG4RC_cjs = require('./chunk-KWNWG4RC.cjs');
+var chunkTEC24ZDA_cjs = require('./chunk-TEC24ZDA.cjs');
+var chunkOJHD3LXJ_cjs = require('./chunk-OJHD3LXJ.cjs');
 
 // src/query/dialect/vector/sqlite-vec-strategy.ts
 var TABLE_PREFIX = "tg_vec";
@@ -57,17 +57,17 @@ function sqliteVecMetricToken(metric) {
   }
 }
 function vecF32Literal(embedding, name) {
-  chunkL3LQNR34_cjs.assertFiniteEmbedding(embedding, name);
-  return chunkEDN4Y4ZG_cjs.sql`vec_f32(${JSON.stringify(embedding)})`;
+  chunkTEC24ZDA_cjs.assertFiniteEmbedding(embedding, name);
+  return chunkOJHD3LXJ_cjs.sql`vec_f32(${JSON.stringify(embedding)})`;
 }
 function distanceExpression(embeddingColumn, queryEmbedding, metric) {
   const query = vecF32Literal(queryEmbedding, "queryEmbedding");
   switch (metric) {
     case "cosine": {
-      return chunkEDN4Y4ZG_cjs.sql`vec_distance_cosine(${embeddingColumn}, ${query})`;
+      return chunkOJHD3LXJ_cjs.sql`vec_distance_cosine(${embeddingColumn}, ${query})`;
     }
     case "l2": {
-      return chunkEDN4Y4ZG_cjs.sql`vec_distance_l2(${embeddingColumn}, ${query})`;
+      return chunkOJHD3LXJ_cjs.sql`vec_distance_l2(${embeddingColumn}, ${query})`;
     }
     case "inner_product": {
       throw new Error(
@@ -81,7 +81,7 @@ function distanceExpression(embeddingColumn, queryEmbedding, metric) {
   }
 }
 function tableName(graphId, nodeKind, fieldPath) {
-  return chunkL3LQNR34_cjs.vectorPhysicalName(TABLE_PREFIX, graphId, nodeKind, fieldPath);
+  return chunkTEC24ZDA_cjs.vectorPhysicalName(TABLE_PREFIX, graphId, nodeKind, fieldPath);
 }
 var sqliteVecStrategy = {
   name: "sqlite-vec",
@@ -89,11 +89,11 @@ var sqliteVecStrategy = {
   tableName,
   ownedTables(slot) {
     const table = tableName(slot.graphId, slot.nodeKind, slot.fieldPath);
-    const name = chunkL3LQNR34_cjs.quoteIdentifier(table);
+    const name = chunkTEC24ZDA_cjs.quoteIdentifier(table);
     const metric = sqliteVecMetricToken(slot.metric);
     return [
       {
-        logicalName: `${chunkL3LQNR34_cjs.VECTOR_CONTRIBUTION_PREFIX}:${slot.nodeKind}.${slot.fieldPath}`,
+        logicalName: `${chunkTEC24ZDA_cjs.VECTOR_CONTRIBUTION_PREFIX}:${slot.nodeKind}.${slot.fieldPath}`,
         owner: "sqlite-vec",
         tableName: table,
         createDdl: [
@@ -110,52 +110,52 @@ var sqliteVecStrategy = {
     ];
   },
   buildUpsert(slot, params, timestamp) {
-    const table = chunkEDN4Y4ZG_cjs.sql.identifier(
+    const table = chunkOJHD3LXJ_cjs.sql.identifier(
       tableName(slot.graphId, slot.nodeKind, slot.fieldPath)
     );
     const value = vecF32Literal(params.embedding, "embedding");
     return [
-      chunkEDN4Y4ZG_cjs.sql`
+      chunkOJHD3LXJ_cjs.sql`
         DELETE FROM ${table}
         WHERE "node_id" = ${params.nodeId} AND "graph_id" = ${params.graphId}
       `,
-      chunkEDN4Y4ZG_cjs.sql`
+      chunkOJHD3LXJ_cjs.sql`
         INSERT INTO ${table} ("node_id", "graph_id", "created_at", "updated_at", "embedding")
         VALUES (${params.nodeId}, ${params.graphId}, ${timestamp}, ${timestamp}, ${value})
       `
     ];
   },
   buildUpsertBatch(slot, params, timestamp) {
-    const table = chunkEDN4Y4ZG_cjs.sql.identifier(
+    const table = chunkOJHD3LXJ_cjs.sql.identifier(
       tableName(slot.graphId, slot.nodeKind, slot.fieldPath)
     );
-    const nodeIds = chunkEDN4Y4ZG_cjs.sql.join(
-      params.rows.map((row) => chunkEDN4Y4ZG_cjs.sql`${row.nodeId}`),
-      chunkEDN4Y4ZG_cjs.sql`, `
+    const nodeIds = chunkOJHD3LXJ_cjs.sql.join(
+      params.rows.map((row) => chunkOJHD3LXJ_cjs.sql`${row.nodeId}`),
+      chunkOJHD3LXJ_cjs.sql`, `
     );
-    const valueRows = chunkEDN4Y4ZG_cjs.sql.join(
+    const valueRows = chunkOJHD3LXJ_cjs.sql.join(
       params.rows.map(
-        (row) => chunkEDN4Y4ZG_cjs.sql`(${row.nodeId}, ${params.graphId}, ${timestamp}, ${timestamp}, ${vecF32Literal(row.embedding, "embedding")})`
+        (row) => chunkOJHD3LXJ_cjs.sql`(${row.nodeId}, ${params.graphId}, ${timestamp}, ${timestamp}, ${vecF32Literal(row.embedding, "embedding")})`
       ),
-      chunkEDN4Y4ZG_cjs.sql`, `
+      chunkOJHD3LXJ_cjs.sql`, `
     );
     return [
-      chunkEDN4Y4ZG_cjs.sql`
+      chunkOJHD3LXJ_cjs.sql`
         DELETE FROM ${table}
         WHERE "graph_id" = ${params.graphId} AND "node_id" IN (${nodeIds})
       `,
-      chunkEDN4Y4ZG_cjs.sql`
+      chunkOJHD3LXJ_cjs.sql`
         INSERT INTO ${table} ("node_id", "graph_id", "created_at", "updated_at", "embedding")
         VALUES ${valueRows}
       `
     ];
   },
   buildDelete(slot, params) {
-    const table = chunkEDN4Y4ZG_cjs.sql.identifier(
+    const table = chunkOJHD3LXJ_cjs.sql.identifier(
       tableName(slot.graphId, slot.nodeKind, slot.fieldPath)
     );
     return [
-      chunkEDN4Y4ZG_cjs.sql`
+      chunkOJHD3LXJ_cjs.sql`
         DELETE FROM ${table}
         WHERE "node_id" = ${params.nodeId} AND "graph_id" = ${params.graphId}
       `
@@ -163,13 +163,13 @@ var sqliteVecStrategy = {
   },
   buildDeleteBatch(slot, params) {
     if (params.nodeIds.length === 0) return [];
-    const table = chunkEDN4Y4ZG_cjs.sql.identifier(
+    const table = chunkOJHD3LXJ_cjs.sql.identifier(
       tableName(slot.graphId, slot.nodeKind, slot.fieldPath)
     );
     return [
-      chunkEDN4Y4ZG_cjs.sql`DELETE FROM ${table} WHERE "graph_id" = ${params.graphId} AND "node_id" IN (${chunkEDN4Y4ZG_cjs.sql.join(
-        params.nodeIds.map((nodeId) => chunkEDN4Y4ZG_cjs.sql`${nodeId}`),
-        chunkEDN4Y4ZG_cjs.sql`, `
+      chunkOJHD3LXJ_cjs.sql`DELETE FROM ${table} WHERE "graph_id" = ${params.graphId} AND "node_id" IN (${chunkOJHD3LXJ_cjs.sql.join(
+        params.nodeIds.map((nodeId) => chunkOJHD3LXJ_cjs.sql`${nodeId}`),
+        chunkOJHD3LXJ_cjs.sql`, `
       )})`
     ];
   },
@@ -179,63 +179,63 @@ var sqliteVecStrategy = {
   // route the NON-approximate `.similarTo()` branch through this form.
   searchIsExact: true,
   buildSearch(slot, params, candidates) {
-    const table = chunkEDN4Y4ZG_cjs.sql.identifier(
+    const table = chunkOJHD3LXJ_cjs.sql.identifier(
       tableName(slot.graphId, slot.nodeKind, slot.fieldPath)
     );
-    const embeddingColumn = chunkEDN4Y4ZG_cjs.sql`${table}."embedding"`;
+    const embeddingColumn = chunkOJHD3LXJ_cjs.sql`${table}."embedding"`;
     const distance = distanceExpression(
       embeddingColumn,
       params.queryEmbedding,
       params.metric
     );
-    const score = chunkL3LQNR34_cjs.vectorScoreExpression(distance, params.metric);
+    const score = chunkTEC24ZDA_cjs.vectorScoreExpression(distance, params.metric);
     if (usesAnnIndex(slot)) {
       const query = vecF32Literal(params.queryEmbedding, "queryEmbedding");
       const knnK = params.limit + (params.offset ?? 0);
       const conditions2 = [
-        chunkEDN4Y4ZG_cjs.sql`${table}."embedding" MATCH ${query}`,
-        chunkEDN4Y4ZG_cjs.sql`k = ${knnK}`,
-        chunkEDN4Y4ZG_cjs.sql`${table}."graph_id" = ${params.graphId}`
+        chunkOJHD3LXJ_cjs.sql`${table}."embedding" MATCH ${query}`,
+        chunkOJHD3LXJ_cjs.sql`k = ${knnK}`,
+        chunkOJHD3LXJ_cjs.sql`${table}."graph_id" = ${params.graphId}`
       ];
       if (params.minScore !== void 0) {
         conditions2.push(
-          chunkL3LQNR34_cjs.vectorMinScoreCondition(distance, params.metric, params.minScore)
+          chunkTEC24ZDA_cjs.vectorMinScoreCondition(distance, params.metric, params.minScore)
         );
       }
       if (candidates !== void 0) {
-        conditions2.push(chunkEDN4Y4ZG_cjs.sql`${table}."node_id" IN (${candidates})`);
+        conditions2.push(chunkOJHD3LXJ_cjs.sql`${table}."node_id" IN (${candidates})`);
       }
-      const knnBody = chunkEDN4Y4ZG_cjs.sql`
+      const knnBody = chunkOJHD3LXJ_cjs.sql`
         SELECT ${table}."node_id" AS node_id, ${score} AS score
         FROM ${table}
-        WHERE ${chunkEDN4Y4ZG_cjs.sql.join(conditions2, chunkEDN4Y4ZG_cjs.sql` AND `)}
+        WHERE ${chunkOJHD3LXJ_cjs.sql.join(conditions2, chunkOJHD3LXJ_cjs.sql` AND `)}
         ORDER BY distance ASC
       `;
       if (params.offset === void 0 || params.offset === 0) {
         return knnBody;
       }
-      return chunkEDN4Y4ZG_cjs.sql`
+      return chunkOJHD3LXJ_cjs.sql`
         WITH knn_page AS MATERIALIZED (${knnBody})
         SELECT node_id, score FROM knn_page
         LIMIT ${params.limit} OFFSET ${params.offset}
       `;
     }
     const conditions = [
-      chunkEDN4Y4ZG_cjs.sql`${table}."graph_id" = ${params.graphId}`
+      chunkOJHD3LXJ_cjs.sql`${table}."graph_id" = ${params.graphId}`
     ];
     if (candidates !== void 0) {
-      conditions.push(chunkEDN4Y4ZG_cjs.sql`${table}."node_id" IN (${candidates})`);
+      conditions.push(chunkOJHD3LXJ_cjs.sql`${table}."node_id" IN (${candidates})`);
     }
     if (params.minScore !== void 0) {
       conditions.push(
-        chunkL3LQNR34_cjs.vectorMinScoreCondition(distance, params.metric, params.minScore)
+        chunkTEC24ZDA_cjs.vectorMinScoreCondition(distance, params.metric, params.minScore)
       );
     }
-    const pageClause = chunkCICO5GXD_cjs.vectorPageClause(params.limit, params.offset);
-    return chunkEDN4Y4ZG_cjs.sql`
+    const pageClause = chunkKWNWG4RC_cjs.vectorPageClause(params.limit, params.offset);
+    return chunkOJHD3LXJ_cjs.sql`
       SELECT ${table}."node_id" AS node_id, ${score} AS score
       FROM ${table}
-      WHERE ${chunkEDN4Y4ZG_cjs.sql.join(conditions, chunkEDN4Y4ZG_cjs.sql` AND `)}
+      WHERE ${chunkOJHD3LXJ_cjs.sql.join(conditions, chunkOJHD3LXJ_cjs.sql` AND `)}
       ORDER BY ${distance} ASC
       ${pageClause}
     `;
@@ -252,7 +252,7 @@ var sqliteVecStrategy = {
     return void 0;
   },
   buildDropStorage(slot) {
-    const table = chunkL3LQNR34_cjs.quoteIdentifier(
+    const table = chunkTEC24ZDA_cjs.quoteIdentifier(
       tableName(slot.graphId, slot.nodeKind, slot.fieldPath)
     );
     return [`DROP TABLE IF EXISTS ${table}`];
@@ -260,5 +260,5 @@ var sqliteVecStrategy = {
 };
 
 exports.sqliteVecStrategy = sqliteVecStrategy;
-//# sourceMappingURL=chunk-OORXGFL5.cjs.map
-//# sourceMappingURL=chunk-OORXGFL5.cjs.map
+//# sourceMappingURL=chunk-BYBDM423.cjs.map
+//# sourceMappingURL=chunk-BYBDM423.cjs.map