@nicia-ai/typegraph 0.34.0 → 0.36.0

package/dist/chunk-7YSP4V4R.cjs

@@ -0,0 +1,69 @@
+'use strict';
+
+var drizzleOrm = require('drizzle-orm');
+
+// src/backend/drizzle/operations/shared.ts
+function sqlNull(value) {
+  return value ?? drizzleOrm.sql.raw("NULL");
+}
+function resolveValidFrom(validFrom, timestamp) {
+  if (validFrom === null) return void 0;
+  return validFrom ?? timestamp;
+}
+function quotedColumn(column) {
+  return drizzleOrm.sql.raw(`"${column.name.replaceAll('"', '""')}"`);
+}
+function quotedTableName(tableName) {
+  return drizzleOrm.sql.raw(`"${tableName.replaceAll('"', '""')}"`);
+}
+function codePointOrderKey(column, dialect) {
+  return dialect === "postgres" ? drizzleOrm.sql`${column} COLLATE "C"` : column;
+}
+function liveNodeIdsSubquery(nodes, graphId, nodeKind, nowIso) {
+  return drizzleOrm.sql`SELECT ${nodes.id} AS node_id FROM ${nodes} WHERE ${nodes.graphId} = ${graphId} AND ${nodes.kind} = ${nodeKind} AND ${nodes.deletedAt} IS NULL AND (${nodes.validFrom} IS NULL OR ${nodes.validFrom} <= ${nowIso}) AND (${nodes.validTo} IS NULL OR ${nodes.validTo} > ${nowIso})`;
+}
+function nodeColumnList(nodes) {
+  return drizzleOrm.sql.raw(`"${nodes.graphId.name}", "${nodes.kind.name}", "${nodes.id.name}", "${nodes.props.name}", "${nodes.version.name}", "${nodes.validFrom.name}", "${nodes.validTo.name}", "${nodes.createdAt.name}", "${nodes.updatedAt.name}"`);
+}
+function edgeColumnList(edges) {
+  return drizzleOrm.sql.raw(`"${edges.graphId.name}", "${edges.id.name}", "${edges.kind.name}", "${edges.fromKind.name}", "${edges.fromId.name}", "${edges.toKind.name}", "${edges.toId.name}", "${edges.props.name}", "${edges.validFrom.name}", "${edges.validTo.name}", "${edges.createdAt.name}", "${edges.updatedAt.name}"`);
+}
+
+// src/constants.ts
+var MAX_PG_IDENTIFIER_LENGTH = 63;
+var TRUNCATED_IDENTIFIER_MAX_LENGTH = 54;
+var IDENTIFIER_COMPONENT_MAX_LENGTH = 20;
+var FNV1A_OFFSET_BASIS = 2166136261;
+var FNV1A_PRIME = 16777619;
+var DEFAULT_PAGINATION_LIMIT = 20;
+var DEFAULT_STREAM_BATCH_SIZE = 1e3;
+var SQLITE_PATH_DELIMITER = "|";
+var PG_PATH_ELEMENT_SEPARATOR = ",";
+var PG_ARRAY_START = "{";
+var PG_ARRAY_END = "}";
+var LIKE_ESCAPE_CHARACTER = "\\";
+var likeEscapeClause = drizzleOrm.sql`ESCAPE '\\'`;
+
+exports.DEFAULT_PAGINATION_LIMIT = DEFAULT_PAGINATION_LIMIT;
+exports.DEFAULT_STREAM_BATCH_SIZE = DEFAULT_STREAM_BATCH_SIZE;
+exports.FNV1A_OFFSET_BASIS = FNV1A_OFFSET_BASIS;
+exports.FNV1A_PRIME = FNV1A_PRIME;
+exports.IDENTIFIER_COMPONENT_MAX_LENGTH = IDENTIFIER_COMPONENT_MAX_LENGTH;
+exports.LIKE_ESCAPE_CHARACTER = LIKE_ESCAPE_CHARACTER;
+exports.MAX_PG_IDENTIFIER_LENGTH = MAX_PG_IDENTIFIER_LENGTH;
+exports.PG_ARRAY_END = PG_ARRAY_END;
+exports.PG_ARRAY_START = PG_ARRAY_START;
+exports.PG_PATH_ELEMENT_SEPARATOR = PG_PATH_ELEMENT_SEPARATOR;
+exports.SQLITE_PATH_DELIMITER = SQLITE_PATH_DELIMITER;
+exports.TRUNCATED_IDENTIFIER_MAX_LENGTH = TRUNCATED_IDENTIFIER_MAX_LENGTH;
+exports.codePointOrderKey = codePointOrderKey;
+exports.edgeColumnList = edgeColumnList;
+exports.likeEscapeClause = likeEscapeClause;
+exports.liveNodeIdsSubquery = liveNodeIdsSubquery;
+exports.nodeColumnList = nodeColumnList;
+exports.quotedColumn = quotedColumn;
+exports.quotedTableName = quotedTableName;
+exports.resolveValidFrom = resolveValidFrom;
+exports.sqlNull = sqlNull;
+//# sourceMappingURL=chunk-7YSP4V4R.cjs.map
+//# sourceMappingURL=chunk-7YSP4V4R.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/backend/drizzle/operations/shared.ts","../src/constants.ts","../src/query/dialect/like-escape.ts"],"names":["sql"],"mappings":"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","file":"chunk-7YSP4V4R.cjs","sourcesContent":["import { type SQL, sql } from \"drizzle-orm\";\n\nimport type { SqlDialect } from \"../../types\";\nimport type { PostgresTables } from \"../schema/postgres\";\nimport type { SqliteTables } from \"../schema/sqlite\";\n\nexport type Tables = SqliteTables | PostgresTables;\n\n/**\n * Converts undefined to SQL NULL for use in template literals.\n * Drizzle doesn't handle undefined in sql`` templates correctly.\n */\nexport function sqlNull(value: string | undefined): SQL | string {\n  return value ?? sql.raw(\"NULL\");\n}\n\n/**\n * Resolves a `validFrom` insert value against the row's creation timestamp.\n * Three states, matching {@link InsertNodeParams.validFrom} /\n * {@link InsertEdgeParams.validFrom}:\n *  - `undefined` (omitted): defaults to `timestamp` — every insert path\n *    (single, batch, returning/non-returning) agrees that \"no validFrom\"\n *    means \"valid from creation\", not open-left NULL (see issue #240).\n *  - `null`: preserves an explicit open-left window — returned as\n *    `undefined` here so the caller's {@link sqlNull} wrap emits SQL NULL,\n *    letting interchange import round-trip a row that predates the #240\n *    fix without narrowing its validity window on re-import (e.g. via a\n *    `branch()` clone).\n *  - a string: passed through unchanged.\n */\nexport function resolveValidFrom(\n  validFrom: string | null | undefined,\n  timestamp: string,\n): string | undefined {\n  if (validFrom === null) return undefined;\n  return validFrom ?? timestamp;\n}\n\nexport function quotedColumn(column: { name: string }): SQL {\n  return sql.raw(`\"${column.name.replaceAll('\"', '\"\"')}\"`);\n}\n\n/**\n * Returns a quoted SQL identifier for a bare table name string.\n * Use when the operation targets a table that isn't represented as a\n * Drizzle table object (e.g. the FTS5 virtual table).\n */\nexport function quotedTableName(tableName: string): SQL {\n  return sql.raw(`\"${tableName.replaceAll('\"', '\"\"')}\"`);\n}\n\n/**\n * `column` rendered so that ORDER BY sorts it by code point on both engines.\n *\n * Relevance-ranking SQL breaks score ties on `node_id`. Left bare, Postgres\n * sorts it under the column's collation — a linguistic collation such as\n * `en_US.UTF-8` orders `a, A, b, B` where byte order gives `A, B, a, b`, so\n * the same query returns different pages on two databases whose `datcollate`\n * differs. SQLite's default `BINARY` collation is already code-point order,\n * as is the store's `compareCodePoints`, which ranks the same rows whenever a\n * search falls back to fusing in JavaScript.\n *\n * Forcing the `C` collation on Postgres makes all three agree. The ranking is\n * sorted anyway (no index supplies the order), so this costs nothing.\n */\nexport function codePointOrderKey(column: SQL, dialect: SqlDialect): SQL {\n  return dialect === \"postgres\" ? sql`${column} COLLATE \"C\"` : column;\n}\n\n/**\n * Subquery yielding the ids of CURRENT nodes of one kind — the candidate\n * set a facade search statement is allowed to return. Passed into the\n * fulltext and vector search builders so top-k is computed over current\n * rows in SQL, instead of ranking side-table rows first and dropping\n * tombstoned/expired nodes after (which silently shrinks results below\n * `limit` under index drift).\n *\n * Currency matches a `current` read: non-tombstoned AND inside the\n * validity window. The instant is BOUND as a parameter (the backend's\n * clock, same source as its write timestamps) rather than compiled as a\n * per-row SQL now() call — on SQLite a per-row strftime() across two\n * search legs dominated unfiltered facade searches.\n */\nexport function liveNodeIdsSubquery(\n  nodes: Tables[\"nodes\"],\n  graphId: string,\n  nodeKind: string,\n  nowIso: string,\n): SQL {\n  return sql`SELECT ${nodes.id} AS node_id FROM ${nodes} WHERE ${nodes.graphId} = ${graphId} AND ${nodes.kind} = ${nodeKind} AND ${nodes.deletedAt} IS NULL AND (${nodes.validFrom} IS NULL OR ${nodes.validFrom} <= ${nowIso}) AND (${nodes.validTo} IS NULL OR ${nodes.validTo} > ${nowIso})`;\n}\n\nexport function nodeColumnList(nodes: Tables[\"nodes\"]): SQL {\n  return sql.raw(`\"${nodes.graphId.name}\", \"${nodes.kind.name}\", \"${nodes.id.name}\", \"${nodes.props.name}\", \"${nodes.version.name}\", \"${nodes.validFrom.name}\", \"${nodes.validTo.name}\", \"${nodes.createdAt.name}\", \"${nodes.updatedAt.name}\"`);\n}\n\nexport function edgeColumnList(edges: Tables[\"edges\"]): SQL {\n  return sql.raw(`\"${edges.graphId.name}\", \"${edges.id.name}\", \"${edges.kind.name}\", \"${edges.fromKind.name}\", \"${edges.fromId.name}\", \"${edges.toKind.name}\", \"${edges.toId.name}\", \"${edges.props.name}\", \"${edges.validFrom.name}\", \"${edges.validTo.name}\", \"${edges.createdAt.name}\", \"${edges.updatedAt.name}\"`);\n}\n","/**\n * Shared constants used across the TypeGraph codebase.\n */\n\n// ============================================================\n// PostgreSQL Limits\n// ============================================================\n\n/**\n * PostgreSQL truncates identifiers longer than 63 bytes.\n * Used for column aliases, index names, and other generated identifiers.\n */\nexport const MAX_PG_IDENTIFIER_LENGTH = 63;\n\n/** Maximum byte length for the truncated portion of a generated identifier. */\nexport const TRUNCATED_IDENTIFIER_MAX_LENGTH = 54;\n\n/** Maximum length for a single component (kind name, field name) in a generated identifier. */\nexport const IDENTIFIER_COMPONENT_MAX_LENGTH = 20;\n\n// ============================================================\n// FNV-1a Hash Constants\n// ============================================================\n\n/** FNV-1a 32-bit offset basis. */\nexport const FNV1A_OFFSET_BASIS = 0x81_1c_9d_c5;\n\n/** FNV-1a 32-bit prime. */\nexport const FNV1A_PRIME = 0x01_00_01_93;\n\n// ============================================================\n// Pagination\n// ============================================================\n\n/** Default page size for paginate() and cursor-based pagination. */\nexport const DEFAULT_PAGINATION_LIMIT = 20;\n\n/** Default batch size for streaming query results. */\nexport const DEFAULT_STREAM_BATCH_SIZE = 1000;\n\n// ============================================================\n// Path Delimiters\n// ============================================================\n\n/** SQLite stores array paths as pipe-delimited strings: |id1|id2|id3| */\nexport const SQLITE_PATH_DELIMITER = \"|\";\n\n/** PostgreSQL text arrays use comma-separated elements: {id1,id2,id3} */\nexport const PG_PATH_ELEMENT_SEPARATOR = \",\";\n\n/** PostgreSQL text array start delimiter. */\nexport const PG_ARRAY_START = \"{\";\n\n/** PostgreSQL text array end delimiter. */\nexport const PG_ARRAY_END = \"}\";\n","/**\n * Shared LIKE-escape clause for the query compiler.\n *\n * The compiler builds `contains` / `startsWith` / `endsWith` patterns by\n * escaping the literal `%`, `_`, and `\\` in user input with a backslash (see\n * the pattern builders in `compiler/predicates.ts`). For that escaping to take\n * effect the emitted `LIKE` / `ILIKE` must declare backslash as its escape\n * character. PostgreSQL's default LIKE escape is already backslash, so this\n * clause is a no-op there; SQLite has *no* default escape character, so without\n * it an escaped `\\%` matches a literal backslash followed by any character —\n * silently diverging from Postgres. Emitting it on every compiled predicate\n * makes the two backends match by construction.\n */\nimport { type SQL, sql } from \"drizzle-orm\";\n\n/**\n * The backslash escape character used by the JS pattern builder\n * (`compileStringPattern` in `compiler/predicates.ts`) to prefix the literal\n * `%`, `_`, and `\\` in user input. It must match the character declared by\n * {@link likeEscapeClause}: the builder prefixes wildcards with this character,\n * and the clause tells SQL to treat it as the escape. Both are backslash.\n */\nexport const LIKE_ESCAPE_CHARACTER = \"\\\\\";\n\n/**\n * `ESCAPE '\\'` clause appended to every compiled `LIKE` / `ILIKE` predicate,\n * declaring {@link LIKE_ESCAPE_CHARACTER} as the escape character. The single\n * backslash inside the quotes is a literal in both PostgreSQL (with\n * `standard_conforming_strings`, the default) and SQLite.\n */\nexport const likeEscapeClause: SQL = sql`ESCAPE '\\\\'`;\n"]}

package/dist/chunk-A42GCBGX.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+// src/utils/compare.ts
+function compareStrings(left, right) {
+  if (left < right) return -1;
+  return left > right ? 1 : 0;
+}
+function compareCodePoints(left, right) {
+  if (left === right) return 0;
+  let leftIndex = 0;
+  let rightIndex = 0;
+  while (leftIndex < left.length && rightIndex < right.length) {
+    const leftPoint = left.codePointAt(leftIndex);
+    const rightPoint = right.codePointAt(rightIndex);
+    if (leftPoint !== rightPoint) return leftPoint < rightPoint ? -1 : 1;
+    leftIndex += leftPoint > 65535 ? 2 : 1;
+    rightIndex += rightPoint > 65535 ? 2 : 1;
+  }
+  const leftExhausted = leftIndex >= left.length;
+  const rightExhausted = rightIndex >= right.length;
+  if (leftExhausted && rightExhausted) return 0;
+  return leftExhausted ? -1 : 1;
+}
+
+exports.compareCodePoints = compareCodePoints;
+exports.compareStrings = compareStrings;
+//# sourceMappingURL=chunk-A42GCBGX.cjs.map
+//# sourceMappingURL=chunk-A42GCBGX.cjs.map

package/dist/chunk-A42GCBGX.cjs.map

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

package/dist/{chunk-ZV5N4DBG.js → chunk-BJVEU3ZL.js}

@@ -1,10 +1,10 @@
-import { createVectorSlotLatch, createSqliteOperationStrategy, createContributionMaterializer, gateFulltextMethods, generateSqliteCreateTableSQL, mapContributionMaterializationRow, SQLITE_CONTRIBUTION_MAT_TIMESTAMPS, buildContributionInsertValues, buildContributionOnConflictSet, assertAdoptedDialect, buildKindRemovalInsertValues, SQLITE_KIND_REMOVAL_TIMESTAMPS, buildKindRemovalOnConflictSet, mapKindRemovalRow, buildMaterializationInsertValues, SQLITE_INDEX_MAT_TIMESTAMPS, buildMaterializationOnConflictSet, mapMaterializationRow, generateSqliteDDL, createCommonOperationBackend, gateFulltext, compileQueryWithDialect, vectorSlotFromDropIndexParams, vectorSlotFromCreateIndexParams, vectorSlotFromParams, mapVectorWriteError, getOrCreateLru } from './chunk-RY2VIWAM.js';
-import { tables } from './chunk-CYX2JTDG.js';
-import { createNodeRowMapper, SQLITE_ROW_MAPPER_CONFIG, createEdgeRowMapper, createUniqueRowMapper, createSchemaVersionRowMapper, nowIso, coerceNumericScore } from './chunk-QV245VMN.js';
-import { fts5Strategy, buildVectorCapabilities, buildFulltextCapabilities, assertVectorSearchLimit } from './chunk-KUTNI6SI.js';
-import { SQLITE_CAPABILITIES, SQLITE_MAX_BIND_PARAMETERS } from './chunk-V3QNTB7Z.js';
-import { isMissingTableError } from './chunk-2MRAX3UE.js';
-import { ConfigurationError, BackendDisposedError } from './chunk-TQOYM4LN.js';
+import { createVectorSlotLatch, createSqliteOperationStrategy, createContributionMaterializer, gateFulltextMethods, generateSqliteCreateTableSQL, mapContributionMaterializationRow, SQLITE_CONTRIBUTION_MAT_TIMESTAMPS, buildContributionInsertValues, buildContributionOnConflictSet, assertAdoptedDialect, buildKindRemovalInsertValues, SQLITE_KIND_REMOVAL_TIMESTAMPS, buildKindRemovalOnConflictSet, mapKindRemovalRow, buildMaterializationInsertValues, SQLITE_INDEX_MAT_TIMESTAMPS, buildMaterializationOnConflictSet, mapMaterializationRow, generateSqliteDDL, createCommonOperationBackend, vectorSlotFromParams, hybridCandidatesRef, mapVectorWriteError, mapHybridSearchRow, gateFulltext, compileQueryWithDialect, EMBEDDING_UPSERT_PARAM_COUNT, vectorSlotFromDropIndexParams, vectorSlotFromCreateIndexParams, getOrCreateLru } from './chunk-4GX2JJXS.js';
+import { tables } from './chunk-VHMPG6UL.js';
+import { createNodeRowMapper, SQLITE_ROW_MAPPER_CONFIG, createEdgeRowMapper, createUniqueRowMapper, createSchemaVersionRowMapper, quoteIdentifier, nowIso, coerceNumericScore } from './chunk-RAXU3RMB.js';
+import { fts5Strategy, buildVectorCapabilities, buildFulltextCapabilities, assertVectorSearchLimit } from './chunk-FPIZFYHE.js';
+import { SQLITE_CAPABILITIES, SQLITE_MAX_BIND_PARAMETERS, D1_MAX_BIND_PARAMETERS, MODERN_SQLITE_MAX_BIND_PARAMETERS, chunk } from './chunk-IU46OHVW.js';
+import { isMissingTableError } from './chunk-JFUPDJXD.js';
+import { ConfigurationError, BackendDisposedError } from './chunk-WI7ISNQF.js';
 import { getTableName, sql, and, eq, isNull, inArray } from 'drizzle-orm';
 import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
 
@@ -62,6 +62,44 @@ function detectTransactionMode(db, profileHints, isSync) {
   if (isSync) return "sql";
   return "drizzle";
 }
+var MAX_VARIABLE_NUMBER_COMPILE_OPTION = /^MAX_VARIABLE_NUMBER=(\d+)$/;
+var FIRST_MODERN_BIND_LIMIT_MAJOR = 3;
+var FIRST_MODERN_BIND_LIMIT_MINOR = 32;
+function parseCompiledMaxVariableNumber(rows) {
+  for (const row of rows) {
+    if (typeof row !== "object" || row === null) continue;
+    const option = row.compile_options;
+    if (typeof option !== "string") continue;
+    const match = MAX_VARIABLE_NUMBER_COMPILE_OPTION.exec(option);
+    if (match !== null) return Number(match[1]);
+  }
+  return void 0;
+}
+function hasModernBindLimitByVersion(rows) {
+  const first = rows[0];
+  if (typeof first !== "object" || first === null) return false;
+  const version = first.version;
+  if (typeof version !== "string") return false;
+  const [major = 0, minor = 0] = version.split(".").map(Number);
+  if (!Number.isFinite(major) || !Number.isFinite(minor)) return false;
+  return major > FIRST_MODERN_BIND_LIMIT_MAJOR || major === FIRST_MODERN_BIND_LIMIT_MAJOR && minor >= FIRST_MODERN_BIND_LIMIT_MINOR;
+}
+function detectMaxBindParameters(db, sqliteClient) {
+  if (isD1DatabaseBySessionName(db)) return D1_MAX_BIND_PARAMETERS;
+  if (sqliteClient === void 0) return SQLITE_MAX_BIND_PARAMETERS;
+  try {
+    const compiled = parseCompiledMaxVariableNumber(
+      sqliteClient.prepare("PRAGMA compile_options").all()
+    );
+    if (compiled !== void 0) return compiled;
+    const isModern = hasModernBindLimitByVersion(
+      sqliteClient.prepare("SELECT sqlite_version() AS version").all()
+    );
+    return isModern ? MODERN_SQLITE_MAX_BIND_PARAMETERS : SQLITE_MAX_BIND_PARAMETERS;
+  } catch {
+    return SQLITE_MAX_BIND_PARAMETERS;
+  }
+}
 function resolveSqliteClient(db) {
   const databaseWithClient = db;
   const sqliteClient = databaseWithClient.$client;
@@ -104,6 +142,7 @@ function createSqliteExecutionAdapter(db, statementCacheMaxOrOptions = {}) {
   const transactionMode = detectTransactionMode(db, profileHints, isSync);
   const profile = {
     isSync,
+    maxBindParameters: detectMaxBindParameters(db, sqliteClient),
     supportsCompiledExecution: sqliteClient !== void 0,
     transactionMode
   };
@@ -118,6 +157,19 @@ function createSqliteExecutionAdapter(db, statementCacheMaxOrOptions = {}) {
       );
       const rows = preparedStatement.all(...compiledQuery.params);
       return Promise.resolve(rows);
+    }, executeCompiledRun2 = function(compiledQuery) {
+      const preparedStatement = getOrCreatePreparedStatement(
+        statementCache,
+        client,
+        compiledQuery.sql,
+        statementCacheMax
+      );
+      if (preparedStatement.run === void 0 || preparedStatement.reader === true) {
+        preparedStatement.all(...compiledQuery.params);
+      } else {
+        preparedStatement.run(...compiledQuery.params);
+      }
+      return Promise.resolve();
     };
     const client = sqliteClient;
     const statementCache = /* @__PURE__ */ new Map();
@@ -131,6 +183,7 @@ function createSqliteExecutionAdapter(db, statementCacheMaxOrOptions = {}) {
         return executeCompiled2(compiledQuery);
       },
       executeCompiled: executeCompiled2,
+      executeCompiledRun: executeCompiledRun2,
       prepare(sqlText) {
         return createPreparedStatementExecutor(
           client,
@@ -156,27 +209,53 @@ function createSqliteExecutionAdapter(db, statementCacheMaxOrOptions = {}) {
 // src/backend/drizzle/sqlite.ts
 var NODE_INSERT_PARAM_COUNT = 9;
 var EDGE_INSERT_PARAM_COUNT = 12;
-var SQLITE_NODE_INSERT_BATCH_SIZE = Math.max(
-  1,
-  Math.floor(SQLITE_MAX_BIND_PARAMETERS / NODE_INSERT_PARAM_COUNT)
-);
-var SQLITE_EDGE_INSERT_BATCH_SIZE = Math.max(
-  1,
-  Math.floor(SQLITE_MAX_BIND_PARAMETERS / EDGE_INSERT_PARAM_COUNT)
-);
-var SQLITE_GET_NODES_ID_CHUNK_SIZE = Math.max(
-  1,
-  SQLITE_MAX_BIND_PARAMETERS - 2
-);
-var SQLITE_GET_EDGES_ID_CHUNK_SIZE = Math.max(
-  1,
-  SQLITE_MAX_BIND_PARAMETERS - 1
-);
+var GET_NODES_FIXED_PARAM_COUNT = 2;
+var GET_EDGES_FIXED_PARAM_COUNT = 1;
 var CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT = 3;
-var SQLITE_CHECK_UNIQUE_BATCH_CHUNK_SIZE = Math.max(
-  1,
-  SQLITE_MAX_BIND_PARAMETERS - CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT
-);
+var FULLTEXT_UPSERT_PARAM_COUNT = 6;
+var FULLTEXT_DELETE_FIXED_PARAM_COUNT = 2;
+var UNIQUE_INSERT_PARAM_COUNT = 6;
+var SQLITE_ANALYZE_ROW_LIMIT = 1e3;
+function computeSqliteBatchChunkSizes(maxBindParameters) {
+  return {
+    checkUniqueBatchChunkSize: Math.max(
+      1,
+      maxBindParameters - CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT
+    ),
+    embeddingUpsertBatchSize: Math.max(
+      1,
+      Math.floor(maxBindParameters / EMBEDDING_UPSERT_PARAM_COUNT)
+    ),
+    fulltextUpsertBatchSize: Math.max(
+      1,
+      Math.floor(maxBindParameters / FULLTEXT_UPSERT_PARAM_COUNT)
+    ),
+    fulltextDeleteChunkSize: Math.max(
+      1,
+      maxBindParameters - FULLTEXT_DELETE_FIXED_PARAM_COUNT
+    ),
+    edgeInsertBatchSize: Math.max(
+      1,
+      Math.floor(maxBindParameters / EDGE_INSERT_PARAM_COUNT)
+    ),
+    getEdgesChunkSize: Math.max(
+      1,
+      maxBindParameters - GET_EDGES_FIXED_PARAM_COUNT
+    ),
+    getNodesChunkSize: Math.max(
+      1,
+      maxBindParameters - GET_NODES_FIXED_PARAM_COUNT
+    ),
+    nodeInsertBatchSize: Math.max(
+      1,
+      Math.floor(maxBindParameters / NODE_INSERT_PARAM_COUNT)
+    ),
+    uniqueInsertBatchSize: Math.max(
+      1,
+      Math.floor(maxBindParameters / UNIQUE_INSERT_PARAM_COUNT)
+    )
+  };
+}
 var toNodeRow = createNodeRowMapper(SQLITE_ROW_MAPPER_CONFIG);
 var toEdgeRow = createEdgeRowMapper(SQLITE_ROW_MAPPER_CONFIG);
 var toUniqueRow = createUniqueRowMapper(SQLITE_ROW_MAPPER_CONFIG);
@@ -259,6 +338,7 @@ function buildSqliteCapabilities(options) {
   const base = options.transactionMode === "none" ? { ...SQLITE_CAPABILITIES, transactions: false } : SQLITE_CAPABILITIES;
   return {
     ...base,
+    maxBindParameters: options.maxBindParameters,
     fulltext: buildFulltextCapabilities(options.fulltextStrategy),
     ...options.vectorStrategy === void 0 ? {} : { vector: buildVectorCapabilities(options.vectorStrategy) }
   };
@@ -275,30 +355,40 @@ function createSqliteOperationBackend(options) {
     vectorStrategy,
     vectorSlotLatch
   } = options;
+  const compiledExecute = executionAdapter.executeCompiled;
+  const compiledRun = executionAdapter.executeCompiledRun;
   function execGet(query) {
     return runWithSerializedQueue(serializedQueue, async () => {
-      const rows = await db.all(query);
+      if (compiledExecute === void 0) {
+        const rows2 = await db.all(query);
+        return rows2[0];
+      }
+      const rows = await compiledExecute(executionAdapter.compile(query));
       return rows[0];
     });
   }
   function execAll(query) {
     return runWithSerializedQueue(serializedQueue, async () => {
-      return await db.all(query);
+      if (compiledExecute === void 0) {
+        return await db.all(query);
+      }
+      return [...await compiledExecute(executionAdapter.compile(query))];
     });
   }
   function execRun(query) {
     return runWithSerializedQueue(serializedQueue, async () => {
-      await db.run(query);
+      if (compiledRun === void 0) {
+        await db.run(query);
+        return;
+      }
+      await compiledRun(executionAdapter.compile(query));
     });
   }
+  const batchConfig = computeSqliteBatchChunkSizes(
+    capabilities.maxBindParameters ?? SQLITE_MAX_BIND_PARAMETERS
+  );
   const commonBackend = createCommonOperationBackend({
-    batchConfig: {
-      checkUniqueBatchChunkSize: SQLITE_CHECK_UNIQUE_BATCH_CHUNK_SIZE,
-      edgeInsertBatchSize: SQLITE_EDGE_INSERT_BATCH_SIZE,
-      getEdgesChunkSize: SQLITE_GET_EDGES_ID_CHUNK_SIZE,
-      getNodesChunkSize: SQLITE_GET_NODES_ID_CHUNK_SIZE,
-      nodeInsertBatchSize: SQLITE_NODE_INSERT_BATCH_SIZE
-    },
+    batchConfig,
     execution: {
       execAll,
       execGet,
@@ -341,6 +431,48 @@ function createSqliteOperationBackend(options) {
         throw mapVectorWriteError(error, params);
       }
     },
+    async upsertEmbeddingBatch(params) {
+      if (params.rows.length === 0) return;
+      const slot = vectorSlotFromParams(params);
+      await ensureVectorSlotStorage(slot);
+      const rowsById = new Map(
+        params.rows.map((row) => [row.nodeId, row])
+      );
+      const rows = [...rowsById.values()];
+      const timestamp = nowIso();
+      try {
+        for (const chunk2 of chunk(
+          rows,
+          batchConfig.embeddingUpsertBatchSize
+        )) {
+          const statements = vectorStrategy.buildUpsertBatch === void 0 ? chunk2.flatMap(
+            (row) => vectorStrategy.buildUpsert(
+              slot,
+              {
+                graphId: params.graphId,
+                nodeKind: params.nodeKind,
+                nodeId: row.nodeId,
+                fieldPath: params.fieldPath,
+                embedding: row.embedding,
+                dimensions: params.dimensions,
+                metric: params.metric,
+                indexType: params.indexType
+              },
+              timestamp
+            )
+          ) : vectorStrategy.buildUpsertBatch(
+            slot,
+            { ...params, rows: chunk2 },
+            timestamp
+          );
+          for (const statement of statements) {
+            await execRun(statement);
+          }
+        }
+      } catch (error) {
+        throw mapVectorWriteError(error, params);
+      }
+    },
     async deleteEmbedding(params) {
       const slot = vectorSlotFromParams(params);
       await ensureVectorSlotStorage(slot);
@@ -353,7 +485,16 @@ function createSqliteOperationBackend(options) {
       assertVectorSearchLimit(params.limit);
       const slot = vectorSlotFromParams(params);
       await ensureVectorSlotStorage(slot);
-      const query = vectorStrategy.buildSearch(slot, params);
+      const query = vectorStrategy.buildSearch(
+        slot,
+        params,
+        // Store-compiled candidates (predicates + subclass + currency)
+        // take precedence; the live-node default covers direct backend use.
+        params.candidates ?? operationStrategy.buildLiveNodeIds(
+          params.graphId,
+          params.nodeKind
+        )
+      );
       let rows;
       try {
         rows = await execAll(query);
@@ -364,7 +505,57 @@ function createSqliteOperationBackend(options) {
         nodeId: row.node_id,
         score: row.score
       }));
-    }
+    },
+    // Single-statement hybrid needs ROW_NUMBER(); a capability profile
+    // that disables window functions keeps the store's multi-statement
+    // fallback by simply not exposing the member.
+    ...capabilities.windowFunctions ? {
+      async hybridSearch(params) {
+        assertVectorSearchLimit(params.limit);
+        assertVectorSearchLimit(params.vector.k);
+        const slot = vectorSlotFromParams({
+          graphId: params.graphId,
+          nodeKind: params.nodeKind,
+          fieldPath: params.vector.fieldPath,
+          dimensions: params.vector.dimensions,
+          metric: params.vector.metric,
+          indexType: params.vector.indexType
+        });
+        await ensureVectorSlotStorage(slot);
+        const candidates = params.candidates ?? operationStrategy.buildLiveNodeIds(
+          params.graphId,
+          params.nodeKind
+        );
+        const vectorParams = {
+          graphId: params.graphId,
+          nodeKind: params.nodeKind,
+          fieldPath: params.vector.fieldPath,
+          queryEmbedding: params.vector.queryEmbedding,
+          metric: params.vector.metric,
+          dimensions: params.vector.dimensions,
+          indexType: params.vector.indexType,
+          limit: params.vector.k,
+          ...params.vector.minScore === void 0 ? {} : { minScore: params.vector.minScore }
+        };
+        const vectorSql = vectorStrategy.buildSearch(
+          slot,
+          vectorParams,
+          hybridCandidatesRef()
+        );
+        const statement = operationStrategy.buildHybridSearch(
+          { ...params, candidates },
+          vectorSql,
+          params.vector.metric === "cosine"
+        );
+        let raw;
+        try {
+          raw = await execAll(statement);
+        } catch (error) {
+          throw mapVectorWriteError(error, vectorParams);
+        }
+        return raw.map((row) => mapHybridSearchRow(row, toNodeRow));
+      }
+    } : {}
   };
   const operationBackend = {
     ...commonBackend,
@@ -415,19 +606,32 @@ function createSqliteOperationBackend(options) {
     async upsertFulltextBatch(params) {
       if (params.rows.length === 0) return;
       const timestamp = nowIso();
-      const statements = operationStrategy.buildUpsertFulltextBatch(
-        params,
-        timestamp
-      );
-      for (const stmt of statements) {
-        await execRun(stmt);
+      for (const rows of chunk(
+        params.rows,
+        batchConfig.fulltextUpsertBatchSize
+      )) {
+        const statements = operationStrategy.buildUpsertFulltextBatch(
+          { ...params, rows },
+          timestamp
+        );
+        for (const stmt of statements) {
+          await execRun(stmt);
+        }
       }
     },
     async deleteFulltextBatch(params) {
       if (params.nodeIds.length === 0) return;
-      const statements = operationStrategy.buildDeleteFulltextBatch(params);
-      for (const stmt of statements) {
-        await execRun(stmt);
+      for (const nodeIds of chunk(
+        params.nodeIds,
+        batchConfig.fulltextDeleteChunkSize
+      )) {
+        const statements = operationStrategy.buildDeleteFulltextBatch({
+          ...params,
+          nodeIds
+        });
+        for (const stmt of statements) {
+          await execRun(stmt);
+        }
       }
     },
     async fulltextSearch(params) {
@@ -465,7 +669,8 @@ function createSqliteBackend(db, options = {}) {
     ...buildSqliteCapabilities({
       fulltextStrategy,
       vectorStrategy,
-      transactionMode
+      transactionMode,
+      maxBindParameters: executionAdapter.profile.maxBindParameters
     }),
     ...options.capabilities
   };
@@ -475,9 +680,21 @@ function createSqliteBackend(db, options = {}) {
     recordedNodes: getTableName(tables2.recordedNodes),
     recordedEdges: getTableName(tables2.recordedEdges),
     recordedClock: getTableName(tables2.recordedClock),
+    revisionOrigins: getTableName(tables2.revisionOrigins),
     fulltext: tables2.fulltextTableName,
     uniques: getTableName(tables2.uniques)
   };
+  const coreAnalyzeTables = [
+    tableNames.nodes,
+    tableNames.edges,
+    tableNames.uniques,
+    tableNames.fulltext
+  ];
+  const recordedAnalyzeTables = [
+    tableNames.recordedNodes,
+    tableNames.recordedEdges,
+    tableNames.recordedClock
+  ];
   const operationStrategy = createSqliteOperationStrategy(
     tables2,
     fulltextStrategy
@@ -507,6 +724,14 @@ function createSqliteBackend(db, options = {}) {
       async () => storageTransaction.call(storage, run)
     );
   }
+  async function runFrameStatement(query) {
+    const compiledRun = executionAdapter.executeCompiledRun;
+    if (compiledRun === void 0) {
+      await db.run(query);
+      return;
+    }
+    await compiledRun(executionAdapter.compile(query));
+  }
   function runSchemaWriteTransaction(fn) {
     if (transactionMode === "none") {
       throwSqliteTransactionsDisabled(
@@ -524,13 +749,13 @@ function createSqliteBackend(db, options = {}) {
           tableNames,
           fulltextStrategy,
           vectorStrategy});
-        await db.run(sql`BEGIN IMMEDIATE`);
+        await runFrameStatement(sql`BEGIN IMMEDIATE`);
         try {
           const result = await fn(txBackend);
-          await db.run(sql`COMMIT`);
+          await runFrameStatement(sql`COMMIT`);
           return result;
         } catch (error) {
-          await db.run(sql`ROLLBACK`);
+          await runFrameStatement(sql`ROLLBACK`);
           throw error;
         }
       });
@@ -635,6 +860,11 @@ function createSqliteBackend(db, options = {}) {
         await db.run(sql.raw(statement));
       }
     },
+    async ensureRevisionOriginsTable() {
+      await db.run(
+        sql.raw(generateSqliteCreateTableSQL(tables2.revisionOrigins))
+      );
+    },
     // Every fulltext-touching method asserts the durable marker instead
     // of lazily emitting DDL. Steady state performs zero ensure; an
     // uninitialized database throws `StoreNotInitializedError` rather
@@ -752,7 +982,19 @@ function createSqliteBackend(db, options = {}) {
       });
     },
     async refreshStatistics() {
-      await db.run(sql`ANALYZE`);
+      await db.run(
+        sql`PRAGMA analysis_limit = ${sql.raw(String(SQLITE_ANALYZE_ROW_LIMIT))}`
+      );
+      for (const tableName of coreAnalyzeTables) {
+        await db.run(sql`ANALYZE ${quoteIdentifier(tableName)}`);
+      }
+      for (const tableName of recordedAnalyzeTables) {
+        try {
+          await db.run(sql`ANALYZE ${quoteIdentifier(tableName)}`);
+        } catch (error) {
+          if (!isMissingTableError(error)) throw error;
+        }
+      }
     },
     async commitSchemaVersion(params) {
       return runSchemaWriteTransaction(
@@ -781,7 +1023,7 @@ function createSqliteBackend(db, options = {}) {
             tableNames,
             fulltextStrategy,
             vectorStrategy});
-          await db.run(sql`BEGIN IMMEDIATE`);
+          await runFrameStatement(sql`BEGIN IMMEDIATE`);
           try {
             const result = await fn(
               gateFulltext(
@@ -790,10 +1032,10 @@ function createSqliteBackend(db, options = {}) {
               ),
               db
             );
-            await db.run(sql`COMMIT`);
+            await runFrameStatement(sql`COMMIT`);
             return result;
           } catch (error) {
-            await db.run(sql`ROLLBACK`);
+            await runFrameStatement(sql`ROLLBACK`);
             throw error;
           }
         });
@@ -847,5 +1089,5 @@ function createTransactionBackend(options) {
 }
 
 export { createSqliteBackend };
-//# sourceMappingURL=chunk-ZV5N4DBG.js.map
-//# sourceMappingURL=chunk-ZV5N4DBG.js.map
+//# sourceMappingURL=chunk-BJVEU3ZL.js.map
+//# sourceMappingURL=chunk-BJVEU3ZL.js.map