@lunora/do 1.0.0-alpha.44 → 1.0.0-alpha.45

package/dist/packem_shared/context-telemetry-CDpyil58.mjs

@@ -1,223 +0,0 @@
-import { isLunoraError } from '@lunora/errors';
-
-const stringifyFieldValue = (value) => {
-  if (typeof value === "string") {
-    return value;
-  }
-  try {
-    return JSON.stringify(value) ?? String(value);
-  } catch {
-    return String(value);
-  }
-};
-const coerceFieldValue = (value) => typeof value === "boolean" || typeof value === "number" || typeof value === "string" ? value : stringifyFieldValue(value);
-const normalizeLogFields = (perCall, bound) => {
-  if (perCall === void 0 && bound === void 0) {
-    return void 0;
-  }
-  const merged = {};
-  if (bound !== void 0) {
-    for (const [key, value] of Object.entries(bound)) {
-      merged[key] = coerceFieldValue(value);
-    }
-  }
-  if (perCall !== void 0) {
-    for (const [key, value] of Object.entries(perCall)) {
-      merged[key] = coerceFieldValue(value);
-    }
-  }
-  return Object.keys(merged).length === 0 ? void 0 : merged;
-};
-
-const otlpRandomHex = (bytes) => {
-  const buffer = new Uint8Array(bytes);
-  crypto.getRandomValues(buffer);
-  let hex = "";
-  for (const byte of buffer) {
-    hex += byte.toString(16).padStart(2, "0");
-  }
-  return hex;
-};
-const HEX_ONLY = /^[0-9a-f]+$/;
-const parseTraceparent = (header) => {
-  if (header === null || header === void 0) {
-    return void 0;
-  }
-  const parts = header.trim().toLowerCase().split("-");
-  const [version, traceId, parentSpanId, flags] = parts;
-  if (parts.length < 4 || version === void 0 || version.length !== 2 || !HEX_ONLY.test(version) || version === "ff" || // Version 00 forbids trailing fields; only a future version may carry them.
-  version === "00" && parts.length !== 4 || traceId === void 0 || parentSpanId === void 0 || flags === void 0 || flags.length !== 2 || !HEX_ONLY.test(flags) || traceId.length !== 32 || parentSpanId.length !== 16 || !HEX_ONLY.test(traceId) || !HEX_ONLY.test(parentSpanId) || traceId === "00000000000000000000000000000000" || parentSpanId === "0000000000000000") {
-    return void 0;
-  }
-  return { parentSpanId, sampled: (Number.parseInt(flags, 16) & 1) === 1, traceId };
-};
-
-const resolveTraceAnchor = (traceparent) => {
-  const inbound = parseTraceparent(traceparent);
-  return { rootSpanId: inbound?.parentSpanId ?? otlpRandomHex(8), traceId: inbound?.traceId ?? otlpRandomHex(16) };
-};
-const toErrorType = (error) => {
-  if (isLunoraError(error)) {
-    return error.code;
-  }
-  return error instanceof Error ? error.constructor.name : "Error";
-};
-
-const applyCloudflareSpanAttributes = (span, meta) => {
-  if (!span.isTraced) {
-    return;
-  }
-  span.setAttribute("lunora.function_path", meta.functionPath);
-  span.setAttribute("lunora.ok", meta.ok);
-  span.setAttribute("lunora.duration_ms", meta.durationMs);
-  if (meta.shardKey !== void 0) {
-    span.setAttribute("lunora.shard_key", meta.shardKey);
-  }
-  if (meta.userId !== void 0) {
-    span.setAttribute("lunora.user_id", meta.userId);
-  }
-  if (meta.error !== void 0) {
-    span.setAttribute("lunora.error.type", meta.error.type);
-    span.setAttribute("lunora.error.message", meta.error.message);
-  }
-  for (const [key, value] of Object.entries(meta.attributes)) {
-    if (typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
-      span.setAttribute(`lunora.attr.${key}`, value);
-    }
-  }
-};
-const createTracer = (deps) => {
-  const { anchor, fuseCloudflareSpans, functionPath, record, resolveCloudflareTracing, shardKey, userId } = deps;
-  const tracerFor = (parentSpanId) => async (name, function_, attributes) => {
-    const spanId = otlpRandomHex(8);
-    const startTs = Date.now();
-    const normalized = normalizeLogFields(attributes);
-    const collected = {};
-    const spanHandle = {
-      setAttribute: (key, value) => {
-        Object.assign(collected, normalizeLogFields({ [key]: value }));
-      },
-      setAttributes: (fields) => {
-        Object.assign(collected, normalizeLogFields(fields));
-      }
-    };
-    const runRecorded = async (cfSpan) => {
-      let ok = true;
-      let error;
-      try {
-        return await function_(tracerFor(spanId), spanHandle);
-      } catch (error_) {
-        ok = false;
-        error = {
-          message: error_ instanceof Error ? error_.message : String(error_),
-          // Prefer a LunoraError's stable `code` over the class name
-          // so spans group by the same taxonomy the RPC spans use.
-          type: toErrorType(error_)
-        };
-        throw error_;
-      } finally {
-        const durationMs = Date.now() - startTs;
-        const resolvedUserId = userId();
-        const merged = { ...normalized, ...collected };
-        try {
-          record({
-            ...Object.keys(merged).length === 0 ? {} : { attributes: merged },
-            durationMs,
-            ...error === void 0 ? {} : { error },
-            functionPath,
-            name,
-            ok,
-            parentSpanId,
-            shardKey,
-            spanId,
-            startTs,
-            traceId: anchor.traceId,
-            userId: resolvedUserId
-          });
-        } catch {
-        }
-        if (cfSpan !== void 0) {
-          try {
-            applyCloudflareSpanAttributes(cfSpan, {
-              attributes: merged,
-              durationMs,
-              error,
-              functionPath,
-              ok,
-              shardKey,
-              userId: resolvedUserId
-            });
-          } catch {
-          }
-        }
-      }
-    };
-    if (fuseCloudflareSpans === true && resolveCloudflareTracing !== void 0) {
-      const cfTracing = await resolveCloudflareTracing();
-      if (cfTracing !== void 0 && typeof cfTracing.enterSpan === "function") {
-        return await cfTracing.enterSpan(name, (span) => runRecorded(span));
-      }
-    }
-    return await runRecorded();
-  };
-  return tracerFor(anchor.rootSpanId);
-};
-const createMetrics = (deps) => {
-  const { functionPath, record, shardKey } = deps;
-  const emit = (kind, name, value, attributes) => {
-    if (!Number.isFinite(value)) {
-      return;
-    }
-    const normalized = normalizeLogFields(attributes);
-    try {
-      record({
-        ...normalized === void 0 ? {} : { attributes: normalized },
-        functionPath,
-        kind,
-        name,
-        shardKey,
-        ts: Date.now(),
-        value
-      });
-    } catch {
-    }
-  };
-  return {
-    count: (name, value = 1, attributes) => {
-      emit("counter", name, value, attributes);
-    },
-    gauge: (name, value, attributes) => {
-      emit("gauge", name, value, attributes);
-    },
-    record: (name, value, attributes) => {
-      emit("histogram", name, value, attributes);
-    }
-  };
-};
-const dispatchRootSpan = (input) => {
-  const { anchor, durationMs, failure, functionPath, shardKey, startTs, userId } = input;
-  return {
-    dispatch: true,
-    durationMs,
-    ...failure === void 0 ? {} : {
-      error: {
-        message: failure.thrown instanceof Error ? failure.thrown.message : String(failure.thrown),
-        type: toErrorType(failure.thrown)
-      }
-    },
-    functionPath,
-    name: functionPath,
-    ok: failure === void 0,
-    // Empty: this span IS the trace's root locally. The worker's own RPC span
-    // sits above it in a full collector-side trace, but it is not in this
-    // buffer, so naming it here would dangle.
-    parentSpanId: "",
-    shardKey,
-    spanId: anchor.rootSpanId,
-    startTs,
-    traceId: anchor.traceId,
-    userId
-  };
-};
-
-export { createTracer as a, applyCloudflareSpanAttributes as b, createMetrics as c, dispatchRootSpan as d, normalizeLogFields as n, parseTraceparent as p, resolveTraceAnchor as r };

package/dist/packem_shared/createMetrics-C4I2Yanj.mjs

@@ -1 +0,0 @@
-export { b as applyCloudflareSpanAttributes, c as createMetrics, a as createTracer, d as dispatchRootSpan } from './context-telemetry-CDpyil58.mjs';

package/dist/packem_shared/createSystemReader-D12eNH13.mjs

@@ -1,82 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-
-const toScheduledFunctionDoc = (record) => {
-  const doc = {
-    args: record["args"] ?? {},
-    enqueuedAt: typeof record["enqueuedAt"] === "number" ? record["enqueuedAt"] : 0,
-    functionPath: typeof record["functionPath"] === "string" ? record["functionPath"] : "",
-    id: typeof record["id"] === "string" ? record["id"] : "",
-    scheduledFor: typeof record["scheduledFor"] === "number" ? record["scheduledFor"] : 0
-  };
-  if (typeof record["attempts"] === "number") {
-    doc.attempts = record["attempts"];
-  }
-  if (typeof record["shardKey"] === "string") {
-    doc.shardKey = record["shardKey"];
-  }
-  return doc;
-};
-const toStorageMetadata = (object) => {
-  const meta = {
-    key: typeof object["key"] === "string" ? object["key"] : "",
-    size: typeof object["size"] === "number" ? object["size"] : 0
-  };
-  const contentType = object["httpMetadata"]?.contentType ?? object["contentType"];
-  if (typeof contentType === "string") {
-    meta.contentType = contentType;
-  }
-  if (object["customMetadata"] && typeof object["customMetadata"] === "object") {
-    meta.customMetadata = object["customMetadata"];
-  }
-  if (typeof object["sha256"] === "string") {
-    meta.sha256 = object["sha256"];
-  }
-  const { uploaded } = object;
-  if (typeof uploaded === "number") {
-    meta.uploaded = uploaded;
-  } else if (uploaded instanceof Date) {
-    meta.uploaded = uploaded.getTime();
-  }
-  return meta;
-};
-const createSystemReader = (options = {}) => {
-  const requireScheduler = () => {
-    if (!options.scheduler) {
-      throw new LunoraError("INTERNAL", 'ctx.db.system.query("_scheduled_functions"): no scheduler configured. Pass `scheduler` to createShardDO().');
-    }
-    return options.scheduler;
-  };
-  const requireStorage = () => {
-    if (!options.storage) {
-      throw new LunoraError("INTERNAL", 'ctx.db.system.query("_storage"): no storage configured. Pass `storage` to createShardDO().');
-    }
-    return options.storage;
-  };
-  const collectScheduled = async () => {
-    const records = await requireScheduler().list();
-    return records.map((record) => toScheduledFunctionDoc(record));
-  };
-  const collectStorage = async () => {
-    const { objects } = await requireStorage().list();
-    return objects.map((object) => toStorageMetadata(object));
-  };
-  const queryReader = ((table) => {
-    if (table === "_scheduled_functions") {
-      return { collect: collectScheduled };
-    }
-    return { collect: collectStorage };
-  });
-  return {
-    get: (async (table, id) => {
-      if (table === "_scheduled_functions") {
-        const record = await requireScheduler().get(id);
-        return record ? toScheduledFunctionDoc(record) : null;
-      }
-      const meta = await requireStorage().getMetadata(id);
-      return meta ? toStorageMetadata(meta) : null;
-    }),
-    query: queryReader
-  };
-};
-
-export { createSystemReader };

package/dist/packem_shared/ctx-db-idempotency-BdcNpvY4.mjs

@@ -1,108 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
-
-const CLIENT_WATERMARK_TABLE = "__client_watermark";
-const migrateClientWatermark = (sql$1) => {
-  runDrizzle(
-    sql$1,
-    sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(CLIENT_WATERMARK_TABLE)} (
-            identity TEXT NOT NULL,
-            client_id TEXT NOT NULL,
-            last_mutation_id INTEGER NOT NULL,
-            PRIMARY KEY (identity, client_id)
-        )`
-  );
-};
-const readClientWatermark = (sql$1, identity, clientId) => {
-  const rows = runDrizzle(
-    sql$1,
-    sql`SELECT last_mutation_id FROM ${sql.identifier(CLIENT_WATERMARK_TABLE)} WHERE identity = ${identity} AND client_id = ${clientId} LIMIT 1`
-  ).toArray();
-  return rows[0]?.last_mutation_id ?? 0;
-};
-const advanceClientWatermark = (sql$1, identity, clientId, mutationId) => {
-  runDrizzle(
-    sql$1,
-    sql`INSERT INTO ${sql.identifier(CLIENT_WATERMARK_TABLE)} (identity, client_id, last_mutation_id) VALUES (${identity}, ${clientId}, ${mutationId})
-             ON CONFLICT(identity, client_id) DO UPDATE SET last_mutation_id = MAX(last_mutation_id, excluded.last_mutation_id)`
-  );
-};
-
-const GLOBAL_SHAPE_SNAPSHOT_TABLE = "__global_shape_snapshot";
-const migrateGlobalShapeSnapshot = (sql$1) => {
-  runDrizzle(
-    sql$1,
-    sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(GLOBAL_SHAPE_SNAPSHOT_TABLE)} (
-            connection_id TEXT NOT NULL,
-            sub_id TEXT NOT NULL,
-            members TEXT NOT NULL,
-            PRIMARY KEY (connection_id, sub_id)
-        )`
-  );
-};
-const readGlobalShapeSnapshot = (sql$1, connectionId, subId) => {
-  const rows = runDrizzle(
-    sql$1,
-    sql`SELECT members FROM ${sql.identifier(GLOBAL_SHAPE_SNAPSHOT_TABLE)} WHERE connection_id = ${connectionId} AND sub_id = ${subId} LIMIT 1`
-  ).toArray();
-  const raw = rows[0]?.members;
-  if (raw === void 0) {
-    return /* @__PURE__ */ new Map();
-  }
-  try {
-    const parsed = JSON.parse(raw);
-    if (parsed === null || typeof parsed !== "object") {
-      return /* @__PURE__ */ new Map();
-    }
-    return new Map(Object.entries(parsed));
-  } catch {
-    return /* @__PURE__ */ new Map();
-  }
-};
-const writeGlobalShapeSnapshot = (sql$1, connectionId, subId, snapshot) => {
-  const members = JSON.stringify(Object.fromEntries(snapshot));
-  runDrizzle(
-    sql$1,
-    sql`INSERT INTO ${sql.identifier(GLOBAL_SHAPE_SNAPSHOT_TABLE)} (connection_id, sub_id, members) VALUES (${connectionId}, ${subId}, ${members})
-             ON CONFLICT(connection_id, sub_id) DO UPDATE SET members = excluded.members`
-  );
-};
-const deleteGlobalShapeSnapshot = (sql$1, connectionId, subId) => {
-  runDrizzle(sql$1, sql`DELETE FROM ${sql.identifier(GLOBAL_SHAPE_SNAPSHOT_TABLE)} WHERE connection_id = ${connectionId} AND sub_id = ${subId}`);
-};
-const deleteGlobalShapeSnapshotsForConnection = (sql$1, connectionId) => {
-  runDrizzle(sql$1, sql`DELETE FROM ${sql.identifier(GLOBAL_SHAPE_SNAPSHOT_TABLE)} WHERE connection_id = ${connectionId}`);
-};
-
-const IDEMPOTENCY_TABLE = "__idempotency";
-const migrateIdempotency = (sql$1) => {
-  runDrizzle(
-    sql$1,
-    sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(IDEMPOTENCY_TABLE)} (
-            identity TEXT NOT NULL,
-            mutation_id TEXT NOT NULL,
-            result_json TEXT NOT NULL,
-            ts REAL NOT NULL,
-            PRIMARY KEY (identity, mutation_id)
-        )`
-  );
-};
-const readIdempotent = (sql$1, identity, mutationId) => {
-  const rows = runDrizzle(
-    sql$1,
-    sql`SELECT result_json, ts FROM ${sql.identifier(IDEMPOTENCY_TABLE)} WHERE identity = ${identity} AND mutation_id = ${mutationId} LIMIT 1`
-  ).toArray();
-  const row = rows[0];
-  return row === void 0 ? void 0 : { resultJson: row.result_json, ts: row.ts };
-};
-const writeIdempotent = (sql$1, identity, mutationId, resultJson, ts) => {
-  runDrizzle(
-    sql$1,
-    sql`INSERT OR IGNORE INTO ${sql.identifier(IDEMPOTENCY_TABLE)} (identity, mutation_id, result_json, ts) VALUES (${identity}, ${mutationId}, ${resultJson}, ${ts})`
-  );
-};
-const trimIdempotent = (sql$1, olderThanTs) => {
-  runDrizzle(sql$1, sql`DELETE FROM ${sql.identifier(IDEMPOTENCY_TABLE)} WHERE ts < ${olderThanTs}`);
-};
-
-export { CLIENT_WATERMARK_TABLE as C, GLOBAL_SHAPE_SNAPSHOT_TABLE as G, IDEMPOTENCY_TABLE as I, migrateIdempotency as a, migrateGlobalShapeSnapshot as b, advanceClientWatermark as c, deleteGlobalShapeSnapshot as d, deleteGlobalShapeSnapshotsForConnection as e, readGlobalShapeSnapshot as f, readIdempotent as g, writeIdempotent as h, migrateClientWatermark as m, readClientWatermark as r, trimIdempotent as t, writeGlobalShapeSnapshot as w };

package/dist/packem_shared/ctx-db-shapes-DTeFiHYS.mjs

@@ -1,53 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
-import { D as DOC_COLUMN, r as rowToDocument, j as jsonPathSql } from './do-sql-CGAgiQUz.mjs';
-import { compileWhereSql } from './compileWhereSql-DE6yfRcQ.mjs';
-import { s as serializeSqlValue } from './serialize-sql-BlRUoiQe.mjs';
-
-const shapeWhereStrategy = { fieldRef: jsonPathSql, serialize: serializeSqlValue };
-const idInClause = (ids) => {
-  if (ids.length === 0) {
-    return void 0;
-  }
-  return sql`id IN (${sql.join(
-    ids.map((id) => sql`${id}`),
-    sql`, `
-  )})`;
-};
-const composeWhere = (effectiveWhere, idRestriction) => {
-  const conditions = [];
-  if (idRestriction) {
-    conditions.push(idRestriction);
-  }
-  const compiled = compileWhereSql(effectiveWhere, shapeWhereStrategy);
-  if (compiled) {
-    conditions.push(compiled);
-  }
-  if (conditions.length === 0) {
-    return sql``;
-  }
-  return sql` WHERE ${sql.join(conditions, sql` AND `)}`;
-};
-const selectShapeRows = (sql$1, table, effectiveWhere) => {
-  const whereClause = composeWhere(effectiveWhere, void 0);
-  const rows = runDrizzle(sql$1, sql`SELECT id, _creationTime, ${sql.identifier(DOC_COLUMN)} FROM ${sql.identifier(table)}${whereClause}`).toArray();
-  const result = [];
-  for (const row of rows) {
-    const doc = rowToDocument(row);
-    const { id } = row;
-    if (doc !== void 0 && typeof id === "string") {
-      result.push({ doc, id });
-    }
-  }
-  return result;
-};
-const selectShapeMemberIds = (sql$1, table, effectiveWhere, ids) => {
-  if (ids.length === 0) {
-    return /* @__PURE__ */ new Set();
-  }
-  const whereClause = composeWhere(effectiveWhere, idInClause(ids));
-  const rows = runDrizzle(sql$1, sql`SELECT id FROM ${sql.identifier(table)}${whereClause}`).toArray();
-  return new Set(rows.map((row) => row.id));
-};
-
-export { selectShapeMemberIds as a, selectShapeRows as s };

package/dist/packem_shared/diffExternalSource-CovHfdyo.mjs

@@ -1,44 +0,0 @@
-import { stableStringify } from './stableStringify-mC40mZts.mjs';
-
-const projectExternalSourceRow = (row, columns) => {
-  const projected = { _id: row._id };
-  if (columns) {
-    for (const key of columns) {
-      if (Object.hasOwn(row, key)) {
-        projected[key] = row[key];
-      }
-    }
-    return projected;
-  }
-  for (const [key, value] of Object.entries(row)) {
-    if (key !== "_id" && key !== "_creationTime") {
-      projected[key] = value;
-    }
-  }
-  return projected;
-};
-const diffExternalSource = (pulled, baseline, options) => {
-  const { columns, table } = options;
-  const changes = [];
-  const nextBaseline = /* @__PURE__ */ new Map();
-  for (const source of pulled) {
-    const value = projectExternalSourceRow(source, columns);
-    const id = String(value._id);
-    const json = stableStringify(value);
-    nextBaseline.set(id, json);
-    const before = baseline.get(id);
-    if (before === void 0) {
-      changes.push({ doc: value, id, op: "insert", seq: 0, table, ts: 0 });
-    } else if (before !== json) {
-      changes.push({ doc: value, id, op: "update", seq: 0, table, ts: 0 });
-    }
-  }
-  for (const id of baseline.keys()) {
-    if (!nextBaseline.has(id)) {
-      changes.push({ id, op: "delete", seq: 0, table, ts: 0 });
-    }
-  }
-  return { changes, nextBaseline };
-};
-
-export { diffExternalSource, projectExternalSourceRow };

package/dist/packem_shared/do-exec-5eQy5cEi.mjs

@@ -1,12 +0,0 @@
-import { renderSql } from './renderSql-D6eUcn2N.mjs';
-
-const runSql = (sql, query, ...params) => {
-  const runner = sql.exec;
-  return runner.call(sql, query, ...params);
-};
-const runDrizzle = (exec, query) => {
-  const { params, sql: text } = renderSql("sqlite", query);
-  return runSql(exec, text, ...params);
-};
-
-export { runDrizzle as r };

package/dist/packem_shared/do-sql-CGAgiQUz.mjs

@@ -1,88 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
-
-const DOC_COLUMN = "__doc__";
-const geoTableName = (table, indexName) => `${table}__geo_${indexName}`;
-const quoteIdentifier = (name) => `"${name.replaceAll('"', '""')}"`;
-const jsonPath = (field) => {
-  if (field === "_id" || field === "id") {
-    return "id";
-  }
-  if (field === "_creationTime") {
-    return "_creationTime";
-  }
-  return `json_extract(${DOC_COLUMN}, '$.${field.replaceAll("'", "''")}')`;
-};
-const jsonPathSql = (field) => sql.raw(jsonPath(field));
-const qualifiedJsonPath = (table, field) => {
-  const qualified = quoteIdentifier(table);
-  if (field === "_id" || field === "id") {
-    return `${qualified}.id`;
-  }
-  if (field === "_creationTime") {
-    return `${qualified}._creationTime`;
-  }
-  return `json_extract(${qualified}.${DOC_COLUMN}, '$.${field.replaceAll("'", "''")}')`;
-};
-const qualifiedJsonPathSql = (table, field) => sql.raw(qualifiedJsonPath(table, field));
-const createIndexSql = (name, table, columns, unique) => sql`CREATE ${unique ? sql`UNIQUE ` : sql``}INDEX IF NOT EXISTS ${sql.identifier(name)} ON ${sql.identifier(table)} (${columns})`;
-const AGG_KEY = sql.identifier("__key__");
-const AGG_VALUE = sql.identifier("__value__");
-const AGG_COUNT = sql.identifier("__count__");
-const aggUpsertSql = (aggTable, key, value, count, set) => sql`INSERT INTO ${sql.identifier(aggTable)} (${AGG_KEY}, ${AGG_VALUE}, ${AGG_COUNT}) VALUES (${key}, ${value}, ${count}) ON CONFLICT(${AGG_KEY}) DO UPDATE SET ${set}`;
-const tableColumns = (definition) => {
-  const columns = [];
-  for (const [field, validator] of Object.entries(definition.shape)) {
-    const column = validator._meta?.column;
-    if (column) {
-      columns.push([field, column]);
-    }
-  }
-  return columns;
-};
-const rowToDocument = (row) => {
-  if (!row) {
-    return void 0;
-  }
-  const raw = row[DOC_COLUMN];
-  let parsed;
-  if (typeof raw === "string") {
-    parsed = JSON.parse(raw);
-  } else if (raw && typeof raw === "object") {
-    parsed = raw;
-  } else {
-    parsed = {};
-  }
-  const { id } = row;
-  if (typeof id === "string") {
-    parsed["_id"] = id;
-  }
-  const creationTime = row["_creationTime"];
-  if (typeof creationTime === "number") {
-    parsed["_creationTime"] = creationTime;
-  }
-  return parsed;
-};
-const ftsAvailabilityCache = /* @__PURE__ */ new WeakMap();
-const isFtsAvailable = (sql$1) => {
-  const cached = ftsAvailabilityCache.get(sql$1);
-  if (cached !== void 0) {
-    return cached;
-  }
-  let available;
-  try {
-    runDrizzle(sql$1, sql`CREATE VIRTUAL TABLE IF NOT EXISTS ${sql.identifier("__lunora_fts_probe")} USING fts5(x)`);
-    available = true;
-  } catch {
-    available = false;
-  } finally {
-    try {
-      runDrizzle(sql$1, sql`DROP TABLE IF EXISTS ${sql.identifier("__lunora_fts_probe")}`);
-    } catch {
-    }
-  }
-  ftsAvailabilityCache.set(sql$1, available);
-  return available;
-};
-
-export { AGG_KEY as A, DOC_COLUMN as D, AGG_VALUE as a, AGG_COUNT as b, createIndexSql as c, aggUpsertSql as d, qualifiedJsonPathSql as e, geoTableName as g, isFtsAvailable as i, jsonPathSql as j, quoteIdentifier as q, rowToDocument as r, tableColumns as t };