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

package/dist/packem_shared/FUNCTION_METRICS_BUCKETS_TABLE-UDNVD7FS.mjs

@@ -1,248 +0,0 @@
-const FUNCTION_METRICS_TABLE = "__lunora_metrics";
-const FUNCTION_METRICS_BUCKETS_TABLE = "__lunora_metrics_buckets";
-const FUNCTION_METRICS_SCANS_TABLE = "__lunora_metrics_scans";
-const FUNCTION_METRICS_INDEX_TABLE = "__lunora_metrics_index";
-const FUNCTION_METRICS_BUCKET_MS = 6e4;
-const FUNCTION_METRICS_BUCKET_RETENTION = 1440;
-const FUNCTION_METRICS_MAX_PATHS = 5e3;
-const FUNCTION_METRICS_READ_LIMIT = 1e3;
-const runSql = (sql, query, ...params) => {
-  const runner = sql.exec;
-  return runner.call(sql, query, ...params);
-};
-const bucketFloor = (ts) => Math.floor(ts / FUNCTION_METRICS_BUCKET_MS) * FUNCTION_METRICS_BUCKET_MS;
-const dedupeIndexHits = (hits) => {
-  const seen = /* @__PURE__ */ new Map();
-  for (const hit of hits) {
-    seen.set(`${hit.table}\0${hit.index}`, { index: hit.index, table: hit.table });
-  }
-  return [...seen.values()];
-};
-const ensureFunctionMetricsTables = (sql) => {
-  runSql(
-    sql,
-    `CREATE TABLE IF NOT EXISTS "${FUNCTION_METRICS_TABLE}" (
-            path TEXT PRIMARY KEY,
-            calls INTEGER NOT NULL DEFAULT 0,
-            errors INTEGER NOT NULL DEFAULT 0,
-            conflicts INTEGER NOT NULL DEFAULT 0,
-            scans INTEGER NOT NULL DEFAULT 0,
-            total_duration_ms REAL NOT NULL DEFAULT 0,
-            min_duration_ms REAL,
-            max_duration_ms REAL NOT NULL DEFAULT 0,
-            last_called_at REAL NOT NULL DEFAULT 0,
-            last_error_at REAL,
-            last_error_message TEXT
-        )`
-  );
-  for (const column of ["scans", "conflicts"]) {
-    try {
-      runSql(sql, `ALTER TABLE "${FUNCTION_METRICS_TABLE}" ADD COLUMN ${column} INTEGER NOT NULL DEFAULT 0`);
-    } catch {
-    }
-  }
-  runSql(
-    sql,
-    `CREATE TABLE IF NOT EXISTS "${FUNCTION_METRICS_BUCKETS_TABLE}" (
-            path TEXT NOT NULL,
-            bucket_ms INTEGER NOT NULL,
-            calls INTEGER NOT NULL DEFAULT 0,
-            errors INTEGER NOT NULL DEFAULT 0,
-            PRIMARY KEY (path, bucket_ms)
-        )`
-  );
-  runSql(
-    sql,
-    `CREATE TABLE IF NOT EXISTS "${FUNCTION_METRICS_SCANS_TABLE}" (
-            path TEXT NOT NULL,
-            table_name TEXT NOT NULL,
-            scans INTEGER NOT NULL DEFAULT 0,
-            PRIMARY KEY (path, table_name)
-        )`
-  );
-  runSql(
-    sql,
-    `CREATE TABLE IF NOT EXISTS "${FUNCTION_METRICS_INDEX_TABLE}" (
-            table_name TEXT NOT NULL,
-            index_name TEXT NOT NULL,
-            reads INTEGER NOT NULL DEFAULT 0,
-            PRIMARY KEY (table_name, index_name)
-        )`
-  );
-};
-const recordFunctionMetric = (sql, input) => {
-  ensureFunctionMetricsTables(sql);
-  const pathCountRow = runSql(sql, `SELECT COUNT(*) AS n FROM "${FUNCTION_METRICS_TABLE}"`).one();
-  if (pathCountRow.n >= FUNCTION_METRICS_MAX_PATHS) {
-    const tracked = runSql(sql, `SELECT COUNT(*) AS c FROM "${FUNCTION_METRICS_TABLE}" WHERE path = ?`, input.path).one();
-    if (tracked.c === 0) {
-      return;
-    }
-  }
-  const scannedTables = input.scannedTables ? [...new Set(input.scannedTables)] : [];
-  const scanCount = scannedTables.length;
-  const indexHits = dedupeIndexHits(input.indexHits ?? []);
-  const errorCount = input.errored ? 1 : 0;
-  const conflictCount = input.conflicted ? 1 : 0;
-  const lastErrorAt = input.errored ? input.ts : null;
-  const lastErrorMessage = input.errored ? input.errorMessage ?? null : null;
-  runSql(
-    sql,
-    `INSERT INTO "${FUNCTION_METRICS_TABLE}"
-            (path, calls, errors, conflicts, scans, total_duration_ms, min_duration_ms, max_duration_ms, last_called_at, last_error_at, last_error_message)
-         VALUES (?, 1, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-         ON CONFLICT(path) DO UPDATE SET
-            calls = calls + 1,
-            errors = errors + excluded.errors,
-            conflicts = conflicts + excluded.conflicts,
-            scans = scans + excluded.scans,
-            total_duration_ms = total_duration_ms + excluded.total_duration_ms,
-            min_duration_ms = MIN(COALESCE(min_duration_ms, excluded.min_duration_ms), excluded.min_duration_ms),
-            max_duration_ms = MAX(max_duration_ms, excluded.max_duration_ms),
-            last_called_at = excluded.last_called_at,
-            last_error_at = CASE WHEN excluded.last_error_at IS NULL THEN last_error_at ELSE excluded.last_error_at END,
-            last_error_message = CASE WHEN excluded.last_error_at IS NULL THEN last_error_message ELSE excluded.last_error_message END`,
-    input.path,
-    errorCount,
-    conflictCount,
-    scanCount,
-    input.durationMs,
-    input.durationMs,
-    input.durationMs,
-    input.ts,
-    lastErrorAt,
-    lastErrorMessage
-  );
-  const bucket = bucketFloor(input.ts);
-  runSql(
-    sql,
-    `INSERT INTO "${FUNCTION_METRICS_BUCKETS_TABLE}" (path, bucket_ms, calls, errors)
-         VALUES (?, ?, 1, ?)
-         ON CONFLICT(path, bucket_ms) DO UPDATE SET
-            calls = calls + 1,
-            errors = errors + excluded.errors`,
-    input.path,
-    bucket,
-    errorCount
-  );
-  runSql(
-    sql,
-    `DELETE FROM "${FUNCTION_METRICS_BUCKETS_TABLE}"
-         WHERE path = ?
-           AND bucket_ms <= (
-            SELECT MAX(bucket_ms) - ? FROM "${FUNCTION_METRICS_BUCKETS_TABLE}" WHERE path = ?
-           )`,
-    input.path,
-    FUNCTION_METRICS_BUCKET_RETENTION * FUNCTION_METRICS_BUCKET_MS,
-    input.path
-  );
-  for (const table of scannedTables) {
-    runSql(
-      sql,
-      `INSERT INTO "${FUNCTION_METRICS_SCANS_TABLE}" (path, table_name, scans)
-             VALUES (?, ?, 1)
-             ON CONFLICT(path, table_name) DO UPDATE SET
-                scans = scans + 1`,
-      input.path,
-      table
-    );
-  }
-  for (const hit of indexHits) {
-    runSql(
-      sql,
-      `INSERT INTO "${FUNCTION_METRICS_INDEX_TABLE}" (table_name, index_name, reads)
-             VALUES (?, ?, 1)
-             ON CONFLICT(table_name, index_name) DO UPDATE SET
-                reads = reads + 1`,
-      hit.table,
-      hit.index
-    );
-  }
-};
-const readFunctionMetricScans = (sql) => {
-  ensureFunctionMetricsTables(sql);
-  const rows = runSql(
-    sql,
-    // Bounded read: cap the materialized rows so a bloated attribution table
-    // can't blow up DO memory. Highest-scan rows lead so the dominant
-    // attributions survive the cut.
-    `SELECT path, table_name, scans FROM "${FUNCTION_METRICS_SCANS_TABLE}" ORDER BY scans DESC, path ASC, table_name ASC LIMIT ${String(FUNCTION_METRICS_READ_LIMIT)}`
-  ).toArray();
-  const byPath = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const list = byPath.get(row.path);
-    const entry = { scans: row.scans, table: row.table_name };
-    if (list === void 0) {
-      byPath.set(row.path, [entry]);
-    } else {
-      list.push(entry);
-    }
-  }
-  return byPath;
-};
-const readFunctionMetricIndexHits = (sql) => {
-  ensureFunctionMetricsTables(sql);
-  const rows = runSql(
-    sql,
-    `SELECT table_name, index_name, reads FROM "${FUNCTION_METRICS_INDEX_TABLE}" ORDER BY table_name ASC, index_name ASC`
-  ).toArray();
-  return rows.map((row) => {
-    return { index: row.index_name, reads: row.reads, table: row.table_name };
-  });
-};
-const mergeScanAttribution = (into, scanned) => {
-  for (const table of scanned) {
-    const entry = into.find((attribution) => attribution.table === table);
-    if (entry === void 0) {
-      into.push({ scans: 1, table });
-    } else {
-      entry.scans += 1;
-    }
-  }
-  into.sort((a, b) => b.scans - a.scans || a.table.localeCompare(b.table));
-  return into;
-};
-const readFunctionMetrics = (sql) => {
-  ensureFunctionMetricsTables(sql);
-  const scansByPath = readFunctionMetricScans(sql);
-  const rows = runSql(sql, `SELECT * FROM "${FUNCTION_METRICS_TABLE}" ORDER BY last_called_at DESC LIMIT ${String(FUNCTION_METRICS_READ_LIMIT)}`).toArray();
-  return rows.map((row) => {
-    return {
-      calls: row.calls,
-      conflicts: row.conflicts,
-      errors: row.errors,
-      lastCalledAt: row.last_called_at,
-      lastErrorAt: row.last_error_at,
-      lastErrorMessage: row.last_error_message,
-      maxDurationMs: row.max_duration_ms,
-      path: row.path,
-      scannedTables: scansByPath.get(row.path) ?? [],
-      scans: row.scans,
-      totalDurationMs: row.total_duration_ms
-    };
-  });
-};
-const readFunctionMetricBuckets = (sql, path) => {
-  ensureFunctionMetricsTables(sql);
-  const rows = path === void 0 ? runSql(
-    sql,
-    `SELECT path, bucket_ms, calls, errors FROM "${FUNCTION_METRICS_BUCKETS_TABLE}" ORDER BY bucket_ms ASC, path ASC`
-  ).toArray() : runSql(
-    sql,
-    `SELECT path, bucket_ms, calls, errors FROM "${FUNCTION_METRICS_BUCKETS_TABLE}" WHERE path = ? ORDER BY bucket_ms ASC`,
-    path
-  ).toArray();
-  return rows.map((row) => {
-    return { bucketMs: row.bucket_ms, calls: row.calls, errors: row.errors, path: row.path };
-  });
-};
-const readFunctionMetricsTotals = (sql) => {
-  ensureFunctionMetricsTables(sql);
-  const row = runSql(
-    sql,
-    `SELECT SUM(calls) AS requests, SUM(errors) AS errors FROM "${FUNCTION_METRICS_TABLE}"`
-  ).one();
-  return { errors: row.errors ?? 0, requests: row.requests ?? 0 };
-};
-
-export { FUNCTION_METRICS_BUCKETS_TABLE, FUNCTION_METRICS_BUCKET_MS, FUNCTION_METRICS_BUCKET_RETENTION, FUNCTION_METRICS_INDEX_TABLE, FUNCTION_METRICS_MAX_PATHS, FUNCTION_METRICS_READ_LIMIT, FUNCTION_METRICS_SCANS_TABLE, FUNCTION_METRICS_TABLE, ensureFunctionMetricsTables, mergeScanAttribution, readFunctionMetricBuckets, readFunctionMetricIndexHits, readFunctionMetricScans, readFunctionMetrics, readFunctionMetricsTotals, recordFunctionMetric };

package/dist/packem_shared/GEO_DEFAULT_PRECISION-BWnsNmpP.mjs

@@ -1,114 +0,0 @@
-const BASE32 = "0123456789bcdefghjkmnpqrstuvwxyz";
-const GEO_DEFAULT_PRECISION = 9;
-const EARTH_RADIUS_METERS = 63710088e-1;
-const CELL_WIDTH_METERS = [Number.POSITIVE_INFINITY, 5009400, 1252300, 156500, 39100, 4900, 1200, 152.9, 38.2, 4.77, 1.19, 0.149, 0.037];
-const clampPrecision = (precision) => Math.min(Math.max(Math.trunc(precision), 1), 12);
-const encodeGeohash = (point, precision) => {
-  const chars = clampPrecision(precision);
-  let latMin = -90;
-  let latMax = 90;
-  let lngMin = -180;
-  let lngMax = 180;
-  let hash = "";
-  let bit = 0;
-  let index = 0;
-  let even = true;
-  while (hash.length < chars) {
-    if (even) {
-      const mid = (lngMin + lngMax) / 2;
-      if (point.lng >= mid) {
-        index = index * 2 + 1;
-        lngMin = mid;
-      } else {
-        index *= 2;
-        lngMax = mid;
-      }
-    } else {
-      const mid = (latMin + latMax) / 2;
-      if (point.lat >= mid) {
-        index = index * 2 + 1;
-        latMin = mid;
-      } else {
-        index *= 2;
-        latMax = mid;
-      }
-    }
-    even = !even;
-    if (bit < 4) {
-      bit += 1;
-    } else {
-      hash += BASE32[index] ?? "0";
-      bit = 0;
-      index = 0;
-    }
-  }
-  return hash;
-};
-const haversineMeters = (a, b) => {
-  const toRadians = (degrees) => degrees * Math.PI / 180;
-  const dLat = toRadians(b.lat - a.lat);
-  const dLng = toRadians(b.lng - a.lng);
-  const lat1 = toRadians(a.lat);
-  const lat2 = toRadians(b.lat);
-  const h = Math.sin(dLat / 2) ** 2 + Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLng / 2) ** 2;
-  return 2 * EARTH_RADIUS_METERS * Math.asin(Math.min(1, Math.sqrt(h)));
-};
-const precisionForRadius = (radiusMeters) => {
-  for (let length = CELL_WIDTH_METERS.length - 1; length >= 1; length -= 1) {
-    const width = CELL_WIDTH_METERS[length];
-    if (width !== void 0 && width >= radiusMeters) {
-      return length;
-    }
-  }
-  return 1;
-};
-const NEIGHBOURS = {
-  east: ["bc01fg45238967deuvhjyznpkmstqrwx", "bc01fg45238967deuvhjyznpkmstqrwx"],
-  north: ["p0r21436x8zb9dcf5h7kjnmqesgutwvy", "bc01fg45238967deuvhjyznpkmstqrwx"],
-  south: ["14365h7k9dcfesgujnmqp0r2twvyx8zb", "238967debc01fg45kmstqrwxuvhjyznp"],
-  west: ["238967debc01fg45kmstqrwxuvhjyznp", "238967debc01fg45kmstqrwxuvhjyznp"]
-};
-const BORDERS = {
-  east: ["bcfguvyz", "prxz"],
-  north: ["prxz", "bcfguvyz"],
-  south: ["028b", "0145hjnp"],
-  west: ["0145hjnp", "028b"]
-};
-const adjacent = (hash, direction) => {
-  const lower = hash.toLowerCase();
-  const lastChar = lower.at(-1) ?? "";
-  let base = lower.slice(0, -1);
-  const type = lower.length % 2 === 0 ? 0 : 1;
-  if (BORDERS[direction][type].includes(lastChar) && base !== "") {
-    base = adjacent(base, direction);
-  }
-  return base + (BASE32[NEIGHBOURS[direction][type].indexOf(lastChar)] ?? "");
-};
-const coveringGeohashes = (center, radiusMeters) => {
-  const precision = precisionForRadius(Math.max(radiusMeters, 1));
-  const origin = encodeGeohash(center, precision);
-  const north = adjacent(origin, "north");
-  const south = adjacent(origin, "south");
-  const cells = [
-    origin,
-    north,
-    south,
-    adjacent(origin, "east"),
-    adjacent(origin, "west"),
-    adjacent(north, "east"),
-    adjacent(north, "west"),
-    adjacent(south, "east"),
-    adjacent(south, "west")
-  ];
-  return [...new Set(cells)];
-};
-const pointInBoundingBox = (point, box) => point.lat >= box.sw.lat && point.lat <= box.ne.lat && point.lng >= box.sw.lng && point.lng <= box.ne.lng;
-const boundingBoxCenter = (box) => {
-  return { lat: (box.sw.lat + box.ne.lat) / 2, lng: (box.sw.lng + box.ne.lng) / 2 };
-};
-const boundingBoxGeohashes = (box) => {
-  const center = boundingBoxCenter(box);
-  return coveringGeohashes(center, Math.max(haversineMeters(center, box.ne), 1));
-};
-
-export { GEO_DEFAULT_PRECISION, boundingBoxCenter, boundingBoxGeohashes, coveringGeohashes, encodeGeohash, haversineMeters, pointInBoundingBox };

package/dist/packem_shared/LogBuffer-B_Ezju_N.mjs

@@ -1,37 +0,0 @@
-const DEFAULT_CAPACITY = 500;
-class LogBuffer {
-  /** Backing store, kept in insertion order (oldest first). */
-  buffer = [];
-  capacity;
-  constructor(capacity = DEFAULT_CAPACITY) {
-    this.capacity = capacity > 0 ? Math.trunc(capacity) : DEFAULT_CAPACITY;
-  }
-  /** Number of entries currently buffered. */
-  get size() {
-    return this.buffer.length;
-  }
-  /** Drop every buffered entry. */
-  clear() {
-    this.buffer.length = 0;
-  }
-  /**
-   * Snapshot of the buffered entries, **newest first** so the panel renders
-   * the most recent activity at the top without re-sorting. Returns a fresh
-   * array each call; the caller may mutate it freely.
-   */
-  entries() {
-    return this.buffer.toReversed();
-  }
-  /**
-   * Append an entry, evicting the oldest when at capacity so the buffer never
-   * grows past its bound.
-   */
-  push(entry) {
-    this.buffer.push(entry);
-    if (this.buffer.length > this.capacity) {
-      this.buffer.shift();
-    }
-  }
-}
-
-export { LogBuffer };

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

@@ -1,104 +0,0 @@
-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/MAX_SQL_ROWS-iFAA8FbD.mjs

@@ -1,61 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-
-const MAX_SQL_ROWS = 1e3;
-const READONLY_LEAD = /^(?:explain\s+(?:query\s+plan\s+)?)?(?:select|with)\b/iu;
-const FORBIDDEN_KEYWORD = /\b(?:alter|attach|create|delete|detach|drop|insert|pragma|reindex|replace|truncate|update|vacuum)\b/iu;
-const TRAILING_SEMICOLON = /;\s*$/u;
-const WHITESPACE = /\s/u;
-const skipLineComment = (sql, from) => {
-  let index = from + 2;
-  while (index < sql.length && sql[index] !== "\n") {
-    index += 1;
-  }
-  return index;
-};
-const skipBlockComment = (sql, from) => {
-  const close = sql.indexOf("*/", from + 2);
-  return close === -1 ? -1 : close + 2;
-};
-const stripLeading = (sql) => {
-  let index = 0;
-  while (index < sql.length) {
-    const char = sql[index];
-    if (char !== void 0 && WHITESPACE.test(char)) {
-      index += 1;
-    } else if (char === "-" && sql[index + 1] === "-") {
-      index = skipLineComment(sql, index);
-    } else if (char === "/" && sql[index + 1] === "*") {
-      const next = skipBlockComment(sql, index);
-      if (next === -1) {
-        break;
-      }
-      index = next;
-    } else {
-      break;
-    }
-  }
-  return sql.slice(index);
-};
-const sqlError = (message, code) => new LunoraError(code, message, { status: 400 });
-const assertReadonly = (query) => {
-  const trimmed = stripLeading(query).trim();
-  if (trimmed === "") {
-    throw sqlError("the query is empty", "SQL_EMPTY");
-  }
-  const single = trimmed.replace(TRAILING_SEMICOLON, "");
-  if (single.includes(";")) {
-    throw sqlError("only a single statement may be run", "SQL_MULTIPLE_STATEMENTS");
-  }
-  if (!READONLY_LEAD.test(single) || FORBIDDEN_KEYWORD.test(single)) {
-    throw sqlError("the SQL editor is read-only — only SELECT / WITH / EXPLAIN queries are allowed", "SQL_NOT_READONLY");
-  }
-};
-const runReadonlySql = (sql, query) => {
-  assertReadonly(query);
-  const all = sql.exec(query).toArray();
-  const rows = all.length > MAX_SQL_ROWS ? all.slice(0, MAX_SQL_ROWS) : all;
-  const columns = rows.length > 0 ? Object.keys(rows[0]) : [];
-  return { columns, rowCount: all.length, rows, truncated: all.length > MAX_SQL_ROWS };
-};
-
-export { MAX_SQL_ROWS, assertReadonly, runReadonlySql };

package/dist/packem_shared/MIN_ADMIN_TOKEN_LENGTH-CCAvoFlr.mjs

@@ -1 +0,0 @@
-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/NotFoundError-C70b9hLw.mjs

@@ -1,9 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-
-class NotFoundError extends LunoraError {
-  constructor(message = "Document not found") {
-    super("NOT_FOUND", message, { name: "NotFoundError" });
-  }
-}
-
-export { NotFoundError as default };