@lunora/do 0.0.0 → 1.0.0-alpha.1

package/dist/packem_shared/backfillAggregateIndexes-BF5eL7kW.mjs

@@ -0,0 +1,80 @@
+import { sql } from 'drizzle-orm';
+import { matchesStaticWhere } from './matchesStaticWhere-CFk6adSu.mjs';
+import { encodeAggregateKey, foldAggregateTally, aggregateTableName } from './aggregateTableName-CxNqY1Sl.mjs';
+import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
+import { D as DOC_COLUMN, r as rowToDocument, A as AGG_KEY, a as AGG_VALUE, b as AGG_COUNT } from './do-sql-BCHCWtrD.mjs';
+import { param } from './renderSql-D6eUcn2N.mjs';
+import { s as sortColumnName, m as matchesRankStaticWhere, e as encodePartitionKey, b as serializeSqlValue, r as rankTableName } from './rank-CrkEIpF4.mjs';
+
+const backfillAggregateIndex = (sql$1, tableName, index) => {
+  const aggTable = aggregateTableName(tableName, index.name);
+  const existing = runDrizzle(sql$1, sql`SELECT COUNT(*) AS count FROM ${sql.identifier(aggTable)}`).one();
+  if (existing.count > 0) {
+    return;
+  }
+  const by = index.by ?? [];
+  const tallies = /* @__PURE__ */ new Map();
+  const rows = runDrizzle(sql$1, sql`SELECT id, _creationTime, ${sql.identifier(DOC_COLUMN)} FROM ${sql.identifier(tableName)}`).toArray();
+  for (const row of rows) {
+    const record = rowToDocument(row);
+    if (!record || index.where && !matchesStaticWhere(record, index.where)) {
+      continue;
+    }
+    const encoded = encodeAggregateKey(by, record);
+    foldAggregateTally(tallies, encoded, index, record);
+  }
+  for (const [encoded, tally] of tallies) {
+    runDrizzle(
+      sql$1,
+      sql`INSERT INTO ${sql.identifier(aggTable)} (${AGG_KEY}, ${AGG_VALUE}, ${AGG_COUNT}) VALUES (${encoded}, ${tally.value}, ${tally.count})`
+    );
+  }
+};
+const backfillAggregateIndexes = (sql, schema) => {
+  for (const [tableName, definition] of Object.entries(schema.tables)) {
+    if (definition.shardMode?.kind === "global" || !definition.aggregateIndexes) {
+      continue;
+    }
+    for (const index of definition.aggregateIndexes) {
+      backfillAggregateIndex(sql, tableName, index);
+    }
+  }
+};
+const backfillRankIndex = (sql$1, tableName, index) => {
+  const rankTable = rankTableName(tableName, index.name);
+  const existing = runDrizzle(sql$1, sql`SELECT COUNT(*) AS count FROM ${sql.identifier(rankTable)}`).one();
+  if (existing.count > 0) {
+    return;
+  }
+  const sortColumns = index.sortBy.map((_, i) => sortColumnName(i));
+  const columnsSql = sql.join(
+    ["__id__", "__partition__", ...sortColumns].map((column) => sql.identifier(column)),
+    sql`, `
+  );
+  const rows = runDrizzle(sql$1, sql`SELECT id, _creationTime, ${sql.identifier(DOC_COLUMN)} FROM ${sql.identifier(tableName)}`).toArray();
+  for (const row of rows) {
+    const record = rowToDocument(row);
+    if (!record || index.where && !matchesRankStaticWhere(record, index.where)) {
+      continue;
+    }
+    const partitionKey = encodePartitionKey(index.partitionBy ?? [], record);
+    const sortValues = index.sortBy.map((key) => serializeSqlValue(record[key.field] ?? null));
+    const valuesSql = sql.join(
+      [record["_id"], partitionKey, ...sortValues].map((value) => param(value)),
+      sql`, `
+    );
+    runDrizzle(sql$1, sql`INSERT INTO ${sql.identifier(rankTable)} (${columnsSql}) VALUES (${valuesSql})`);
+  }
+};
+const backfillRankIndexes = (sql, schema) => {
+  for (const [tableName, definition] of Object.entries(schema.tables)) {
+    if (definition.shardMode?.kind === "global" || !definition.rankIndexes) {
+      continue;
+    }
+    for (const index of definition.rankIndexes) {
+      backfillRankIndex(sql, tableName, index);
+    }
+  }
+};
+
+export { backfillAggregateIndexes, backfillRankIndexes };

package/dist/packem_shared/buildSecurityAudit-CCAvoFlr.mjs

@@ -0,0 +1 @@
+export { M as MIN_ADMIN_TOKEN_LENGTH, a as MIN_AUTH_SECRET_LENGTH, b as buildSecurityAudit } from './security-audit-CucgBice.mjs';

package/dist/packem_shared/buildSeekWhere-lVsNXSLy.mjs

@@ -0,0 +1,84 @@
+const TIEBREAK_FIELD = "id";
+const ID_FIELDS = /* @__PURE__ */ new Set(["_id", "id"]);
+const normalizeOrderKeys = (orderBy) => {
+  const keys = [];
+  for (const entry of orderBy ?? []) {
+    for (const [field, direction] of Object.entries(entry)) {
+      keys.push({ direction, field });
+    }
+  }
+  if (keys.length === 0) {
+    return [{ direction: "asc", field: "_creationTime" }];
+  }
+  return keys;
+};
+const toBase64 = (text) => {
+  const bytes = new TextEncoder().encode(text);
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCodePoint(byte);
+  }
+  return btoa(binary);
+};
+const fromBase64 = (encoded) => {
+  const binary = atob(encoded);
+  const bytes = Uint8Array.from(binary, (character) => character.codePointAt(0) ?? 0);
+  return new TextDecoder().decode(bytes);
+};
+const encodeCursor = (record, keys) => {
+  const values = keys.map((key) => record[key.field]);
+  values.push(record["_id"]);
+  return toBase64(JSON.stringify(values));
+};
+const invalidCursor = () => Object.assign(new TypeError("invalid cursor"), { code: "BAD_REQUEST", name: "LunoraError", status: 400 });
+const decodeCursor = (cursor) => {
+  let decoded;
+  try {
+    decoded = JSON.parse(fromBase64(cursor));
+  } catch {
+    throw invalidCursor();
+  }
+  if (!Array.isArray(decoded)) {
+    throw invalidCursor();
+  }
+  return decoded;
+};
+const buildSeekWhere = (keys, cursorValues) => {
+  const columns = keys.some((key) => ID_FIELDS.has(key.field)) ? keys : [...keys, { direction: "asc", field: TIEBREAK_FIELD }];
+  const branches = [];
+  for (const [pivot, pivotColumn] of columns.entries()) {
+    const conditions = [];
+    for (const [prefix, prefixColumn] of columns.slice(0, pivot).entries()) {
+      conditions.push({ [prefixColumn.field]: { eq: cursorValues[prefix] } });
+    }
+    const strictOperator = pivotColumn.direction === "desc" ? "lt" : "gt";
+    conditions.push({ [pivotColumn.field]: { [strictOperator]: cursorValues[pivot] } });
+    const [first] = conditions;
+    branches.push(conditions.length === 1 && first !== void 0 ? first : { AND: conditions });
+  }
+  return { OR: branches };
+};
+const seekBeforeOperator = (direction, isFinal) => {
+  if (direction === "desc") {
+    return isFinal ? "gte" : "gt";
+  }
+  return isFinal ? "lte" : "lt";
+};
+const buildSeekBeforeWhere = (keys, cursorValues) => {
+  const columns = keys.some((key) => ID_FIELDS.has(key.field)) ? keys : [...keys, { direction: "asc", field: TIEBREAK_FIELD }];
+  const branches = [];
+  for (const [pivot, pivotColumn] of columns.entries()) {
+    const conditions = [];
+    for (const [prefix, prefixColumn] of columns.slice(0, pivot).entries()) {
+      conditions.push({ [prefixColumn.field]: { eq: cursorValues[prefix] } });
+    }
+    const isFinal = pivot === columns.length - 1;
+    const operator = seekBeforeOperator(pivotColumn.direction, isFinal);
+    conditions.push({ [pivotColumn.field]: { [operator]: cursorValues[pivot] } });
+    const [first] = conditions;
+    branches.push(conditions.length === 1 && first !== void 0 ? first : { AND: conditions });
+  }
+  return { OR: branches };
+};
+
+export { buildSeekBeforeWhere, buildSeekWhere, decodeCursor, encodeCursor, normalizeOrderKeys };

package/dist/packem_shared/clearCapturedMail-CPpgl-dX.mjs

@@ -0,0 +1,104 @@
+const MAIL_TABLE = "__lunora_mail";
+const MAIL_RETENTION = 500;
+const MAX_BODY_CHARS = 256 * 1024;
+const capBody = (value) => value !== void 0 && value.length > MAX_BODY_CHARS ? `${value.slice(0, MAX_BODY_CHARS)}
+… [truncated by the dev mail catcher]` : value;
+const runSql = (sql, query, ...params) => {
+  const runner = sql.exec;
+  return runner.call(sql, query, ...params);
+};
+const orNull = (value) => (
+  // eslint-disable-next-line unicorn/no-null -- SQL NULL is the correct value for an absent column.
+  value ?? null
+);
+const encode = (value) => {
+  if (value === void 0) {
+    return null;
+  }
+  return JSON.stringify(value);
+};
+const decode = (value) => {
+  if (value === null || value === void 0 || value === "") {
+    return void 0;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+};
+const ensureMailTable = (sql) => {
+  runSql(
+    sql,
+    `CREATE TABLE IF NOT EXISTS "${MAIL_TABLE}" (
+            id TEXT PRIMARY KEY,
+            captured_at INTEGER NOT NULL,
+            from_addr TEXT,
+            to_addrs TEXT NOT NULL,
+            cc_addrs TEXT,
+            bcc_addrs TEXT,
+            reply_to TEXT,
+            subject TEXT NOT NULL,
+            html TEXT,
+            body_text TEXT,
+            headers TEXT
+        )`
+  );
+};
+const recordCapturedMail = (sql, input, capturedAt) => {
+  ensureMailTable(sql);
+  const id = crypto.randomUUID();
+  runSql(
+    sql,
+    `INSERT INTO "${MAIL_TABLE}" (id, captured_at, from_addr, to_addrs, cc_addrs, bcc_addrs, reply_to, subject, html, body_text, headers)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    id,
+    capturedAt,
+    orNull(input.from),
+    JSON.stringify(input.to),
+    encode(input.cc),
+    encode(input.bcc),
+    orNull(input.replyTo),
+    input.subject,
+    orNull(capBody(input.html)),
+    orNull(capBody(input.text)),
+    encode(input.headers)
+  );
+  runSql(
+    sql,
+    `DELETE FROM "${MAIL_TABLE}"
+         WHERE id NOT IN (
+            SELECT id FROM "${MAIL_TABLE}" ORDER BY captured_at DESC, id DESC LIMIT ?
+         )`,
+    MAIL_RETENTION
+  );
+  return { id };
+};
+const readCapturedMail = (sql, options = {}) => {
+  ensureMailTable(sql);
+  const limit = Math.min(Math.max(options.limit ?? 50, 1), MAIL_RETENTION);
+  const rows = runSql(sql, `SELECT * FROM "${MAIL_TABLE}" ORDER BY captured_at DESC, id DESC LIMIT ?`, limit).toArray();
+  const entries = rows.map((row) => {
+    return {
+      bcc: decode(row.bcc_addrs),
+      capturedAt: row.captured_at,
+      cc: decode(row.cc_addrs),
+      from: row.from_addr ?? void 0,
+      headers: decode(row.headers),
+      html: row.html ?? void 0,
+      id: row.id,
+      replyTo: row.reply_to ?? void 0,
+      subject: row.subject,
+      text: row.body_text ?? void 0,
+      to: decode(row.to_addrs) ?? row.to_addrs
+    };
+  });
+  return { entries };
+};
+const clearCapturedMail = (sql) => {
+  ensureMailTable(sql);
+  runSql(sql, `DELETE FROM "${MAIL_TABLE}"`);
+  return { cleared: true };
+};
+
+export { MAIL_RETENTION, MAIL_TABLE, MAX_BODY_CHARS, clearCapturedMail, ensureMailTable, readCapturedMail, recordCapturedMail };

package/dist/packem_shared/compileWhereSql-CXrhFA3G.mjs

@@ -0,0 +1,127 @@
+import { sql } from 'drizzle-orm';
+
+const RELATION_EXISTS_KEY = "__relationExists";
+const OPERATOR_KEYS = ["eq", "ne", "lt", "lte", "gt", "gte", "in", "notIn", "isNull", "contains"];
+const OPERATOR_KEY_SET = new Set(OPERATOR_KEYS);
+const BINARY_COMPARATORS = { eq: "=", gt: ">", gte: ">=", lt: "<", lte: "<=", ne: "<>" };
+const isOperatorObject = (value) => {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const keys = Object.keys(value);
+  return keys.length > 0 && keys.every((key) => OPERATOR_KEY_SET.has(key));
+};
+const compileContains = (reference, value, strategy) => {
+  const term = sql`${strategy.serialize(value)}`;
+  return strategy.likeContains ? strategy.likeContains(reference, term) : sql`${reference} LIKE '%' || ${term} || '%'`;
+};
+const compileComparator = (reference, operator, comparator, value, strategy) => {
+  if (value === null) {
+    return operator === "ne" ? sql`${reference} IS NOT NULL` : sql`${reference} IS NULL`;
+  }
+  return sql`${reference} ${sql.raw(comparator)} ${strategy.serialize(value)}`;
+};
+const compileInList = (reference, keyword, value, strategy) => {
+  const items = Array.isArray(value) ? value : [];
+  if (items.length === 0) {
+    return keyword === "IN" ? sql`0 = 1` : sql`1 = 1`;
+  }
+  const list = sql.join(
+    items.map((item) => sql`${strategy.serialize(item)}`),
+    sql`, `
+  );
+  return keyword === "IN" ? sql`${reference} IN (${list})` : sql`${reference} NOT IN (${list})`;
+};
+const compileFieldOperators = (reference, operators, strategy) => {
+  const record = operators;
+  const clauses = [];
+  for (const operator of OPERATOR_KEYS) {
+    if (!(operator in record)) {
+      continue;
+    }
+    const value = record[operator];
+    const comparator = BINARY_COMPARATORS[operator];
+    if (comparator) {
+      clauses.push(compileComparator(reference, operator, comparator, value, strategy));
+    } else if (operator === "isNull") {
+      clauses.push(value ? sql`${reference} IS NULL` : sql`${reference} IS NOT NULL`);
+    } else if (operator === "contains") {
+      clauses.push(compileContains(reference, value, strategy));
+    } else {
+      clauses.push(compileInList(reference, operator === "in" ? "IN" : "NOT IN", value, strategy));
+    }
+  }
+  return clauses;
+};
+const compileField = (field, value, strategy) => {
+  const reference = strategy.fieldRef(field);
+  if (isOperatorObject(value)) {
+    return compileFieldOperators(reference, value, strategy);
+  }
+  if (value === null) {
+    return [sql`${reference} IS NULL`];
+  }
+  return [sql`${reference} = ${strategy.serialize(value)}`];
+};
+const joinClauses = (clauses, connector) => {
+  if (clauses.length === 0) {
+    return void 0;
+  }
+  if (clauses.length === 1) {
+    return clauses[0];
+  }
+  return sql.join(
+    clauses.map((clause) => sql`(${clause})`),
+    sql` ${sql.raw(connector)} `
+  );
+};
+const compileGroup = (value, connector, strategy) => {
+  const branches = Array.isArray(value) ? value : [];
+  const parts = [];
+  for (const branch of branches) {
+    const compiled = compileNode(branch ?? {}, strategy);
+    if (compiled) {
+      parts.push(compiled);
+    }
+  }
+  if (parts.length === 0) {
+    return connector === "OR" ? sql`0 = 1` : void 0;
+  }
+  return joinClauses(parts, connector);
+};
+const STRUCTURAL_KEYS = /* @__PURE__ */ new Set(["AND", "NOT", "OR", RELATION_EXISTS_KEY]);
+const compileStructuralKey = (key, value, strategy) => {
+  if (key === RELATION_EXISTS_KEY) {
+    if (!strategy.relationExists) {
+      throw new Error("encountered a relation EXISTS marker without a relationExists strategy hook");
+    }
+    return strategy.relationExists(value);
+  }
+  if (key === "NOT") {
+    const inner = compileNode(value ?? {}, strategy);
+    return inner ? sql`NOT (${inner})` : void 0;
+  }
+  return compileGroup(value, key, strategy);
+};
+const compileNode = (where, strategy) => {
+  const clauses = [];
+  for (const [key, value] of Object.entries(where)) {
+    if (STRUCTURAL_KEYS.has(key)) {
+      const compiled = compileStructuralKey(key, value, strategy);
+      if (compiled) {
+        clauses.push(compiled);
+      }
+    } else {
+      clauses.push(...compileField(key, value, strategy));
+    }
+  }
+  return joinClauses(clauses, "AND");
+};
+const compileWhereSql = (where, strategy) => {
+  if (!where || Object.keys(where).length === 0) {
+    return void 0;
+  }
+  return compileNode(where, strategy);
+};
+
+export { compileWhereSql };

package/dist/packem_shared/createSystemReader-8CzSZP9V.mjs

@@ -0,0 +1,80 @@
+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 Error('ctx.db.system.query("_scheduled_functions"): no scheduler configured. Pass `scheduler` to createShardDO().');
+    }
+    return options.scheduler;
+  };
+  const requireStorage = () => {
+    if (!options.storage) {
+      throw new Error('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-DkC9rP91.mjs

@@ -0,0 +1,35 @@
+import { sql } from 'drizzle-orm';
+import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
+
+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 { IDEMPOTENCY_TABLE as I, migrateIdempotency as m, readIdempotent as r, trimIdempotent as t, writeIdempotent as w };

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

@@ -0,0 +1,12 @@
+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-BCHCWtrD.mjs

@@ -0,0 +1,87 @@
+import { sql } from 'drizzle-orm';
+import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
+
+const DOC_COLUMN = "__doc__";
+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, isFtsAvailable as i, jsonPathSql as j, quoteIdentifier as q, rowToDocument as r, tableColumns as t };

package/dist/packem_shared/encodePartitionKey-C6blLR5K.mjs

@@ -0,0 +1 @@
+export { R as RANK_TIEBREAK, e as encodePartitionKey, m as matchesRankStaticWhere, c as rankKeyFromDoc, r as rankTableName, a as resolveRankPartition, s as sortColumnName } from './rank-CrkEIpF4.mjs';