@typicalday/firegraph 0.14.0 → 0.15.0

package/dist/cloudflare/index.cjs

@@ -172,7 +172,7 @@ __export(cloudflare_exports, {
   FiregraphDO: () => FiregraphDO,
   META_EDGE_TYPE: () => META_EDGE_TYPE,
   META_NODE_TYPE: () => META_NODE_TYPE,
-  buildDOSchemaStatements: () => buildDOSchemaStatements,
+  buildDOSchemaStatements: () => buildSchemaStatements,
   createCapabilities: () => createCapabilities,
   createDOClient: () => createDOClient,
   createMergedRegistry: () => createMergedRegistry,
@@ -281,6 +281,31 @@ var BUILTIN_FIELDS = /* @__PURE__ */ new Set([
 ]);
 var SHARD_SEPARATOR = ":";
 
+// src/timestamp.ts
+var GraphTimestampImpl = class _GraphTimestampImpl {
+  constructor(seconds, nanoseconds) {
+    this.seconds = seconds;
+    this.nanoseconds = nanoseconds;
+  }
+  toDate() {
+    return new Date(this.toMillis());
+  }
+  toMillis() {
+    return this.seconds * 1e3 + Math.floor(this.nanoseconds / 1e6);
+  }
+  toJSON() {
+    return { seconds: this.seconds, nanoseconds: this.nanoseconds };
+  }
+  static fromMillis(ms) {
+    const seconds = Math.floor(ms / 1e3);
+    const nanoseconds = (ms - seconds * 1e3) * 1e6;
+    return new _GraphTimestampImpl(seconds, nanoseconds);
+  }
+  static now() {
+    return _GraphTimestampImpl.fromMillis(Date.now());
+  }
+};
+
 // src/internal/sqlite-data-ops.ts
 var FIRESTORE_TYPE_NAMES = /* @__PURE__ */ new Set([
   "Timestamp",
@@ -309,6 +334,9 @@ function validateJsonPathKey(key, backendLabel) {
     );
   }
 }
+function buildJsonPath(segments) {
+  return "$" + segments.map((seg) => "." + JSON.stringify(seg)).join("");
+}
 function jsonBind(value, backendLabel) {
   if (value === void 0) return "null";
   if (value !== null && typeof value === "object") {
@@ -332,16 +360,14 @@ function compileDataOpsExpr(ops, base, params, backendLabel) {
     const placeholders = deletes.map(() => "?").join(", ");
     expr = `json_remove(${expr}, ${placeholders})`;
     for (const op of deletes) {
-      for (const seg of op.path) validateJsonPathKey(seg, backendLabel);
-      params.push(`$.${op.path.join(".")}`);
+      params.push(buildJsonPath(op.path));
     }
   }
   if (sets.length > 0) {
     const pieces = sets.map(() => "?, json(?)").join(", ");
     expr = `json_set(${expr}, ${pieces})`;
     for (const op of sets) {
-      for (const seg of op.path) validateJsonPathKey(seg, backendLabel);
-      params.push(`$.${op.path.join(".")}`);
+      params.push(buildJsonPath(op.path));
       params.push(jsonBind(op.value, backendLabel));
     }
   }
@@ -384,7 +410,6 @@ function isTerminalValue(value) {
   if (ctor && typeof ctor.name === "string" && FIRESTORE_TERMINAL_CTOR.has(ctor.name)) return true;
   return true;
 }
-var SAFE_KEY_RE = /^[A-Za-z_][A-Za-z0-9_-]*$/;
 function assertUpdatePayloadExclusive(update) {
   if (update.replaceData !== void 0 && update.dataOps !== void 0) {
     throw new Error(
@@ -423,9 +448,9 @@ function walkForDeleteSentinels(node, path, parent, visit) {
 }
 function assertSafePath(path) {
   for (const seg of path) {
-    if (!SAFE_KEY_RE.test(seg)) {
+    if (seg === "") {
       throw new Error(
-        `firegraph: unsafe object key ${JSON.stringify(seg)} at path ${path.map((p) => JSON.stringify(p)).join(" > ")}. Keys used inside update payloads must match /^[A-Za-z_][A-Za-z0-9_-]*$/ so they can be embedded safely in SQLite JSON paths.`
+        `firegraph: empty object key at path ${path.map((p) => JSON.stringify(p)).join(" > ")}. Object keys in update payloads must be non-empty.`
       );
     }
   }
@@ -571,31 +596,6 @@ function formatTagValue(value) {
   return typeof value;
 }
 
-// src/timestamp.ts
-var GraphTimestampImpl = class _GraphTimestampImpl {
-  constructor(seconds, nanoseconds) {
-    this.seconds = seconds;
-    this.nanoseconds = nanoseconds;
-  }
-  toDate() {
-    return new Date(this.toMillis());
-  }
-  toMillis() {
-    return this.seconds * 1e3 + Math.floor(this.nanoseconds / 1e6);
-  }
-  toJSON() {
-    return { seconds: this.seconds, nanoseconds: this.nanoseconds };
-  }
-  static fromMillis(ms) {
-    const seconds = Math.floor(ms / 1e3);
-    const nanoseconds = (ms - seconds * 1e3) * 1e6;
-    return new _GraphTimestampImpl(seconds, nanoseconds);
-  }
-  static now() {
-    return _GraphTimestampImpl.fromMillis(Date.now());
-  }
-};
-
 // src/default-indexes.ts
 var DEFAULT_CORE_INDEXES = Object.freeze([
   { fields: ["aUid"] },
@@ -640,9 +640,9 @@ function normalizeFields(fields) {
     return { path: f.path, desc: !!f.desc };
   });
 }
-function specFingerprint(spec, leadingColumns) {
+function specFingerprint(spec) {
   const normalized = {
-    lead: leadingColumns,
+    lead: [],
     fields: normalizeFields(spec.fields),
     where: spec.where ?? ""
   };
@@ -673,17 +673,14 @@ function compileFieldExpr(path, fieldToColumn) {
   );
 }
 function buildIndexDDL(spec, options) {
-  const { table, fieldToColumn, leadingColumns = [] } = options;
+  const { table, fieldToColumn } = options;
   if (!spec.fields || spec.fields.length === 0) {
     throw new FiregraphError("IndexSpec.fields must be a non-empty array", "INVALID_INDEX");
   }
   const normalized = normalizeFields(spec.fields);
-  const hash = specFingerprint(spec, leadingColumns);
+  const hash = specFingerprint(spec);
   const indexName = `${table}_idx_${hash}`;
   const cols = [];
-  for (const col of leadingColumns) {
-    cols.push(quoteIdent(col));
-  }
   for (const f of normalized) {
     const expr = compileFieldExpr(f.path, fieldToColumn);
     cols.push(f.desc ? `${expr} DESC` : expr);
@@ -694,11 +691,11 @@ function buildIndexDDL(spec, options) {
   }
   return ddl;
 }
-function dedupeIndexSpecs(specs, leadingColumns = []) {
+function dedupeIndexSpecs(specs) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
   for (const spec of specs) {
-    const fp = specFingerprint(spec, leadingColumns);
+    const fp = specFingerprint(spec);
     if (seen.has(fp)) continue;
     seen.add(fp);
     out.push(spec);
@@ -706,8 +703,8 @@ function dedupeIndexSpecs(specs, leadingColumns = []) {
   return out;
 }
 
-// src/cloudflare/schema.ts
-var DO_FIELD_TO_COLUMN = {
+// src/internal/sqlite-schema.ts
+var FIELD_TO_COLUMN = {
   aType: "a_type",
   aUid: "a_uid",
   axbType: "axb_type",
@@ -717,21 +714,8 @@ var DO_FIELD_TO_COLUMN = {
   createdAt: "created_at",
   updatedAt: "updated_at"
 };
-var IDENT_RE2 = /^[A-Za-z_][A-Za-z0-9_]*$/;
-function validateDOTableName(name) {
-  if (!IDENT_RE2.test(name)) {
-    throw new Error(`Invalid SQL identifier: ${name}. Must match /^[A-Za-z_][A-Za-z0-9_]*$/.`);
-  }
-}
-function quoteDOIdent(name) {
-  validateDOTableName(name);
-  return `"${name}"`;
-}
-function quoteDOColumnAlias(label) {
-  return `"${label.replace(/"/g, '""')}"`;
-}
-function buildDOSchemaStatements(table, options = {}) {
-  const t = quoteDOIdent(table);
+function buildSchemaStatements(table, options = {}) {
+  const t = quoteIdent2(table);
   const statements = [
     `CREATE TABLE IF NOT EXISTS ${t} (
       doc_id      TEXT NOT NULL PRIMARY KEY,
@@ -750,33 +734,42 @@ function buildDOSchemaStatements(table, options = {}) {
   const fromRegistry = options.registry?.entries().flatMap((e) => e.indexes ?? []) ?? [];
   const deduped = dedupeIndexSpecs([...core, ...fromRegistry]);
   for (const spec of deduped) {
-    statements.push(buildIndexDDL(spec, { table, fieldToColumn: DO_FIELD_TO_COLUMN }));
+    statements.push(buildIndexDDL(spec, { table, fieldToColumn: FIELD_TO_COLUMN }));
   }
   return statements;
 }
+function quoteIdent2(name) {
+  validateTableName(name);
+  return `"${name}"`;
+}
+function validateTableName(name) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+    throw new Error(`Invalid SQL identifier: ${name}. Must match /^[A-Za-z_][A-Za-z0-9_]*$/.`);
+  }
+}
+function quoteColumnAlias(label) {
+  return `"${label.replace(/"/g, '""')}"`;
+}
 
-// src/cloudflare/sql.ts
-var DO_BACKEND_LABEL = "DO SQLite";
-var DO_BACKEND_ERR_LABEL = "DO SQLite backend";
+// src/internal/sqlite-sql.ts
+var BACKEND_LABEL = "SQLite";
+var BACKEND_ERR_LABEL = "SQLite backend";
 function compileFieldRef(field) {
-  const column = DO_FIELD_TO_COLUMN[field];
+  const column = FIELD_TO_COLUMN[field];
   if (column) {
-    return { expr: quoteDOIdent(column) };
+    return { expr: quoteIdent2(column) };
   }
   if (field.startsWith("data.")) {
     const suffix = field.slice(5);
     for (const part of suffix.split(".")) {
-      validateJsonPathKey(part, DO_BACKEND_ERR_LABEL);
+      validateJsonPathKey(part, BACKEND_ERR_LABEL);
     }
     return { expr: `json_extract("data", '$.${suffix}')` };
   }
   if (field === "data") {
     return { expr: `json_extract("data", '$')` };
   }
-  throw new FiregraphError(
-    `DO SQLite backend cannot resolve filter field: ${field}`,
-    "INVALID_QUERY"
-  );
+  throw new FiregraphError(`SQLite backend cannot resolve filter field: ${field}`, "INVALID_QUERY");
 }
 function bindValue(value) {
   if (value === null || value === void 0) return null;
@@ -788,7 +781,7 @@ function bindValue(value) {
     const firestoreType = isFirestoreSpecialType(value);
     if (firestoreType) {
       throw new FiregraphError(
-        `DO SQLite backend cannot bind a Firestore ${firestoreType} value \u2014 JSON serialization would silently drop fields and the resulting bind would never match a stored row. Convert to a primitive (e.g. \`ts.toMillis()\` for Timestamp) before filtering or updating.`,
+        `SQLite backend cannot bind a Firestore ${firestoreType} value \u2014 JSON serialization would silently drop fields and the resulting bind would never match a stored row. Convert to a primitive (e.g. \`ts.toMillis()\` for Timestamp) before filtering or updating.`,
         "INVALID_QUERY"
       );
     }
@@ -841,7 +834,7 @@ function compileFilter(filter, params) {
     }
     default:
       throw new FiregraphError(
-        `DO SQLite backend does not support filter operator: ${String(filter.op)}`,
+        `SQLite backend does not support filter operator: ${String(filter.op)}`,
         "INVALID_QUERY"
       );
   }
@@ -864,22 +857,22 @@ function compileLimit(options, params) {
   params.push(options.limit);
   return ` LIMIT ?`;
 }
-function compileDOSelect(table, filters, options) {
+function compileSelect(table, filters, options) {
   const params = [];
   const conditions = [];
   for (const f of filters) {
     conditions.push(compileFilter(f, params));
   }
   const where = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
-  let sql = `SELECT * FROM ${quoteDOIdent(table)}${where}`;
+  let sql = `SELECT * FROM ${quoteIdent2(table)}${where}`;
   sql += compileOrderBy(options, params);
   sql += compileLimit(options, params);
   return { sql, params };
 }
-function compileDOExpand(table, params) {
+function compileExpand(table, params) {
   if (params.sources.length === 0) {
     throw new FiregraphError(
-      "compileDOExpand requires a non-empty sources list \u2014 empty IN () is invalid SQL.",
+      "compileExpand requires a non-empty sources list \u2014 empty IN () is invalid SQL.",
       "INVALID_QUERY"
     );
   }
@@ -906,7 +899,7 @@ function compileDOExpand(table, params) {
   if (params.axbType === NODE_RELATION) {
     conditions.push(`${aUidCol} != ${bUidCol}`);
   }
-  let sql = `SELECT * FROM ${quoteDOIdent(table)} WHERE ${conditions.join(" AND ")}`;
+  let sql = `SELECT * FROM ${quoteIdent2(table)} WHERE ${conditions.join(" AND ")}`;
   if (params.orderBy) {
     sql += compileOrderBy({ orderBy: params.orderBy }, sqlParams);
   }
@@ -917,10 +910,10 @@ function compileDOExpand(table, params) {
   }
   return { sql, params: sqlParams };
 }
-function compileDOExpandHydrate(table, targetUids) {
+function compileExpandHydrate(table, targetUids) {
   if (targetUids.length === 0) {
     throw new FiregraphError(
-      "compileDOExpandHydrate requires a non-empty target list \u2014 empty IN () is invalid SQL.",
+      "compileExpandHydrate requires a non-empty target list \u2014 empty IN () is invalid SQL.",
       "INVALID_QUERY"
     );
   }
@@ -931,25 +924,25 @@ function compileDOExpandHydrate(table, targetUids) {
   const bUidCol = compileFieldRef("bUid").expr;
   const axbTypeCol = compileFieldRef("axbType").expr;
   return {
-    sql: `SELECT * FROM ${quoteDOIdent(table)} WHERE ${axbTypeCol} = ? AND ${aUidCol} = ${bUidCol} AND ${bUidCol} IN (${placeholders})`,
+    sql: `SELECT * FROM ${quoteIdent2(table)} WHERE ${axbTypeCol} = ? AND ${aUidCol} = ${bUidCol} AND ${bUidCol} IN (${placeholders})`,
     params: sqlParams
   };
 }
-function compileDOSelectByDocId(table, docId) {
+function compileSelectByDocId(table, docId) {
   return {
-    sql: `SELECT * FROM ${quoteDOIdent(table)} WHERE "doc_id" = ? LIMIT 1`,
+    sql: `SELECT * FROM ${quoteIdent2(table)} WHERE "doc_id" = ? LIMIT 1`,
     params: [docId]
   };
 }
-function normalizeDOProjectionField(field) {
-  if (field in DO_FIELD_TO_COLUMN) return field;
+function normalizeProjectionField(field) {
+  if (field in FIELD_TO_COLUMN) return field;
   if (field === "data" || field.startsWith("data.")) return field;
   return `data.${field}`;
 }
-function compileDOFindEdgesProjected(table, select, filters, options) {
+function compileFindEdgesProjected(table, select, filters, options) {
   if (select.length === 0) {
     throw new FiregraphError(
-      "compileDOFindEdgesProjected requires a non-empty select list \u2014 an empty projection has no SQL representation distinct from `findEdges`.",
+      "compileFindEdgesProjected requires a non-empty select list \u2014 an empty projection has no SQL representation distinct from `findEdges`.",
       "INVALID_QUERY"
     );
   }
@@ -965,9 +958,9 @@ function compileDOFindEdgesProjected(table, select, filters, options) {
   const columns = [];
   for (let idx = 0; idx < uniqueFields.length; idx++) {
     const field = uniqueFields[idx];
-    const canonical = normalizeDOProjectionField(field);
+    const canonical = normalizeProjectionField(field);
     const { expr } = compileFieldRef(canonical);
-    const alias = quoteDOColumnAlias(field);
+    const alias = quoteColumnAlias(field);
     projections.push(`${expr} AS ${alias}`);
     let kind;
     let typeAliasName;
@@ -976,7 +969,7 @@ function compileDOFindEdgesProjected(table, select, filters, options) {
     } else if (canonical.startsWith("data.")) {
       kind = "json";
       typeAliasName = `__fg_t_${idx}`;
-      const typeAlias = quoteDOColumnAlias(typeAliasName);
+      const typeAlias = quoteColumnAlias(typeAliasName);
       projections.push(`json_type("data", '$.${canonical.slice(5)}') AS ${typeAlias}`);
     } else {
       if (canonical === "v") kind = "builtin-int";
@@ -991,12 +984,12 @@ function compileDOFindEdgesProjected(table, select, filters, options) {
     conditions.push(compileFilter(f, params));
   }
   const where = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
-  let sql = `SELECT ${projections.join(", ")} FROM ${quoteDOIdent(table)}${where}`;
+  let sql = `SELECT ${projections.join(", ")} FROM ${quoteIdent2(table)}${where}`;
   sql += compileOrderBy(options, params);
   sql += compileLimit(options, params);
   return { stmt: { sql, params }, columns };
 }
-function decodeDOProjectedRow(row, columns) {
+function decodeProjectedRow(row, columns) {
   const out = {};
   for (const c of columns) {
     const raw = row[c.field];
@@ -1016,7 +1009,7 @@ function decodeDOProjectedRow(row, columns) {
         }
         break;
       case "builtin-timestamp": {
-        const ms = toMillis(raw);
+        const ms = rowTimestampToMillis(raw);
         out[c.field] = GraphTimestampImpl.fromMillis(ms);
         break;
       }
@@ -1044,7 +1037,7 @@ function decodeDOProjectedRow(row, columns) {
   }
   return out;
 }
-function compileDOAggregate(table, spec, filters) {
+function compileAggregate(table, spec, filters) {
   const aliases = Object.keys(spec);
   if (aliases.length === 0) {
     throw new FiregraphError(
@@ -1055,7 +1048,7 @@ function compileDOAggregate(table, spec, filters) {
   const projections = [];
   for (const alias of aliases) {
     const { op, field } = spec[alias];
-    validateJsonPathKey(alias, DO_BACKEND_ERR_LABEL);
+    validateJsonPathKey(alias, BACKEND_ERR_LABEL);
     if (op === "count") {
       if (field !== void 0) {
         throw new FiregraphError(
@@ -1063,7 +1056,7 @@ function compileDOAggregate(table, spec, filters) {
           "INVALID_QUERY"
         );
       }
-      projections.push(`COUNT(*) AS ${quoteDOIdent(alias)}`);
+      projections.push(`COUNT(*) AS ${quoteIdent2(alias)}`);
       continue;
     }
     if (!field) {
@@ -1074,13 +1067,13 @@ function compileDOAggregate(table, spec, filters) {
     }
     const { expr } = compileFieldRef(field);
     const numeric = `CAST(${expr} AS REAL)`;
-    if (op === "sum") projections.push(`SUM(${numeric}) AS ${quoteDOIdent(alias)}`);
-    else if (op === "avg") projections.push(`AVG(${numeric}) AS ${quoteDOIdent(alias)}`);
-    else if (op === "min") projections.push(`MIN(${numeric}) AS ${quoteDOIdent(alias)}`);
-    else if (op === "max") projections.push(`MAX(${numeric}) AS ${quoteDOIdent(alias)}`);
+    if (op === "sum") projections.push(`SUM(${numeric}) AS ${quoteIdent2(alias)}`);
+    else if (op === "avg") projections.push(`AVG(${numeric}) AS ${quoteIdent2(alias)}`);
+    else if (op === "min") projections.push(`MIN(${numeric}) AS ${quoteIdent2(alias)}`);
+    else if (op === "max") projections.push(`MAX(${numeric}) AS ${quoteIdent2(alias)}`);
     else
       throw new FiregraphError(
-        `DO SQLite backend does not support aggregate op: ${String(op)}`,
+        `SQLite backend does not support aggregate op: ${String(op)}`,
         "INVALID_QUERY"
       );
   }
@@ -1090,13 +1083,13 @@ function compileDOAggregate(table, spec, filters) {
     conditions.push(compileFilter(f, params));
   }
   const where = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
-  const sql = `SELECT ${projections.join(", ")} FROM ${quoteDOIdent(table)}${where}`;
+  const sql = `SELECT ${projections.join(", ")} FROM ${quoteIdent2(table)}${where}`;
   return { stmt: { sql, params }, aliases };
 }
-function compileDOSet(table, docId, record, nowMillis, mode) {
-  assertJsonSafePayload(record.data, DO_BACKEND_LABEL);
+function compileSet(table, docId, record, nowMillis, mode) {
+  assertJsonSafePayload(record.data, BACKEND_LABEL);
   if (mode === "replace") {
-    const sql2 = `INSERT OR REPLACE INTO ${quoteDOIdent(table)} (
+    const sql2 = `INSERT OR REPLACE INTO ${quoteIdent2(table)} (
       doc_id, a_type, a_uid, axb_type, b_type, b_uid, data, v, created_at, updated_at
     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
     const params = [
@@ -1127,8 +1120,8 @@ function compileDOSet(table, docId, record, nowMillis, mode) {
   ];
   const ops = flattenPatch(record.data ?? {});
   const updateParams = [];
-  const dataExpr = compileDataOpsExpr(ops, `COALESCE("data", '{}')`, updateParams, DO_BACKEND_ERR_LABEL) ?? `COALESCE("data", '{}')`;
-  const sql = `INSERT INTO ${quoteDOIdent(table)} (
+  const dataExpr = compileDataOpsExpr(ops, `COALESCE("data", '{}')`, updateParams, BACKEND_ERR_LABEL) ?? `COALESCE("data", '{}')`;
+  const sql = `INSERT INTO ${quoteIdent2(table)} (
       doc_id, a_type, a_uid, axb_type, b_type, b_uid, data, v, created_at, updated_at
     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     ON CONFLICT(doc_id) DO UPDATE SET
@@ -1143,23 +1136,23 @@ function compileDOSet(table, docId, record, nowMillis, mode) {
       "updated_at" = excluded."updated_at"`;
   return { sql, params: [...insertParams, ...updateParams] };
 }
-function compileDOUpdate(table, docId, update, nowMillis) {
+function compileUpdate(table, docId, update, nowMillis) {
   assertUpdatePayloadExclusive(update);
   const setClauses = [];
   const params = [];
   if (update.replaceData) {
-    assertJsonSafePayload(update.replaceData, DO_BACKEND_LABEL);
+    assertJsonSafePayload(update.replaceData, BACKEND_LABEL);
     setClauses.push(`"data" = ?`);
     params.push(JSON.stringify(update.replaceData));
   } else if (update.dataOps && update.dataOps.length > 0) {
     for (const op of update.dataOps) {
-      if (!op.delete) assertJsonSafePayload(op.value, DO_BACKEND_LABEL);
+      if (!op.delete) assertJsonSafePayload(op.value, BACKEND_LABEL);
     }
     const expr = compileDataOpsExpr(
       update.dataOps,
       `COALESCE("data", '{}')`,
       params,
-      DO_BACKEND_ERR_LABEL
+      BACKEND_ERR_LABEL
     );
     if (expr !== null) {
       setClauses.push(`"data" = ${expr}`);
@@ -1173,17 +1166,17 @@ function compileDOUpdate(table, docId, update, nowMillis) {
   params.push(nowMillis);
   params.push(docId);
   return {
-    sql: `UPDATE ${quoteDOIdent(table)} SET ${setClauses.join(", ")} WHERE "doc_id" = ?`,
+    sql: `UPDATE ${quoteIdent2(table)} SET ${setClauses.join(", ")} WHERE "doc_id" = ?`,
     params
   };
 }
-function compileDODelete(table, docId) {
+function compileDelete(table, docId) {
   return {
-    sql: `DELETE FROM ${quoteDOIdent(table)} WHERE "doc_id" = ?`,
+    sql: `DELETE FROM ${quoteIdent2(table)} WHERE "doc_id" = ?`,
     params: [docId]
   };
 }
-function compileDOBulkDelete(table, filters) {
+function compileBulkDelete(table, filters) {
   const params = [];
   const conditions = [];
   for (const f of filters) {
@@ -1191,11 +1184,11 @@ function compileDOBulkDelete(table, filters) {
   }
   const where = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
   return {
-    sql: `DELETE FROM ${quoteDOIdent(table)}${where}`,
+    sql: `DELETE FROM ${quoteIdent2(table)}${where}`,
     params
   };
 }
-function compileDOBulkUpdate(table, filters, patchData, nowMillis) {
+function compileBulkUpdate(table, filters, patchData, nowMillis) {
   const dataOps = flattenPatch(patchData);
   if (dataOps.length === 0) {
     throw new FiregraphError(
@@ -1204,15 +1197,10 @@ function compileDOBulkUpdate(table, filters, patchData, nowMillis) {
     );
   }
   for (const op of dataOps) {
-    if (!op.delete) assertJsonSafePayload(op.value, DO_BACKEND_LABEL);
+    if (!op.delete) assertJsonSafePayload(op.value, BACKEND_LABEL);
   }
   const setParams = [];
-  const expr = compileDataOpsExpr(
-    dataOps,
-    `COALESCE("data", '{}')`,
-    setParams,
-    DO_BACKEND_ERR_LABEL
-  );
+  const expr = compileDataOpsExpr(dataOps, `COALESCE("data", '{}')`, setParams, BACKEND_ERR_LABEL);
   if (expr === null) {
     throw new FiregraphError(
       "bulkUpdate() patch produced no SQL operations \u2014 internal invariant violated.",
@@ -1228,21 +1216,35 @@ function compileDOBulkUpdate(table, filters, patchData, nowMillis) {
   }
   const where = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
   return {
-    sql: `UPDATE ${quoteDOIdent(table)} SET ${setClauses.join(", ")}${where}`,
+    sql: `UPDATE ${quoteIdent2(table)} SET ${setClauses.join(", ")}${where}`,
     params: [...setParams, ...whereParams]
   };
 }
-function compileDODeleteAll(table) {
+function compileDeleteAll(table) {
   return {
-    sql: `DELETE FROM ${quoteDOIdent(table)}`,
+    sql: `DELETE FROM ${quoteIdent2(table)}`,
     params: []
   };
 }
+function rowTimestampToMillis(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "bigint") return Number(value);
+  if (typeof value === "string") {
+    const n = Number(value);
+    if (Number.isFinite(n)) return n;
+  }
+  throw new FiregraphError(
+    `SQLite row has non-numeric timestamp column: ${typeof value} (${String(value)})`,
+    "INVALID_QUERY"
+  );
+}
+
+// src/cloudflare/sql.ts
 function rowToDORecord(row) {
   const dataString = row.data;
   const data = dataString ? JSON.parse(dataString) : {};
-  const createdAtMs = toMillis(row.created_at);
-  const updatedAtMs = toMillis(row.updated_at);
+  const createdAtMs = rowTimestampToMillis(row.created_at);
+  const updatedAtMs = rowTimestampToMillis(row.updated_at);
   const record = {
     aType: row.a_type,
     aUid: row.a_uid,
@@ -1274,18 +1276,6 @@ function hydrateDORecord(wire) {
   }
   return record;
 }
-function toMillis(value) {
-  if (typeof value === "number") return value;
-  if (typeof value === "bigint") return Number(value);
-  if (typeof value === "string") {
-    const n = Number(value);
-    if (Number.isFinite(n)) return n;
-  }
-  throw new FiregraphError(
-    `DO SQLite row has non-numeric timestamp column: ${typeof value} (${String(value)})`,
-    "INVALID_QUERY"
-  );
-}
 
 // src/cloudflare/backend.ts
 function validateSegment(value, label) {
@@ -1549,7 +1539,7 @@ var DORPCBackend = class _DORPCBackend {
       );
     }
     const { rows, columns } = await stub._fgFindEdgesProjected(select, filters, options);
-    return rows.map((row) => decodeDOProjectedRow(row, columns));
+    return rows.map((row) => decodeProjectedRow(row, columns));
   }
   // --- Cross-scope queries ---
   //
@@ -3627,7 +3617,7 @@ var FiregraphDO = class extends import_cloudflare_workers.DurableObject {
     super(ctx, env);
     this.state = ctx;
     const table = options.table ?? DEFAULT_OPTIONS.table;
-    validateDOTableName(table);
+    validateTableName(table);
     this.table = table;
     this.registry = options.registry;
     this.coreIndexes = options.coreIndexes;
@@ -3646,12 +3636,12 @@ var FiregraphDO = class extends import_cloudflare_workers.DurableObject {
   // `src/cloudflare/backend.ts` calls these directly on the DO stub.
   // ---------------------------------------------------------------------------
   async _fgGetDoc(docId) {
-    const stmt = compileDOSelectByDocId(this.table, docId);
+    const stmt = compileSelectByDocId(this.table, docId);
     const rows = this.execAll(stmt);
     return rows.length === 0 ? null : rowToDORecord(rows[0]);
   }
   async _fgQuery(filters, options) {
-    const stmt = compileDOSelect(this.table, filters, options);
+    const stmt = compileSelect(this.table, filters, options);
     const rows = this.execAll(stmt);
     return rows.map(rowToDORecord);
   }
@@ -3663,7 +3653,7 @@ var FiregraphDO = class extends import_cloudflare_workers.DurableObject {
    * the wire payload stays a plain row of (alias → number | null).
    */
   async _fgAggregate(spec, filters) {
-    const { stmt, aliases } = compileDOAggregate(this.table, spec, filters);
+    const { stmt, aliases } = compileAggregate(this.table, spec, filters);
     const rows = this.execAll(stmt);
     const row = rows[0] ?? {};
     const out = {};
@@ -3680,11 +3670,11 @@ var FiregraphDO = class extends import_cloudflare_workers.DurableObject {
   // RPC: writes
   // ---------------------------------------------------------------------------
   async _fgSetDoc(docId, record, mode) {
-    const stmt = compileDOSet(this.table, docId, record, Date.now(), mode);
+    const stmt = compileSet(this.table, docId, record, Date.now(), mode);
     this.execRun(stmt);
   }
   async _fgUpdateDoc(docId, update) {
-    const stmt = compileDOUpdate(this.table, docId, update, Date.now());
+    const stmt = compileUpdate(this.table, docId, update, Date.now());
     const sqlWithReturning = `${stmt.sql} RETURNING "doc_id"`;
     const rows = this.state.storage.sql.exec(sqlWithReturning, ...stmt.params).toArray();
     if (rows.length === 0) {
@@ -3692,7 +3682,7 @@ var FiregraphDO = class extends import_cloudflare_workers.DurableObject {
     }
   }
   async _fgDeleteDoc(docId) {
-    const stmt = compileDODelete(this.table, docId);
+    const stmt = compileDelete(this.table, docId);
     this.execRun(stmt);
   }
   // ---------------------------------------------------------------------------
@@ -3710,11 +3700,11 @@ var FiregraphDO = class extends import_cloudflare_workers.DurableObject {
     const statements = ops.map((op) => {
       switch (op.kind) {
         case "set":
-          return compileDOSet(this.table, op.docId, op.record, now, op.mode);
+          return compileSet(this.table, op.docId, op.record, now, op.mode);
         case "update":
-          return compileDOUpdate(this.table, op.docId, op.update, now);
+          return compileUpdate(this.table, op.docId, op.update, now);
         case "delete":
-          return compileDODelete(this.table, op.docId);
+          return compileDelete(this.table, op.docId);
       }
     });
     this.state.storage.transactionSync(() => {
@@ -3733,8 +3723,8 @@ var FiregraphDO = class extends import_cloudflare_workers.DurableObject {
   // Without that topology the DO has no way to enumerate its children.
   // ---------------------------------------------------------------------------
   async _fgRemoveNodeCascade(uid) {
-    const outgoingStmt = compileDOSelect(this.table, [{ field: "aUid", op: "==", value: uid }]);
-    const incomingStmt = compileDOSelect(this.table, [{ field: "bUid", op: "==", value: uid }]);
+    const outgoingStmt = compileSelect(this.table, [{ field: "aUid", op: "==", value: uid }]);
+    const incomingStmt = compileSelect(this.table, [{ field: "bUid", op: "==", value: uid }]);
     const outgoingRows = this.execAll(outgoingStmt);
     const incomingRows = this.execAll(incomingStmt);
     const seen = /* @__PURE__ */ new Set();
@@ -3754,9 +3744,9 @@ var FiregraphDO = class extends import_cloudflare_workers.DurableObject {
         edgeDocIds.push(docId);
       }
     }
-    const statements = edgeDocIds.map((id) => compileDODelete(this.table, id));
+    const statements = edgeDocIds.map((id) => compileDelete(this.table, id));
     if (nodeExists) {
-      statements.push(compileDODelete(this.table, computeNodeDocId(uid)));
+      statements.push(compileDelete(this.table, computeNodeDocId(uid)));
     }
     if (statements.length === 0) {
       return {
@@ -3795,11 +3785,11 @@ var FiregraphDO = class extends import_cloudflare_workers.DurableObject {
     const plan = buildEdgeQueryPlan(params);
     let docIds;
     if (plan.strategy === "get") {
-      const existsStmt = compileDOSelectByDocId(this.table, plan.docId);
+      const existsStmt = compileSelectByDocId(this.table, plan.docId);
       const rows = this.execAll(existsStmt);
       docIds = rows.length > 0 ? [plan.docId] : [];
     } else {
-      const selectStmt = compileDOSelect(this.table, plan.filters, plan.options);
+      const selectStmt = compileSelect(this.table, plan.filters, plan.options);
       const rows = this.execAll(selectStmt);
       docIds = rows.map(
         (row) => computeEdgeDocId(row.a_uid, row.axb_type, row.b_uid)
@@ -3808,7 +3798,7 @@ var FiregraphDO = class extends import_cloudflare_workers.DurableObject {
     if (docIds.length === 0) {
       return { deleted: 0, batches: 0, errors: [] };
     }
-    const deleteStmts = docIds.map((id) => compileDODelete(this.table, id));
+    const deleteStmts = docIds.map((id) => compileDelete(this.table, id));
     try {
       this.state.storage.transactionSync(() => {
         for (const stmt of deleteStmts) {
@@ -3853,12 +3843,12 @@ var FiregraphDO = class extends import_cloudflare_workers.DurableObject {
         "INVALID_ARGUMENT"
       );
     }
-    const stmt = compileDOBulkDelete(this.table, filters);
+    const stmt = compileBulkDelete(this.table, filters);
     return this.execDmlWithReturning(stmt);
   }
   async _fgBulkUpdate(filters, patch, _options) {
     void _options;
-    const stmt = compileDOBulkUpdate(this.table, filters, patch.data, Date.now());
+    const stmt = compileBulkUpdate(this.table, filters, patch.data, Date.now());
     return this.execDmlWithReturning(stmt);
   }
   // ---------------------------------------------------------------------------
@@ -3875,7 +3865,7 @@ var FiregraphDO = class extends import_cloudflare_workers.DurableObject {
     if (params.sources.length === 0) {
       return params.hydrate ? { edges: [], targets: [] } : { edges: [] };
     }
-    const stmt = compileDOExpand(this.table, params);
+    const stmt = compileExpand(this.table, params);
     const rows = this.state.storage.sql.exec(stmt.sql, ...stmt.params).toArray();
     const edges = rows.map((row) => rowToDORecord(row));
     if (!params.hydrate) {
@@ -3887,7 +3877,7 @@ var FiregraphDO = class extends import_cloudflare_workers.DurableObject {
     if (uniqueTargets.length === 0) {
       return { edges, targets: [] };
     }
-    const hydrateStmt = compileDOExpandHydrate(this.table, uniqueTargets);
+    const hydrateStmt = compileExpandHydrate(this.table, uniqueTargets);
     const hydrateRows = this.state.storage.sql.exec(hydrateStmt.sql, ...hydrateStmt.params).toArray();
     const byUid = /* @__PURE__ */ new Map();
     for (const row of hydrateRows) {
@@ -3909,7 +3899,7 @@ var FiregraphDO = class extends import_cloudflare_workers.DurableObject {
   // a typical projection); structured clone copes happily.
   // ---------------------------------------------------------------------------
   async _fgFindEdgesProjected(select, filters, options) {
-    const { stmt, columns } = compileDOFindEdgesProjected(this.table, select, filters, options);
+    const { stmt, columns } = compileFindEdgesProjected(this.table, select, filters, options);
     const rows = this.state.storage.sql.exec(stmt.sql, ...stmt.params).toArray();
     return { rows, columns };
   }
@@ -3947,14 +3937,14 @@ var FiregraphDO = class extends import_cloudflare_workers.DurableObject {
    * forever), but its storage can be emptied.
    */
   async _fgDestroy() {
-    const stmt = compileDODeleteAll(this.table);
+    const stmt = compileDeleteAll(this.table);
     this.execRun(stmt);
   }
   // ---------------------------------------------------------------------------
   // Internals
   // ---------------------------------------------------------------------------
   runSchema() {
-    const statements = buildDOSchemaStatements(this.table, {
+    const statements = buildSchemaStatements(this.table, {
       coreIndexes: this.coreIndexes,
       registry: this.registry
     });