@lunora/do 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/FUNCTION_METRICS_BUCKETS_TABLE-UDNVD7FS.mjs

@@ -0,0 +1,248 @@
+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/LogBuffer-B_Ezju_N.mjs

@@ -0,0 +1,37 @@
+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

@@ -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/MAX_SQL_ROWS-dDcFE1YZ.mjs

@@ -0,0 +1,29 @@
+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 LEADING_NOISE = /^(?:\s|--[^\n]*\n?|\/\*[\s\S]*?\*\/)+/u;
+const TRAILING_SEMICOLON = /;\s*$/u;
+const stripLeading = (sql) => sql.replace(LEADING_NOISE, "");
+const sqlError = (message, code) => Object.assign(new Error(message), { code, name: "LunoraError", 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

@@ -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/NotFoundError-CMuMZt81.mjs

@@ -0,0 +1,10 @@
+class NotFoundError extends Error {
+  code = "NOT_FOUND";
+  status = 404;
+  constructor(message = "Document not found") {
+    super(message);
+    this.name = "NotFoundError";
+  }
+}
+
+export { NotFoundError as default };