@lunora/do 0.0.0 → 1.0.0-alpha.10

package/dist/index.mjs

@@ -0,0 +1,37 @@
+export { exportShardRows, exportShardTable, importShardRows, parseExportShardArgs, parseImportShardArgs, selectExportTables, validateImportRow } from './packem_shared/exportShardRows-DZEhUeyI.mjs';
+export { AGGREGATE_SQL_FUNCTION, aggregateSqlFunction, matchesStaticWhere, normalizeCountArgument, throwingScheduler } from './packem_shared/AGGREGATE_SQL_FUNCTION-CFk6adSu.mjs';
+export { aggregateTableName, coerceAggregateNumber, encodeAggregateKey, foldAggregateTally, readAggregateValue } from './packem_shared/aggregateTableName-CxNqY1Sl.mjs';
+export { CountRlsUnsupportedError, mergeWhere, planAggregateLookup, selectIndexForAggregate, selectIndexForCount, selectIndexForGroupBy } from './packem_shared/CountRlsUnsupportedError-28ZvvwKS.mjs';
+export { AUTH_METRICS_BUCKETS_TABLE, AUTH_METRICS_BUCKET_MS, AUTH_METRICS_BUCKET_RETENTION, AUTH_METRICS_TABLE, ensureAuthMetricsTables, readAuthMetrics, recordAuthEvent } from './packem_shared/AUTH_METRICS_BUCKETS_TABLE-CiHHYeJi.mjs';
+export { NotUniqueError, assertValidClientId, createShardCtxDb, normalizeIdStructurally } from './packem_shared/NotUniqueError-DZQtH02h.mjs';
+export { DATA_MIGRATION_STATE_TABLE, readMigrationStatus, runDataMigration } from './packem_shared/DATA_MIGRATION_STATE_TABLE-PTtTiQ7U.mjs';
+export { SCAN_DEP, createDependencyTracker, depKey } from './packem_shared/SCAN_DEP-DLJF8dsj.mjs';
+export { renderSql } from './packem_shared/renderSql-D6eUcn2N.mjs';
+export { FUNCTION_METRICS_BUCKETS_TABLE, FUNCTION_METRICS_BUCKET_MS, FUNCTION_METRICS_BUCKET_RETENTION, FUNCTION_METRICS_INDEX_TABLE, FUNCTION_METRICS_TABLE, ensureFunctionMetricsTables, readFunctionMetricBuckets, readFunctionMetricIndexHits, readFunctionMetrics, readFunctionMetricsTotals, recordFunctionMetric } from './packem_shared/FUNCTION_METRICS_BUCKETS_TABLE-UDNVD7FS.mjs';
+export { ADMIN_FUNCTIONS, ADMIN_FUNCTION_PREFIX, FLAGS_FUNCTION_PREFIX, RELATION_FUNCTION_PREFIX, facetColumn, listTables, readTablePage, selectMatchingIds } from './packem_shared/ADMIN_FUNCTIONS-D_UiYJFk.mjs';
+export { LogBuffer } from './packem_shared/LogBuffer-B_Ezju_N.mjs';
+export { MAIL_RETENTION, MAIL_TABLE, clearCapturedMail, ensureMailTable, readCapturedMail, recordCapturedMail } from './packem_shared/MAIL_RETENTION-CPpgl-dX.mjs';
+export { default as NotFoundError } from './packem_shared/NotFoundError-CMuMZt81.mjs';
+export { armRestore, readBookmark } from './packem_shared/armRestore-BJk53Ro8.mjs';
+export { applySelect, buildSeekWhere, decodeCursor, encodeCursor, normalizeOrderKeys, softDeleteScope } from './packem_shared/applySelect-BvZdFUBT.mjs';
+export { RANK_TIEBREAK, encodePartitionKey, matchesRankStaticWhere, rankTableName, resolveRankPartition, sortColumnName } from './packem_shared/RANK_TIEBREAK-CXhdcA1o.mjs';
+export { ReactiveCache, reactiveCacheKey } from './packem_shared/ReactiveCache-1hDydFyv.mjs';
+export { serveRelationFanout } from './packem_shared/serveRelationFanout-C6lDaesn.mjs';
+export { DEFAULT_MAX_RELATION_KEYS, assertFlatPredicate, assertShapeShardable, containsRelationPredicate, isRelationPredicate, resolveRelationPredicates } from './packem_shared/DEFAULT_MAX_RELATION_KEYS-DU-Y4-LJ.mjs';
+export { applyOnDelete, fanOutScalarCounts, resolveWith, runRowValidators } from './packem_shared/applyOnDelete-BQ-8ZlZ1.mjs';
+export { RLS_UNWRAP_SYMBOL, RlsRequiredError, guardWriter } from './packem_shared/RLS_UNWRAP_SYMBOL-EtGQdC9d.mjs';
+export { buildFtsMatch, ftsTableName, scoreDocument, stringifySearchText, tokenizeSearch } from './packem_shared/buildFtsMatch-BLEMawrp.mjs';
+export { M as MIN_ADMIN_TOKEN_LENGTH, a as MIN_AUTH_SECRET_LENGTH, b as buildSecurityAudit } from './packem_shared/security-audit-CucgBice.mjs';
+export { SESSION_DO_TTL_DEFAULT, SessionDO } from './packem_shared/SESSION_DO_TTL_DEFAULT-ilPZsVwu.mjs';
+export { ROOT_DO_SIZE_WARN_BYTES, ROOT_SHARD_NAME, ShardDO } from './packem_shared/ROOT_DO_SIZE_WARN_BYTES-DKwBF3Jp.mjs';
+export { SHARD_REGISTRY_DO_NAME, ShardRegistryDO } from './packem_shared/SHARD_REGISTRY_DO_NAME-BsAbi5Mn.mjs';
+export { MAX_SQL_ROWS, assertReadonly, runReadonlySql } from './packem_shared/MAX_SQL_ROWS-dDcFE1YZ.mjs';
+export { createSystemReader } from './packem_shared/createSystemReader-8CzSZP9V.mjs';
+export { ConflictError } from './packem_shared/ConflictError-C0STs6bU.mjs';
+export { hasTrigger, runTriggers } from './packem_shared/hasTrigger-5N6_Fx0A.mjs';
+export { compileWhereSql } from './packem_shared/compileWhereSql-CXrhFA3G.mjs';
+export { CDC_LOG_TABLE, applyCdcChanges, readCdcChanges, trimCdcChanges } from './packem_shared/CDC_LOG_TABLE-DSycmnDf.mjs';
+export { backfillAggregateIndexes, backfillRankIndexes } from './packem_shared/backfillAggregateIndexes-BZsOqDXP.mjs';
+export { runShardMigrations } from './packem_shared/runShardMigrations-nIwoQeOK.mjs';
+export { stableStringify } from './packem_shared/stableStringify-CyHKJXre.mjs';
+export { subscriptionListDeltas } from './packem_shared/subscriptionListDeltas-ce84gpwL.mjs';

package/dist/packem_shared/ADMIN_FUNCTIONS-D_UiYJFk.mjs

@@ -0,0 +1,316 @@
+const ADMIN_FUNCTION_PREFIX = "__lunora_admin__:";
+const RELATION_FUNCTION_PREFIX = "__lunora_relation__:";
+const FLAGS_FUNCTION_PREFIX = "__lunora_flags__:";
+const ADMIN_FUNCTIONS = {
+  applyCdc: "__lunora_admin__:applyCdc",
+  cdcSync: "__lunora_admin__:cdcSync",
+  clearCapturedMail: "__lunora_admin__:clearCapturedMail",
+  clearTable: "__lunora_admin__:clearTable",
+  createWorkflowInstance: "__lunora_admin__:createWorkflowInstance",
+  deleteRows: "__lunora_admin__:deleteRows",
+  describeTable: "__lunora_admin__:describeTable",
+  describeTables: "__lunora_admin__:describeTables",
+  exportShard: "__lunora_admin__:exportShard",
+  facetColumn: "__lunora_admin__:facetColumn",
+  getAdvisories: "__lunora_admin__:getAdvisories",
+  getAuditLog: "__lunora_admin__:getAuditLog",
+  getAuthMetrics: "__lunora_admin__:getAuthMetrics",
+  getCapturedMail: "__lunora_admin__:getCapturedMail",
+  getFunctionStats: "__lunora_admin__:getFunctionStats",
+  listSubscriptions: "__lunora_admin__:listSubscriptions",
+  listTableIndexes: "__lunora_admin__:listTableIndexes",
+  getLogs: "__lunora_admin__:getLogs",
+  getMetrics: "__lunora_admin__:getMetrics",
+  getPitrBookmark: "__lunora_admin__:getPitrBookmark",
+  getRequestLog: "__lunora_admin__:getRequestLog",
+  getSecurityAudit: "__lunora_admin__:getSecurityAudit",
+  getSettings: "__lunora_admin__:getSettings",
+  // eslint-disable-next-line no-secrets/no-secrets -- reserved admin RPC path constant, not a credential
+  getWorkflowInstanceStatus: "__lunora_admin__:getWorkflowInstanceStatus",
+  importShard: "__lunora_admin__:importShard",
+  listFlags: "__lunora_admin__:listFlags",
+  listQueues: "__lunora_admin__:listQueues",
+  listTables: "__lunora_admin__:listTables",
+  listWorkflows: "__lunora_admin__:listWorkflows",
+  maskPolicies: "__lunora_admin__:maskPolicies",
+  migrationStatus: "__lunora_admin__:migrationStatus",
+  pitrRestore: "__lunora_admin__:pitrRestore",
+  rankBefore: "__lunora_admin__:rankBefore",
+  rankPage: "__lunora_admin__:rankPage",
+  readTablePage: "__lunora_admin__:readTablePage",
+  recordAuthEvent: "__lunora_admin__:recordAuthEvent",
+  recordContainerEvent: "__lunora_admin__:recordContainerEvent",
+  recordMail: "__lunora_admin__:recordMail",
+  rlsPolicies: "__lunora_admin__:rlsPolicies",
+  runAs: "__lunora_admin__:runAs",
+  runMigration: "__lunora_admin__:runMigration",
+  runSql: "__lunora_admin__:runSql",
+  sendTestMail: "__lunora_admin__:sendTestMail",
+  storageOrphans: "__lunora_admin__:storageOrphans",
+  storageReferences: "__lunora_admin__:storageReferences",
+  storageRules: "__lunora_admin__:storageRules",
+  studioFeatures: "__lunora_admin__:studioFeatures",
+  writeRow: "__lunora_admin__:writeRow"
+};
+const DEFAULT_PAGE_SIZE = 50;
+const MAX_PAGE_SIZE = 500;
+const DEFAULT_FACET_LIMIT = 30;
+const MAX_FACET_LIMIT = 200;
+const DOC_COLUMN = "__doc__";
+const safeParseObject = (text) => {
+  try {
+    const value = JSON.parse(text);
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+  } catch {
+    return void 0;
+  }
+};
+const expandDocumentRows = (columns, rows) => {
+  if (!columns.includes(DOC_COLUMN)) {
+    return { columns, rows };
+  }
+  const parsed = [];
+  for (const row of rows) {
+    const raw = row[DOC_COLUMN];
+    const documentData = typeof raw === "string" ? safeParseObject(raw) : void 0;
+    if (documentData === void 0) {
+      return { columns, rows };
+    }
+    const meta = Object.fromEntries(Object.entries(row).filter(([column]) => column !== DOC_COLUMN));
+    parsed.push({ ...meta, ...documentData });
+  }
+  const metaColumns = columns.filter((name) => name !== DOC_COLUMN);
+  const documentKeys = [];
+  const seen = new Set(metaColumns);
+  for (const documentData of parsed) {
+    for (const key of Object.keys(documentData)) {
+      if (!seen.has(key)) {
+        seen.add(key);
+        documentKeys.push(key);
+      }
+    }
+  }
+  return { columns: [...metaColumns, ...documentKeys], rows: parsed };
+};
+const escapeLike = (value) => value.replaceAll(/[\\%_]/g, (character) => `\\${character}`);
+const isInternalTable = (name) => name.startsWith("sqlite_") || name.startsWith("_cf_") || name.startsWith("__miniflare") || name.startsWith("__lunora") || name.includes("__fts_");
+const quoteIdentifier = (name) => `"${name.replaceAll('"', '""')}"`;
+const clamp = (value, min, max) => Math.min(Math.max(value, min), max);
+const countRows = (sql, quotedTable) => {
+  const row = sql.exec(`SELECT COUNT(*) AS c FROM ${quotedTable}`).one();
+  return Number(row.c);
+};
+const listTables = (sql) => {
+  const names = sql.exec("SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name").toArray();
+  const tables = [];
+  for (const { name } of names) {
+    if (isInternalTable(name)) {
+      continue;
+    }
+    tables.push({ name, rowCount: countRows(sql, quoteIdentifier(name)) });
+  }
+  return tables;
+};
+const tableExists = (sql, table) => sql.exec("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ? LIMIT 1", table).toArray().length > 0;
+const FILTER_SQL_OPERATOR = { eq: "=", gt: ">", gte: ">=", lt: "<", lte: "<=", ne: "<>" };
+const filterValueText = (value) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  return typeof value === "number" || typeof value === "boolean" ? String(value) : "";
+};
+const resolveColumnExpression = (column, physicalColumns) => {
+  const isPhysical = physicalColumns.includes(column);
+  const isDocumentStored = physicalColumns.includes(DOC_COLUMN);
+  if (!isPhysical && !isDocumentStored) {
+    return void 0;
+  }
+  return isPhysical ? { expression: quoteIdentifier(column), params: [] } : { expression: `json_extract(${quoteIdentifier(DOC_COLUMN)}, ?)`, params: [`$."${column.replaceAll('"', '""')}"`] };
+};
+const buildFilterClause = (clause, physicalColumns) => {
+  const resolved = resolveColumnExpression(clause.column, physicalColumns);
+  if (resolved === void 0) {
+    return void 0;
+  }
+  const { expression, params: pathParameters } = resolved;
+  if (clause.operator === "contains") {
+    return {
+      params: [...pathParameters, `%${escapeLike(filterValueText(clause.value))}%`],
+      sql: String.raw`CAST(${expression} AS TEXT) LIKE ? ESCAPE '\'`
+    };
+  }
+  return { params: [...pathParameters, clause.value], sql: `${expression} ${FILTER_SQL_OPERATOR[clause.operator]} ?` };
+};
+const buildTablePredicate = (columns, needle, filters) => {
+  const conjuncts = [];
+  const parameters = [];
+  if (needle !== "" && columns.length > 0) {
+    const pattern = `%${escapeLike(needle)}%`;
+    conjuncts.push(`(${columns.map((name) => String.raw`CAST(${quoteIdentifier(name)} AS TEXT) LIKE ? ESCAPE '\'`).join(" OR ")})`);
+    parameters.push(...columns.map(() => pattern));
+  }
+  for (const clause of filters ?? []) {
+    const built = buildFilterClause(clause, columns);
+    if (built !== void 0) {
+      conjuncts.push(`(${built.sql})`);
+      parameters.push(...built.params);
+    }
+  }
+  return conjuncts.length === 0 ? void 0 : { parameters, where: conjuncts.join(" AND ") };
+};
+const buildOrderBy = (orderBy, physicalColumns) => {
+  if (orderBy === void 0) {
+    return void 0;
+  }
+  const resolved = resolveColumnExpression(orderBy.column, physicalColumns);
+  if (resolved === void 0) {
+    return void 0;
+  }
+  const keyword = orderBy.direction === "desc" ? "DESC" : "ASC";
+  return { params: resolved.params, sql: `${resolved.expression} ${keyword}` };
+};
+const readTablePage = (sql, options) => {
+  const { table } = options;
+  if (isInternalTable(table) || !tableExists(sql, table)) {
+    throw Object.assign(new Error(`unknown table: ${table}`), { code: "UNKNOWN_TABLE", name: "LunoraError", status: 404 });
+  }
+  const limit = clamp(Math.trunc(options.limit ?? DEFAULT_PAGE_SIZE), 1, MAX_PAGE_SIZE);
+  const offset = Math.max(0, Math.trunc(options.offset ?? 0));
+  const quoted = quoteIdentifier(table);
+  const columns = sql.exec(`PRAGMA table_info(${quoted})`).toArray().map((column) => column.name);
+  const needle = options.search?.trim() ?? "";
+  const withReferences = (page) => {
+    if (options.refs === void 0) {
+      return page;
+    }
+    const references = {};
+    for (const column of page.columns) {
+      const target = options.refs[column];
+      if (target !== void 0) {
+        references[column] = target;
+      }
+    }
+    return Object.keys(references).length > 0 ? { ...page, refs: references } : page;
+  };
+  const predicate = buildTablePredicate(columns, needle, options.filters);
+  const order = buildOrderBy(options.orderBy, columns);
+  const whereSql = predicate === void 0 ? "" : ` WHERE ${predicate.where}`;
+  const orderSql = order === void 0 ? "" : ` ORDER BY ${order.sql}`;
+  const whereParams = predicate?.parameters ?? [];
+  const orderParams = order?.params ?? [];
+  const total = predicate === void 0 ? countRows(sql, quoted) : Number(sql.exec(`SELECT COUNT(*) AS c FROM ${quoted}${whereSql}`, ...whereParams).one().c);
+  const rawRows = sql.exec(`SELECT * FROM ${quoted}${whereSql}${orderSql} LIMIT ? OFFSET ?`, ...whereParams, ...orderParams, limit, offset).toArray();
+  return withReferences({ ...expandDocumentRows(columns, rawRows), total });
+};
+const selectMatchingIds = (sql, options) => {
+  const { table } = options;
+  if (isInternalTable(table) || !tableExists(sql, table)) {
+    throw Object.assign(new Error(`unknown table: ${table}`), { code: "UNKNOWN_TABLE", name: "LunoraError", status: 404 });
+  }
+  const limit = clamp(Math.trunc(options.limit ?? MAX_PAGE_SIZE), 1, MAX_PAGE_SIZE);
+  const quoted = quoteIdentifier(table);
+  const columns = sql.exec(`PRAGMA table_info(${quoted})`).toArray().map((column) => column.name);
+  const needle = options.search?.trim() ?? "";
+  const predicate = buildTablePredicate(columns, needle, options.filters);
+  const fetched = predicate === void 0 ? sql.exec(`SELECT id FROM ${quoted} LIMIT ?`, limit + 1).toArray() : sql.exec(`SELECT id FROM ${quoted} WHERE ${predicate.where} LIMIT ?`, ...predicate.parameters, limit + 1).toArray();
+  const hasMore = fetched.length > limit;
+  const ids = (hasMore ? fetched.slice(0, limit) : fetched).map((row) => row.id);
+  return { hasMore, ids };
+};
+const knownDisplayColumns = (sql, quotedTable, physicalColumns) => {
+  const known = new Set(physicalColumns.filter((name) => name !== DOC_COLUMN));
+  if (!physicalColumns.includes(DOC_COLUMN)) {
+    return known;
+  }
+  const sample = sql.exec(`SELECT ${quoteIdentifier(DOC_COLUMN)} AS doc FROM ${quotedTable} LIMIT ?`, MAX_PAGE_SIZE).toArray();
+  for (const { doc } of sample) {
+    const documentData = typeof doc === "string" ? safeParseObject(doc) : void 0;
+    if (documentData !== void 0) {
+      for (const key of Object.keys(documentData)) {
+        known.add(key);
+      }
+    }
+  }
+  return known;
+};
+const facetColumn = (sql, options) => {
+  const { column, table } = options;
+  if (isInternalTable(table) || !tableExists(sql, table)) {
+    throw Object.assign(new Error(`unknown table: ${table}`), { code: "UNKNOWN_TABLE", name: "LunoraError", status: 404 });
+  }
+  const quoted = quoteIdentifier(table);
+  const physicalColumns = sql.exec(`PRAGMA table_info(${quoted})`).toArray().map((info) => info.name);
+  if (!knownDisplayColumns(sql, quoted, physicalColumns).has(column)) {
+    throw Object.assign(new Error(`unknown column: ${column}`), { code: "UNKNOWN_COLUMN", name: "LunoraError", status: 404 });
+  }
+  const resolved = resolveColumnExpression(column, physicalColumns);
+  if (resolved === void 0) {
+    throw Object.assign(new Error(`unknown column: ${column}`), { code: "UNKNOWN_COLUMN", name: "LunoraError", status: 404 });
+  }
+  const limit = clamp(Math.trunc(options.limit ?? DEFAULT_FACET_LIMIT), 1, MAX_FACET_LIMIT);
+  const needle = options.search?.trim() ?? "";
+  const predicate = buildTablePredicate(physicalColumns, needle, options.filters);
+  const whereSql = predicate === void 0 ? "" : ` WHERE ${predicate.where}`;
+  const whereParams = predicate?.parameters ?? [];
+  const rows = sql.exec(
+    `SELECT ${resolved.expression} AS value, COUNT(*) AS count FROM ${quoted}${whereSql} GROUP BY ${resolved.expression} ORDER BY count DESC LIMIT ?`,
+    ...resolved.params,
+    ...whereParams,
+    ...resolved.params,
+    limit + 1
+  ).toArray();
+  const truncated = rows.length > limit;
+  const kept = truncated ? rows.slice(0, limit) : rows;
+  return {
+    truncated,
+    values: kept.map((row) => {
+      return { count: Number(row.count), value: row.value };
+    })
+  };
+};
+const findStorageReferences = (sql, storageColumns, keys) => {
+  const references = {};
+  const scanned = keys.slice(0, MAX_PAGE_SIZE);
+  for (const key of scanned) {
+    references[key] = [];
+  }
+  if (scanned.length === 0) {
+    return { references, storageColumns };
+  }
+  const placeholders = scanned.map(() => "?").join(", ");
+  for (const [table, columns] of Object.entries(storageColumns)) {
+    if (isInternalTable(table) || !tableExists(sql, table)) {
+      continue;
+    }
+    const quoted = quoteIdentifier(table);
+    const physicalColumns = sql.exec(`PRAGMA table_info(${quoted})`).toArray().map((column) => column.name);
+    for (const column of columns) {
+      const resolved = resolveColumnExpression(column, physicalColumns);
+      if (resolved === void 0) {
+        continue;
+      }
+      const rows = sql.exec(
+        `SELECT id, ${resolved.expression} AS ref FROM ${quoted} WHERE ${resolved.expression} IN (${placeholders})`,
+        ...resolved.params,
+        ...resolved.params,
+        ...scanned
+      ).toArray();
+      for (const row of rows) {
+        references[row.ref]?.push({ column, id: row.id, table });
+      }
+    }
+  }
+  return { references, storageColumns };
+};
+const summarizeSubscriptions = (attachments) => {
+  const connections = attachments.map((attachment, id) => {
+    const subscriptions = Object.values(attachment.subs ?? {}).map((sub) => {
+      return { args: sub.args, functionPath: sub.functionPath, table: sub.table };
+    });
+    return { admin: attachment.admin === true, id, subscriptions };
+  });
+  const totalSubscriptions = connections.reduce((sum, connection) => sum + connection.subscriptions.length, 0);
+  return { connections, totalConnections: connections.length, totalSubscriptions };
+};
+
+export { ADMIN_FUNCTIONS, ADMIN_FUNCTION_PREFIX, FLAGS_FUNCTION_PREFIX, MAX_PAGE_SIZE, RELATION_FUNCTION_PREFIX, facetColumn, findStorageReferences, listTables, readTablePage, selectMatchingIds, summarizeSubscriptions };

package/dist/packem_shared/AGGREGATE_SQL_FUNCTION-CFk6adSu.mjs

@@ -0,0 +1,54 @@
+const COUNT_OPTION_KEYS = /* @__PURE__ */ new Set(["baseWhere", "relationBaseWhere", "restrictsCounts", "where"]);
+const matchesStaticWhere = (document, predicate) => {
+  for (const [field, expected] of Object.entries(predicate)) {
+    const actual = document[field];
+    if (expected !== null && typeof expected === "object" && !Array.isArray(expected)) {
+      const operatorKeys = Object.keys(expected);
+      if (operatorKeys.length === 1 && operatorKeys[0] === "eq") {
+        if (actual !== expected.eq) {
+          return false;
+        }
+        continue;
+      }
+      return false;
+    }
+    if (actual !== expected) {
+      return false;
+    }
+  }
+  return true;
+};
+const normalizeCountArgument = (argument) => {
+  if (argument === void 0) {
+    return {};
+  }
+  if (typeof argument !== "object" || Array.isArray(argument)) {
+    return { where: argument };
+  }
+  const keys = Object.keys(argument);
+  if (keys.length === 0) {
+    return {};
+  }
+  if (keys.every((key) => COUNT_OPTION_KEYS.has(key))) {
+    return argument;
+  }
+  return { where: argument };
+};
+const AGGREGATE_SQL_FUNCTION = { avg: "AVG", count: "COUNT", max: "MAX", min: "MIN", sum: "SUM" };
+const aggregateSqlFunction = (op) => {
+  const sqlFunction = AGGREGATE_SQL_FUNCTION[op];
+  if (sqlFunction === void 0) {
+    throw new Error(`unknown aggregate op "${op}": expected one of ${Object.keys(AGGREGATE_SQL_FUNCTION).join(", ")}`);
+  }
+  return sqlFunction;
+};
+const throwingScheduler = {
+  runAfter: () => {
+    throw new Error("ctx.scheduler: no scheduler configured for triggers. Pass `scheduler` to the ctx-db factory.");
+  },
+  runAt: () => {
+    throw new Error("ctx.scheduler: no scheduler configured for triggers. Pass `scheduler` to the ctx-db factory.");
+  }
+};
+
+export { AGGREGATE_SQL_FUNCTION, aggregateSqlFunction, matchesStaticWhere, normalizeCountArgument, throwingScheduler };

package/dist/packem_shared/AUTH_METRICS_BUCKETS_TABLE-CiHHYeJi.mjs

@@ -0,0 +1,84 @@
+const AUTH_METRICS_TABLE = "__lunora_auth_metrics";
+const AUTH_METRICS_BUCKETS_TABLE = "__lunora_auth_metrics_buckets";
+const AUTH_METRICS_ROW_KEY = "app";
+const AUTH_METRICS_BUCKET_MS = 6e4;
+const AUTH_METRICS_BUCKET_RETENTION = 1440;
+const runSql = (sql, query, ...params) => {
+  const runner = sql.exec;
+  return runner.call(sql, query, ...params);
+};
+const bucketFloor = (ts) => Math.floor(ts / AUTH_METRICS_BUCKET_MS) * AUTH_METRICS_BUCKET_MS;
+const ensureAuthMetricsTables = (sql) => {
+  runSql(
+    sql,
+    `CREATE TABLE IF NOT EXISTS "${AUTH_METRICS_TABLE}" (
+            key TEXT PRIMARY KEY,
+            attempts INTEGER NOT NULL DEFAULT 0,
+            failures INTEGER NOT NULL DEFAULT 0,
+            since_ms INTEGER NOT NULL DEFAULT 0
+        )`
+  );
+  runSql(
+    sql,
+    `CREATE TABLE IF NOT EXISTS "${AUTH_METRICS_BUCKETS_TABLE}" (
+            bucket_ms INTEGER PRIMARY KEY,
+            attempts INTEGER NOT NULL DEFAULT 0,
+            failures INTEGER NOT NULL DEFAULT 0
+        )`
+  );
+};
+const recordAuthEvent = (sql, input) => {
+  ensureAuthMetricsTables(sql);
+  const failureCount = input.outcome === "fail" ? 1 : 0;
+  runSql(
+    sql,
+    `INSERT INTO "${AUTH_METRICS_TABLE}" (key, attempts, failures, since_ms)
+         VALUES (?, 1, ?, ?)
+         ON CONFLICT(key) DO UPDATE SET
+            attempts = attempts + 1,
+            failures = failures + excluded.failures,
+            since_ms = CASE WHEN since_ms = 0 THEN excluded.since_ms ELSE since_ms END`,
+    AUTH_METRICS_ROW_KEY,
+    failureCount,
+    input.ts
+  );
+  const bucket = bucketFloor(input.ts);
+  runSql(
+    sql,
+    `INSERT INTO "${AUTH_METRICS_BUCKETS_TABLE}" (bucket_ms, attempts, failures)
+         VALUES (?, 1, ?)
+         ON CONFLICT(bucket_ms) DO UPDATE SET
+            attempts = attempts + 1,
+            failures = failures + excluded.failures`,
+    bucket,
+    failureCount
+  );
+  runSql(
+    sql,
+    `DELETE FROM "${AUTH_METRICS_BUCKETS_TABLE}"
+         WHERE bucket_ms <= (
+            SELECT MAX(bucket_ms) - ? FROM "${AUTH_METRICS_BUCKETS_TABLE}"
+         )`,
+    AUTH_METRICS_BUCKET_RETENTION * AUTH_METRICS_BUCKET_MS
+  );
+};
+const readAuthMetrics = (sql) => {
+  ensureAuthMetricsTables(sql);
+  const row = runSql(
+    sql,
+    `SELECT attempts, failures, since_ms FROM "${AUTH_METRICS_TABLE}" WHERE key = ?`,
+    AUTH_METRICS_ROW_KEY
+  ).toArray()[0];
+  const attempts = row?.attempts ?? 0;
+  const failures = row?.failures ?? 0;
+  const sinceMs = row?.since_ms ?? 0;
+  const history = runSql(
+    sql,
+    `SELECT bucket_ms, attempts, failures FROM "${AUTH_METRICS_BUCKETS_TABLE}" ORDER BY bucket_ms ASC`
+  ).toArray().map((bucket) => {
+    return { attempts: bucket.attempts, bucketMs: bucket.bucket_ms, failures: bucket.failures };
+  });
+  return { attempts, failureRate: attempts === 0 ? 0 : failures / attempts, failures, history, sinceMs };
+};
+
+export { AUTH_METRICS_BUCKETS_TABLE, AUTH_METRICS_BUCKET_MS, AUTH_METRICS_BUCKET_RETENTION, AUTH_METRICS_ROW_KEY, AUTH_METRICS_TABLE, ensureAuthMetricsTables, readAuthMetrics, recordAuthEvent };

package/dist/packem_shared/CDC_LOG_TABLE-DSycmnDf.mjs

@@ -0,0 +1,107 @@
+import { sql } from 'drizzle-orm';
+import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
+import { ConflictError } from './ConflictError-C0STs6bU.mjs';
+
+const CDC_LOG_TABLE = "__cdc_log";
+const migrateCdcLog = (sql$1) => {
+  runDrizzle(
+    sql$1,
+    sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(CDC_LOG_TABLE)} (
+            seq INTEGER PRIMARY KEY AUTOINCREMENT,
+            ts REAL NOT NULL,
+            ${sql.identifier("table")} TEXT NOT NULL,
+            id TEXT NOT NULL,
+            op TEXT NOT NULL,
+            doc TEXT
+        )`
+  );
+};
+const appendCdcChange = (sql$1, ts, table, id, op, doc) => {
+  const docValue = doc === void 0 ? null : JSON.stringify(doc);
+  runDrizzle(
+    sql$1,
+    sql`INSERT INTO ${sql.identifier(CDC_LOG_TABLE)} (ts, ${sql.identifier("table")}, id, op, doc) VALUES (${ts}, ${table}, ${id}, ${op}, ${docValue})`
+  );
+};
+const readCdcChanges = (sql$1, options = {}) => {
+  const sinceSeq = options.sinceSeq ?? 0;
+  const limit = Math.max(1, Math.min(options.limit ?? 1e3, 1e4));
+  const tableFilter = options.tables && options.tables.size > 0 ? sql` AND ${sql.identifier("table")} IN (${sql.join(
+    [...options.tables].map((table) => sql`${table}`),
+    sql`, `
+  )})` : sql``;
+  const rows = runDrizzle(
+    sql$1,
+    sql`SELECT seq, ts, ${sql.identifier("table")}, id, op, doc FROM ${sql.identifier(CDC_LOG_TABLE)} WHERE seq > ${sinceSeq}${tableFilter} ORDER BY seq ASC LIMIT ${limit}`
+  ).toArray();
+  const changes = rows.map((row) => {
+    const base = { id: row.id, op: row.op, seq: row.seq, table: row.table, ts: row.ts };
+    return row.doc === null ? base : { ...base, doc: JSON.parse(row.doc) };
+  });
+  return { changes, cursor: changes.at(-1)?.seq ?? sinceSeq };
+};
+const trimCdcChanges = (sql$1, throughSeq) => {
+  runDrizzle(sql$1, sql`DELETE FROM ${sql.identifier(CDC_LOG_TABLE)} WHERE seq <= ${throughSeq}`);
+};
+const readCdcCursor = (sql$1) => {
+  const seqRow = runDrizzle(sql$1, sql`SELECT seq FROM sqlite_sequence WHERE name = ${CDC_LOG_TABLE}`).toArray();
+  const fromSequence = seqRow[0]?.seq;
+  if (typeof fromSequence === "number") {
+    return fromSequence;
+  }
+  const rows = runDrizzle(sql$1, sql`SELECT MAX(seq) AS seq FROM ${sql.identifier(CDC_LOG_TABLE)}`).toArray();
+  return rows[0]?.seq ?? 0;
+};
+const minCdcSeq = (sql$1) => {
+  const rows = runDrizzle(sql$1, sql`SELECT MIN(seq) AS seq FROM ${sql.identifier(CDC_LOG_TABLE)}`).toArray();
+  return rows[0]?.seq ?? void 0;
+};
+const CDC_META_TABLE = "__cdc_meta";
+const migrateCdcMeta = (sql$1) => {
+  runDrizzle(sql$1, sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(CDC_META_TABLE)} (id INTEGER PRIMARY KEY CHECK (id = 1), epoch TEXT NOT NULL)`);
+};
+const readCdcEpoch = (sql$1) => {
+  migrateCdcMeta(sql$1);
+  const rows = runDrizzle(sql$1, sql`SELECT epoch FROM ${sql.identifier(CDC_META_TABLE)} WHERE id = 1`).toArray();
+  const existing = rows[0]?.epoch;
+  if (typeof existing === "string" && existing.length > 0) {
+    return existing;
+  }
+  const minted = crypto.randomUUID();
+  runDrizzle(sql$1, sql`INSERT INTO ${sql.identifier(CDC_META_TABLE)} (id, epoch) VALUES (1, ${minted})`);
+  return minted;
+};
+const bumpCdcEpoch = (sql$1) => {
+  migrateCdcMeta(sql$1);
+  const next = crypto.randomUUID();
+  runDrizzle(sql$1, sql`INSERT INTO ${sql.identifier(CDC_META_TABLE)} (id, epoch) VALUES (1, ${next}) ON CONFLICT(id) DO UPDATE SET epoch = excluded.epoch`);
+  return next;
+};
+const applyCdcChange = async (writer, change) => {
+  if (change.op === "delete") {
+    await writer.delete(change.id);
+    return;
+  }
+  const document = change.doc ?? {};
+  try {
+    await writer.insert(change.table, document, { allowExplicitId: true });
+  } catch (error) {
+    if (!(error instanceof ConflictError)) {
+      throw error;
+    }
+    const fields = {};
+    for (const [key, value] of Object.entries(document)) {
+      if (key !== "_id") {
+        fields[key] = value;
+      }
+    }
+    await writer.replace(change.id, fields);
+  }
+};
+const applyCdcChanges = async (writer, changes) => {
+  for (const change of changes) {
+    await applyCdcChange(writer, change);
+  }
+};
+
+export { CDC_LOG_TABLE, CDC_META_TABLE, appendCdcChange, applyCdcChanges, bumpCdcEpoch, migrateCdcLog, migrateCdcMeta, minCdcSeq, readCdcChanges, readCdcCursor, readCdcEpoch, trimCdcChanges };

package/dist/packem_shared/ConflictError-C0STs6bU.mjs

@@ -0,0 +1,13 @@
+class ConflictError extends Error {
+  code = "CONFLICT";
+  /** Why the conflict fired; `occ` is the contention signal the metrics layer counts. */
+  kind;
+  status = 409;
+  constructor(message = "Optimistic concurrency conflict", kind = "conflict") {
+    super(message);
+    this.name = "ConflictError";
+    this.kind = kind;
+  }
+}
+
+export { ConflictError };