@nicia-ai/typegraph 0.19.0 → 0.21.0

package/dist/index.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
-var chunkX33WV2UF_cjs = require('./chunk-X33WV2UF.cjs');
-var chunk5GZMPJOP_cjs = require('./chunk-5GZMPJOP.cjs');
+var chunkHRNQ3DVJ_cjs = require('./chunk-HRNQ3DVJ.cjs');
+var chunkWRWVWKQL_cjs = require('./chunk-WRWVWKQL.cjs');
 var chunkO5PST6TB_cjs = require('./chunk-O5PST6TB.cjs');
-var chunkMME3H4ZF_cjs = require('./chunk-MME3H4ZF.cjs');
-var chunkP5CNM325_cjs = require('./chunk-P5CNM325.cjs');
+var chunkFQCQM3KG_cjs = require('./chunk-FQCQM3KG.cjs');
+var chunkUVZHTBZ5_cjs = require('./chunk-UVZHTBZ5.cjs');
 var zod = require('zod');
 var drizzleOrm = require('drizzle-orm');
 var nanoid = require('nanoid');
@@ -29,6 +29,44 @@ var PROTOTYPE_POLLUTION_KEYS = /* @__PURE__ */ new Set([
   "constructor",
   "prototype"
 ]);
+var RESERVED_PROPERTY_PREFIX = "$";
+function isReservedPropertyName(name) {
+  return name.startsWith(RESERVED_PROPERTY_PREFIX);
+}
+function assertSchemaKeysAreFree(entityKind, name, keys, reservedStructuralKeys) {
+  const structuralConflicts = keys.filter(
+    (key) => reservedStructuralKeys.has(key)
+  );
+  if (structuralConflicts.length > 0) {
+    const label = entityKind.toLowerCase();
+    throw new chunkO5PST6TB_cjs.ConfigurationError(
+      `${entityKind} "${name}" schema contains reserved property names: ${structuralConflicts.join(", ")}`,
+      {
+        [`${label}Type`]: name,
+        conflicts: structuralConflicts,
+        reservedKeys: [...reservedStructuralKeys]
+      },
+      {
+        suggestion: `Rename the conflicting properties. Reserved names (${[...reservedStructuralKeys].join(", ")}) are added automatically to all ${label}s.`
+      }
+    );
+  }
+  const prefixConflicts = keys.filter((key) => isReservedPropertyName(key));
+  if (prefixConflicts.length > 0) {
+    const label = entityKind.toLowerCase();
+    throw new chunkO5PST6TB_cjs.ConfigurationError(
+      `${entityKind} "${name}" schema uses the reserved "${RESERVED_PROPERTY_PREFIX}" prefix on: ${prefixConflicts.join(", ")}`,
+      {
+        [`${label}Type`]: name,
+        conflicts: prefixConflicts,
+        reservedPrefix: RESERVED_PROPERTY_PREFIX
+      },
+      {
+        suggestion: `Property names starting with "${RESERVED_PROPERTY_PREFIX}" are reserved for TypeGraph accessors (e.g. $fulltext). Rename each field.`
+      }
+    );
+  }
+}
 function validateProjectionField(field2, entityType, kind) {
   const reserved = entityType === "node" ? RESERVED_NODE_KEYS : RESERVED_EDGE_KEYS;
   if (reserved.has(field2)) {
@@ -62,24 +100,17 @@ function filterReservedKeys(props, reservedKeys) {
 
 // src/core/node.ts
 function validateSchemaKeys(schema, name) {
-  const shape = schema.shape;
-  const conflicts = Object.keys(shape).filter(
-    (key) => RESERVED_NODE_KEYS.has(key)
+  assertSchemaKeysAreFree(
+    "Node",
+    name,
+    Object.keys(schema.shape),
+    RESERVED_NODE_KEYS
   );
-  if (conflicts.length > 0) {
-    throw new chunkO5PST6TB_cjs.ConfigurationError(
-      `Node "${name}" schema contains reserved property names: ${conflicts.join(", ")}`,
-      { nodeType: name, conflicts, reservedKeys: [...RESERVED_NODE_KEYS] },
-      {
-        suggestion: `Rename the conflicting properties. Reserved names (id, kind, meta) are added automatically to all nodes.`
-      }
-    );
-  }
 }
 function defineNode(name, options) {
   validateSchemaKeys(options.schema, name);
   return Object.freeze({
-    [chunk5GZMPJOP_cjs.NODE_TYPE_BRAND]: true,
+    [chunkWRWVWKQL_cjs.NODE_TYPE_BRAND]: true,
     kind: name,
     schema: options.schema,
     description: options.description
@@ -87,25 +118,18 @@ function defineNode(name, options) {
 }
 var EMPTY_SCHEMA = zod.z.object({});
 function validateSchemaKeys2(schema, name) {
-  const shape = schema.shape;
-  const conflicts = Object.keys(shape).filter(
-    (key) => RESERVED_EDGE_KEYS.has(key)
+  assertSchemaKeysAreFree(
+    "Edge",
+    name,
+    Object.keys(schema.shape),
+    RESERVED_EDGE_KEYS
   );
-  if (conflicts.length > 0) {
-    throw new chunkO5PST6TB_cjs.ConfigurationError(
-      `Edge "${name}" schema contains reserved property names: ${conflicts.join(", ")}`,
-      { edgeType: name, conflicts, reservedKeys: [...RESERVED_EDGE_KEYS] },
-      {
-        suggestion: `Rename the conflicting properties. Reserved names are added automatically to all edges.`
-      }
-    );
-  }
 }
 function defineEdge(name, options) {
   const schema = options?.schema ?? EMPTY_SCHEMA;
   validateSchemaKeys2(schema, name);
   return Object.freeze({
-    [chunk5GZMPJOP_cjs.EDGE_TYPE_BRAND]: true,
+    [chunkWRWVWKQL_cjs.EDGE_TYPE_BRAND]: true,
     kind: name,
     schema,
     description: options?.description,
@@ -125,7 +149,7 @@ function metaEdge(name, options = {}) {
     description: options.description
   };
   return Object.freeze({
-    [chunkX33WV2UF_cjs.META_EDGE_BRAND]: true,
+    [chunkHRNQ3DVJ_cjs.META_EDGE_BRAND]: true,
     name,
     properties
   });
@@ -161,7 +185,7 @@ function createExternalRef(table) {
 // src/ontology/core-meta-edges.ts
 function createMetaEdge(name, properties) {
   return Object.freeze({
-    [chunkX33WV2UF_cjs.META_EDGE_BRAND]: true,
+    [chunkHRNQ3DVJ_cjs.META_EDGE_BRAND]: true,
     name,
     properties: {
       transitive: properties.transitive ?? false,
@@ -173,7 +197,7 @@ function createMetaEdge(name, properties) {
     }
   });
 }
-var subClassOfMetaEdge = createMetaEdge(chunkX33WV2UF_cjs.META_EDGE_SUB_CLASS_OF, {
+var subClassOfMetaEdge = createMetaEdge(chunkHRNQ3DVJ_cjs.META_EDGE_SUB_CLASS_OF, {
   transitive: true,
   inference: "subsumption",
   description: "Type inheritance (Podcast subClassOf Media)"
@@ -185,9 +209,9 @@ function subClassOf(child, parent) {
     to: parent
   };
 }
-var broaderMetaEdge = createMetaEdge(chunkX33WV2UF_cjs.META_EDGE_BROADER, {
+var broaderMetaEdge = createMetaEdge(chunkHRNQ3DVJ_cjs.META_EDGE_BROADER, {
   transitive: true,
-  inverse: chunkX33WV2UF_cjs.META_EDGE_NARROWER,
+  inverse: chunkHRNQ3DVJ_cjs.META_EDGE_NARROWER,
   inference: "hierarchy",
   description: "Broader concept (ML broader AI)"
 });
@@ -198,9 +222,9 @@ function broader(narrowerConcept, broaderConcept) {
     to: broaderConcept
   };
 }
-var narrowerMetaEdge = createMetaEdge(chunkX33WV2UF_cjs.META_EDGE_NARROWER, {
+var narrowerMetaEdge = createMetaEdge(chunkHRNQ3DVJ_cjs.META_EDGE_NARROWER, {
   transitive: true,
-  inverse: chunkX33WV2UF_cjs.META_EDGE_BROADER,
+  inverse: chunkHRNQ3DVJ_cjs.META_EDGE_BROADER,
   inference: "hierarchy",
   description: "Narrower concept (AI narrower ML)"
 });
@@ -211,7 +235,7 @@ function narrower(broaderConcept, narrowerConcept) {
     to: narrowerConcept
   };
 }
-var relatedToMetaEdge = createMetaEdge(chunkX33WV2UF_cjs.META_EDGE_RELATED_TO, {
+var relatedToMetaEdge = createMetaEdge(chunkHRNQ3DVJ_cjs.META_EDGE_RELATED_TO, {
   symmetric: true,
   inference: "association",
   description: "Non-hierarchical association"
@@ -223,7 +247,7 @@ function relatedTo(conceptA, conceptB) {
     to: conceptB
   };
 }
-var equivalentToMetaEdge = createMetaEdge(chunkX33WV2UF_cjs.META_EDGE_EQUIVALENT_TO, {
+var equivalentToMetaEdge = createMetaEdge(chunkHRNQ3DVJ_cjs.META_EDGE_EQUIVALENT_TO, {
   symmetric: true,
   transitive: true,
   inference: "substitution",
@@ -236,7 +260,7 @@ function equivalentTo(kindA, kindBOrIri) {
     to: kindBOrIri
   };
 }
-var sameAsMetaEdge = createMetaEdge(chunkX33WV2UF_cjs.META_EDGE_SAME_AS, {
+var sameAsMetaEdge = createMetaEdge(chunkHRNQ3DVJ_cjs.META_EDGE_SAME_AS, {
   symmetric: true,
   transitive: true,
   inference: "substitution",
@@ -249,7 +273,7 @@ function sameAs(kindA, kindBOrIri) {
     to: kindBOrIri
   };
 }
-var differentFromMetaEdge = createMetaEdge(chunkX33WV2UF_cjs.META_EDGE_DIFFERENT_FROM, {
+var differentFromMetaEdge = createMetaEdge(chunkHRNQ3DVJ_cjs.META_EDGE_DIFFERENT_FROM, {
   symmetric: true,
   inference: "constraint",
   description: "Explicitly different individuals"
@@ -261,7 +285,7 @@ function differentFrom(kindA, kindB) {
     to: kindB
   };
 }
-var disjointWithMetaEdge = createMetaEdge(chunkX33WV2UF_cjs.META_EDGE_DISJOINT_WITH, {
+var disjointWithMetaEdge = createMetaEdge(chunkHRNQ3DVJ_cjs.META_EDGE_DISJOINT_WITH, {
   symmetric: true,
   inference: "constraint",
   description: "Mutually exclusive types"
@@ -273,9 +297,9 @@ function disjointWith(kindA, kindB) {
     to: kindB
   };
 }
-var partOfMetaEdge = createMetaEdge(chunkX33WV2UF_cjs.META_EDGE_PART_OF, {
+var partOfMetaEdge = createMetaEdge(chunkHRNQ3DVJ_cjs.META_EDGE_PART_OF, {
   transitive: true,
-  inverse: chunkX33WV2UF_cjs.META_EDGE_HAS_PART,
+  inverse: chunkHRNQ3DVJ_cjs.META_EDGE_HAS_PART,
   inference: "composition",
   description: "X is part of Y"
 });
@@ -286,9 +310,9 @@ function partOf(part, whole) {
     to: whole
   };
 }
-var hasPartMetaEdge = createMetaEdge(chunkX33WV2UF_cjs.META_EDGE_HAS_PART, {
+var hasPartMetaEdge = createMetaEdge(chunkHRNQ3DVJ_cjs.META_EDGE_HAS_PART, {
   transitive: true,
-  inverse: chunkX33WV2UF_cjs.META_EDGE_PART_OF,
+  inverse: chunkHRNQ3DVJ_cjs.META_EDGE_PART_OF,
   inference: "composition",
   description: "Y has part X"
 });
@@ -299,12 +323,12 @@ function hasPart(whole, part) {
     to: part
   };
 }
-var inverseOfMetaEdge = createMetaEdge(chunkX33WV2UF_cjs.META_EDGE_INVERSE_OF, {
+var inverseOfMetaEdge = createMetaEdge(chunkHRNQ3DVJ_cjs.META_EDGE_INVERSE_OF, {
   symmetric: true,
   inference: "none",
   description: "Edge A is inverse of edge B"
 });
-var impliesMetaEdge = createMetaEdge(chunkX33WV2UF_cjs.META_EDGE_IMPLIES, {
+var impliesMetaEdge = createMetaEdge(chunkHRNQ3DVJ_cjs.META_EDGE_IMPLIES, {
   transitive: true,
   inference: "none",
   description: "Edge A implies edge B exists"
@@ -565,6 +589,41 @@ function stringField(field2) {
     ilike: (pattern) => stringOp("ilike", field2, pattern)
   };
 }
+var DEFAULT_FULLTEXT_MATCH_K = 50;
+function createFulltextAccessor(alias, hasSearchableField) {
+  return {
+    matches: (query, k, options) => {
+      if (!hasSearchableField()) {
+        throw new chunkO5PST6TB_cjs.UnsupportedPredicateError(
+          `Cannot call .$fulltext.matches() on alias "${alias}" \u2014 its node kind has no fields declared with searchable(). Add at least one: \`title: searchable({ language: "english" })\`.`
+        );
+      }
+      return fulltextMatch(
+        fieldRef(alias, ["$fulltext"]),
+        query,
+        k ?? DEFAULT_FULLTEXT_MATCH_K,
+        options
+      );
+    }
+  };
+}
+function fulltextMatch(field2, query, limit, options) {
+  if (!Number.isFinite(limit) || limit <= 0) {
+    throw new chunkO5PST6TB_cjs.UnsupportedPredicateError(
+      `matches() limit must be a positive finite number, got ${String(limit)}`
+    );
+  }
+  const expr = {
+    __type: "fulltext_match",
+    field: field2,
+    query,
+    mode: options?.mode ?? "websearch",
+    limit,
+    ...options?.language === void 0 ? {} : { language: options.language },
+    ...options?.minScore === void 0 ? {} : { minScore: options.minScore }
+  };
+  return predicate(expr);
+}
 function numberField(field2) {
   return {
     ...baseFieldBuilder(field2),
@@ -664,7 +723,7 @@ function buildFieldBuilderForTypeInfo(field2, typeInfo) {
   }
 }
 function resolvePointerTypeInfo(typeInfo, pointer) {
-  return chunkP5CNM325_cjs.resolveFieldTypeInfoAtJsonPointer(typeInfo, pointer);
+  return chunkUVZHTBZ5_cjs.resolveFieldTypeInfoAtJsonPointer(typeInfo, pointer);
 }
 function objectOp(op, field2, pointer, value, options) {
   const expr = {
@@ -687,8 +746,8 @@ function objectField(field2, options) {
   return {
     ...baseFieldBuilder(field2),
     get: (key) => {
-      const pointer = chunkP5CNM325_cjs.jsonPointer([key]);
-      const nestedPointer = chunkP5CNM325_cjs.joinJsonPointers(basePointer, pointer);
+      const pointer = chunkUVZHTBZ5_cjs.jsonPointer([key]);
+      const nestedPointer = chunkUVZHTBZ5_cjs.joinJsonPointers(basePointer, pointer);
       const resolved = resolvePointerTypeInfo(options?.typeInfo, pointer);
       const nestedRef = fieldRef(field2.alias, field2.path, {
         jsonPointer: nestedPointer,
@@ -702,17 +761,17 @@ function objectField(field2, options) {
       return buildFieldBuilderForTypeInfo(nestedRef, resolved);
     },
     hasKey: (key) => {
-      const pointer = chunkP5CNM325_cjs.jsonPointer([key]);
+      const pointer = chunkUVZHTBZ5_cjs.jsonPointer([key]);
       resolvePointerTypeInfo(options?.typeInfo, pointer);
       return objectOp("hasKey", field2, pointer);
     },
     hasPath: (pointer) => {
-      const normalized = chunkP5CNM325_cjs.normalizeJsonPointer(pointer);
+      const normalized = chunkUVZHTBZ5_cjs.normalizeJsonPointer(pointer);
       resolvePointerTypeInfo(options?.typeInfo, normalized);
       return objectOp("hasPath", field2, normalized);
     },
     pathEquals: (pointer, value) => {
-      const normalized = chunkP5CNM325_cjs.normalizeJsonPointer(pointer);
+      const normalized = chunkUVZHTBZ5_cjs.normalizeJsonPointer(pointer);
       const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);
       if (resolved && (resolved.valueType === "array" || resolved.valueType === "object")) {
         throw new Error("pathEquals is only supported for scalar JSON values");
@@ -721,7 +780,7 @@ function objectField(field2, options) {
       return objectOp("pathEquals", field2, normalized, value, predicateOptions);
     },
     pathContains: (pointer, value) => {
-      const normalized = chunkP5CNM325_cjs.normalizeJsonPointer(pointer);
+      const normalized = chunkUVZHTBZ5_cjs.normalizeJsonPointer(pointer);
       const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);
       if (resolved && resolved.valueType !== "array") {
         throw new Error("pathContains is only supported for JSON array values");
@@ -736,7 +795,7 @@ function objectField(field2, options) {
       );
     },
     pathIsNull: (pointer) => {
-      const normalized = chunkP5CNM325_cjs.normalizeJsonPointer(pointer);
+      const normalized = chunkUVZHTBZ5_cjs.normalizeJsonPointer(pointer);
       const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);
       const predicateOptions = resolved?.valueType === void 0 ? void 0 : { valueType: resolved.valueType };
       return objectOp(
@@ -748,7 +807,7 @@ function objectField(field2, options) {
       );
     },
     pathIsNotNull: (pointer) => {
-      const normalized = chunkP5CNM325_cjs.normalizeJsonPointer(pointer);
+      const normalized = chunkUVZHTBZ5_cjs.normalizeJsonPointer(pointer);
       const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);
       const predicateOptions = resolved?.valueType === void 0 ? void 0 : { valueType: resolved.valueType };
       return objectOp(
@@ -760,8 +819,8 @@ function objectField(field2, options) {
       );
     },
     field: (pointer) => {
-      const normalized = chunkP5CNM325_cjs.normalizeJsonPointer(pointer);
-      const nestedPointer = chunkP5CNM325_cjs.joinJsonPointers(basePointer, normalized);
+      const normalized = chunkUVZHTBZ5_cjs.normalizeJsonPointer(pointer);
+      const nestedPointer = chunkUVZHTBZ5_cjs.joinJsonPointers(basePointer, normalized);
       const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);
       const nestedRef = fieldRef(field2.alias, field2.path, {
         jsonPointer: nestedPointer,
@@ -891,7 +950,7 @@ function getFieldPointer(field2) {
     return field2.jsonPointer;
   }
   if (field2.path.length > 1 && field2.path[0] === "props") {
-    return chunkP5CNM325_cjs.jsonPointer(field2.path.slice(1));
+    return chunkUVZHTBZ5_cjs.jsonPointer(field2.path.slice(1));
   }
   return void 0;
 }
@@ -1140,11 +1199,13 @@ function compilePredicateExpression(expr, ctx) {
     case "in_subquery": {
       return compileInSubquery(expr, ctx);
     }
-    case "vector_similarity": {
-      return compileVectorSimilarityPredicate();
+    case "vector_similarity":
+    case "fulltext_match": {
+      return STRUCTURAL_PREDICATE_NOOP;
     }
   }
 }
+var STRUCTURAL_PREDICATE_NOOP = drizzleOrm.sql.raw("1=1");
 function compileComparisonPredicate(expr, dialect, cteColumnPrefix) {
   if (isParameterRef(expr.right)) {
     const parameterValueType = normalizeValueType2(expr.right.valueType) ?? normalizeValueType2(expr.left.valueType);
@@ -1248,7 +1309,7 @@ function compileArrayPredicate(expr, dialect, cteColumnPrefix) {
 }
 function compileObjectPredicate(expr, dialect, cteColumnPrefix) {
   const basePointer = getFieldPointer(expr.field);
-  const pointer = chunkP5CNM325_cjs.joinJsonPointers(basePointer, expr.pointer);
+  const pointer = chunkUVZHTBZ5_cjs.joinJsonPointers(basePointer, expr.pointer);
   const column = compileFieldColumn(expr.field, void 0, cteColumnPrefix);
   switch (expr.op) {
     case "hasKey":
@@ -1398,45 +1459,61 @@ function compileInSubquery(expr, ctx) {
   const subSql = ctx.compileQuery(expr.subquery, expr.subquery.graphId);
   return expr.negated ? drizzleOrm.sql`${fieldSql} NOT IN (${subSql})` : drizzleOrm.sql`${fieldSql} IN (${subSql})`;
 }
-function compileVectorSimilarityPredicate(_expr, _ctx) {
-  return drizzleOrm.sql.raw("1=1");
-}
-function extractVectorSimilarityPredicates(predicates) {
+function extractStructuralPredicates(predicates, isMatch, rejectionMessage) {
   const results = [];
   function visit(expr, inDisallowedBranch) {
-    switch (expr.__type) {
-      case "vector_similarity": {
-        if (inDisallowedBranch) {
-          throw new chunkO5PST6TB_cjs.UnsupportedPredicateError(
-            "Vector similarity predicates cannot be nested under OR or NOT. Use top-level AND combinations instead."
-          );
-        }
-        results.push(expr);
-        break;
+    if (isMatch(expr)) {
+      if (inDisallowedBranch) {
+        throw new chunkO5PST6TB_cjs.UnsupportedPredicateError(rejectionMessage);
       }
+      results.push(expr);
+      return;
+    }
+    switch (expr.__type) {
       case "and": {
-        for (const predicate2 of expr.predicates) {
-          visit(predicate2, inDisallowedBranch);
-        }
-        break;
+        for (const child of expr.predicates) visit(child, inDisallowedBranch);
+        return;
       }
       case "or": {
-        for (const predicate2 of expr.predicates) {
-          visit(predicate2, true);
-        }
-        break;
+        for (const child of expr.predicates) visit(child, true);
+        return;
       }
       case "not": {
         visit(expr.predicate, true);
-        break;
+        return;
+      }
+      case "comparison":
+      case "string_op":
+      case "null_check":
+      case "between":
+      case "array_op":
+      case "object_op":
+      case "aggregate_comparison":
+      case "exists":
+      case "in_subquery":
+      case "vector_similarity":
+      case "fulltext_match": {
+        return;
       }
     }
   }
-  for (const pred of predicates) {
-    visit(pred.expression, false);
-  }
+  for (const pred of predicates) visit(pred.expression, false);
   return results;
 }
+function extractVectorSimilarityPredicates(predicates) {
+  return extractStructuralPredicates(
+    predicates,
+    (expr) => expr.__type === "vector_similarity",
+    "Vector similarity predicates cannot be nested under OR or NOT. Use top-level AND combinations instead."
+  );
+}
+function extractFulltextMatchPredicates(predicates) {
+  return extractStructuralPredicates(
+    predicates,
+    (expr) => expr.__type === "fulltext_match",
+    "Fulltext match predicates cannot be nested under OR or NOT. Use top-level AND combinations instead."
+  );
+}
 
 // src/query/compiler/predicate-utils.ts
 var EMPTY_PREDICATES = [];
@@ -1495,6 +1572,10 @@ function getNodeKindsForAlias(ast, alias) {
   }
   throw new chunkO5PST6TB_cjs.CompilerInvariantError(`Unknown traversal source alias: ${alias}`);
 }
+function getHybridTargetAlias(vectorPredicate, fulltextPredicate) {
+  if (!vectorPredicate || !fulltextPredicate) return void 0;
+  return vectorPredicate.field.alias === fulltextPredicate.field.alias ? vectorPredicate.field.alias : void 0;
+}
 
 // src/query/compiler/emitter/plan-inspector.ts
 function collectPlanOperations(node, ops) {
@@ -1502,6 +1583,7 @@ function collectPlanOperations(node, ops) {
   switch (node.op) {
     case "aggregate":
     case "filter":
+    case "fulltext_match":
     case "join":
     case "limit_offset":
     case "project":
@@ -1530,6 +1612,7 @@ function findUnaryNodeInProjectChain(rootNode, op) {
     switch (currentNode.op) {
       case "aggregate":
       case "filter":
+      case "fulltext_match":
       case "join":
       case "limit_offset":
       case "recursive_expand":
@@ -1565,6 +1648,7 @@ function inspectProjectPlan(logicalPlan) {
   );
   return {
     hasAggregate: operations.has("aggregate"),
+    hasFulltextMatch: operations.has("fulltext_match"),
     hasLimitOffset: operations.has("limit_offset"),
     hasRecursiveExpand: operations.has("recursive_expand"),
     hasSetOperation: operations.has("set_op"),
@@ -1616,6 +1700,7 @@ function findTopLevelLimitOffsetNode(rootNode) {
     switch (currentNode.op) {
       case "aggregate":
       case "filter":
+      case "fulltext_match":
       case "join":
       case "project":
       case "recursive_expand":
@@ -1640,6 +1725,7 @@ function findTopLevelSortNode(rootNode) {
     switch (currentNode.op) {
       case "aggregate":
       case "filter":
+      case "fulltext_match":
       case "join":
       case "limit_offset":
       case "project":
@@ -1774,16 +1860,16 @@ function assertStandardEmitterClauseAlignment(logicalPlan, input) {
       { component: "standard-emitter" }
     );
   }
-  const expectsOrderBy = planShape.hasSort || planShape.hasVectorKnn;
+  const expectsOrderBy = planShape.hasSort || planShape.hasVectorKnn || planShape.hasFulltextMatch;
   if (expectsOrderBy && input.orderBy === void 0) {
     throw new chunkO5PST6TB_cjs.CompilerInvariantError(
-      "Standard SQL emitter expected ORDER BY clause for plan containing a sort or vector_knn node",
+      "Standard SQL emitter expected ORDER BY clause for plan containing a sort, vector_knn, or fulltext_match node",
       { component: "standard-emitter" }
     );
   }
   if (!expectsOrderBy && input.orderBy !== void 0) {
     throw new chunkO5PST6TB_cjs.CompilerInvariantError(
-      "Standard SQL emitter received ORDER BY clause for a plan without sort or vector_knn nodes",
+      "Standard SQL emitter received ORDER BY clause for a plan without sort, vector_knn, or fulltext_match nodes",
       { component: "standard-emitter" }
     );
   }
@@ -1822,6 +1908,62 @@ function emitStandardQuerySql(input) {
   return drizzleOrm.sql.join(parts, drizzleOrm.sql` `);
 }
 
+// src/query/ast.ts
+var DEFAULT_RRF_K = 60;
+var DEFAULT_RRF_WEIGHT = 1;
+function mergeEdgeKinds(traversal) {
+  const inverse = traversal.inverseEdgeKinds;
+  if (inverse === void 0 || inverse.length === 0) return traversal.edgeKinds;
+  return [
+    ...traversal.edgeKinds,
+    ...inverse.filter((kind) => !traversal.edgeKinds.includes(kind))
+  ];
+}
+var DEFAULT_TABLE_NAMES = {
+  nodes: "typegraph_nodes",
+  edges: "typegraph_edges",
+  embeddings: "typegraph_node_embeddings",
+  fulltext: "typegraph_node_fulltext"
+};
+var VALID_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_$]*$/i;
+function validateTableName(name, label) {
+  if (!name || name.length === 0) {
+    throw new chunkO5PST6TB_cjs.ConfigurationError(`${label} table name cannot be empty`);
+  }
+  if (name.length > chunkFQCQM3KG_cjs.MAX_PG_IDENTIFIER_LENGTH) {
+    throw new chunkO5PST6TB_cjs.ConfigurationError(
+      `${label} table name exceeds maximum length of ${chunkFQCQM3KG_cjs.MAX_PG_IDENTIFIER_LENGTH} characters`
+    );
+  }
+  if (!VALID_IDENTIFIER_PATTERN.test(name)) {
+    throw new chunkO5PST6TB_cjs.ConfigurationError(
+      `${label} table name "${name}" is not a valid SQL identifier. Table names must start with a letter or underscore and contain only letters, digits, underscores, or dollar signs.`
+    );
+  }
+}
+function quoteIdentifier(name) {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+function createSqlSchema(names = {}) {
+  const tables = { ...DEFAULT_TABLE_NAMES, ...names };
+  validateTableName(tables.nodes, "nodes");
+  validateTableName(tables.edges, "edges");
+  validateTableName(tables.embeddings, "embeddings");
+  validateTableName(tables.fulltext, "fulltext");
+  return {
+    tables,
+    nodesTable: drizzleOrm.sql.raw(quoteIdentifier(tables.nodes)),
+    edgesTable: drizzleOrm.sql.raw(quoteIdentifier(tables.edges)),
+    embeddingsTable: drizzleOrm.sql.raw(quoteIdentifier(tables.embeddings)),
+    fulltextTable: drizzleOrm.sql.raw(quoteIdentifier(tables.fulltext))
+  };
+}
+var DEFAULT_SQL_SCHEMA = createSqlSchema();
+var ALIAS_CTE_PREFIX = "cte_";
+var EMBEDDINGS_CTE_ALIAS = "cte_embeddings";
+var FULLTEXT_CTE_ALIAS = "cte_fulltext";
+var HYBRID_CANDIDATES_CTE_ALIAS = "cte_relevance_candidates";
+
 // src/query/compiler/typed-json-extract.ts
 function compileTypedJsonExtract(input) {
   const { column, dialect, pointer, valueType } = input;
@@ -1875,7 +2017,7 @@ var EDGE_COLUMNS = [
   "deleted_at"
 ];
 var EMPTY_REQUIRED_COLUMNS = /* @__PURE__ */ new Set();
-function quoteIdentifier(identifier) {
+function quoteIdentifier2(identifier) {
   return drizzleOrm.sql.raw(`"${identifier.replaceAll('"', '""')}"`);
 }
 function shouldProjectColumn(requiredColumns, column, alwaysRequiredColumns) {
@@ -1929,6 +2071,21 @@ function compileColumnReference(tableAlias, column) {
   }
   return drizzleOrm.sql`${drizzleOrm.sql.raw(tableAlias)}.${drizzleOrm.sql.raw(column)}`;
 }
+function qualifyColumn(owner, name) {
+  return drizzleOrm.sql`${quoteIdentifier2(owner)}.${quoteIdentifier2(name)}`;
+}
+var SCOPED_RELEVANCE_NODES_ALIAS = "scoped_relevance_nodes";
+function buildScopedNodeIdsSubquery(nodeAlias) {
+  const cteAlias = `${ALIAS_CTE_PREFIX}${nodeAlias}`;
+  return drizzleOrm.sql`
+    (
+        SELECT DISTINCT
+          ${qualifyColumn(cteAlias, `${nodeAlias}_id`)} AS node_id,
+          ${qualifyColumn(cteAlias, `${nodeAlias}_kind`)} AS node_kind
+        FROM ${quoteIdentifier2(cteAlias)}
+      ) AS ${drizzleOrm.sql.raw(SCOPED_RELEVANCE_NODES_ALIAS)}
+  `;
+}
 function compileNodeSelectColumns(tableAlias, alias, requiredColumns) {
   return NODE_COLUMNS.filter(
     (column) => column === "id" || column === "kind" || shouldProjectColumn(requiredColumns, column)
@@ -2181,7 +2338,7 @@ function buildStandardProjection(input) {
   }
   const projectedFields = fields.map((field2) => {
     const source = compileProjectedSource(field2, dialect);
-    return drizzleOrm.sql`${source} AS ${quoteIdentifier(field2.outputName)}`;
+    return drizzleOrm.sql`${source} AS ${quoteIdentifier2(field2.outputName)}`;
   });
   return drizzleOrm.sql.join(projectedFields, drizzleOrm.sql`, `);
 }
@@ -2201,23 +2358,67 @@ function compileSelectiveProjection(fields, dialect, ast, collapsedTraversalCteA
     const cteAlias = collapsedTraversalCteAlias ?? aliasToCte.get(field2.alias) ?? `cte_${field2.alias}`;
     if (field2.isSystemField) {
       const dbColumn = mapSelectiveSystemFieldToColumn(field2.field);
-      return drizzleOrm.sql`${drizzleOrm.sql.raw(cteAlias)}.${drizzleOrm.sql.raw(`${field2.alias}_${dbColumn}`)} AS ${quoteIdentifier(field2.outputName)}`;
+      return drizzleOrm.sql`${drizzleOrm.sql.raw(cteAlias)}.${drizzleOrm.sql.raw(`${field2.alias}_${dbColumn}`)} AS ${quoteIdentifier2(field2.outputName)}`;
     }
     const propsColumn = `${field2.alias}_props`;
     const column = drizzleOrm.sql`${drizzleOrm.sql.raw(cteAlias)}.${drizzleOrm.sql.raw(propsColumn)}`;
-    const pointer = chunkP5CNM325_cjs.jsonPointer([field2.field]);
+    const pointer = chunkUVZHTBZ5_cjs.jsonPointer([field2.field]);
     const extracted = compileTypedJsonExtract({
       column,
       dialect,
       pointer,
       valueType: field2.valueType
     });
-    return drizzleOrm.sql`${extracted} AS ${quoteIdentifier(field2.outputName)}`;
+    return drizzleOrm.sql`${extracted} AS ${quoteIdentifier2(field2.outputName)}`;
   });
   return drizzleOrm.sql.join(columns, drizzleOrm.sql`, `);
 }
+function buildRelevanceJoins(vectorPredicate, fulltextPredicate) {
+  const hybridTargetAlias = getHybridTargetAlias(
+    vectorPredicate,
+    fulltextPredicate
+  );
+  if (hybridTargetAlias !== void 0) {
+    return [
+      buildHybridCandidateJoin(hybridTargetAlias),
+      buildRelevanceJoin(EMBEDDINGS_CTE_ALIAS, hybridTargetAlias, "LEFT JOIN"),
+      buildRelevanceJoin(FULLTEXT_CTE_ALIAS, hybridTargetAlias, "LEFT JOIN")
+    ];
+  }
+  const joins = [];
+  if (vectorPredicate) {
+    joins.push(
+      buildRelevanceJoin(EMBEDDINGS_CTE_ALIAS, vectorPredicate.field.alias)
+    );
+  }
+  if (fulltextPredicate) {
+    joins.push(
+      buildRelevanceJoin(FULLTEXT_CTE_ALIAS, fulltextPredicate.field.alias)
+    );
+  }
+  return joins;
+}
+function buildHybridCandidateJoin(nodeAlias) {
+  const candidateCte = drizzleOrm.sql.raw(HYBRID_CANDIDATES_CTE_ALIAS);
+  const node = drizzleOrm.sql.raw(`${ALIAS_CTE_PREFIX}${nodeAlias}`);
+  const idColumn = drizzleOrm.sql.raw(`${nodeAlias}_id`);
+  const kindColumn = drizzleOrm.sql.raw(`${nodeAlias}_kind`);
+  return drizzleOrm.sql`INNER JOIN ${candidateCte} ON ${candidateCte}.node_id = ${node}.${idColumn} AND ${candidateCte}.node_kind = ${node}.${kindColumn}`;
+}
+function buildRelevanceJoin(cteAlias, nodeAlias, joinType = "INNER JOIN") {
+  const cte = drizzleOrm.sql.raw(cteAlias);
+  const node = drizzleOrm.sql.raw(`${ALIAS_CTE_PREFIX}${nodeAlias}`);
+  const idColumn = drizzleOrm.sql.raw(`${nodeAlias}_id`);
+  const kindColumn = drizzleOrm.sql.raw(`${nodeAlias}_kind`);
+  return drizzleOrm.sql`${drizzleOrm.sql.raw(joinType)} ${cte} ON ${cte}.node_id = ${node}.${idColumn} AND ${cte}.node_kind = ${node}.${kindColumn}`;
+}
 function buildStandardFromClause(input) {
-  const { ast, collapsedTraversalCteAlias, vectorPredicate } = input;
+  const {
+    ast,
+    collapsedTraversalCteAlias,
+    fulltextPredicate,
+    vectorPredicate
+  } = input;
   if (collapsedTraversalCteAlias !== void 0) {
     return drizzleOrm.sql`FROM ${drizzleOrm.sql.raw(collapsedTraversalCteAlias)}`;
   }
@@ -2232,11 +2433,8 @@ function buildStandardFromClause(input) {
       drizzleOrm.sql`${drizzleOrm.sql.raw(joinType)} ${drizzleOrm.sql.raw(cteAlias)} ON ${drizzleOrm.sql.raw(cteAlias)}.${drizzleOrm.sql.raw(previousAlias)}_id = cte_${drizzleOrm.sql.raw(previousAlias)}.${drizzleOrm.sql.raw(previousAlias)}_id AND ${drizzleOrm.sql.raw(cteAlias)}.${drizzleOrm.sql.raw(previousAlias)}_kind = cte_${drizzleOrm.sql.raw(previousAlias)}.${drizzleOrm.sql.raw(previousAlias)}_kind`
     );
   }
-  if (vectorPredicate) {
-    const nodeAlias = vectorPredicate.field.alias;
-    joins.push(
-      drizzleOrm.sql`INNER JOIN cte_embeddings ON cte_embeddings.node_id = cte_${drizzleOrm.sql.raw(nodeAlias)}.${drizzleOrm.sql.raw(nodeAlias)}_id`
-    );
+  for (const join of buildRelevanceJoins(vectorPredicate, fulltextPredicate)) {
+    joins.push(join);
   }
   return joins.length === 0 ? fromClause : drizzleOrm.sql`${fromClause} ${drizzleOrm.sql.join(joins, drizzleOrm.sql` `)}`;
 }
@@ -2275,6 +2473,15 @@ function fieldRefKey(field2) {
   const pointer = field2.jsonPointer ?? "";
   return `${field2.alias}:${field2.path.join(".")}:${pointer}`;
 }
+function resolveEmbeddingFieldPath(field2) {
+  if (field2.jsonPointer !== void 0 && field2.jsonPointer !== "" && field2.jsonPointer !== "/") {
+    return field2.jsonPointer.replace(/^\//u, "").replaceAll("/", ".");
+  }
+  if (field2.path[0] === "props") {
+    return field2.path.slice(1).join(".");
+  }
+  return field2.path.join(".");
+}
 function buildStandardGroupBy(input) {
   const { ast, dialect } = input;
   if (!ast.groupBy || ast.groupBy.fields.length === 0) {
@@ -2321,18 +2528,29 @@ function buildStandardHaving(input) {
   return drizzleOrm.sql`HAVING ${condition}`;
 }
 function buildStandardEmbeddingsCte(input) {
-  const { ctx, graphId, vectorPredicate } = input;
+  const { ctx, graphId, nodeKinds, vectorPredicate } = input;
   const { dialect } = ctx;
   const { field: field2, metric, minScore, queryEmbedding } = vectorPredicate;
-  const fieldPath = field2.jsonPointer ?? (field2.path.length > 1 && field2.path[0] === "props" ? `/${field2.path.slice(1).join("/")}` : `/${field2.path.join("/")}`);
+  const embeddingsTableName = ctx.schema.tables.embeddings;
+  if (nodeKinds.length === 0) {
+    throw new chunkO5PST6TB_cjs.UnsupportedPredicateError(
+      "Vector predicate must resolve to at least one node kind"
+    );
+  }
+  const fieldPath = resolveEmbeddingFieldPath(field2);
   const distanceExpr = dialect.vectorDistance(
-    drizzleOrm.sql.raw("embedding"),
+    qualifyColumn(embeddingsTableName, "embedding"),
     queryEmbedding,
     metric
   );
+  const scopedNodes = buildScopedNodeIdsSubquery(field2.alias);
   const conditions = [
-    drizzleOrm.sql`graph_id = ${graphId}`,
-    drizzleOrm.sql`field_path = ${fieldPath}`
+    drizzleOrm.sql`${qualifyColumn(embeddingsTableName, "graph_id")} = ${graphId}`,
+    compileKindFilter(
+      qualifyColumn(embeddingsTableName, "node_kind"),
+      nodeKinds
+    ),
+    drizzleOrm.sql`${qualifyColumn(embeddingsTableName, "field_path")} = ${fieldPath}`
   ];
   if (minScore !== void 0) {
     conditions.push(
@@ -2341,14 +2559,29 @@ function buildStandardEmbeddingsCte(input) {
   }
   const scoreExpr = compileVectorScoreExpression(distanceExpr, metric);
   return drizzleOrm.sql`
-    cte_embeddings AS (
+    ${drizzleOrm.sql.raw(EMBEDDINGS_CTE_ALIAS)} AS (
       SELECT
         node_id,
-        ${distanceExpr} AS distance,
-        ${scoreExpr} AS score
-      FROM ${ctx.schema.embeddingsTable}
-      WHERE ${drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `)}
-      ORDER BY ${distanceExpr} ASC
+        node_kind,
+        distance,
+        score,
+        ROW_NUMBER() OVER (ORDER BY distance ASC) AS ord
+      FROM (
+        SELECT
+          ${qualifyColumn(embeddingsTableName, "node_id")} AS node_id,
+          ${qualifyColumn(embeddingsTableName, "node_kind")} AS node_kind,
+          ${distanceExpr} AS distance,
+          ${scoreExpr} AS score
+        FROM ${ctx.schema.embeddingsTable}
+        INNER JOIN ${scopedNodes}
+          ON ${drizzleOrm.sql.raw(`${SCOPED_RELEVANCE_NODES_ALIAS}.node_id`)} =
+             ${qualifyColumn(embeddingsTableName, "node_id")}
+         AND ${drizzleOrm.sql.raw(`${SCOPED_RELEVANCE_NODES_ALIAS}.node_kind`)} =
+             ${qualifyColumn(embeddingsTableName, "node_kind")}
+        WHERE ${drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `)}
+        ORDER BY distance ASC
+        LIMIT ${vectorPredicate.limit}
+      ) AS vec_inner
     )
   `;
 }
@@ -2378,37 +2611,130 @@ function compileVectorMinScoreCondition(distanceExpr, metric, minScore) {
     }
   }
 }
-function buildStandardVectorOrderBy(input) {
-  const { ast, dialect } = input;
-  const distanceOrder = drizzleOrm.sql`cte_embeddings.distance ASC`;
-  const additionalOrders = [];
-  if (ast.orderBy && ast.orderBy.length > 0) {
-    const aliasToCte = buildAliasToCteMap(ast);
-    for (const orderSpec of ast.orderBy) {
-      const valueType = orderSpec.field.valueType;
-      if (valueType === "array" || valueType === "object") {
-        throw new chunkO5PST6TB_cjs.UnsupportedPredicateError(
-          "Ordering by JSON arrays or objects is not supported"
-        );
-      }
-      const cteAlias = aliasToCte.get(orderSpec.field.alias) ?? `cte_${orderSpec.field.alias}`;
-      const field2 = compileFieldValue(
-        orderSpec.field,
-        dialect,
-        valueType,
-        cteAlias
-      );
-      const direction = drizzleOrm.sql.raw(orderSpec.direction.toUpperCase());
-      const nulls = orderSpec.nulls ?? (orderSpec.direction === "asc" ? "last" : "first");
-      const nullsDirection = drizzleOrm.sql.raw(nulls === "first" ? "DESC" : "ASC");
-      additionalOrders.push(
-        drizzleOrm.sql`(${field2} IS NULL) ${nullsDirection}`,
-        drizzleOrm.sql`${field2} ${direction}`
+function buildStandardFulltextCte(input) {
+  const { ctx, fulltextPredicate, graphId, nodeKinds } = input;
+  const { dialect, schema } = ctx;
+  const { query, mode, language, limit, minScore } = fulltextPredicate;
+  if (nodeKinds.length === 0) {
+    throw new chunkO5PST6TB_cjs.UnsupportedPredicateError(
+      "Fulltext predicate must resolve to at least one node kind"
+    );
+  }
+  const tableName = schema.tables.fulltext;
+  const scopedNodes = buildScopedNodeIdsSubquery(fulltextPredicate.field.alias);
+  const fulltextStrategy = dialect.fulltext;
+  if (fulltextStrategy === void 0) {
+    throw new chunkO5PST6TB_cjs.UnsupportedPredicateError(
+      `Fulltext match predicates are not supported for dialect "${dialect.name}"`
+    );
+  }
+  const matchCondition = fulltextStrategy.matchCondition(
+    tableName,
+    query,
+    mode,
+    language
+  );
+  const rankExpression = fulltextStrategy.rankExpression(
+    tableName,
+    query,
+    mode,
+    language
+  );
+  const conditions = [
+    drizzleOrm.sql`${qualifyColumn(tableName, "graph_id")} = ${graphId}`,
+    compileKindFilter(qualifyColumn(tableName, "node_kind"), nodeKinds),
+    matchCondition
+  ];
+  if (minScore !== void 0) {
+    conditions.push(drizzleOrm.sql`${rankExpression} >= ${minScore}`);
+  }
+  return drizzleOrm.sql`
+    ${drizzleOrm.sql.raw(FULLTEXT_CTE_ALIAS)} AS (
+      SELECT
+        node_id,
+        node_kind,
+        rank,
+        ROW_NUMBER() OVER (ORDER BY rank DESC, node_id ASC) AS ord
+      FROM (
+        SELECT
+          ${qualifyColumn(tableName, "node_id")} AS node_id,
+          ${qualifyColumn(tableName, "node_kind")} AS node_kind,
+          ${rankExpression} AS rank
+        FROM ${schema.fulltextTable}
+        INNER JOIN ${scopedNodes}
+          ON ${drizzleOrm.sql.raw(`${SCOPED_RELEVANCE_NODES_ALIAS}.node_id`)} =
+             ${qualifyColumn(tableName, "node_id")}
+         AND ${drizzleOrm.sql.raw(`${SCOPED_RELEVANCE_NODES_ALIAS}.node_kind`)} =
+             ${qualifyColumn(tableName, "node_kind")}
+        WHERE ${drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `)}
+        ORDER BY rank DESC, ${qualifyColumn(tableName, "node_id")} ASC
+        LIMIT ${limit}
+      ) AS fts_inner
+    )
+  `;
+}
+function buildStandardHybridCandidateCte() {
+  return drizzleOrm.sql`
+    ${drizzleOrm.sql.raw(HYBRID_CANDIDATES_CTE_ALIAS)} AS (
+      SELECT node_id, node_kind FROM ${drizzleOrm.sql.raw(EMBEDDINGS_CTE_ALIAS)}
+      UNION
+      SELECT node_id, node_kind FROM ${drizzleOrm.sql.raw(FULLTEXT_CTE_ALIAS)}
+    )
+  `;
+}
+function compileUserOrderBy(ast, dialect) {
+  if (!ast.orderBy || ast.orderBy.length === 0) return [];
+  const aliasToCte = buildAliasToCteMap(ast);
+  const fragments = [];
+  for (const orderSpec of ast.orderBy) {
+    const valueType = orderSpec.field.valueType;
+    if (valueType === "array" || valueType === "object") {
+      throw new chunkO5PST6TB_cjs.UnsupportedPredicateError(
+        "Ordering by JSON arrays or objects is not supported"
       );
     }
+    const cteAlias = aliasToCte.get(orderSpec.field.alias) ?? `${ALIAS_CTE_PREFIX}${orderSpec.field.alias}`;
+    const field2 = compileFieldValue(
+      orderSpec.field,
+      dialect,
+      valueType,
+      cteAlias
+    );
+    const direction = drizzleOrm.sql.raw(orderSpec.direction.toUpperCase());
+    const nulls = orderSpec.nulls ?? (orderSpec.direction === "asc" ? "last" : "first");
+    const nullsDirection = drizzleOrm.sql.raw(nulls === "first" ? "DESC" : "ASC");
+    fragments.push(
+      drizzleOrm.sql`(${field2} IS NULL) ${nullsDirection}`,
+      drizzleOrm.sql`${field2} ${direction}`
+    );
   }
-  const allOrders = [distanceOrder, ...additionalOrders];
-  return drizzleOrm.sql`ORDER BY ${drizzleOrm.sql.join(allOrders, drizzleOrm.sql`, `)}`;
+  return fragments;
+}
+function buildStandardFulltextOrderBy(input) {
+  const { ast, dialect } = input;
+  const rankOrder = drizzleOrm.sql.raw(`${FULLTEXT_CTE_ALIAS}.rank DESC`);
+  const userOrders = compileUserOrderBy(ast, dialect);
+  return drizzleOrm.sql`ORDER BY ${drizzleOrm.sql.join([rankOrder, ...userOrders], drizzleOrm.sql`, `)}`;
+}
+function buildStandardHybridRrfOrderBy(input) {
+  const { ast, dialect, fusion } = input;
+  const k = fusion?.k ?? DEFAULT_RRF_K;
+  const vectorWeight = fusion?.weights?.vector ?? DEFAULT_RRF_WEIGHT;
+  const fulltextWeight = fusion?.weights?.fulltext ?? DEFAULT_RRF_WEIGHT;
+  const rrfOrder = drizzleOrm.sql.raw(
+    `(COALESCE(${vectorWeight} / (${k} + ${EMBEDDINGS_CTE_ALIAS}.ord), 0) + COALESCE(${fulltextWeight} / (${k} + ${FULLTEXT_CTE_ALIAS}.ord), 0)) DESC`
+  );
+  const idTiebreak = drizzleOrm.sql.raw(
+    `COALESCE(${FULLTEXT_CTE_ALIAS}.node_id, ${EMBEDDINGS_CTE_ALIAS}.node_id) ASC`
+  );
+  const userOrders = compileUserOrderBy(ast, dialect);
+  return drizzleOrm.sql`ORDER BY ${drizzleOrm.sql.join([rrfOrder, ...userOrders, idTiebreak], drizzleOrm.sql`, `)}`;
+}
+function buildStandardVectorOrderBy(input) {
+  const { ast, dialect } = input;
+  const distanceOrder = drizzleOrm.sql.raw(`${EMBEDDINGS_CTE_ALIAS}.distance ASC`);
+  const userOrders = compileUserOrderBy(ast, dialect);
+  return drizzleOrm.sql`ORDER BY ${drizzleOrm.sql.join([distanceOrder, ...userOrders], drizzleOrm.sql`, `)}`;
 }
 function buildLimitOffsetClause(input) {
   const { limit, offset } = input;
@@ -2422,6 +2748,74 @@ function buildLimitOffsetClause(input) {
   return parts.length > 0 ? drizzleOrm.sql.join(parts, drizzleOrm.sql` `) : void 0;
 }
 
+// src/query/compiler/passes/fulltext.ts
+function runFulltextPredicatePass(ast, dialect) {
+  const fulltextPredicates = extractFulltextMatchPredicates(ast.predicates);
+  if (fulltextPredicates.length > 1) {
+    throw new chunkO5PST6TB_cjs.UnsupportedPredicateError(
+      "Multiple fulltext match predicates in a single query are not supported"
+    );
+  }
+  const fulltextPredicate = fulltextPredicates[0];
+  if (fulltextPredicate === void 0) {
+    return { fulltextPredicate: void 0 };
+  }
+  if (!dialect.capabilities.supportsFulltext) {
+    throw new chunkO5PST6TB_cjs.UnsupportedPredicateError(
+      `Fulltext match predicates are not supported for dialect "${dialect.name}"`
+    );
+  }
+  const strategy = dialect.fulltext;
+  if (strategy === void 0) {
+    throw new chunkO5PST6TB_cjs.UnsupportedPredicateError(
+      `Dialect "${dialect.name}" advertises fulltext support but has no strategy configured`
+    );
+  }
+  if (!strategy.supportedModes.includes(fulltextPredicate.mode)) {
+    throw new chunkO5PST6TB_cjs.UnsupportedPredicateError(
+      `Fulltext query mode "${fulltextPredicate.mode}" is not supported by the "${strategy.name}" strategy. Supported modes: ${strategy.supportedModes.join(", ")}.`
+    );
+  }
+  if (!Number.isFinite(fulltextPredicate.limit) || fulltextPredicate.limit <= 0) {
+    throw new chunkO5PST6TB_cjs.UnsupportedPredicateError(
+      `Fulltext match limit must be a positive finite number, got ${String(fulltextPredicate.limit)}`
+    );
+  }
+  const { minScore } = fulltextPredicate;
+  if (minScore !== void 0 && !Number.isFinite(minScore)) {
+    throw new chunkO5PST6TB_cjs.UnsupportedPredicateError(
+      `Fulltext minScore must be a finite number, got ${String(minScore)}`
+    );
+  }
+  return { fulltextPredicate };
+}
+function resolveFulltextAwareLimit(astLimit, fulltextPredicate) {
+  if (fulltextPredicate === void 0) {
+    return astLimit;
+  }
+  if (astLimit === void 0) {
+    return fulltextPredicate.limit;
+  }
+  return Math.min(astLimit, fulltextPredicate.limit);
+}
+
+// src/query/compiler/passes/fusion.ts
+function runFusionConfigPass(ast, vectorPredicate, fulltextPredicate) {
+  const fusion = ast.fusion;
+  if (fusion === void 0) return { fusion: void 0 };
+  if (vectorPredicate === void 0 || fulltextPredicate === void 0) {
+    throw new chunkO5PST6TB_cjs.UnsupportedPredicateError(
+      `.fuseWith() requires both a .similarTo() and a .$fulltext.matches() predicate in the same query. Remove .fuseWith(), or add the missing predicate.`
+    );
+  }
+  if (vectorPredicate.field.alias !== fulltextPredicate.field.alias) {
+    throw new chunkO5PST6TB_cjs.UnsupportedPredicateError(
+      `.fuseWith() requires .similarTo() and .$fulltext.matches() to target the same node alias. Got vector=${vectorPredicate.field.alias}, fulltext=${fulltextPredicate.field.alias}.`
+    );
+  }
+  return { fusion };
+}
+
 // src/query/compiler/passes/recursive.ts
 function runRecursiveTraversalSelectionPass(ast) {
   const variableLengthTraversal = ast.traversals.find(
@@ -2691,6 +3085,14 @@ function lowerStandardQueryToLogicalPlanNode(input) {
       predicate: input.vectorPredicate
     };
   }
+  if (input.fulltextPredicate !== void 0) {
+    currentNode = {
+      id: nextPlanNodeId(),
+      input: currentNode,
+      op: "fulltext_match",
+      predicate: input.fulltextPredicate
+    };
+  }
   return appendAggregateSortLimitAndProjectNodes(
     currentNode,
     ast,
@@ -2768,17 +3170,30 @@ function lowerComposableQueryToLogicalPlanNode(query, dialect, graphId, nextPlan
       nextPlanNodeId
     });
   }
+  const dialectAdapter = chunkFQCQM3KG_cjs.getDialect(dialect);
   const vectorPredicate = runVectorPredicatePass(
     query,
-    chunkMME3H4ZF_cjs.getDialect(dialect)
+    dialectAdapter
   ).vectorPredicate;
-  const effectiveLimit = resolveVectorAwareLimit(query.limit, vectorPredicate);
+  const fulltextPredicate = runFulltextPredicatePass(
+    query,
+    dialectAdapter
+  ).fulltextPredicate;
+  const limitAfterVector = resolveVectorAwareLimit(
+    query.limit,
+    vectorPredicate
+  );
+  const effectiveLimit = resolveFulltextAwareLimit(
+    limitAfterVector,
+    fulltextPredicate
+  );
   const loweringInput = {
     ast: query,
     graphId,
     nextPlanNodeId,
     ...effectiveLimit === void 0 ? {} : { effectiveLimit },
-    ...vectorPredicate === void 0 ? {} : { vectorPredicate }
+    ...vectorPredicate === void 0 ? {} : { vectorPredicate },
+    ...fulltextPredicate === void 0 ? {} : { fulltextPredicate }
   };
   return lowerStandardQueryToLogicalPlanNode(loweringInput);
 }
@@ -3285,10 +3700,10 @@ function compileRecursiveProjection(ast, traversal, dialect) {
     drizzleOrm.sql`${drizzleOrm.sql.raw(nodeAlias)}_deleted_at`
   ];
   if (vl.depthAlias !== void 0) {
-    fields.push(drizzleOrm.sql`depth AS ${quoteIdentifier(vl.depthAlias)}`);
+    fields.push(drizzleOrm.sql`depth AS ${quoteIdentifier2(vl.depthAlias)}`);
   }
   if (vl.pathAlias !== void 0) {
-    fields.push(drizzleOrm.sql`path AS ${quoteIdentifier(vl.pathAlias)}`);
+    fields.push(drizzleOrm.sql`path AS ${quoteIdentifier2(vl.pathAlias)}`);
   }
   return drizzleOrm.sql.join(fields, drizzleOrm.sql`, `);
 }
@@ -3302,23 +3717,23 @@ function compileRecursiveSelectiveProjection(fields, ast, traversal, dialect) {
     }
     if (field2.isSystemField) {
       const dbColumn = mapSelectiveSystemFieldToColumn(field2.field);
-      return drizzleOrm.sql`${drizzleOrm.sql.raw(`${field2.alias}_${dbColumn}`)} AS ${quoteIdentifier(field2.outputName)}`;
+      return drizzleOrm.sql`${drizzleOrm.sql.raw(`${field2.alias}_${dbColumn}`)} AS ${quoteIdentifier2(field2.outputName)}`;
     }
     const column = drizzleOrm.sql.raw(`${field2.alias}_props`);
     const extracted = compileTypedJsonExtract({
       column,
       dialect,
-      pointer: chunkP5CNM325_cjs.jsonPointer([field2.field]),
+      pointer: chunkUVZHTBZ5_cjs.jsonPointer([field2.field]),
       valueType: field2.valueType
     });
-    return drizzleOrm.sql`${extracted} AS ${quoteIdentifier(field2.outputName)}`;
+    return drizzleOrm.sql`${extracted} AS ${quoteIdentifier2(field2.outputName)}`;
   });
   const vl = traversal.variableLength;
   if (vl.depthAlias !== void 0) {
-    columns.push(drizzleOrm.sql`depth AS ${quoteIdentifier(vl.depthAlias)}`);
+    columns.push(drizzleOrm.sql`depth AS ${quoteIdentifier2(vl.depthAlias)}`);
   }
   if (vl.pathAlias !== void 0) {
-    columns.push(drizzleOrm.sql`path AS ${quoteIdentifier(vl.pathAlias)}`);
+    columns.push(drizzleOrm.sql`path AS ${quoteIdentifier2(vl.pathAlias)}`);
   }
   return drizzleOrm.sql.join(columns, drizzleOrm.sql`, `);
 }
@@ -3355,43 +3770,6 @@ function compileLimitOffset(ast) {
   }
   return parts.length > 0 ? drizzleOrm.sql.join(parts, drizzleOrm.sql` `) : void 0;
 }
-var DEFAULT_TABLE_NAMES = {
-  nodes: "typegraph_nodes",
-  edges: "typegraph_edges",
-  embeddings: "typegraph_node_embeddings"
-};
-var VALID_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_$]*$/i;
-function validateTableName(name, label) {
-  if (!name || name.length === 0) {
-    throw new chunkO5PST6TB_cjs.ConfigurationError(`${label} table name cannot be empty`);
-  }
-  if (name.length > chunkMME3H4ZF_cjs.MAX_PG_IDENTIFIER_LENGTH) {
-    throw new chunkO5PST6TB_cjs.ConfigurationError(
-      `${label} table name exceeds maximum length of ${chunkMME3H4ZF_cjs.MAX_PG_IDENTIFIER_LENGTH} characters`
-    );
-  }
-  if (!VALID_IDENTIFIER_PATTERN.test(name)) {
-    throw new chunkO5PST6TB_cjs.ConfigurationError(
-      `${label} table name "${name}" is not a valid SQL identifier. Table names must start with a letter or underscore and contain only letters, digits, underscores, or dollar signs.`
-    );
-  }
-}
-function quoteIdentifier2(name) {
-  return `"${name.replaceAll('"', '""')}"`;
-}
-function createSqlSchema(names = {}) {
-  const tables = { ...DEFAULT_TABLE_NAMES, ...names };
-  validateTableName(tables.nodes, "nodes");
-  validateTableName(tables.edges, "edges");
-  validateTableName(tables.embeddings, "embeddings");
-  return {
-    tables,
-    nodesTable: drizzleOrm.sql.raw(quoteIdentifier2(tables.nodes)),
-    edgesTable: drizzleOrm.sql.raw(quoteIdentifier2(tables.edges)),
-    embeddingsTable: drizzleOrm.sql.raw(quoteIdentifier2(tables.embeddings))
-  };
-}
-var DEFAULT_SQL_SCHEMA = createSqlSchema();
 
 // src/query/execution/value-decoder.ts
 function nullToUndefined(value) {
@@ -3449,6 +3827,116 @@ function decodeByValueType(value, valueType) {
     }
   }
 }
+function buildReachableCte(options) {
+  const trackPath = options.cyclePolicy === "prevent" || options.includePath;
+  const edgeKindFilter = compileKindFilter(
+    drizzleOrm.sql.raw("e.kind"),
+    options.edgeKinds
+  );
+  const currentTimestamp = options.dialect.currentTimestamp();
+  const nodeTemporalFilter = compileTemporalFilter({
+    mode: options.temporalMode,
+    asOf: options.asOf,
+    tableAlias: "n",
+    currentTimestamp
+  });
+  const edgeTemporalFilter = compileTemporalFilter({
+    mode: options.temporalMode,
+    asOf: options.asOf,
+    tableAlias: "e",
+    currentTimestamp
+  });
+  const initialPath = trackPath ? options.dialect.initializePath(drizzleOrm.sql.raw("n.id")) : void 0;
+  const pathExtension = trackPath ? options.dialect.extendPath(drizzleOrm.sql.raw("r.path"), drizzleOrm.sql.raw("n.id")) : void 0;
+  const cycleCheck = options.cyclePolicy === "prevent" ? options.dialect.cycleCheck(drizzleOrm.sql.raw("n.id"), drizzleOrm.sql.raw("r.path")) : void 0;
+  const baseColumns = [drizzleOrm.sql`n.id`, drizzleOrm.sql`n.kind`, drizzleOrm.sql`0 AS depth`];
+  if (initialPath !== void 0) {
+    baseColumns.push(drizzleOrm.sql`${initialPath} AS path`);
+  }
+  const baseCase = drizzleOrm.sql`SELECT ${drizzleOrm.sql.join(baseColumns, drizzleOrm.sql`, `)} FROM ${options.schema.nodesTable} n WHERE n.graph_id = ${options.graphId} AND n.id = ${options.sourceId} AND ${nodeTemporalFilter}`;
+  const recursiveColumns = [
+    drizzleOrm.sql`n.id`,
+    drizzleOrm.sql`n.kind`,
+    drizzleOrm.sql`r.depth + 1 AS depth`
+  ];
+  if (pathExtension !== void 0) {
+    recursiveColumns.push(drizzleOrm.sql`${pathExtension} AS path`);
+  }
+  const recursiveWhere = [
+    drizzleOrm.sql`e.graph_id = ${options.graphId}`,
+    edgeKindFilter,
+    edgeTemporalFilter,
+    nodeTemporalFilter,
+    drizzleOrm.sql`r.depth < ${options.maxHops}`
+  ];
+  if (cycleCheck !== void 0) recursiveWhere.push(cycleCheck);
+  const forceWorktableOuterJoinOrder = options.dialect.capabilities.forceRecursiveWorktableOuterJoinOrder;
+  const recursiveCase = compileRecursiveBranch({
+    recursiveColumns,
+    whereClauses: recursiveWhere,
+    direction: options.direction,
+    forceWorktableOuterJoinOrder,
+    schema: options.schema
+  });
+  return drizzleOrm.sql`WITH RECURSIVE reachable AS (${baseCase} UNION ALL ${recursiveCase})`;
+}
+function compileRecursiveBranch(options) {
+  const selectClause = drizzleOrm.sql`SELECT ${drizzleOrm.sql.join([...options.recursiveColumns], drizzleOrm.sql`, `)}`;
+  switch (options.direction) {
+    case "out": {
+      return buildDirectionalBranch({
+        selectClause,
+        whereClauses: options.whereClauses,
+        joinField: "from_id",
+        targetField: "to_id",
+        targetKindField: "to_kind",
+        forceWorktableOuterJoinOrder: options.forceWorktableOuterJoinOrder,
+        schema: options.schema
+      });
+    }
+    case "in": {
+      return buildDirectionalBranch({
+        selectClause,
+        whereClauses: options.whereClauses,
+        joinField: "to_id",
+        targetField: "from_id",
+        targetKindField: "from_kind",
+        forceWorktableOuterJoinOrder: options.forceWorktableOuterJoinOrder,
+        schema: options.schema
+      });
+    }
+    case "both": {
+      return buildBidirectionalBranch({
+        selectClause,
+        whereClauses: options.whereClauses,
+        forceWorktableOuterJoinOrder: options.forceWorktableOuterJoinOrder,
+        schema: options.schema
+      });
+    }
+  }
+}
+function buildDirectionalBranch(options) {
+  const nodeJoin = drizzleOrm.sql`JOIN ${options.schema.nodesTable} n ON n.graph_id = e.graph_id AND n.id = e.${drizzleOrm.sql.raw(options.targetField)} AND n.kind = e.${drizzleOrm.sql.raw(options.targetKindField)}`;
+  if (options.forceWorktableOuterJoinOrder) {
+    const allWhere = [
+      ...options.whereClauses,
+      drizzleOrm.sql`e.${drizzleOrm.sql.raw(options.joinField)} = r.id`
+    ];
+    return drizzleOrm.sql`${options.selectClause} FROM reachable r CROSS JOIN ${options.schema.edgesTable} e ${nodeJoin} WHERE ${drizzleOrm.sql.join(allWhere, drizzleOrm.sql` AND `)}`;
+  }
+  return drizzleOrm.sql`${options.selectClause} FROM reachable r JOIN ${options.schema.edgesTable} e ON e.${drizzleOrm.sql.raw(options.joinField)} = r.id ${nodeJoin} WHERE ${drizzleOrm.sql.join([...options.whereClauses], drizzleOrm.sql` AND `)}`;
+}
+function buildBidirectionalBranch(options) {
+  const nodeJoin = drizzleOrm.sql`JOIN ${options.schema.nodesTable} n ON n.graph_id = e.graph_id AND ((e.to_id = r.id AND n.id = e.from_id AND n.kind = e.from_kind) OR (e.from_id = r.id AND n.id = e.to_id AND n.kind = e.to_kind))`;
+  if (options.forceWorktableOuterJoinOrder) {
+    const allWhere = [
+      ...options.whereClauses,
+      drizzleOrm.sql`(e.from_id = r.id OR e.to_id = r.id)`
+    ];
+    return drizzleOrm.sql`${options.selectClause} FROM reachable r CROSS JOIN ${options.schema.edgesTable} e ${nodeJoin} WHERE ${drizzleOrm.sql.join(allWhere, drizzleOrm.sql` AND `)}`;
+  }
+  return drizzleOrm.sql`${options.selectClause} FROM reachable r JOIN ${options.schema.edgesTable} e ON (e.from_id = r.id OR e.to_id = r.id) ${nodeJoin} WHERE ${drizzleOrm.sql.join([...options.whereClauses], drizzleOrm.sql` AND `)}`;
+}
 
 // src/store/row-mappers.ts
 function nullToUndefined2(value) {
@@ -3512,9 +4000,9 @@ function truncateToBytes(value, maxBytes) {
 }
 function projectionAlias(entityPrefix, kind, field2) {
   const prefix = entityPrefix === "node" ? "sg_n" : "sg_e";
-  const hash = chunkMME3H4ZF_cjs.fnv1aBase36(`${kind}\0${field2}`);
+  const hash = chunkFQCQM3KG_cjs.fnv1aBase36(`${kind}\0${field2}`);
   const fixedBytes = prefix.length + 1 + 1 + hash.length;
-  const maxKindBytes = chunkMME3H4ZF_cjs.MAX_PG_IDENTIFIER_LENGTH - fixedBytes;
+  const maxKindBytes = chunkFQCQM3KG_cjs.MAX_PG_IDENTIFIER_LENGTH - fixedBytes;
   const truncatedKind = truncateToBytes(kind, maxKindBytes);
   return `${prefix}_${truncatedKind}_${hash}`;
 }
@@ -3539,6 +4027,8 @@ async function executeSubgraph(params) {
     excludeRoot: options.excludeRoot ?? false,
     direction: options.direction ?? "out",
     cyclePolicy: options.cyclePolicy ?? "prevent",
+    temporalMode: options.temporalMode ?? params.graph.defaults.temporalMode,
+    asOf: options.asOf,
     dialect: params.dialect,
     schema: params.schema ?? DEFAULT_SQL_SCHEMA,
     backend: params.backend
@@ -3556,7 +4046,19 @@ async function executeSubgraph(params) {
     (kind, field2) => schemaIntrospector.getEdgeFieldTypeInfo(kind, field2),
     "edge"
   );
-  const reachableCte = buildReachableCte(ctx);
+  const reachableCte = buildReachableCte({
+    graphId: ctx.graphId,
+    sourceId: ctx.rootId,
+    edgeKinds: ctx.edgeKinds,
+    maxHops: ctx.maxDepth,
+    direction: ctx.direction,
+    cyclePolicy: ctx.cyclePolicy,
+    includePath: false,
+    temporalMode: ctx.temporalMode,
+    ...ctx.asOf !== void 0 && { asOf: ctx.asOf },
+    dialect: ctx.dialect,
+    schema: ctx.schema
+  });
   const includedIdsCte = buildIncludedIdsCte(ctx);
   const [nodeRows, edgeRows] = await Promise.all([
     fetchSubgraphNodes(ctx, reachableCte, includedIdsCte, nodeProjectionPlan),
@@ -3572,12 +4074,7 @@ async function executeSubgraph(params) {
   for (const row of edgeRows) {
     const edge = mapSubgraphEdgeRow(row, edgeProjectionPlan);
     insertAdjacencyEntry(adjacency, edge.fromId, edge.kind, edge);
-    insertAdjacencyEntry(
-      reverseAdjacency,
-      edge.toId,
-      edge.kind,
-      edge
-    );
+    insertAdjacencyEntry(reverseAdjacency, edge.toId, edge.kind, edge);
   }
   const root = nodesMap.get(ctx.rootId);
   return {
@@ -3603,7 +4100,7 @@ function getSubgraphSchemaIntrospector(graph) {
       { schema: definition.type.schema }
     ])
   );
-  const introspector = chunkP5CNM325_cjs.createSchemaIntrospector(nodeKinds, edgeKinds);
+  const introspector = chunkUVZHTBZ5_cjs.createSchemaIntrospector(nodeKinds, edgeKinds);
   introspectorCache.set(graph, introspector);
   return introspector;
 }
@@ -3654,79 +4151,6 @@ function getIncludedNodeKinds(graph, includeKinds) {
 function dedupeStrings(values) {
   return [...new Set(values)];
 }
-function buildReachableCte(ctx) {
-  const shouldTrackPath = ctx.cyclePolicy === "prevent";
-  const edgeKindFilter = compileKindFilter(drizzleOrm.sql.raw("e.kind"), ctx.edgeKinds);
-  const initialPath = shouldTrackPath ? ctx.dialect.initializePath(drizzleOrm.sql.raw("n.id")) : void 0;
-  const pathExtension = shouldTrackPath ? ctx.dialect.extendPath(drizzleOrm.sql.raw("r.path"), drizzleOrm.sql.raw("n.id")) : void 0;
-  const cycleCheck = shouldTrackPath ? ctx.dialect.cycleCheck(drizzleOrm.sql.raw("n.id"), drizzleOrm.sql.raw("r.path")) : void 0;
-  const baseColumns = [drizzleOrm.sql`n.id`, drizzleOrm.sql`n.kind`, drizzleOrm.sql`0 AS depth`];
-  if (initialPath !== void 0) {
-    baseColumns.push(drizzleOrm.sql`${initialPath} AS path`);
-  }
-  const baseCase = drizzleOrm.sql`SELECT ${drizzleOrm.sql.join(baseColumns, drizzleOrm.sql`, `)} FROM ${ctx.schema.nodesTable} n WHERE n.graph_id = ${ctx.graphId} AND n.id = ${ctx.rootId} AND n.deleted_at IS NULL`;
-  const recursiveColumns = [
-    drizzleOrm.sql`n.id`,
-    drizzleOrm.sql`n.kind`,
-    drizzleOrm.sql`r.depth + 1 AS depth`
-  ];
-  if (pathExtension !== void 0) {
-    recursiveColumns.push(drizzleOrm.sql`${pathExtension} AS path`);
-  }
-  const recursiveWhereClauses = [
-    drizzleOrm.sql`e.graph_id = ${ctx.graphId}`,
-    edgeKindFilter,
-    drizzleOrm.sql`e.deleted_at IS NULL`,
-    drizzleOrm.sql`n.deleted_at IS NULL`,
-    drizzleOrm.sql`r.depth < ${ctx.maxDepth}`
-  ];
-  if (cycleCheck !== void 0) {
-    recursiveWhereClauses.push(cycleCheck);
-  }
-  const forceWorktableOuterJoinOrder = ctx.dialect.capabilities.forceRecursiveWorktableOuterJoinOrder;
-  const recursiveCase = ctx.direction === "both" ? compileBidirectionalBranch({
-    recursiveColumns,
-    whereClauses: recursiveWhereClauses,
-    forceWorktableOuterJoinOrder,
-    schema: ctx.schema
-  }) : compileRecursiveBranch({
-    recursiveColumns,
-    whereClauses: recursiveWhereClauses,
-    joinField: "from_id",
-    targetField: "to_id",
-    targetKindField: "to_kind",
-    forceWorktableOuterJoinOrder,
-    schema: ctx.schema
-  });
-  return drizzleOrm.sql`WITH RECURSIVE reachable AS (${baseCase} UNION ALL ${recursiveCase})`;
-}
-function compileRecursiveBranch(params) {
-  const columns = [...params.recursiveColumns];
-  const selectClause = drizzleOrm.sql`SELECT ${drizzleOrm.sql.join(columns, drizzleOrm.sql`, `)}`;
-  const nodeJoin = drizzleOrm.sql`JOIN ${params.schema.nodesTable} n ON n.graph_id = e.graph_id AND n.id = e.${drizzleOrm.sql.raw(params.targetField)} AND n.kind = e.${drizzleOrm.sql.raw(params.targetKindField)}`;
-  if (params.forceWorktableOuterJoinOrder) {
-    const allWhere = [
-      ...params.whereClauses,
-      drizzleOrm.sql`e.${drizzleOrm.sql.raw(params.joinField)} = r.id`
-    ];
-    return drizzleOrm.sql`${selectClause} FROM reachable r CROSS JOIN ${params.schema.edgesTable} e ${nodeJoin} WHERE ${drizzleOrm.sql.join(allWhere, drizzleOrm.sql` AND `)}`;
-  }
-  const where = [...params.whereClauses];
-  return drizzleOrm.sql`${selectClause} FROM reachable r JOIN ${params.schema.edgesTable} e ON e.${drizzleOrm.sql.raw(params.joinField)} = r.id ${nodeJoin} WHERE ${drizzleOrm.sql.join(where, drizzleOrm.sql` AND `)}`;
-}
-function compileBidirectionalBranch(params) {
-  const columns = [...params.recursiveColumns];
-  const selectClause = drizzleOrm.sql`SELECT ${drizzleOrm.sql.join(columns, drizzleOrm.sql`, `)}`;
-  const nodeJoin = drizzleOrm.sql`JOIN ${params.schema.nodesTable} n ON n.graph_id = e.graph_id AND ((e.to_id = r.id AND n.id = e.from_id AND n.kind = e.from_kind) OR (e.from_id = r.id AND n.id = e.to_id AND n.kind = e.to_kind))`;
-  if (params.forceWorktableOuterJoinOrder) {
-    const allWhere = [
-      ...params.whereClauses,
-      drizzleOrm.sql`(e.from_id = r.id OR e.to_id = r.id)`
-    ];
-    return drizzleOrm.sql`${selectClause} FROM reachable r CROSS JOIN ${params.schema.edgesTable} e ${nodeJoin} WHERE ${drizzleOrm.sql.join(allWhere, drizzleOrm.sql` AND `)}`;
-  }
-  return drizzleOrm.sql`${selectClause} FROM reachable r JOIN ${params.schema.edgesTable} e ON (e.from_id = r.id OR e.to_id = r.id) ${nodeJoin} WHERE ${drizzleOrm.sql.join([...params.whereClauses], drizzleOrm.sql` AND `)}`;
-}
 function buildIncludedIdsCte(ctx) {
   const filters = [];
   if (ctx.includeKinds !== void 0 && ctx.includeKinds.length > 0) {
@@ -3758,6 +4182,12 @@ async function fetchSubgraphNodes(ctx, reachableCte, includedIdsCte, projectionP
 }
 async function fetchSubgraphEdges(ctx, reachableCte, includedIdsCte, projectionPlan) {
   const edgeKindFilter = compileKindFilter(drizzleOrm.sql.raw("e.kind"), ctx.edgeKinds);
+  const edgeTemporalFilter = compileTemporalFilter({
+    mode: ctx.temporalMode,
+    asOf: ctx.asOf,
+    tableAlias: "e",
+    currentTimestamp: ctx.dialect.currentTimestamp()
+  });
   const columns = [
     drizzleOrm.sql`e.id`,
     drizzleOrm.sql`e.kind`,
@@ -3775,7 +4205,7 @@ async function fetchSubgraphEdges(ctx, reachableCte, includedIdsCte, projectionP
     ]),
     ...buildProjectedPropertyColumns("e", projectionPlan, ctx.dialect)
   ];
-  const query = drizzleOrm.sql`${reachableCte}${includedIdsCte} SELECT ${drizzleOrm.sql.join(columns, drizzleOrm.sql`, `)} FROM ${ctx.schema.edgesTable} e WHERE e.graph_id = ${ctx.graphId} AND ${edgeKindFilter} AND e.deleted_at IS NULL AND e.from_id IN (SELECT id FROM included_ids) AND e.to_id IN (SELECT id FROM included_ids)`;
+  const query = drizzleOrm.sql`${reachableCte}${includedIdsCte} SELECT ${drizzleOrm.sql.join(columns, drizzleOrm.sql`, `)} FROM ${ctx.schema.edgesTable} e WHERE e.graph_id = ${ctx.graphId} AND ${edgeKindFilter} AND ${edgeTemporalFilter} AND e.from_id IN (SELECT id FROM included_ids) AND e.to_id IN (SELECT id FROM included_ids)`;
   return ctx.backend.execute(query);
 }
 function buildMetadataColumns(alias, plan, columns) {
@@ -3814,11 +4244,11 @@ function buildProjectedPropertyColumns(alias, plan, dialect) {
       const extracted = compileTypedJsonExtract({
         column: drizzleOrm.sql.raw(`${alias}.props`),
         dialect,
-        pointer: chunkP5CNM325_cjs.jsonPointer([fieldPlan.field]),
+        pointer: chunkUVZHTBZ5_cjs.jsonPointer([fieldPlan.field]),
         valueType: fieldPlan.typeInfo?.valueType
       });
       columns.push(
-        drizzleOrm.sql`CASE WHEN ${drizzleOrm.sql.raw(alias)}.kind = ${kind} THEN ${extracted} ELSE NULL END AS ${quoteIdentifier(fieldPlan.outputName)}`
+        drizzleOrm.sql`CASE WHEN ${drizzleOrm.sql.raw(alias)}.kind = ${kind} THEN ${extracted} ELSE NULL END AS ${quoteIdentifier2(fieldPlan.outputName)}`
       );
     }
   }
@@ -3885,16 +4315,6 @@ function mapSubgraphEdgeRow(row, projectionPlan) {
   applyProjectedFields(projectedEdge, row, kindPlan);
   return projectedEdge;
 }
-
-// src/query/ast.ts
-function mergeEdgeKinds(traversal) {
-  const inverse = traversal.inverseEdgeKinds;
-  if (inverse === void 0 || inverse.length === 0) return traversal.edgeKinds;
-  return [
-    ...traversal.edgeKinds,
-    ...inverse.filter((kind) => !traversal.edgeKinds.includes(kind))
-  ];
-}
 var OPERATOR_MAP = {
   union: "UNION",
   unionAll: "UNION ALL",
@@ -4051,6 +4471,9 @@ function validateSqliteSetOpLeaf(ast) {
   if (hasVectorSimilarityPredicates(ast)) {
     unsupported.push("vector similarity predicates");
   }
+  if (hasFulltextMatchPredicates(ast)) {
+    unsupported.push("fulltext match predicates");
+  }
   if (ast.groupBy !== void 0) {
     unsupported.push("GROUP BY");
   }
@@ -4100,7 +4523,42 @@ function hasVectorSimilarityInExpression(expr) {
       case "between":
       case "array_op":
       case "object_op":
-      case "aggregate_comparison": {
+      case "aggregate_comparison":
+      case "fulltext_match": {
+        return false;
+      }
+    }
+  }
+  return false;
+}
+function hasFulltextMatchPredicates(ast) {
+  return ast.predicates.some(
+    (predicate2) => hasFulltextMatchInExpression(predicate2.expression)
+  );
+}
+function hasFulltextMatchInExpression(expr) {
+  if ("__type" in expr) {
+    switch (expr.__type) {
+      case "and":
+      case "or": {
+        return expr.predicates.some((p) => hasFulltextMatchInExpression(p));
+      }
+      case "not": {
+        return hasFulltextMatchInExpression(expr.predicate);
+      }
+      case "fulltext_match": {
+        return true;
+      }
+      case "exists":
+      case "in_subquery":
+      case "comparison":
+      case "string_op":
+      case "null_check":
+      case "between":
+      case "array_op":
+      case "object_op":
+      case "aggregate_comparison":
+      case "vector_similarity": {
         return false;
       }
     }
@@ -4136,7 +4594,8 @@ function hasSubqueryInExpression(expr) {
       case "array_op":
       case "object_op":
       case "aggregate_comparison":
-      case "vector_similarity": {
+      case "vector_similarity":
+      case "fulltext_match": {
         return false;
       }
     }
@@ -4302,7 +4761,7 @@ function getLeftmostProjection(op) {
 function normalizeFieldRefKey(field2) {
   let pointer = field2.jsonPointer;
   if (pointer === void 0 && field2.path.length > 1 && field2.path[0] === "props") {
-    pointer = chunkP5CNM325_cjs.jsonPointer(field2.path.slice(1));
+    pointer = chunkUVZHTBZ5_cjs.jsonPointer(field2.path.slice(1));
   }
   const basePath = field2.path.length > 0 && field2.path[0] === "props" ? "props" : field2.path.join(".");
   return `${field2.alias}:${basePath}:${pointer ?? ""}`;
@@ -4414,6 +4873,10 @@ function markPredicateFieldsAsRequired(requiredColumnsByAlias, expression) {
       markFieldRefAsRequired(requiredColumnsByAlias, expression.field);
       return;
     }
+    case "fulltext_match": {
+      markFieldRefAsRequired(requiredColumnsByAlias, expression.field);
+      return;
+    }
     case "exists": {
       return;
     }
@@ -4478,7 +4941,8 @@ function hasIdEqualityPredicate(expression, alias) {
     case "aggregate_comparison":
     case "exists":
     case "in_subquery":
-    case "vector_similarity": {
+    case "vector_similarity":
+    case "fulltext_match": {
       return false;
     }
   }
@@ -4519,10 +4983,13 @@ function resolveTraversalCteLimit(ast, predicateIndex) {
   );
   return Math.max(ast.limit, pushdownLimit);
 }
-function canCollapseSelectiveTraversalRowset(ast, vectorPredicate) {
+function canCollapseSelectiveTraversalRowset(ast, vectorPredicate, fulltextPredicate) {
   if (vectorPredicate !== void 0) {
     return false;
   }
+  if (fulltextPredicate !== void 0) {
+    return false;
+  }
   if (ast.traversals.length === 0) {
     return false;
   }
@@ -4562,6 +5029,8 @@ function runStandardQueryPassPipeline(ast, graphId, ctx) {
     collapsedTraversalCteAlias: void 0,
     ctx,
     effectiveLimit: void 0,
+    fulltextPredicate: void 0,
+    fusion: void 0,
     logicalPlan: void 0,
     predicateIndex: buildPredicateIndex(ast),
     requiredColumnsByAlias: void 0,
@@ -4583,6 +5052,39 @@ function runStandardQueryPassPipeline(ast, graphId, ctx) {
     }
   });
   state = vectorPass.state;
+  const fulltextPass = runCompilerPass(state, {
+    name: "fulltext_predicate",
+    execute(currentState) {
+      return runFulltextPredicatePass(
+        currentState.ast,
+        currentState.ctx.dialect
+      ).fulltextPredicate;
+    },
+    update(currentState, fulltextPredicate) {
+      return {
+        ...currentState,
+        fulltextPredicate
+      };
+    }
+  });
+  state = fulltextPass.state;
+  const fusionPass = runCompilerPass(state, {
+    name: "fusion_config",
+    execute(currentState) {
+      return runFusionConfigPass(
+        currentState.ast,
+        currentState.vectorPredicate,
+        currentState.fulltextPredicate
+      ).fusion;
+    },
+    update(currentState, fusion) {
+      return {
+        ...currentState,
+        fusion
+      };
+    }
+  });
+  state = fusionPass.state;
   const temporalPass = runCompilerPass(state, {
     name: "temporal_filters",
     execute(currentState) {
@@ -4617,7 +5119,8 @@ function runStandardQueryPassPipeline(ast, graphId, ctx) {
     execute(currentState) {
       const shouldCollapseSelectiveTraversalRowset = canCollapseSelectiveTraversalRowset(
         currentState.ast,
-        currentState.vectorPredicate
+        currentState.vectorPredicate,
+        currentState.fulltextPredicate
       );
       const lastTraversal = currentState.ast.traversals.at(-1);
       const collapsedTraversalCteAlias = shouldCollapseSelectiveTraversalRowset && lastTraversal !== void 0 ? `cte_${lastTraversal.nodeAlias}` : void 0;
@@ -4653,9 +5156,9 @@ function runStandardQueryPassPipeline(ast, graphId, ctx) {
   state = traversalLimitPass.state;
   state = {
     ...state,
-    effectiveLimit: resolveVectorAwareLimit(
-      state.ast.limit,
-      state.vectorPredicate
+    effectiveLimit: resolveFulltextAwareLimit(
+      resolveVectorAwareLimit(state.ast.limit, state.vectorPredicate),
+      state.fulltextPredicate
     )
   };
   const logicalPlanPass = runCompilerPass(state, {
@@ -4672,7 +5175,8 @@ function runStandardQueryPassPipeline(ast, graphId, ctx) {
           collapsedTraversalCteAlias: currentState.collapsedTraversalCteAlias
         },
         ...currentState.effectiveLimit === void 0 ? {} : { effectiveLimit: currentState.effectiveLimit },
-        ...currentState.vectorPredicate === void 0 ? {} : { vectorPredicate: currentState.vectorPredicate }
+        ...currentState.vectorPredicate === void 0 ? {} : { vectorPredicate: currentState.vectorPredicate },
+        ...currentState.fulltextPredicate === void 0 ? {} : { fulltextPredicate: currentState.fulltextPredicate }
       });
     },
     update(currentState, logicalPlan) {
@@ -4691,11 +5195,11 @@ function compileQuery(ast, graphId, options = "sqlite") {
   const options_ = typeof options === "string" ? { dialect: options } : options;
   const dialect = options_.dialect ?? "sqlite";
   const schema = options_.schema ?? DEFAULT_SQL_SCHEMA;
-  const adapter = chunkMME3H4ZF_cjs.getDialect(dialect);
+  const adapter = resolveDialectAdapter(dialect, options_.fulltextStrategy);
   const ctx = {
     dialect: adapter,
     schema,
-    compileQuery: (subAst, subGraphId) => compileQuery(subAst, subGraphId, { dialect, schema })
+    compileQuery: (subAst, subGraphId) => compileQuery(subAst, subGraphId, propagateOptions(options_))
   };
   if (hasVariableLengthTraversal(ast)) {
     const lowered = tryLowerSingleHopRecursiveTraversal(ast);
@@ -4731,15 +5235,29 @@ function compileSetOperation2(op, graphId, options = "sqlite") {
   const options_ = typeof options === "string" ? { dialect: options } : options;
   const dialect = options_.dialect ?? "sqlite";
   const schema = options_.schema ?? DEFAULT_SQL_SCHEMA;
-  const adapter = chunkMME3H4ZF_cjs.getDialect(dialect);
+  const adapter = resolveDialectAdapter(dialect, options_.fulltextStrategy);
   return compileSetOperation(
     op,
     graphId,
     adapter,
     schema,
-    (ast, gid) => compileQuery(ast, gid, { dialect, schema })
+    (ast, gid) => compileQuery(ast, gid, propagateOptions(options_))
   );
 }
+function resolveDialectAdapter(dialect, fulltextStrategy) {
+  const baseAdapter = chunkFQCQM3KG_cjs.getDialect(dialect);
+  if (fulltextStrategy === void 0 || fulltextStrategy === baseAdapter.fulltext) {
+    return baseAdapter;
+  }
+  return { ...baseAdapter, fulltext: fulltextStrategy };
+}
+function propagateOptions(options_) {
+  return {
+    dialect: options_.dialect ?? "sqlite",
+    ...options_.schema === void 0 ? {} : { schema: options_.schema },
+    ...options_.fulltextStrategy === void 0 ? {} : { fulltextStrategy: options_.fulltextStrategy }
+  };
+}
 function resolveCountAggregateFastPath(ast) {
   if (ast.traversals.length !== 1) {
     return void 0;
@@ -4888,12 +5406,12 @@ function compileCountAggregateFastPath(ast, graphId, ctx, logicalPlan, requiredC
           source.valueType,
           `cte_${source.alias}`
         );
-        return drizzleOrm.sql`${value} AS ${quoteIdentifier(projectedField.outputName)}`;
+        return drizzleOrm.sql`${value} AS ${quoteIdentifier2(projectedField.outputName)}`;
       }
       const projectedCountColumn = source.function === "countDistinct" ? countDistinctColumn : countColumn;
       const countValue = drizzleOrm.sql`${drizzleOrm.sql.raw(countCteAlias)}.${drizzleOrm.sql.raw(projectedCountColumn)}`;
       const aggregateValue = traversal.optional ? drizzleOrm.sql`COALESCE(${countValue}, 0)` : countValue;
-      return drizzleOrm.sql`${aggregateValue} AS ${quoteIdentifier(projectedField.outputName)}`;
+      return drizzleOrm.sql`${aggregateValue} AS ${quoteIdentifier2(projectedField.outputName)}`;
     }),
     drizzleOrm.sql`, `
   );
@@ -4918,19 +5436,45 @@ function compileCountAggregateFastPath(ast, graphId, ctx, logicalPlan, requiredC
     projection
   });
 }
-var STANDARD_QUERY_STRATEGY_HANDLERS = {
-  cte_project: compileStandardQueryWithCteStrategy
-};
-function compileStandardQuery(ast, graphId, ctx) {
-  const strategy = ctx.dialect.capabilities.standardQueryStrategy;
-  const handler = STANDARD_QUERY_STRATEGY_HANDLERS[strategy];
-  return handler(ast, graphId, ctx);
-}
+var STANDARD_QUERY_STRATEGY_HANDLERS = {
+  cte_project: compileStandardQueryWithCteStrategy
+};
+function compileStandardQuery(ast, graphId, ctx) {
+  const strategy = ctx.dialect.capabilities.standardQueryStrategy;
+  const handler = STANDARD_QUERY_STRATEGY_HANDLERS[strategy];
+  return handler(ast, graphId, ctx);
+}
+function selectStandardOrderBy(input) {
+  const {
+    ast,
+    collapsedTraversalCteAlias,
+    dialect,
+    fulltextPredicate,
+    fusion,
+    vectorPredicate
+  } = input;
+  if (vectorPredicate && fulltextPredicate) {
+    return buildStandardHybridRrfOrderBy({ ast, dialect, fusion });
+  }
+  if (vectorPredicate) {
+    return buildStandardVectorOrderBy({ ast, dialect });
+  }
+  if (fulltextPredicate) {
+    return buildStandardFulltextOrderBy({ ast, dialect });
+  }
+  return buildStandardOrderBy({
+    ast,
+    ...collapsedTraversalCteAlias === void 0 ? {} : { collapsedTraversalCteAlias },
+    dialect
+  });
+}
 function compileStandardQueryWithCteStrategy(ast, graphId, ctx) {
   const { dialect } = ctx;
   const {
     collapsedTraversalCteAlias,
     effectiveLimit,
+    fulltextPredicate,
+    fusion,
     logicalPlan,
     predicateIndex,
     requiredColumnsByAlias,
@@ -4951,7 +5495,7 @@ function compileStandardQueryWithCteStrategy(ast, graphId, ctx) {
       { phase: "standard-pass-pipeline" }
     );
   }
-  if (!vectorPredicate) {
+  if (!vectorPredicate && !fulltextPredicate) {
     const fastPathSql = compileCountAggregateFastPath(
       ast,
       graphId,
@@ -4997,7 +5541,29 @@ function compileStandardQueryWithCteStrategy(ast, graphId, ctx) {
     );
   }
   if (vectorPredicate) {
-    ctes.push(buildStandardEmbeddingsCte({ ctx, graphId, vectorPredicate }));
+    const nodeKinds = getNodeKindsForAlias(ast, vectorPredicate.field.alias);
+    ctes.push(
+      buildStandardEmbeddingsCte({
+        ctx,
+        graphId,
+        nodeKinds,
+        vectorPredicate
+      })
+    );
+  }
+  if (fulltextPredicate) {
+    const nodeKinds = getNodeKindsForAlias(ast, fulltextPredicate.field.alias);
+    ctes.push(
+      buildStandardFulltextCte({
+        ctx,
+        fulltextPredicate,
+        graphId,
+        nodeKinds
+      })
+    );
+  }
+  if (getHybridTargetAlias(vectorPredicate, fulltextPredicate) !== void 0) {
+    ctes.push(buildStandardHybridCandidateCte());
   }
   const projection = buildStandardProjection({
     ast,
@@ -5007,14 +5573,18 @@ function compileStandardQueryWithCteStrategy(ast, graphId, ctx) {
   const fromClause = buildStandardFromClause({
     ast,
     ...collapsedTraversalCteAlias === void 0 ? {} : { collapsedTraversalCteAlias },
-    ...vectorPredicate === void 0 ? {} : { vectorPredicate }
+    ...vectorPredicate === void 0 ? {} : { vectorPredicate },
+    ...fulltextPredicate === void 0 ? {} : { fulltextPredicate }
   });
   const groupBy = buildStandardGroupBy({ ast, dialect });
   const having2 = buildStandardHaving({ ast, ctx });
-  const orderBy = vectorPredicate ? buildStandardVectorOrderBy({ ast, dialect }) : buildStandardOrderBy({
+  const orderBy = selectStandardOrderBy({
     ast,
-    ...collapsedTraversalCteAlias === void 0 ? {} : { collapsedTraversalCteAlias },
-    dialect
+    collapsedTraversalCteAlias,
+    dialect,
+    fulltextPredicate,
+    fusion,
+    vectorPredicate
   });
   const limitOffset = buildLimitOffsetClause({
     limit: effectiveLimit,
@@ -5136,7 +5706,7 @@ function extractCursorValue(row, spec) {
       current = record[segment];
     }
     if (jsonPointer2) {
-      const segments = chunkP5CNM325_cjs.parseJsonPointer(jsonPointer2);
+      const segments = chunkUVZHTBZ5_cjs.parseJsonPointer(jsonPointer2);
       for (const segment of segments) {
         if (current === null || current === void 0) return void 0;
         if (typeof current !== "object") return void 0;
@@ -5206,14 +5776,14 @@ function generateId() {
 
 // src/utils/path.ts
 function parseSqlitePath(path) {
-  const emptyPath = `${chunkMME3H4ZF_cjs.SQLITE_PATH_DELIMITER}${chunkMME3H4ZF_cjs.SQLITE_PATH_DELIMITER}`;
+  const emptyPath = `${chunkFQCQM3KG_cjs.SQLITE_PATH_DELIMITER}${chunkFQCQM3KG_cjs.SQLITE_PATH_DELIMITER}`;
   if (!path || path === emptyPath) return [];
   const trimmed = path.slice(1, -1);
   if (trimmed === "") return [];
-  return trimmed.split(chunkMME3H4ZF_cjs.SQLITE_PATH_DELIMITER);
+  return trimmed.split(chunkFQCQM3KG_cjs.SQLITE_PATH_DELIMITER);
 }
 function isSqlitePath(value) {
-  return typeof value === "string" && value.startsWith(chunkMME3H4ZF_cjs.SQLITE_PATH_DELIMITER) && value.endsWith(chunkMME3H4ZF_cjs.SQLITE_PATH_DELIMITER);
+  return typeof value === "string" && value.startsWith(chunkFQCQM3KG_cjs.SQLITE_PATH_DELIMITER) && value.endsWith(chunkFQCQM3KG_cjs.SQLITE_PATH_DELIMITER);
 }
 function normalizePath(value) {
   if (Array.isArray(value)) {
@@ -5228,12 +5798,12 @@ function normalizePath(value) {
   return [];
 }
 function isPostgresTextArray(value) {
-  return typeof value === "string" && value.startsWith(chunkMME3H4ZF_cjs.PG_ARRAY_START) && value.endsWith(chunkMME3H4ZF_cjs.PG_ARRAY_END);
+  return typeof value === "string" && value.startsWith(chunkFQCQM3KG_cjs.PG_ARRAY_START) && value.endsWith(chunkFQCQM3KG_cjs.PG_ARRAY_END);
 }
 function parsePostgresTextArray(value) {
   const inner = value.slice(1, -1);
   if (inner === "") return [];
-  return inner.split(chunkMME3H4ZF_cjs.PG_PATH_ELEMENT_SEPARATOR);
+  return inner.split(chunkFQCQM3KG_cjs.PG_PATH_ELEMENT_SEPARATOR);
 }
 
 // src/query/execution/result-mapper.ts
@@ -5435,11 +6005,7 @@ function buildComparisonPredicate(field2, op, value) {
   };
 }
 function buildCursorFromContext(context, orderBy, direction) {
-  return buildCursorFromRow(
-    context,
-    orderBy,
-    direction
-  );
+  return buildCursorFromRow(context, orderBy, direction);
 }
 function buildPaginatedResult(data, orderedRows, orderBy, limit, hasMore, isBackward, cursor, buildContext) {
   let nextCursor;
@@ -5474,7 +6040,7 @@ async function* createStreamIterable(batchSize, paginate) {
   }
 }
 function getStreamBatchSize(options) {
-  return options?.batchSize ?? chunkMME3H4ZF_cjs.DEFAULT_STREAM_BATCH_SIZE;
+  return options?.batchSize ?? chunkFQCQM3KG_cjs.DEFAULT_STREAM_BATCH_SIZE;
 }
 
 // src/query/execution/field-tracker.ts
@@ -5556,7 +6122,7 @@ function createNodeTrackingProxy(alias, kindNames, tracker, options) {
           return getPlaceholderForSystemField(property, options.mode);
         }
         if (property === "meta") {
-          for (const key of chunkMME3H4ZF_cjs.NODE_META_KEYS) {
+          for (const key of chunkFQCQM3KG_cjs.NODE_META_KEYS) {
             tracker.record(alias, `meta.${key}`, true);
           }
           return buildNodeMetaPlaceholder(options.mode);
@@ -5589,7 +6155,7 @@ function createEdgeTrackingProxy(alias, edgeKindNames, tracker, options) {
           return getPlaceholderForSystemField(property, options.mode);
         }
         if (property === "meta") {
-          for (const key of chunkMME3H4ZF_cjs.EDGE_META_KEYS) {
+          for (const key of chunkFQCQM3KG_cjs.EDGE_META_KEYS) {
             tracker.record(alias, `meta.${key}`, true);
           }
           return buildEdgeMetaPlaceholder(options.mode);
@@ -6032,59 +6598,41 @@ function validateSqlIdentifier(alias) {
     );
   }
 }
-function throwInvalidVectorPredicatePlacement(path) {
-  throw new chunkO5PST6TB_cjs.ValidationError(
-    "Vector similarity predicates cannot be nested under OR or NOT. Use top-level AND combinations instead.",
-    {
-      issues: [
-        {
-          path,
-          message: "Vector similarity predicates are only supported at top-level or inside AND groups."
-        }
-      ]
-    },
-    {
-      suggestion: "Rewrite the predicate to keep vector similarity at top-level or combine with additional filters using AND."
-    }
-  );
-}
-function validateVectorPredicateExpression(expression, inDisallowedBranch, path) {
+function validateStructuralPredicatePlacement(expression, matchType, buildError, inDisallowedBranch, path) {
+  if (expression.__type === matchType) {
+    if (inDisallowedBranch) buildError(path);
+    return;
+  }
   switch (expression.__type) {
-    case "vector_similarity": {
-      if (inDisallowedBranch) {
-        throwInvalidVectorPredicatePlacement(path);
-      }
-      return;
-    }
     case "and": {
-      for (const [
-        predicateIndex,
-        predicate2
-      ] of expression.predicates.entries()) {
-        validateVectorPredicateExpression(
-          predicate2,
+      for (const [index, child] of expression.predicates.entries()) {
+        validateStructuralPredicatePlacement(
+          child,
+          matchType,
+          buildError,
           inDisallowedBranch,
-          `${path}.predicates[${predicateIndex}]`
+          `${path}.predicates[${index}]`
         );
       }
       return;
     }
     case "or": {
-      for (const [
-        predicateIndex,
-        predicate2
-      ] of expression.predicates.entries()) {
-        validateVectorPredicateExpression(
-          predicate2,
+      for (const [index, child] of expression.predicates.entries()) {
+        validateStructuralPredicatePlacement(
+          child,
+          matchType,
+          buildError,
           true,
-          `${path}.predicates[${predicateIndex}]`
+          `${path}.predicates[${index}]`
         );
       }
       return;
     }
     case "not": {
-      validateVectorPredicateExpression(
+      validateStructuralPredicatePlacement(
         expression.predicate,
+        matchType,
+        buildError,
         true,
         `${path}.predicate`
       );
@@ -6098,24 +6646,108 @@ function validateVectorPredicateExpression(expression, inDisallowedBranch, path)
     case "object_op":
     case "aggregate_comparison":
     case "exists":
-    case "in_subquery": {
+    case "in_subquery":
+    case "vector_similarity":
+    case "fulltext_match": {
       return;
     }
   }
 }
+function throwInvalidVectorPredicatePlacement(path) {
+  throw new chunkO5PST6TB_cjs.ValidationError(
+    "Vector similarity predicates cannot be nested under OR or NOT. Use top-level AND combinations instead.",
+    {
+      issues: [
+        {
+          path,
+          message: "Vector similarity predicates are only supported at top-level or inside AND groups."
+        }
+      ]
+    },
+    {
+      suggestion: "Rewrite the predicate to keep vector similarity at top-level or combine with additional filters using AND."
+    }
+  );
+}
+function throwInvalidFulltextPredicatePlacement(path) {
+  throw new chunkO5PST6TB_cjs.ValidationError(
+    "Fulltext match predicates (.matches()) cannot be nested under OR or NOT. Use top-level AND combinations instead.",
+    {
+      issues: [
+        {
+          path,
+          message: "Fulltext match predicates are only supported at top-level or inside AND groups."
+        }
+      ]
+    },
+    {
+      suggestion: "Restructure your query so the fulltext match appears at the top level of a whereNode() or inside an .and() combination."
+    }
+  );
+}
 function validateVectorPredicatePlacement(predicates) {
-  for (const [predicateIndex, predicate2] of predicates.entries()) {
-    validateVectorPredicateExpression(
+  for (const [index, predicate2] of predicates.entries()) {
+    validateStructuralPredicatePlacement(
+      predicate2.expression,
+      "vector_similarity",
+      throwInvalidVectorPredicatePlacement,
+      false,
+      `predicates[${index}].expression`
+    );
+  }
+}
+function validateFulltextPredicatePlacement(predicates) {
+  for (const [index, predicate2] of predicates.entries()) {
+    validateStructuralPredicatePlacement(
       predicate2.expression,
+      "fulltext_match",
+      throwInvalidFulltextPredicatePlacement,
       false,
-      `predicates[${predicateIndex}].expression`
+      `predicates[${index}].expression`
+    );
+  }
+}
+function validateHybridFusionOptions(options) {
+  const method = options.method;
+  if (method !== void 0 && method !== "rrf") {
+    throw new chunkO5PST6TB_cjs.ValidationError(`Unsupported fusion method: ${method}`, {
+      issues: [{ path: "fusion.method", message: `Only "rrf" is supported.` }]
+    });
+  }
+  const { k } = options;
+  if (k !== void 0 && (!Number.isFinite(k) || k <= 0)) {
+    throw new chunkO5PST6TB_cjs.ValidationError(
+      `Fusion k must be a positive finite number, got: ${String(k)}`,
+      {
+        issues: [{ path: "fusion.k", message: "Must be a positive number." }]
+      }
     );
   }
+  const weights = options.weights;
+  if (weights !== void 0) {
+    for (const key of ["vector", "fulltext"]) {
+      const weight = weights[key];
+      if (weight !== void 0 && (!Number.isFinite(weight) || weight < 0)) {
+        throw new chunkO5PST6TB_cjs.ValidationError(
+          `Fusion weight for "${key}" must be a non-negative finite number, got: ${String(weight)}`,
+          {
+            issues: [
+              {
+                path: `fusion.weights.${key}`,
+                message: "Must be a non-negative number."
+              }
+            ]
+          }
+        );
+      }
+    }
+  }
 }
 
 // src/query/builder/ast-builder.ts
 function buildQueryAst(config, state) {
   validateVectorPredicatePlacement(state.predicates);
+  validateFulltextPredicatePlacement(state.predicates);
   const temporalMode = {
     mode: state.temporalMode
   };
@@ -6139,7 +6771,18 @@ function buildQueryAst(config, state) {
     ...state.limit !== void 0 && { limit: state.limit },
     ...state.offset !== void 0 && { offset: state.offset },
     ...state.groupBy !== void 0 && { groupBy: state.groupBy },
-    ...state.having !== void 0 && { having: state.having }
+    ...state.having !== void 0 && { having: state.having },
+    ...state.fusion !== void 0 && { fusion: state.fusion }
+  };
+}
+
+// src/query/builder/compile-options.ts
+function buildCompileOptions(config) {
+  const fulltextStrategy = config.backend?.fulltextStrategy;
+  return {
+    dialect: config.dialect ?? "sqlite",
+    schema: config.schema,
+    ...fulltextStrategy === void 0 ? {} : { fulltextStrategy }
   };
 }
 function toLiteral(value) {
@@ -6241,7 +6884,8 @@ function substitutePredicateExpression(expr, bindings) {
     case "array_op":
     case "object_op":
     case "aggregate_comparison":
-    case "vector_similarity": {
+    case "vector_similarity":
+    case "fulltext_match": {
       return expr;
     }
     case "exists": {
@@ -6280,7 +6924,7 @@ function substituteParameters(ast, bindings) {
   };
 }
 function fillPlaceholders(params, bindings, dialect) {
-  const adapter = chunkMME3H4ZF_cjs.getDialect(dialect);
+  const adapter = chunkFQCQM3KG_cjs.getDialect(dialect);
   return params.map((parameter) => {
     if (parameter instanceof drizzleOrm.Placeholder) {
       const name = parameter.name;
@@ -6493,7 +7137,8 @@ function collectParameterMetadataFromExpression(expression, names, stringOpParam
     case "array_op":
     case "object_op":
     case "aggregate_comparison":
-    case "vector_similarity": {
+    case "vector_similarity":
+    case "fulltext_match": {
       return;
     }
     case "exists": {
@@ -6624,7 +7269,7 @@ var ExecutableQuery = class _ExecutableQuery {
       direction
     } : {
       field: fieldRef(alias, ["props"], {
-        jsonPointer: chunkP5CNM325_cjs.jsonPointer([field2]),
+        jsonPointer: chunkUVZHTBZ5_cjs.jsonPointer([field2]),
         valueType: typeInfo?.valueType,
         elementType: typeInfo?.elementType
       }),
@@ -6848,10 +7493,7 @@ var ExecutableQuery = class _ExecutableQuery {
    * Builds compile options from the config.
    */
   #compileOptions() {
-    return {
-      dialect: this.#config.dialect ?? "sqlite",
-      schema: this.#config.schema
-    };
+    return buildCompileOptions(this.#config);
   }
   #requireBackend() {
     const { backend } = this.#config;
@@ -7233,7 +7875,7 @@ var ExecutableQuery = class _ExecutableQuery {
       if (field2.jsonPointer === void 0) {
         return false;
       }
-      const segments = chunkP5CNM325_cjs.parseJsonPointer(field2.jsonPointer);
+      const segments = chunkUVZHTBZ5_cjs.parseJsonPointer(field2.jsonPointer);
       if (segments.length !== 1) {
         return false;
       }
@@ -7281,7 +7923,7 @@ var ExecutableQuery = class _ExecutableQuery {
         aliasObject2[fieldName] = nullToUndefined(row[outputName2]);
         continue;
       }
-      const segments = chunkP5CNM325_cjs.parseJsonPointer(jsonPointer2);
+      const segments = chunkUVZHTBZ5_cjs.parseJsonPointer(jsonPointer2);
       if (segments.length === 0) {
         throw new MissingSelectiveFieldError(alias, "orderBy");
       }
@@ -7377,7 +8019,7 @@ var ExecutableQuery = class _ExecutableQuery {
       );
     }
     const isBackward = options.last !== void 0 || options.before !== void 0;
-    const limit = options.first ?? options.last ?? chunkMME3H4ZF_cjs.DEFAULT_PAGINATION_LIMIT;
+    const limit = options.first ?? options.last ?? chunkFQCQM3KG_cjs.DEFAULT_PAGINATION_LIMIT;
     const cursor = options.after ?? options.before;
     let cursorData;
     if (cursor) {
@@ -7566,14 +8208,8 @@ var ExecutableAggregateQuery = class _ExecutableAggregateQuery {
     this.#cachedCompiled = compiled;
     return compiled;
   }
-  /**
-   * Builds compile options from the config.
-   */
   #compileOptions() {
-    return {
-      dialect: this.#config.dialect ?? "sqlite",
-      schema: this.#config.schema
-    };
+    return buildCompileOptions(this.#config);
   }
   /**
    * Executes the query and returns typed results.
@@ -7804,7 +8440,7 @@ var TraversalBuilder = class _TraversalBuilder {
       const valueType = typeInfo?.valueType;
       const elementType = typeInfo?.elementType;
       const ref = fieldRef(alias, ["props"], {
-        jsonPointer: chunkP5CNM325_cjs.jsonPointer([propertyName]),
+        jsonPointer: chunkUVZHTBZ5_cjs.jsonPointer([propertyName]),
         valueType,
         elementType
       });
@@ -8124,7 +8760,7 @@ var QueryBuilder = class _QueryBuilder {
         if (source.valueType !== void 0 || source.path.length !== 1 || source.path[0] !== "props" || source.jsonPointer === void 0) {
           return [outputName, source];
         }
-        const segments = chunkP5CNM325_cjs.parseJsonPointer(source.jsonPointer);
+        const segments = chunkUVZHTBZ5_cjs.parseJsonPointer(source.jsonPointer);
         if (segments.length !== 1) {
           return [outputName, source];
         }
@@ -8178,7 +8814,7 @@ var QueryBuilder = class _QueryBuilder {
       direction
     } : {
       field: fieldRef(alias, ["props"], {
-        jsonPointer: chunkP5CNM325_cjs.jsonPointer([field2]),
+        jsonPointer: chunkUVZHTBZ5_cjs.jsonPointer([field2]),
         valueType: typeInfo?.valueType,
         elementType: typeInfo?.elementType
       }),
@@ -8253,7 +8889,7 @@ var QueryBuilder = class _QueryBuilder {
       __type: "field_ref",
       alias,
       path: ["props"],
-      jsonPointer: chunkP5CNM325_cjs.jsonPointer([field2]),
+      jsonPointer: chunkUVZHTBZ5_cjs.jsonPointer([field2]),
       valueType: typeInfo?.valueType,
       elementType: typeInfo?.elementType
     };
@@ -8300,6 +8936,36 @@ var QueryBuilder = class _QueryBuilder {
       having: predicate2
     });
   }
+  /**
+   * Sets fusion parameters for hybrid (vector + fulltext) queries.
+   *
+   * Applies only when the query contains both a `.similarTo()` and a
+   * `.$fulltext.matches()` predicate. Without this call, the default is
+   * RRF with k=60 and equal weights. A mismatch between `.fuseWith()`
+   * configuration and the predicates on the query is caught during
+   * compilation, not here.
+   *
+   * @example
+   * ```typescript
+   * store.query()
+   *   .from("Document", "d")
+   *   .whereNode("d", d =>
+   *     d.$fulltext.matches("renewable energy", 50)
+   *       .and(d.embedding.similarTo(vec, 50))
+   *       .and(d.tenantId.eq(tenant))
+   *   )
+   *   .fuseWith({ k: 60, weights: { fulltext: 1.5 } })
+   *   .limit(10)
+   *   .execute();
+   * ```
+   */
+  fuseWith(options) {
+    validateHybridFusionOptions(options);
+    return new _QueryBuilder(this.#config, {
+      ...this.#state,
+      fusion: options
+    });
+  }
   /**
    * Applies a query fragment to transform this builder.
    *
@@ -8351,42 +9017,14 @@ var QueryBuilder = class _QueryBuilder {
       property
     ) : void 0;
     const ref = fieldRef(alias, ["props"], {
-      jsonPointer: chunkP5CNM325_cjs.jsonPointer([property]),
+      jsonPointer: chunkUVZHTBZ5_cjs.jsonPointer([property]),
       valueType: typeInfo?.valueType,
       elementType: typeInfo?.elementType
     });
     return this.#buildFieldBuilderForTypeInfo(ref, typeInfo);
   }
   #buildFieldBuilderForTypeInfo(ref, typeInfo) {
-    if (!typeInfo) {
-      return baseField(ref);
-    }
-    switch (typeInfo.valueType) {
-      case "string": {
-        return stringField(ref);
-      }
-      case "number": {
-        return numberField(ref);
-      }
-      case "boolean": {
-        return baseField(ref);
-      }
-      case "date": {
-        return dateField(ref);
-      }
-      case "array": {
-        return arrayField(ref);
-      }
-      case "object": {
-        return objectField(ref, { typeInfo });
-      }
-      case "embedding": {
-        return embeddingField(ref);
-      }
-      case "unknown": {
-        return baseField(ref);
-      }
-    }
+    return buildFieldBuilderForTypeInfo(ref, typeInfo);
   }
   #createNodeAccessor(alias) {
     const kindNames = this.#getKindNamesForAlias(alias);
@@ -8396,6 +9034,10 @@ var QueryBuilder = class _QueryBuilder {
     const kindAccessor = stringField(
       fieldRef(alias, ["kind"], { valueType: "string" })
     );
+    const fulltextAccessor = createFulltextAccessor(
+      alias,
+      () => this.#hasSearchableField(kindNames)
+    );
     return new Proxy({}, {
       get: (_, property) => {
         if (typeof property === "symbol") return;
@@ -8403,10 +9045,15 @@ var QueryBuilder = class _QueryBuilder {
         if (property === "toJSON") return;
         if (property === "id") return idAccessor;
         if (property === "kind") return kindAccessor;
+        if (property === "$fulltext") return fulltextAccessor;
         return this.#getFieldBuilderForProperty(kindNames, property, alias);
       }
     });
   }
+  #hasSearchableField(kindNames) {
+    if (!kindNames) return false;
+    return this.#config.schemaIntrospector.hasSearchableField(kindNames);
+  }
   #expandTraversalEdgeKinds(edgeKind, includeImplyingEdges) {
     return includeImplyingEdges ? this.#config.registry.expandImplyingEdges(edgeKind) : [edgeKind];
   }
@@ -8449,7 +9096,7 @@ var QueryBuilder = class _QueryBuilder {
       property
     ) : void 0;
     const ref = fieldRef(alias, ["props"], {
-      jsonPointer: chunkP5CNM325_cjs.jsonPointer([property]),
+      jsonPointer: chunkUVZHTBZ5_cjs.jsonPointer([property]),
       valueType: typeInfo?.valueType,
       elementType: typeInfo?.elementType
     });
@@ -8632,14 +9279,8 @@ var UnionableQuery = class _UnionableQuery {
     this.#cachedCompiled = compiled;
     return compiled;
   }
-  /**
-   * Builds compile options from the config.
-   */
   #compileOptions() {
-    return {
-      dialect: this.#config.dialect ?? "sqlite",
-      schema: this.#config.schema
-    };
+    return buildCompileOptions(this.#config);
   }
   /**
    * Executes the combined query.
@@ -8701,7 +9342,7 @@ function count(alias, field2) {
       __type: "field_ref",
       alias,
       path: field2 ? ["props"] : ["id"],
-      jsonPointer: field2 ? chunkP5CNM325_cjs.jsonPointer([field2]) : void 0,
+      jsonPointer: field2 ? chunkUVZHTBZ5_cjs.jsonPointer([field2]) : void 0,
       valueType: field2 ? void 0 : "string"
     }
   };
@@ -8714,7 +9355,7 @@ function countDistinct(alias, field2) {
       __type: "field_ref",
       alias,
       path: field2 ? ["props"] : ["id"],
-      jsonPointer: field2 ? chunkP5CNM325_cjs.jsonPointer([field2]) : void 0,
+      jsonPointer: field2 ? chunkUVZHTBZ5_cjs.jsonPointer([field2]) : void 0,
       valueType: field2 ? void 0 : "string"
     }
   };
@@ -8727,7 +9368,7 @@ function sum(alias, field2) {
       __type: "field_ref",
       alias,
       path: ["props"],
-      jsonPointer: chunkP5CNM325_cjs.jsonPointer([field2]),
+      jsonPointer: chunkUVZHTBZ5_cjs.jsonPointer([field2]),
       valueType: "number"
     }
   };
@@ -8740,7 +9381,7 @@ function avg(alias, field2) {
       __type: "field_ref",
       alias,
       path: ["props"],
-      jsonPointer: chunkP5CNM325_cjs.jsonPointer([field2]),
+      jsonPointer: chunkUVZHTBZ5_cjs.jsonPointer([field2]),
       valueType: "number"
     }
   };
@@ -8753,7 +9394,7 @@ function min(alias, field2) {
       __type: "field_ref",
       alias,
       path: ["props"],
-      jsonPointer: chunkP5CNM325_cjs.jsonPointer([field2]),
+      jsonPointer: chunkUVZHTBZ5_cjs.jsonPointer([field2]),
       valueType: "number"
     }
   };
@@ -8766,7 +9407,7 @@ function max(alias, field2) {
       __type: "field_ref",
       alias,
       path: ["props"],
-      jsonPointer: chunkP5CNM325_cjs.jsonPointer([field2]),
+      jsonPointer: chunkUVZHTBZ5_cjs.jsonPointer([field2]),
       valueType: "number"
     }
   };
@@ -8797,7 +9438,7 @@ function field(alias, ...path) {
     __type: "field_ref",
     alias,
     path: ["props"],
-    jsonPointer: chunkP5CNM325_cjs.jsonPointer(path)
+    jsonPointer: chunkUVZHTBZ5_cjs.jsonPointer(path)
   };
 }
 function having(aggregate, op, value) {
@@ -8855,16 +9496,12 @@ function offsetFragment(n) {
 }
 
 // src/query/builder/index.ts
-setQueryBuilderClass(
-  QueryBuilder
-);
-setUnionableQueryClass(
-  UnionableQuery
-);
+setQueryBuilderClass(QueryBuilder);
+setUnionableQueryClass(UnionableQuery);
 
 // src/query/builder.ts
 function createQueryBuilder(graphId, registry, options) {
-  const schemaIntrospector = chunkP5CNM325_cjs.createSchemaIntrospector(
+  const schemaIntrospector = chunkUVZHTBZ5_cjs.createSchemaIntrospector(
     registry.nodeKinds,
     registry.edgeKinds
   );
@@ -8891,7 +9528,8 @@ function createQueryBuilder(graphId, registry, options) {
     temporalMode: "current",
     asOf: void 0,
     groupBy: void 0,
-    having: void 0
+    having: void 0,
+    fusion: void 0
   };
   return new QueryBuilder(config, initialState);
 }
@@ -8900,12 +9538,12 @@ function createQueryBuilder(graphId, registry, options) {
 function buildKindRegistry(graph) {
   const nodeTypes = extractNodeTypes(graph);
   const edgeTypes = extractEdgeTypes(graph);
-  const closures = graph.ontology.length > 0 ? chunkX33WV2UF_cjs.computeClosuresFromOntology(graph.ontology) : chunkX33WV2UF_cjs.createEmptyClosures();
-  return new chunkX33WV2UF_cjs.KindRegistry(nodeTypes, edgeTypes, closures);
+  const closures = graph.ontology.length > 0 ? chunkHRNQ3DVJ_cjs.computeClosuresFromOntology(graph.ontology) : chunkHRNQ3DVJ_cjs.createEmptyClosures();
+  return new chunkHRNQ3DVJ_cjs.KindRegistry(nodeTypes, edgeTypes, closures);
 }
 function extractNodeTypes(graph) {
   const result = /* @__PURE__ */ new Map();
-  for (const typeName of chunk5GZMPJOP_cjs.getNodeKinds(graph)) {
+  for (const typeName of chunkWRWVWKQL_cjs.getNodeKinds(graph)) {
     const registration = graph.nodes[typeName];
     result.set(typeName, registration.type);
   }
@@ -8913,13 +9551,253 @@ function extractNodeTypes(graph) {
 }
 function extractEdgeTypes(graph) {
   const result = /* @__PURE__ */ new Map();
-  for (const typeName of chunk5GZMPJOP_cjs.getEdgeKinds(graph)) {
+  for (const typeName of chunkWRWVWKQL_cjs.getEdgeKinds(graph)) {
     const registration = graph.edges[typeName];
     result.set(typeName, registration.type);
   }
   return result;
 }
 
+// src/store/algorithms/context.ts
+var DEFAULT_ALGORITHM_MAX_HOPS = 10;
+var DEFAULT_NEIGHBOR_DEPTH = 1;
+function resolveTemporalOptions(ctx, options) {
+  return {
+    temporalMode: options.temporalMode ?? ctx.defaultTemporalMode,
+    ...options.asOf !== void 0 && { asOf: options.asOf }
+  };
+}
+function resolveTemporalFilter(ctx, options, tableAlias) {
+  const resolved = resolveTemporalOptions(ctx, options);
+  const filterOptions = {
+    mode: resolved.temporalMode,
+    asOf: resolved.asOf,
+    tableAlias,
+    currentTimestamp: ctx.dialect.currentTimestamp()
+  };
+  return compileTemporalFilter(filterOptions);
+}
+function resolveMaxHops(rawMaxHops, fallback, optionName) {
+  const value = rawMaxHops ?? fallback;
+  if (!Number.isFinite(value) || !Number.isInteger(value)) {
+    throw new chunkO5PST6TB_cjs.ConfigurationError(
+      `Graph algorithm ${optionName} must be a finite integer, got ${String(value)}.`,
+      { option: optionName, value }
+    );
+  }
+  if (value < 1) {
+    throw new chunkO5PST6TB_cjs.ConfigurationError(
+      `Graph algorithm ${optionName} must be at least 1, got ${value}.`,
+      { option: optionName, value }
+    );
+  }
+  if (value > MAX_EXPLICIT_RECURSIVE_DEPTH) {
+    throw new chunkO5PST6TB_cjs.ConfigurationError(
+      `Graph algorithm ${optionName} (${value}) exceeds the maximum of ${MAX_EXPLICIT_RECURSIVE_DEPTH}.`,
+      { option: optionName, value, limit: MAX_EXPLICIT_RECURSIVE_DEPTH }
+    );
+  }
+  return value;
+}
+function assertEdgeKinds(edges) {
+  if (edges.length === 0) {
+    throw new chunkO5PST6TB_cjs.ConfigurationError(
+      `Graph algorithms require at least one edge kind in 'edges'.`,
+      { edges }
+    );
+  }
+}
+
+// src/store/algorithms/degree.ts
+async function executeDegree(ctx, nodeId, options = {}) {
+  const direction = options.direction ?? "both";
+  const whereClauses = [
+    drizzleOrm.sql`graph_id = ${ctx.graphId}`,
+    resolveTemporalFilter(ctx, options),
+    compileDirectionFilter(direction, nodeId)
+  ];
+  if (options.edges !== void 0) {
+    whereClauses.push(compileKindFilter(drizzleOrm.sql.raw("kind"), options.edges));
+  }
+  const countExpr = direction === "both" ? drizzleOrm.sql`COUNT(DISTINCT id)` : drizzleOrm.sql`COUNT(*)`;
+  const query = drizzleOrm.sql`SELECT ${countExpr} AS count FROM ${ctx.schema.edgesTable} WHERE ${drizzleOrm.sql.join(whereClauses, drizzleOrm.sql` AND `)}`;
+  const rows = await ctx.backend.execute(query);
+  return Number(rows[0]?.count ?? 0);
+}
+function compileDirectionFilter(direction, nodeId) {
+  switch (direction) {
+    case "out": {
+      return drizzleOrm.sql`from_id = ${nodeId}`;
+    }
+    case "in": {
+      return drizzleOrm.sql`to_id = ${nodeId}`;
+    }
+    case "both": {
+      return drizzleOrm.sql`(from_id = ${nodeId} OR to_id = ${nodeId})`;
+    }
+  }
+}
+async function executeReachable(ctx, sourceId, options) {
+  assertEdgeKinds(options.edges);
+  const maxHops = resolveMaxHops(
+    options.maxHops,
+    DEFAULT_ALGORITHM_MAX_HOPS,
+    "maxHops"
+  );
+  const cte = buildReachableCte({
+    graphId: ctx.graphId,
+    sourceId,
+    edgeKinds: options.edges,
+    maxHops,
+    direction: options.direction ?? "out",
+    cyclePolicy: options.cyclePolicy ?? "prevent",
+    includePath: false,
+    ...resolveTemporalOptions(ctx, options),
+    dialect: ctx.dialect,
+    schema: ctx.schema
+  });
+  const sourceFilter = options.excludeSource === true ? drizzleOrm.sql` WHERE id != ${sourceId}` : drizzleOrm.sql``;
+  const query = drizzleOrm.sql`${cte} SELECT id, kind, MIN(depth) AS depth FROM reachable${sourceFilter} GROUP BY id, kind ORDER BY depth ASC, id ASC`;
+  const rows = await ctx.backend.execute(query);
+  return rows.map((row) => ({
+    id: row.id,
+    kind: row.kind,
+    depth: Number(row.depth)
+  }));
+}
+async function executeCanReach(ctx, sourceId, targetId, options) {
+  assertEdgeKinds(options.edges);
+  const maxHops = resolveMaxHops(
+    options.maxHops,
+    DEFAULT_ALGORITHM_MAX_HOPS,
+    "maxHops"
+  );
+  const cte = buildReachableCte({
+    graphId: ctx.graphId,
+    sourceId,
+    edgeKinds: options.edges,
+    maxHops,
+    direction: options.direction ?? "out",
+    cyclePolicy: options.cyclePolicy ?? "prevent",
+    includePath: false,
+    ...resolveTemporalOptions(ctx, options),
+    dialect: ctx.dialect,
+    schema: ctx.schema
+  });
+  const query = drizzleOrm.sql`${cte} SELECT 1 AS hit FROM reachable WHERE id = ${targetId} LIMIT 1`;
+  const rows = await ctx.backend.execute(query);
+  return rows.length > 0;
+}
+async function executeNeighbors(ctx, sourceId, options) {
+  const depth = resolveMaxHops(options.depth, DEFAULT_NEIGHBOR_DEPTH, "depth");
+  return executeReachable(ctx, sourceId, {
+    edges: options.edges,
+    maxHops: depth,
+    direction: options.direction ?? "out",
+    cyclePolicy: options.cyclePolicy ?? "prevent",
+    ...options.temporalMode !== void 0 && {
+      temporalMode: options.temporalMode
+    },
+    ...options.asOf !== void 0 && { asOf: options.asOf },
+    excludeSource: true
+  });
+}
+async function executeShortestPath(ctx, sourceId, targetId, options) {
+  assertEdgeKinds(options.edges);
+  const maxHops = resolveMaxHops(
+    options.maxHops,
+    DEFAULT_ALGORITHM_MAX_HOPS,
+    "maxHops"
+  );
+  if (sourceId === targetId) {
+    const source = await fetchNodeKind(ctx, sourceId, options);
+    if (source === void 0) return void 0;
+    return { nodes: [source], depth: 0 };
+  }
+  const cte = buildReachableCte({
+    graphId: ctx.graphId,
+    sourceId,
+    edgeKinds: options.edges,
+    maxHops,
+    direction: options.direction ?? "out",
+    cyclePolicy: options.cyclePolicy ?? "prevent",
+    includePath: true,
+    ...resolveTemporalOptions(ctx, options),
+    dialect: ctx.dialect,
+    schema: ctx.schema
+  });
+  const pathContainsCheck = drizzleOrm.sql`NOT (${ctx.dialect.cycleCheck(drizzleOrm.sql.raw("r.id"), drizzleOrm.sql.raw("h.path"))})`;
+  const query = drizzleOrm.sql`${cte}, hit AS (SELECT id, kind, depth, path FROM reachable WHERE id = ${targetId} ORDER BY depth ASC LIMIT 1) SELECT h.id AS hit_id, h.kind AS hit_kind, h.depth AS hit_depth, h.path AS hit_path, r.id AS node_id, r.kind AS node_kind FROM hit h LEFT JOIN reachable r ON ${pathContainsCheck}`;
+  const rows = await ctx.backend.execute(query);
+  const first = rows[0];
+  if (first === void 0) return void 0;
+  const pathIds = normalizePath(first.hit_path);
+  const kindById = buildKindIndex(rows);
+  const pathNodes = pathIds.map((id) => ({
+    id,
+    kind: kindById.get(id) ?? ""
+  }));
+  return { nodes: pathNodes, depth: Number(first.hit_depth) };
+}
+function buildKindIndex(rows) {
+  const map = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (row.node_id !== void 0 && row.node_kind !== void 0) {
+      map.set(row.node_id, row.node_kind);
+    }
+  }
+  return map;
+}
+async function fetchNodeKind(ctx, nodeId, options) {
+  const temporalFilter = resolveTemporalFilter(ctx, options);
+  const query = drizzleOrm.sql`SELECT id, kind FROM ${ctx.schema.nodesTable} WHERE graph_id = ${ctx.graphId} AND id = ${nodeId} AND ${temporalFilter} LIMIT 1`;
+  const rows = await ctx.backend.execute(query);
+  const row = rows[0];
+  if (row === void 0) return void 0;
+  return { id: row.id, kind: row.kind };
+}
+
+// src/store/algorithms/index.ts
+function resolveNodeId(value) {
+  return typeof value === "string" ? value : value.id;
+}
+function createGraphAlgorithms(params) {
+  const ctx = {
+    graphId: params.graphId,
+    backend: params.backend,
+    dialect: chunkFQCQM3KG_cjs.getDialect(params.backend.dialect),
+    schema: params.schema ?? (params.backend.tableNames ? createSqlSchema(params.backend.tableNames) : createSqlSchema()),
+    defaultTemporalMode: params.defaultTemporalMode
+  };
+  return {
+    shortestPath(from, to, options) {
+      return executeShortestPath(
+        ctx,
+        resolveNodeId(from),
+        resolveNodeId(to),
+        options
+      );
+    },
+    reachable(from, options) {
+      return executeReachable(ctx, resolveNodeId(from), options);
+    },
+    canReach(from, to, options) {
+      return executeCanReach(
+        ctx,
+        resolveNodeId(from),
+        resolveNodeId(to),
+        options
+      );
+    },
+    neighbors(node, options) {
+      return executeNeighbors(ctx, resolveNodeId(node), options);
+    },
+    degree(node, options) {
+      return executeDegree(ctx, resolveNodeId(node), options ?? {});
+    }
+  };
+}
+
 // src/store/collections/edge-collection.ts
 function narrowEdge(edge) {
   return edge;
@@ -8992,20 +9870,13 @@ function createEdgeCollection(config) {
     const result = {};
     if (options?.matchOn !== void 0)
       result.matchOn = options.matchOn;
-    if (options?.props !== void 0)
-      result.props = options.props;
+    if (options?.props !== void 0) result.props = options.props;
     return result;
   }
   return {
     async create(from, to, props, options) {
       const result = await executeEdgeCreate2(
-        buildCreateEdgeInput(
-          kind,
-          from,
-          to,
-          props ?? {},
-          options
-        ),
+        buildCreateEdgeInput(kind, from, to, props ?? {}, options),
         backend
       );
       return narrowEdge(result);
@@ -9100,7 +9971,7 @@ function createEdgeCollection(config) {
         temporalMode: mode
       };
       if (mode === "current" || mode === "asOf") {
-        params.asOf = options?.asOf ?? chunk5GZMPJOP_cjs.nowIso();
+        params.asOf = options?.asOf ?? chunkWRWVWKQL_cjs.nowIso();
       }
       if (options?.from?.kind !== void 0)
         params.fromKind = options.from.kind;
@@ -9121,7 +9992,7 @@ function createEdgeCollection(config) {
         temporalMode: mode
       };
       if (mode === "current" || mode === "asOf") {
-        params.asOf = options?.asOf ?? chunk5GZMPJOP_cjs.nowIso();
+        params.asOf = options?.asOf ?? chunkWRWVWKQL_cjs.nowIso();
       }
       if (options?.from?.kind !== void 0)
         params.fromKind = options.from.kind;
@@ -9131,10 +10002,7 @@ function createEdgeCollection(config) {
       return backend.countEdgesByKind(params);
     },
     async bulkCreate(items) {
-      const batchInputs = mapBulkEdgeInputs(
-        kind,
-        items
-      );
+      const batchInputs = mapBulkEdgeInputs(kind, items);
       if (backend.capabilities.transactions && "transaction" in backend) {
         const results2 = await backend.transaction(
           async (txBackend) => executeEdgeCreateBatch2(batchInputs, txBackend)
@@ -9170,11 +10038,7 @@ function createEdgeCollection(config) {
           if (existing) {
             toUpdate.push({
               index: itemIndex,
-              input: buildUpdateEdgeInput(
-                item.id,
-                item.props ?? {},
-                item
-              ),
+              input: buildUpdateEdgeInput(item.id, item.props ?? {}, item),
               clearDeleted: existing.deleted_at !== void 0
             });
           } else {
@@ -9213,10 +10077,7 @@ function createEdgeCollection(config) {
       return upsertAll(backend);
     },
     async bulkInsert(items) {
-      const batchInputs = mapBulkEdgeInputs(
-        kind,
-        items
-      );
+      const batchInputs = mapBulkEdgeInputs(kind, items);
       if (backend.capabilities.transactions && "transaction" in backend) {
         await backend.transaction(async (txBackend) => {
           await executeEdgeCreateNoReturnBatch2(batchInputs, txBackend);
@@ -9367,11 +10228,7 @@ function createNodeCollection(config) {
     async getByIds(ids, options) {
       if (ids.length === 0) return [];
       if (backend.getNodes !== void 0) {
-        const rows = await backend.getNodes(
-          graphId,
-          kind,
-          ids
-        );
+        const rows = await backend.getNodes(graphId, kind, ids);
         const rowMap = /* @__PURE__ */ new Map();
         for (const row of rows) {
           rowMap.set(row.id, row);
@@ -9416,7 +10273,7 @@ function createNodeCollection(config) {
         const mode2 = options.temporalMode ?? defaultTemporalMode;
         let query = createQuery().from(kind, "_n").temporal(
           mode2,
-          mode2 === "asOf" ? options.asOf ?? chunk5GZMPJOP_cjs.nowIso() : void 0
+          mode2 === "asOf" ? options.asOf ?? chunkWRWVWKQL_cjs.nowIso() : void 0
         ).whereNode("_n", options.where).select((ctx) => ctx._n);
         if (options.limit !== void 0) query = query.limit(options.limit);
         if (options.offset !== void 0) query = query.offset(options.offset);
@@ -9431,7 +10288,7 @@ function createNodeCollection(config) {
         temporalMode: mode
       };
       if (mode === "current" || mode === "asOf") {
-        params.asOf = options?.asOf ?? chunk5GZMPJOP_cjs.nowIso();
+        params.asOf = options?.asOf ?? chunkWRWVWKQL_cjs.nowIso();
       }
       if (options?.limit !== void 0) params.limit = options.limit;
       if (options?.offset !== void 0) params.offset = options.offset;
@@ -9447,16 +10304,12 @@ function createNodeCollection(config) {
         temporalMode: mode
       };
       if (mode === "current" || mode === "asOf") {
-        params.asOf = options?.asOf ?? chunk5GZMPJOP_cjs.nowIso();
+        params.asOf = options?.asOf ?? chunkWRWVWKQL_cjs.nowIso();
       }
       return backend.countNodesByKind(params);
     },
     async upsertById(id, props, options) {
-      return this.upsertByIdFromRecord(
-        id,
-        props,
-        options
-      );
+      return this.upsertByIdFromRecord(id, props, options);
     },
     async upsertByIdFromRecord(id, data, options) {
       const existing = await backend.getNode(graphId, kind, id);
@@ -9476,10 +10329,7 @@ function createNodeCollection(config) {
       return narrowNode(result);
     },
     async bulkCreate(items) {
-      const batchInputs = mapBulkNodeInputs(
-        kind,
-        items
-      );
+      const batchInputs = mapBulkNodeInputs(kind, items);
       if (backend.capabilities.transactions && "transaction" in backend) {
         const results2 = await backend.transaction(
           async (txBackend) => executeNodeCreateBatch2(batchInputs, txBackend)
@@ -9502,11 +10352,7 @@ function createNodeCollection(config) {
             if (row !== void 0) existingMap.set(row.id, row);
           }
         } else {
-          const rows = await target.getNodes(
-            graphId,
-            kind,
-            ids
-          );
+          const rows = await target.getNodes(graphId, kind, ids);
           for (const row of rows) {
             existingMap.set(row.id, row);
           }
@@ -9519,22 +10365,13 @@ function createNodeCollection(config) {
           if (existing) {
             toUpdate.push({
               index: itemIndex,
-              input: buildUpdateInput(
-                kind,
-                item.id,
-                item.props,
-                item
-              ),
+              input: buildUpdateInput(kind, item.id, item.props, item),
               clearDeleted: existing.deleted_at !== void 0
             });
           } else {
             toCreate.push({
               index: itemIndex,
-              input: buildCreateInput(
-                kind,
-                item.props,
-                item
-              )
+              input: buildCreateInput(kind, item.props, item)
             });
           }
           itemIndex++;
@@ -9561,10 +10398,7 @@ function createNodeCollection(config) {
       return upsertAll(backend);
     },
     async bulkInsert(items) {
-      const batchInputs = mapBulkNodeInputs(
-        kind,
-        items
-      );
+      const batchInputs = mapBulkNodeInputs(kind, items);
       if (backend.capabilities.transactions && "transaction" in backend) {
         await backend.transaction(async (txBackend) => {
           await executeNodeCreateNoReturnBatch2(batchInputs, txBackend);
@@ -10097,12 +10931,12 @@ async function validateAndPrepareEdgeCreate(ctx, input, id, backend) {
       nodeId: input.toId
     });
   }
-  const validatedProps = chunkX33WV2UF_cjs.validateEdgeProps(edgeKind.schema, input.props, {
+  const validatedProps = chunkHRNQ3DVJ_cjs.validateEdgeProps(edgeKind.schema, input.props, {
     kind,
     operation: "create"
   });
-  const validFrom = chunk5GZMPJOP_cjs.validateOptionalIsoDate(input.validFrom, "validFrom");
-  const validTo = chunk5GZMPJOP_cjs.validateOptionalIsoDate(input.validTo, "validTo");
+  const validFrom = chunkWRWVWKQL_cjs.validateOptionalIsoDate(input.validFrom, "validFrom");
+  const validTo = chunkWRWVWKQL_cjs.validateOptionalIsoDate(input.validTo, "validTo");
   const cardinality = registration.cardinality ?? "many";
   const constraintContext = {
     graphId: ctx.graphId,
@@ -10247,12 +11081,12 @@ async function executeEdgeUpdate(ctx, input, backend) {
     const edgeKind = registration.type;
     const existingProps = JSON.parse(existing.props);
     const mergedProps = { ...existingProps, ...input.props };
-    const validatedProps = chunkX33WV2UF_cjs.validateEdgeProps(edgeKind.schema, mergedProps, {
+    const validatedProps = chunkHRNQ3DVJ_cjs.validateEdgeProps(edgeKind.schema, mergedProps, {
       kind: existing.kind,
       operation: "update",
       id
     });
-    const validTo = chunk5GZMPJOP_cjs.validateOptionalIsoDate(input.validTo, "validTo");
+    const validTo = chunkWRWVWKQL_cjs.validateOptionalIsoDate(input.validTo, "validTo");
     const updateParams = {
       graphId: ctx.graphId,
       id,
@@ -10273,12 +11107,12 @@ async function executeEdgeUpsertUpdate(ctx, input, backend, options) {
   const edgeKind = registration.type;
   const existingProps = JSON.parse(existing.props);
   const mergedProps = { ...existingProps, ...input.props };
-  const validatedProps = chunkX33WV2UF_cjs.validateEdgeProps(edgeKind.schema, mergedProps, {
+  const validatedProps = chunkHRNQ3DVJ_cjs.validateEdgeProps(edgeKind.schema, mergedProps, {
     kind: existing.kind,
     operation: "update",
     id
   });
-  const validTo = chunk5GZMPJOP_cjs.validateOptionalIsoDate(input.validTo, "validTo");
+  const validTo = chunkWRWVWKQL_cjs.validateOptionalIsoDate(input.validTo, "validTo");
   const updateParams = {
     graphId: ctx.graphId,
     id,
@@ -10430,7 +11264,7 @@ async function executeEdgeGetOrCreateByEndpoints(ctx, kind, fromKind, fromId, to
   const matchOn = options?.matchOn ?? [];
   const registration = getEdgeRegistration(ctx.graph, kind);
   const edgeKind = registration.type;
-  const validatedProps = chunkX33WV2UF_cjs.validateEdgeProps(edgeKind.schema, props, {
+  const validatedProps = chunkHRNQ3DVJ_cjs.validateEdgeProps(edgeKind.schema, props, {
     kind,
     operation: "create"
   });
@@ -10512,7 +11346,7 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
   validateMatchOnFields(edgeKind.schema, matchOn, kind);
   const validated = [];
   for (const item of items) {
-    const validatedProps = chunkX33WV2UF_cjs.validateEdgeProps(edgeKind.schema, item.props, {
+    const validatedProps = chunkHRNQ3DVJ_cjs.validateEdgeProps(edgeKind.schema, item.props, {
       kind,
       operation: "create"
     });
@@ -10670,15 +11504,19 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
 }
 
 // src/store/embedding-sync.ts
+var embeddingFieldsCache = /* @__PURE__ */ new WeakMap();
 function getEmbeddingFields(schema) {
-  if (schema.type !== "object") {
-    return [];
-  }
+  const cached = embeddingFieldsCache.get(schema);
+  if (cached) return cached;
+  const fields = computeEmbeddingFields(schema);
+  embeddingFieldsCache.set(schema, fields);
+  return fields;
+}
+function computeEmbeddingFields(schema) {
+  if (schema.type !== "object") return [];
   const def = schema.def;
   const shape = def.shape;
-  if (!shape) {
-    return [];
-  }
+  if (!shape) return [];
   const fields = [];
   for (const [fieldPath, fieldSchema] of Object.entries(shape)) {
     const dimensions = getEmbeddingDimensionsFromField(fieldSchema);
@@ -10689,13 +11527,13 @@ function getEmbeddingFields(schema) {
   return fields;
 }
 function getEmbeddingDimensionsFromField(schema) {
-  const directDimensions = chunkP5CNM325_cjs.getEmbeddingDimensions(schema);
+  const directDimensions = chunkUVZHTBZ5_cjs.getEmbeddingDimensions(schema);
   if (directDimensions !== void 0) {
     return directDimensions;
   }
   const unwrapped = unwrapToEmbedding(schema);
   if (unwrapped) {
-    return chunkP5CNM325_cjs.getEmbeddingDimensions(unwrapped);
+    return chunkUVZHTBZ5_cjs.getEmbeddingDimensions(unwrapped);
   }
   return void 0;
 }
@@ -10703,7 +11541,7 @@ function unwrapToEmbedding(schema) {
   const type = schema.type;
   const def = schema.def;
   if ((type === "optional" || type === "nullable" || type === "default" || type === "readonly") && def.innerType) {
-    if (chunkP5CNM325_cjs.isEmbeddingSchema(def.innerType)) {
+    if (chunkUVZHTBZ5_cjs.isEmbeddingSchema(def.innerType)) {
       return def.innerType;
     }
     return unwrapToEmbedding(def.innerType);
@@ -10765,6 +11603,101 @@ function isValidEmbeddingValue(value) {
   return value.every((n) => typeof n === "number" && Number.isFinite(n));
 }
 
+// src/store/fulltext-sync.ts
+var searchableFieldsCache = /* @__PURE__ */ new WeakMap();
+function getSearchableFields(schema) {
+  const cached = searchableFieldsCache.get(schema);
+  if (cached) return cached;
+  const fields = computeSearchableFields(schema);
+  searchableFieldsCache.set(schema, fields);
+  return fields;
+}
+function computeSearchableFields(schema) {
+  if (schema.type !== "object") return [];
+  const def = schema.def;
+  const shape = def.shape;
+  if (!shape) return [];
+  const fields = [];
+  for (const [fieldPath, fieldSchema] of Object.entries(shape)) {
+    const metadata = chunkUVZHTBZ5_cjs.getSearchableMetadata(fieldSchema);
+    if (metadata !== void 0) {
+      fields.push({ fieldPath, metadata });
+    }
+  }
+  warnIfConflictingLanguages(fields);
+  return fields;
+}
+function warnIfConflictingLanguages(fields) {
+  if (fields.length < 2) return;
+  const languages = new Set(fields.map((field2) => field2.metadata.language));
+  if (languages.size < 2) return;
+  if (typeof console === "undefined" || typeof console.warn !== "function") {
+    return;
+  }
+  const fieldSummary = fields.map((field2) => `${field2.fieldPath}=${field2.metadata.language}`).join(", ");
+  const winning = fields[0]?.metadata.language ?? chunkUVZHTBZ5_cjs.DEFAULT_SEARCHABLE_LANGUAGE;
+  console.warn(
+    `[typegraph] searchable() fields declare conflicting languages (${fieldSummary}). The first field's language ("${winning}") is recorded on the fulltext row; true multilingual indexing requires a dedicated node kind per language.`
+  );
+}
+var FIELD_SEPARATOR = "\n";
+function resolveCombinedLanguage(fields) {
+  return fields[0]?.metadata.language ?? chunkUVZHTBZ5_cjs.DEFAULT_SEARCHABLE_LANGUAGE;
+}
+function computeFulltextContent(schema, props) {
+  const searchableFields = getSearchableFields(schema);
+  if (searchableFields.length === 0) return void 0;
+  const parts = [];
+  for (const field2 of searchableFields) {
+    const value = props[field2.fieldPath];
+    if (typeof value === "string" && value.length > 0) {
+      parts.push(value);
+    }
+  }
+  if (parts.length === 0) return void 0;
+  return {
+    content: parts.join(FIELD_SEPARATOR),
+    language: resolveCombinedLanguage(searchableFields)
+  };
+}
+async function syncFulltext(ctx, schema, props) {
+  const { backend } = ctx;
+  if (!backend.upsertFulltext || !backend.deleteFulltext) {
+    return;
+  }
+  const computed = computeFulltextContent(schema, props);
+  if (computed !== void 0) {
+    await backend.upsertFulltext({
+      graphId: ctx.graphId,
+      nodeKind: ctx.nodeKind,
+      nodeId: ctx.nodeId,
+      content: computed.content,
+      language: computed.language
+    });
+    return;
+  }
+  if (getSearchableFields(schema).length === 0) return;
+  await backend.deleteFulltext({
+    graphId: ctx.graphId,
+    nodeKind: ctx.nodeKind,
+    nodeId: ctx.nodeId
+  });
+}
+async function deleteNodeFulltext(ctx, schema) {
+  const { backend } = ctx;
+  if (!backend.deleteFulltext) {
+    return;
+  }
+  if (getSearchableFields(schema).length === 0) {
+    return;
+  }
+  await backend.deleteFulltext({
+    graphId: ctx.graphId,
+    nodeKind: ctx.nodeKind,
+    nodeId: ctx.nodeId
+  });
+}
+
 // src/store/uniqueness.ts
 async function checkUniquenessConstraints(ctx, kind, id, props, constraints) {
   for (const constraint of constraints) {
@@ -10958,6 +11891,9 @@ function createUniquenessContext(graphId, registry, backend) {
 function createEmbeddingSyncContext(graphId, nodeKind, nodeId, backend) {
   return { graphId, nodeKind, nodeId, backend };
 }
+function createFulltextSyncContext(graphId, nodeKind, nodeId, backend) {
+  return { graphId, nodeKind, nodeId, backend };
+}
 function createNodeBatchValidationBackend(graphId, registry, backend) {
   const nodeCache = /* @__PURE__ */ new Map();
   const pendingNodes = /* @__PURE__ */ new Map();
@@ -11057,12 +11993,12 @@ async function validateAndPrepareNodeCreate(ctx, input, id, backend) {
   const kind = input.kind;
   const registration = getNodeRegistration(ctx.graph, kind);
   const nodeKind = registration.type;
-  const validatedProps = chunkX33WV2UF_cjs.validateNodeProps(nodeKind.schema, input.props, {
+  const validatedProps = chunkHRNQ3DVJ_cjs.validateNodeProps(nodeKind.schema, input.props, {
     kind,
     operation: "create"
   });
-  const validFrom = chunk5GZMPJOP_cjs.validateOptionalIsoDate(input.validFrom, "validFrom");
-  const validTo = chunk5GZMPJOP_cjs.validateOptionalIsoDate(input.validTo, "validTo");
+  const validFrom = chunkWRWVWKQL_cjs.validateOptionalIsoDate(input.validFrom, "validFrom");
+  const validTo = chunkWRWVWKQL_cjs.validateOptionalIsoDate(input.validTo, "validTo");
   const existingNode = await backend.getNode(ctx.graphId, kind, id);
   if (existingNode && !existingNode.deleted_at) {
     throw createNodeAlreadyExistsError(kind, id);
@@ -11115,6 +12051,11 @@ async function finalizeNodeCreate(ctx, prepared, backend) {
     prepared.nodeKind.schema,
     prepared.validatedProps
   );
+  await syncFulltext(
+    createFulltextSyncContext(ctx.graphId, prepared.kind, prepared.id, backend),
+    prepared.nodeKind.schema,
+    prepared.validatedProps
+  );
 }
 async function performNodeUpdate(ctx, input, backend, options) {
   const { kind, id } = input;
@@ -11126,12 +12067,12 @@ async function performNodeUpdate(ctx, input, backend, options) {
   const existingProps = JSON.parse(existing.props);
   const mergedProps = { ...existingProps, ...input.props };
   const nodeKind = registration.type;
-  const validatedProps = chunkX33WV2UF_cjs.validateNodeProps(nodeKind.schema, mergedProps, {
+  const validatedProps = chunkHRNQ3DVJ_cjs.validateNodeProps(nodeKind.schema, mergedProps, {
     kind,
     operation: "update",
     id
   });
-  const validTo = chunk5GZMPJOP_cjs.validateOptionalIsoDate(input.validTo, "validTo");
+  const validTo = chunkWRWVWKQL_cjs.validateOptionalIsoDate(input.validTo, "validTo");
   await updateUniquenessEntries(
     createUniquenessContext(ctx.graphId, ctx.registry, backend),
     kind,
@@ -11155,6 +12096,11 @@ async function performNodeUpdate(ctx, input, backend, options) {
     nodeKind.schema,
     validatedProps
   );
+  await syncFulltext(
+    createFulltextSyncContext(ctx.graphId, kind, id, backend),
+    nodeKind.schema,
+    validatedProps
+  );
   return rowToNode(row);
 }
 async function enforceDeleteBehavior(ctx, kind, id, mode, backend, registration) {
@@ -11371,6 +12317,10 @@ async function executeNodeDelete(ctx, kind, id, backend) {
       createEmbeddingSyncContext(ctx.graphId, kind, id, backend),
       nodeKind.schema
     );
+    await deleteNodeFulltext(
+      createFulltextSyncContext(ctx.graphId, kind, id, backend),
+      nodeKind.schema
+    );
   });
 }
 async function executeNodeHardDelete(ctx, kind, id, backend) {
@@ -11390,7 +12340,7 @@ async function executeNodeGetOrCreateByConstraint(ctx, kind, constraintName, pro
   const ifExists = options?.ifExists ?? "return";
   const registration = getNodeRegistration(ctx.graph, kind);
   const nodeKind = registration.type;
-  const validatedProps = chunkX33WV2UF_cjs.validateNodeProps(nodeKind.schema, props, {
+  const validatedProps = chunkHRNQ3DVJ_cjs.validateNodeProps(nodeKind.schema, props, {
     kind,
     operation: "create"
   });
@@ -11462,7 +12412,7 @@ async function executeNodeGetOrCreateByConstraint(ctx, kind, constraintName, pro
 async function executeNodeFindByConstraint(ctx, kind, constraintName, props, backend) {
   const registration = getNodeRegistration(ctx.graph, kind);
   const nodeKind = registration.type;
-  const validatedProps = chunkX33WV2UF_cjs.validateNodeProps(nodeKind.schema, props, {
+  const validatedProps = chunkHRNQ3DVJ_cjs.validateNodeProps(nodeKind.schema, props, {
     kind,
     operation: "create"
   });
@@ -11499,7 +12449,7 @@ async function executeNodeFindByConstraint(ctx, kind, constraintName, props, bac
 function validateAndComputeKeys(nodeKind, kind, constraint, items) {
   const validated = [];
   for (const item of items) {
-    const validatedProps = chunkX33WV2UF_cjs.validateNodeProps(nodeKind.schema, item.props, {
+    const validatedProps = chunkHRNQ3DVJ_cjs.validateNodeProps(nodeKind.schema, item.props, {
       kind,
       operation: "create"
     });
@@ -11677,6 +12627,503 @@ async function executeNodeBulkGetOrCreateByConstraint(ctx, kind, constraintName,
   return results;
 }
 
+// src/store/fulltext-rebuild.ts
+var DEFAULT_PAGE_SIZE = 500;
+var DEFAULT_MAX_SKIPPED_IDS = 1e4;
+function validatePageSize(value) {
+  if (value === void 0) return DEFAULT_PAGE_SIZE;
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new chunkO5PST6TB_cjs.ValidationError(
+      `pageSize must be a positive integer, got: ${String(value)}`,
+      {
+        issues: [{ path: "pageSize", message: "Must be a positive integer." }]
+      }
+    );
+  }
+  return value;
+}
+function validateMaxSkippedIds(value) {
+  if (value === void 0) return DEFAULT_MAX_SKIPPED_IDS;
+  if (!Number.isInteger(value) || value < 0) {
+    throw new chunkO5PST6TB_cjs.ValidationError(
+      `maxSkippedIds must be a non-negative integer, got: ${String(value)}`,
+      {
+        issues: [
+          {
+            path: "maxSkippedIds",
+            message: "Must be a non-negative integer."
+          }
+        ]
+      }
+    );
+  }
+  return value;
+}
+function isPropsObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function rebuildFulltextIndex(ctx, nodeKind, options) {
+  const { backend, registry } = ctx;
+  if (!backend.upsertFulltext || !backend.deleteFulltext) {
+    throw new chunkO5PST6TB_cjs.ConfigurationError(
+      "Backend does not support fulltext; cannot rebuild index",
+      { backend: backend.dialect, capability: "fulltext" }
+    );
+  }
+  const pageSize = validatePageSize(options.pageSize);
+  const maxSkippedIds = validateMaxSkippedIds(options.maxSkippedIds);
+  const targetKinds = nodeKind === void 0 ? [...registry.nodeKinds.keys()] : [nodeKind];
+  const rebuiltKinds = [];
+  let processed = 0;
+  let upserted = 0;
+  let cleared = 0;
+  let skipped = 0;
+  const skippedIds = [];
+  for (const kind of targetKinds) {
+    const nodeType = registry.getNodeType(kind);
+    if (!nodeType) {
+      throw new chunkO5PST6TB_cjs.ConfigurationError(`Unknown node kind: ${kind}`, { kind });
+    }
+    if (getSearchableFields(nodeType.schema).length === 0) {
+      continue;
+    }
+    rebuiltKinds.push(kind);
+    let cursor;
+    for (; ; ) {
+      const rows = await backend.findNodesByKind({
+        graphId: ctx.graphId,
+        kind,
+        limit: pageSize,
+        excludeDeleted: false,
+        orderBy: "id",
+        ...cursor === void 0 ? {} : { after: cursor }
+      });
+      if (rows.length === 0) break;
+      const pageResult = processPage(nodeType.schema, rows);
+      skipped += pageResult.skipped;
+      const remaining = maxSkippedIds - skippedIds.length;
+      if (remaining > 0 && pageResult.skippedIds.length > 0) {
+        skippedIds.push(...pageResult.skippedIds.slice(0, remaining));
+      }
+      await backend.transaction(async (tx) => {
+        if (pageResult.toUpsert.length > 0) {
+          if (tx.upsertFulltextBatch) {
+            await tx.upsertFulltextBatch({
+              graphId: ctx.graphId,
+              nodeKind: kind,
+              rows: pageResult.toUpsert
+            });
+          } else if (tx.upsertFulltext) {
+            for (const item of pageResult.toUpsert) {
+              await tx.upsertFulltext({
+                graphId: ctx.graphId,
+                nodeKind: kind,
+                nodeId: item.nodeId,
+                content: item.content,
+                language: item.language
+              });
+            }
+          }
+        }
+        if (pageResult.toDelete.length > 0) {
+          if (tx.deleteFulltextBatch) {
+            await tx.deleteFulltextBatch({
+              graphId: ctx.graphId,
+              nodeKind: kind,
+              nodeIds: pageResult.toDelete
+            });
+          } else if (tx.deleteFulltext) {
+            for (const nodeId of pageResult.toDelete) {
+              await tx.deleteFulltext({
+                graphId: ctx.graphId,
+                nodeKind: kind,
+                nodeId
+              });
+            }
+          }
+        }
+      });
+      processed += rows.length;
+      upserted += pageResult.toUpsert.length;
+      cleared += pageResult.toDelete.length;
+      const lastRow = rows.at(-1);
+      if (!lastRow) break;
+      cursor = lastRow.id;
+      if (rows.length < pageSize) break;
+    }
+  }
+  return {
+    kinds: rebuiltKinds,
+    processed,
+    upserted,
+    cleared,
+    skipped,
+    skippedIds,
+    skippedTruncated: skipped > skippedIds.length
+  };
+}
+function processPage(schema, rows) {
+  const toUpsert = [];
+  const toDelete = [];
+  const skippedIds = [];
+  let skipped = 0;
+  for (const row of rows) {
+    if (row.deleted_at !== void 0) {
+      toDelete.push(row.id);
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(row.props);
+    } catch {
+      skipped += 1;
+      skippedIds.push(row.id);
+      continue;
+    }
+    if (!isPropsObject(parsed)) {
+      skipped += 1;
+      skippedIds.push(row.id);
+      continue;
+    }
+    const computed = computeFulltextContent(schema, parsed);
+    if (computed === void 0) {
+      toDelete.push(row.id);
+    } else {
+      toUpsert.push({
+        nodeId: row.id,
+        content: computed.content,
+        language: computed.language
+      });
+    }
+  }
+  return { toUpsert, toDelete, skipped, skippedIds };
+}
+
+// src/store/search.ts
+async function executeFulltextSearch(ctx, nodeKind, options) {
+  const { backend, graphId } = ctx;
+  if (!backend.fulltextSearch) {
+    throw new chunkO5PST6TB_cjs.ConfigurationError("Backend does not support fulltext search", {
+      backend: backend.dialect,
+      capability: "fulltext"
+    });
+  }
+  if (!Number.isInteger(options.limit) || options.limit <= 0) {
+    throw new RangeError(
+      `fulltextSearch.limit must be a positive integer, got: ${options.limit}`
+    );
+  }
+  validateFulltextCallOptions(backend, {
+    mode: options.mode,
+    includeSnippets: options.includeSnippets,
+    language: options.language
+  });
+  const params = {
+    graphId,
+    nodeKind,
+    query: options.query,
+    limit: options.limit,
+    ...options.mode ? { mode: options.mode } : {},
+    ...options.language ? { language: options.language } : {},
+    ...options.minScore === void 0 ? {} : { minScore: options.minScore },
+    ...options.includeSnippets === void 0 ? {} : { includeSnippets: options.includeSnippets }
+  };
+  const rows = await backend.fulltextSearch(params);
+  if (rows.length === 0) return [];
+  const ids = rows.map((r) => r.nodeId);
+  const nodeMap = await fetchNodesByIds(backend, graphId, nodeKind, ids);
+  const hits = [];
+  let rank = 1;
+  for (const row of rows) {
+    const node = nodeMap.get(row.nodeId);
+    if (!node) continue;
+    hits.push({
+      node,
+      score: row.score,
+      rank,
+      ...row.snippet === void 0 ? {} : { snippet: row.snippet }
+    });
+    rank += 1;
+  }
+  return hits;
+}
+async function executeHybridSearch(ctx, nodeKind, options) {
+  const { backend, graphId } = ctx;
+  if (!backend.vectorSearch) {
+    throw new chunkO5PST6TB_cjs.ConfigurationError("Backend does not support vector search", {
+      backend: backend.dialect,
+      capability: "vector"
+    });
+  }
+  if (!backend.fulltextSearch) {
+    throw new chunkO5PST6TB_cjs.ConfigurationError("Backend does not support fulltext search", {
+      backend: backend.dialect,
+      capability: "fulltext"
+    });
+  }
+  if (!Number.isInteger(options.limit) || options.limit <= 0) {
+    throw new RangeError(
+      `hybridSearch.limit must be a positive integer, got: ${options.limit}`
+    );
+  }
+  if (options.fusion !== void 0) {
+    validateHybridFusionOptions(options.fusion);
+  }
+  validateFulltextCallOptions(backend, {
+    mode: options.fulltext.mode,
+    includeSnippets: options.fulltext.includeSnippets,
+    language: options.fulltext.language
+  });
+  const fusionK = options.fusion?.k ?? DEFAULT_RRF_K;
+  const vectorWeight = options.fusion?.weights?.vector ?? DEFAULT_RRF_WEIGHT;
+  const fulltextWeight = options.fusion?.weights?.fulltext ?? DEFAULT_RRF_WEIGHT;
+  const overFetchMultiplier = 4;
+  const vectorK = options.vector.k ?? options.limit * overFetchMultiplier;
+  const fulltextK = options.fulltext.k ?? options.limit * overFetchMultiplier;
+  const vectorPromise = backend.vectorSearch({
+    graphId,
+    nodeKind,
+    fieldPath: options.vector.fieldPath,
+    queryEmbedding: options.vector.queryEmbedding,
+    metric: options.vector.metric ?? "cosine",
+    limit: vectorK,
+    ...options.vector.minScore === void 0 ? {} : { minScore: options.vector.minScore }
+  });
+  const fulltextPromise = backend.fulltextSearch({
+    graphId,
+    nodeKind,
+    query: options.fulltext.query,
+    limit: fulltextK,
+    ...options.fulltext.mode ? { mode: options.fulltext.mode } : {},
+    ...options.fulltext.language ? { language: options.fulltext.language } : {},
+    ...options.fulltext.minScore === void 0 ? {} : { minScore: options.fulltext.minScore },
+    ...options.fulltext.includeSnippets === void 0 ? {} : { includeSnippets: options.fulltext.includeSnippets }
+  });
+  const [vectorRows, fulltextRows] = await Promise.all([
+    vectorPromise,
+    fulltextPromise
+  ]);
+  const fused = /* @__PURE__ */ new Map();
+  for (const [index, row] of vectorRows.entries()) {
+    const rank2 = index + 1;
+    const contribution = vectorWeight / (fusionK + rank2);
+    const entry = fused.get(row.nodeId) ?? {
+      nodeId: row.nodeId,
+      fusedScore: 0
+    };
+    entry.fusedScore += contribution;
+    entry.vectorRank = rank2;
+    entry.vectorScore = row.score;
+    fused.set(row.nodeId, entry);
+  }
+  for (const [index, row] of fulltextRows.entries()) {
+    const rank2 = index + 1;
+    const contribution = fulltextWeight / (fusionK + rank2);
+    const entry = fused.get(row.nodeId) ?? {
+      nodeId: row.nodeId,
+      fusedScore: 0
+    };
+    entry.fusedScore += contribution;
+    entry.fulltextRank = rank2;
+    entry.fulltextScore = row.score;
+    if (row.snippet !== void 0) {
+      entry.fulltextSnippet = row.snippet;
+    }
+    fused.set(row.nodeId, entry);
+  }
+  const ranked = [...fused.values()].toSorted(
+    (a, b) => b.fusedScore - a.fusedScore || a.nodeId.localeCompare(b.nodeId)
+  ).slice(0, options.limit);
+  const ids = ranked.map((entry) => entry.nodeId);
+  const nodeMap = await fetchNodesByIds(backend, graphId, nodeKind, ids);
+  const hits = [];
+  let rank = 1;
+  for (const entry of ranked) {
+    const node = nodeMap.get(entry.nodeId);
+    if (!node) continue;
+    const typedNode = node;
+    const hit = {
+      node: typedNode,
+      score: entry.fusedScore,
+      rank,
+      ...entry.vectorRank !== void 0 && entry.vectorScore !== void 0 ? {
+        vector: {
+          node: typedNode,
+          score: entry.vectorScore,
+          rank: entry.vectorRank
+        }
+      } : {},
+      ...entry.fulltextRank !== void 0 && entry.fulltextScore !== void 0 ? {
+        fulltext: {
+          node: typedNode,
+          score: entry.fulltextScore,
+          rank: entry.fulltextRank,
+          ...entry.fulltextSnippet === void 0 ? {} : { snippet: entry.fulltextSnippet }
+        }
+      } : {}
+    };
+    hits.push(hit);
+    rank += 1;
+  }
+  return hits;
+}
+function validateFulltextCallOptions(backend, options) {
+  const strategy = backend.fulltextStrategy;
+  const capabilities = backend.capabilities.fulltext;
+  if (options.mode !== void 0) {
+    validateFulltextMode(backend, strategy, capabilities, options.mode);
+  }
+  if (options.includeSnippets === true) {
+    validateFulltextSnippets(backend, strategy, capabilities);
+  }
+  if (options.language !== void 0) {
+    validateFulltextLanguageOption(
+      backend,
+      strategy,
+      capabilities,
+      options.language
+    );
+  }
+}
+function validateFulltextMode(backend, strategy, capabilities, mode) {
+  if (strategy !== void 0) {
+    if (strategy.supportedModes.includes(mode)) return;
+    throw new chunkO5PST6TB_cjs.ConfigurationError(
+      `Backend "${backend.dialect}" fulltext strategy "${strategy.name}" does not support mode "${mode}". Supported modes: ${strategy.supportedModes.join(", ")}`,
+      {
+        backend: backend.dialect,
+        strategy: strategy.name,
+        capability: `fulltext.modes.${mode}`
+      }
+    );
+  }
+  if (mode === "phrase" && capabilities && !capabilities.phraseQueries) {
+    throw new chunkO5PST6TB_cjs.ConfigurationError(
+      `Backend "${backend.dialect}" does not support phrase queries`,
+      { backend: backend.dialect, capability: "fulltext.phraseQueries" }
+    );
+  }
+}
+function validateFulltextSnippets(backend, strategy, capabilities) {
+  const supportsSnippets = strategy === void 0 ? capabilities?.highlighting !== false : strategy.supportsSnippets;
+  if (supportsSnippets) return;
+  throw new chunkO5PST6TB_cjs.ConfigurationError(
+    `Backend "${backend.dialect}" does not support snippet highlighting; drop includeSnippets or switch to a backend where highlighting is supported`,
+    { backend: backend.dialect, capability: "fulltext.highlighting" }
+  );
+}
+function validateFulltextLanguageOption(backend, strategy, capabilities, language) {
+  if (strategy !== void 0 && !strategy.supportsLanguageOverride) {
+    throw new chunkO5PST6TB_cjs.ConfigurationError(
+      `Backend "${backend.dialect}" fulltext strategy "${strategy.name}" does not honor a per-query \`language\` override (its tokenizer is fixed at table-create time). Drop the option, or pick a strategy that advertises \`supportsLanguageOverride: true\`.`,
+      {
+        backend: backend.dialect,
+        strategy: strategy.name,
+        capability: "fulltext.languageOverride"
+      }
+    );
+  }
+  if (capabilities !== void 0) {
+    warnIfLanguageNotAdvertised(backend.dialect, capabilities, language);
+  }
+}
+function warnIfLanguageNotAdvertised(dialect, capabilities, language) {
+  if (capabilities.languages.length === 0) return;
+  if (capabilities.languages.includes(language)) return;
+  if (typeof console === "undefined" || typeof console.warn !== "function") {
+    return;
+  }
+  console.warn(
+    `[typegraph] fulltext language "${language}" is not in the advertised list for dialect "${dialect}" (${capabilities.languages.join(", ")}). If your backend has this language installed this warning is safe to ignore.`
+  );
+}
+async function fetchNodesByIds(backend, graphId, nodeKind, ids) {
+  if (ids.length === 0) return /* @__PURE__ */ new Map();
+  const map = /* @__PURE__ */ new Map();
+  if (backend.getNodes) {
+    const rows = await backend.getNodes(graphId, nodeKind, ids);
+    for (const row of rows) {
+      if (row.deleted_at !== void 0) continue;
+      map.set(row.id, rowToNode(row));
+    }
+    return map;
+  }
+  for (const id of ids) {
+    const row = await backend.getNode(graphId, nodeKind, id);
+    if (row && row.deleted_at === void 0) map.set(row.id, rowToNode(row));
+  }
+  return map;
+}
+
+// src/store/search-facade.ts
+var StoreSearch = class {
+  #context;
+  constructor(context) {
+    this.#context = context;
+  }
+  /**
+   * Runs a fulltext search against nodes of the given kind.
+   *
+   * Requires fields on the node schema declared with `searchable()`.
+   * The search hits the backend's fulltext index (tsvector + GIN on
+   * Postgres, FTS5 on SQLite — or whatever strategy the backend is
+   * configured with) and resolves the matching node IDs back to typed
+   * `Node` objects.
+   */
+  async fulltext(nodeKind, options) {
+    return executeFulltextSearch(
+      { graphId: this.#context.graphId, backend: this.#context.backend },
+      nodeKind,
+      options
+    );
+  }
+  /**
+   * Runs a vector + fulltext hybrid search and fuses the results with
+   * Reciprocal Rank Fusion.
+   *
+   * RRF is rank-based, so it composes well across heterogeneous score
+   * scales (cosine similarity vs ts_rank_cd vs FTS5 BM25). Default
+   * over-fetch is 4× `limit` from each source — tune via `vector.k` /
+   * `fulltext.k` for higher-recall corpora.
+   */
+  async hybrid(nodeKind, options) {
+    return executeHybridSearch(
+      { graphId: this.#context.graphId, backend: this.#context.backend },
+      nodeKind,
+      options
+    );
+  }
+  /**
+   * Rebuilds the fulltext index from existing node data.
+   *
+   * Use when:
+   * - A node kind gained a `searchable()` field after data was already
+   *   written and existing rows were never indexed.
+   * - The fulltext table was dropped / truncated.
+   * - `language` was changed on a `searchable()` field.
+   *
+   * Iterates nodes with keyset pagination (stable under shared
+   * timestamps and light concurrent writes), transacts per page, skips
+   * kinds with no searchable fields, and cleans up stale rows for
+   * soft-deleted nodes. Corrupt or non-object `props` are counted in
+   * `skipped` with their node IDs surfaced via `skippedIds` so operators
+   * can investigate. Concurrent hard-deletes between page fetches can
+   * be missed by a single pass — run during a maintenance window for
+   * full consistency.
+   */
+  async rebuildFulltext(nodeKind, options = {}) {
+    return rebuildFulltextIndex(
+      {
+        graphId: this.#context.graphId,
+        backend: this.#context.backend,
+        registry: this.#context.registry
+      },
+      nodeKind,
+      options
+    );
+  }
+};
+
 // src/store/store.ts
 var Store = class {
   #graph;
@@ -11687,6 +13134,8 @@ var Store = class {
   #defaultTraversalExpansion;
   #nodeCollections;
   #edgeCollections;
+  #algorithms;
+  #search;
   constructor(graph, backend, options) {
     this.#graph = graph;
     this.#backend = backend;
@@ -11768,6 +13217,38 @@ var Store = class {
     }
     return this.#edgeCollections;
   }
+  // === Graph Algorithms ===
+  /**
+   * Tier 1 graph algorithms: shortest path, reachability, neighborhoods, and
+   * degree centrality.
+   *
+   * Each call compiles to a single recursive-CTE query against the backend.
+   * The facade is built lazily on first access and cached for the lifetime
+   * of the store.
+   *
+   * @example
+   * ```typescript
+   * const path = await store.algorithms.shortestPath(alice, bob, {
+   *   edges: ["knows"],
+   * });
+   *
+   * const friends = await store.algorithms.neighbors(alice, {
+   *   edges: ["knows"],
+   *   depth: 2,
+   * });
+   * ```
+   */
+  get algorithms() {
+    if (this.#algorithms === void 0) {
+      this.#algorithms = createGraphAlgorithms({
+        graphId: this.graphId,
+        backend: this.#backend,
+        schema: this.#schema,
+        defaultTemporalMode: this.#graph.defaults.temporalMode
+      });
+    }
+    return this.#algorithms;
+  }
   // === Dynamic Collection Access ===
   /**
    * Returns the node collection for the given kind, or undefined if the kind
@@ -11903,6 +13384,44 @@ var Store = class {
   query() {
     return this.#createQueryForBackend(this.#backend);
   }
+  // === Search ===
+  /**
+   * Search-related operations (fulltext, hybrid, and rebuild).
+   *
+   * All search methods live under this facade to keep the top-level
+   * Store API focused on CRUD + graph traversal. The facade is
+   * lazy-initialized and cached for the lifetime of the store.
+   *
+   * @example
+   * ```typescript
+   * // Fulltext
+   * const hits = await store.search.fulltext("Document", {
+   *   query: "climate warming",
+   *   limit: 10,
+   *   includeSnippets: true,
+   * });
+   *
+   * // Hybrid (vector + fulltext fused with RRF)
+   * const ranked = await store.search.hybrid("Document", {
+   *   limit: 10,
+   *   vector: { fieldPath: "embedding", queryEmbedding: vec },
+   *   fulltext: { query: "climate warming" },
+   * });
+   *
+   * // Rebuild index after schema change
+   * const stats = await store.search.rebuildFulltext();
+   * ```
+   */
+  get search() {
+    if (this.#search === void 0) {
+      this.#search = new StoreSearch({
+        graphId: this.graphId,
+        backend: this.#backend,
+        registry: this.#registry
+      });
+    }
+    return this.#search;
+  }
   // === Batch Query Execution ===
   /**
    * Executes multiple queries over a single connection with snapshot consistency.
@@ -11976,7 +13495,7 @@ var Store = class {
       graphId: this.graphId,
       rootId,
       backend: this.#backend,
-      dialect: chunkMME3H4ZF_cjs.getDialect(this.#backend.dialect),
+      dialect: chunkFQCQM3KG_cjs.getDialect(this.#backend.dialect),
       schema: this.#schema,
       options
     });
@@ -12046,6 +13565,8 @@ var Store = class {
     await (this.#backend.capabilities.transactions ? this.#backend.transaction(async (tx) => doClear(tx)) : doClear(this.#backend));
     this.#nodeCollections = void 0;
     this.#edgeCollections = void 0;
+    this.#algorithms = void 0;
+    this.#search = void 0;
   }
   // === Lifecycle ===
   /**
@@ -12115,7 +13636,7 @@ var Store = class {
   // === Internal: Temporal Filtering ===
   #matchesTemporalMode(row, options) {
     const mode = options?.temporalMode ?? this.#graph.defaults.temporalMode;
-    const asOf = options?.asOf ?? chunk5GZMPJOP_cjs.nowIso();
+    const asOf = options?.asOf ?? chunkWRWVWKQL_cjs.nowIso();
     switch (mode) {
       case "current":
       case "asOf": {
@@ -12148,41 +13669,41 @@ function createStore(graph, backend, options) {
 }
 async function createStoreWithSchema(graph, backend, options) {
   const store = createStore(graph, backend, options);
-  const result = await chunkX33WV2UF_cjs.ensureSchema(backend, graph, options);
+  const result = await chunkHRNQ3DVJ_cjs.ensureSchema(backend, graph, options);
   return [store, result];
 }
 
 Object.defineProperty(exports, "isMetaEdge", {
   enumerable: true,
-  get: function () { return chunkX33WV2UF_cjs.isMetaEdge; }
+  get: function () { return chunkHRNQ3DVJ_cjs.isMetaEdge; }
 });
 Object.defineProperty(exports, "defineGraph", {
   enumerable: true,
-  get: function () { return chunk5GZMPJOP_cjs.defineGraph; }
+  get: function () { return chunkWRWVWKQL_cjs.defineGraph; }
 });
 Object.defineProperty(exports, "getEdgeKinds", {
   enumerable: true,
-  get: function () { return chunk5GZMPJOP_cjs.getEdgeKinds; }
+  get: function () { return chunkWRWVWKQL_cjs.getEdgeKinds; }
 });
 Object.defineProperty(exports, "getNodeKinds", {
   enumerable: true,
-  get: function () { return chunk5GZMPJOP_cjs.getNodeKinds; }
+  get: function () { return chunkWRWVWKQL_cjs.getNodeKinds; }
 });
 Object.defineProperty(exports, "isEdgeType", {
   enumerable: true,
-  get: function () { return chunk5GZMPJOP_cjs.isEdgeType; }
+  get: function () { return chunkWRWVWKQL_cjs.isEdgeType; }
 });
 Object.defineProperty(exports, "isEdgeTypeWithEndpoints", {
   enumerable: true,
-  get: function () { return chunk5GZMPJOP_cjs.isEdgeTypeWithEndpoints; }
+  get: function () { return chunkWRWVWKQL_cjs.isEdgeTypeWithEndpoints; }
 });
 Object.defineProperty(exports, "isGraphDef", {
   enumerable: true,
-  get: function () { return chunk5GZMPJOP_cjs.isGraphDef; }
+  get: function () { return chunkWRWVWKQL_cjs.isGraphDef; }
 });
 Object.defineProperty(exports, "isNodeType", {
   enumerable: true,
-  get: function () { return chunk5GZMPJOP_cjs.isNodeType; }
+  get: function () { return chunkWRWVWKQL_cjs.isNodeType; }
 });
 Object.defineProperty(exports, "BackendDisposedError", {
   enumerable: true,
@@ -12284,37 +13805,61 @@ Object.defineProperty(exports, "isUserRecoverable", {
   enumerable: true,
   get: function () { return chunkO5PST6TB_cjs.isUserRecoverable; }
 });
+Object.defineProperty(exports, "fts5Strategy", {
+  enumerable: true,
+  get: function () { return chunkFQCQM3KG_cjs.fts5Strategy; }
+});
+Object.defineProperty(exports, "tsvectorStrategy", {
+  enumerable: true,
+  get: function () { return chunkFQCQM3KG_cjs.tsvectorStrategy; }
+});
+Object.defineProperty(exports, "DEFAULT_SEARCHABLE_LANGUAGE", {
+  enumerable: true,
+  get: function () { return chunkUVZHTBZ5_cjs.DEFAULT_SEARCHABLE_LANGUAGE; }
+});
 Object.defineProperty(exports, "MAX_JSON_POINTER_DEPTH", {
   enumerable: true,
-  get: function () { return chunkP5CNM325_cjs.MAX_JSON_POINTER_DEPTH; }
+  get: function () { return chunkUVZHTBZ5_cjs.MAX_JSON_POINTER_DEPTH; }
 });
 Object.defineProperty(exports, "embedding", {
   enumerable: true,
-  get: function () { return chunkP5CNM325_cjs.embedding; }
+  get: function () { return chunkUVZHTBZ5_cjs.embedding; }
 });
 Object.defineProperty(exports, "getEmbeddingDimensions", {
   enumerable: true,
-  get: function () { return chunkP5CNM325_cjs.getEmbeddingDimensions; }
+  get: function () { return chunkUVZHTBZ5_cjs.getEmbeddingDimensions; }
+});
+Object.defineProperty(exports, "getSearchableMetadata", {
+  enumerable: true,
+  get: function () { return chunkUVZHTBZ5_cjs.getSearchableMetadata; }
 });
 Object.defineProperty(exports, "isEmbeddingSchema", {
   enumerable: true,
-  get: function () { return chunkP5CNM325_cjs.isEmbeddingSchema; }
+  get: function () { return chunkUVZHTBZ5_cjs.isEmbeddingSchema; }
+});
+Object.defineProperty(exports, "isSearchableSchema", {
+  enumerable: true,
+  get: function () { return chunkUVZHTBZ5_cjs.isSearchableSchema; }
 });
 Object.defineProperty(exports, "joinJsonPointers", {
   enumerable: true,
-  get: function () { return chunkP5CNM325_cjs.joinJsonPointers; }
+  get: function () { return chunkUVZHTBZ5_cjs.joinJsonPointers; }
 });
 Object.defineProperty(exports, "jsonPointer", {
   enumerable: true,
-  get: function () { return chunkP5CNM325_cjs.jsonPointer; }
+  get: function () { return chunkUVZHTBZ5_cjs.jsonPointer; }
 });
 Object.defineProperty(exports, "normalizeJsonPointer", {
   enumerable: true,
-  get: function () { return chunkP5CNM325_cjs.normalizeJsonPointer; }
+  get: function () { return chunkUVZHTBZ5_cjs.normalizeJsonPointer; }
 });
 Object.defineProperty(exports, "parseJsonPointer", {
   enumerable: true,
-  get: function () { return chunkP5CNM325_cjs.parseJsonPointer; }
+  get: function () { return chunkUVZHTBZ5_cjs.parseJsonPointer; }
+});
+Object.defineProperty(exports, "searchable", {
+  enumerable: true,
+  get: function () { return chunkUVZHTBZ5_cjs.searchable; }
 });
 exports.DEFAULT_SQL_SCHEMA = DEFAULT_SQL_SCHEMA;
 exports.ExecutableAggregateQuery = ExecutableAggregateQuery;
@@ -12323,6 +13868,7 @@ exports.MAX_EXPLICIT_RECURSIVE_DEPTH = MAX_EXPLICIT_RECURSIVE_DEPTH;
 exports.MAX_RECURSIVE_DEPTH = MAX_RECURSIVE_DEPTH;
 exports.PreparedQuery = PreparedQuery;
 exports.QueryBuilder = QueryBuilder;
+exports.StoreSearch = StoreSearch;
 exports.UnionableQuery = UnionableQuery;
 exports.avg = avg;
 exports.broader = broader;