@lunora/do 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/applyOnDelete-BQ-8ZlZ1.mjs

@@ -0,0 +1,175 @@
+import { applySelect } from './applySelect-BvZdFUBT.mjs';
+
+const projectChildren = (documents, nested) => nested.select ? applySelect(documents, nested.select, nested.with) : documents;
+const fanOutScalarCounts = async (counter, tableName, whereField, values, policyWhere) => {
+  const pairs = await Promise.all(
+    values.map(async (value) => {
+      const countWhere = policyWhere ? { AND: [{ [whereField]: value }, policyWhere] } : { [whereField]: value };
+      return [value, await counter(tableName, countWhere)];
+    })
+  );
+  return new Map(pairs);
+};
+const distinctValues = (rows, field) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    const value = row[field];
+    if (value !== null && value !== void 0) {
+      seen.add(value);
+    }
+  }
+  return [...seen];
+};
+const resolveWith = async (options) => {
+  const { groupedCounter, fetcher, parents, relationBaseWhere, schema, tableName, with: withInput } = options;
+  if (parents.length === 0) {
+    return;
+  }
+  const parentDefinition = schema.tables[tableName];
+  if (!parentDefinition) {
+    throw new Error(`unknown table: ${tableName}`);
+  }
+  const relationMap = parentDefinition.relationMap ?? {};
+  const requireRelation = (name) => {
+    const relation = relationMap[name];
+    if (!relation) {
+      throw new Error(`unknown relation "${name}" on table "${tableName}"`);
+    }
+    return relation;
+  };
+  const loadOne = async (name, relation, nested) => {
+    const fkValues = distinctValues(parents, relation.field);
+    if (fkValues.length === 0) {
+      for (const parent of parents) {
+        parent[name] = null;
+      }
+      return;
+    }
+    const { page } = await fetcher(relation.table, {
+      baseWhere: relationBaseWhere?.(relation.table),
+      relationBaseWhere,
+      where: { [relation.references]: { in: fkValues } },
+      with: nested.with
+    });
+    const byReference = /* @__PURE__ */ new Map();
+    for (const child of page) {
+      byReference.set(child[relation.references], child);
+    }
+    for (const parent of parents) {
+      const child = byReference.get(parent[relation.field]);
+      parent[name] = child ? projectChildren([child], nested)[0] ?? null : null;
+    }
+  };
+  const loadMany = async (name, relation, nested) => {
+    const referenceValues = distinctValues(parents, relation.references);
+    if (referenceValues.length === 0) {
+      for (const parent of parents) {
+        parent[name] = [];
+      }
+      return;
+    }
+    const fkFilter = { [relation.field]: { in: referenceValues } };
+    const where = nested.where ? { AND: [nested.where, fkFilter] } : fkFilter;
+    const { page } = await fetcher(relation.table, {
+      baseWhere: relationBaseWhere?.(relation.table),
+      orderBy: nested.orderBy,
+      relationBaseWhere,
+      where,
+      with: nested.with
+    });
+    const groups = /* @__PURE__ */ new Map();
+    for (const child of page) {
+      const key = child[relation.field];
+      const group = groups.get(key);
+      if (group) {
+        group.push(child);
+      } else {
+        groups.set(key, [child]);
+      }
+    }
+    const cap = typeof nested.limit === "number" ? Math.max(0, Math.floor(nested.limit)) : void 0;
+    for (const parent of parents) {
+      const group = groups.get(parent[relation.references]) ?? [];
+      parent[name] = projectChildren(cap === void 0 ? group : group.slice(0, cap), nested);
+    }
+  };
+  const resolveCounts = async (countInput) => {
+    for (const name of Object.keys(countInput)) {
+      const relation = requireRelation(name);
+      const [whereField, parentField] = relation.kind === "many" ? [relation.field, relation.references] : [relation.references, relation.field];
+      const policyWhere = relationBaseWhere?.(relation.table);
+      const values = distinctValues(parents, parentField);
+      const countByValue = values.length === 0 ? /* @__PURE__ */ new Map() : await groupedCounter(relation.table, whereField, values, policyWhere);
+      for (const parent of parents) {
+        const counts = parent["_count"] ?? {};
+        const parentValue = parent[parentField];
+        counts[name] = parentValue === null || parentValue === void 0 ? 0 : countByValue.get(parentValue) ?? 0;
+        parent["_count"] = counts;
+      }
+    }
+  };
+  for (const [name, value] of Object.entries(withInput)) {
+    if (value === void 0 || value === false) {
+      continue;
+    }
+    if (name === "_count") {
+      await resolveCounts(value);
+      continue;
+    }
+    const relation = requireRelation(name);
+    const nested = value === true ? {} : value;
+    await (relation.kind === "one" ? loadOne(name, relation, nested) : loadMany(name, relation, nested));
+  }
+};
+const applyRelationOnDelete = async (options, holderTable, relation) => {
+  const { deletedId, deletedReference, findHolders, onCascade, onRestrict, onSetNull, tableName } = options;
+  const referencedValue = relation.references === "_id" ? deletedId : deletedReference(relation.references);
+  if (referencedValue === null || referencedValue === void 0) {
+    return;
+  }
+  const holders = await findHolders(holderTable, relation.field, referencedValue);
+  if (holders.length === 0) {
+    return;
+  }
+  if (relation.onDelete === "restrict") {
+    onRestrict(`cannot delete "${tableName}" row: "${holderTable}.${relation.field}" still references it`);
+  }
+  for (const holder of holders) {
+    const holderId = holder["_id"];
+    if (typeof holderId !== "string") {
+      continue;
+    }
+    await (relation.onDelete === "cascade" ? onCascade(holderTable, holderId) : onSetNull(holderTable, holderId, relation.field));
+  }
+};
+const applyOnDelete = async (options) => {
+  const { schema, tableName } = options;
+  if (!schema.tables[tableName]) {
+    throw new Error(`unknown table: ${tableName}`);
+  }
+  for (const [holderTable, holderDefinition] of Object.entries(schema.tables)) {
+    const relations = holderDefinition.relationMap;
+    if (!relations) {
+      continue;
+    }
+    for (const relation of Object.values(relations)) {
+      if (relation.kind !== "one" || relation.table !== tableName || !relation.onDelete) {
+        continue;
+      }
+      await applyRelationOnDelete(options, holderTable, relation);
+    }
+  }
+};
+const runRowValidators = (definition, document) => {
+  for (const [field, validator] of Object.entries(definition.shape)) {
+    if (!(field in document)) {
+      continue;
+    }
+    if (typeof validator.parse !== "function") {
+      continue;
+    }
+    validator.parse(document[field]);
+  }
+};
+
+export { applyOnDelete, distinctValues, fanOutScalarCounts, resolveWith, runRowValidators };

package/dist/packem_shared/applySelect-BvZdFUBT.mjs

@@ -0,0 +1,101 @@
+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 };
+};
+const SELECT_SYSTEM_FIELDS = ["_id", "_creationTime"];
+const applySelect = (page, select, withInput) => {
+  if (!select) {
+    return page;
+  }
+  const keep = /* @__PURE__ */ new Set([...select, ...SELECT_SYSTEM_FIELDS, ...withInput ? Object.keys(withInput) : []]);
+  return page.map((document) => {
+    const projected = {};
+    for (const key of keep) {
+      if (key in document) {
+        projected[key] = document[key];
+      }
+    }
+    return projected;
+  });
+};
+const softDeleteScope = (softDeleteMode, includeDeleted) => softDeleteMode && includeDeleted !== true ? { [softDeleteMode.field]: { isNull: true } } : void 0;
+
+export { applySelect, buildSeekBeforeWhere, buildSeekWhere, decodeCursor, encodeCursor, normalizeOrderKeys, softDeleteScope };

package/dist/packem_shared/armRestore-BJk53Ro8.mjs

@@ -0,0 +1,55 @@
+const pitrUnavailable = () => Object.assign(
+  new Error("native PITR is unavailable here (local dev or a non-SQLite Durable Object); use `lunora backup restore` for off-platform recovery"),
+  {
+    code: "PITR_UNAVAILABLE",
+    name: "LunoraError",
+    status: 409
+  }
+);
+const toTime = (time) => {
+  if (typeof time === "number") {
+    return time;
+  }
+  const parsed = Date.parse(time);
+  if (Number.isNaN(parsed)) {
+    throw Object.assign(new Error(`pitr: invalid time "${time}" — expected epoch-ms or an ISO timestamp`), {
+      code: "BAD_REQUEST",
+      name: "LunoraError",
+      status: 400
+    });
+  }
+  return parsed;
+};
+const readBookmark = async (storage, time) => {
+  if (!storage.getCurrentBookmark) {
+    throw pitrUnavailable();
+  }
+  const current = await storage.getCurrentBookmark();
+  if (time === void 0 || !storage.getBookmarkForTime) {
+    return { current };
+  }
+  return { current, forTime: await storage.getBookmarkForTime(toTime(time)) };
+};
+const armRestore = async (storage, args) => {
+  if (!storage.onNextSessionRestoreBookmark) {
+    throw pitrUnavailable();
+  }
+  let target = args.bookmark;
+  if (target === void 0) {
+    if (args.time === void 0) {
+      throw Object.assign(new Error("pitrRestore: provide a `bookmark` or a `time` to restore to"), {
+        code: "BAD_REQUEST",
+        name: "LunoraError",
+        status: 400
+      });
+    }
+    if (!storage.getBookmarkForTime) {
+      throw pitrUnavailable();
+    }
+    target = await storage.getBookmarkForTime(toTime(args.time));
+  }
+  const undoBookmark = await storage.onNextSessionRestoreBookmark(target);
+  return { restoredTo: target, undoBookmark };
+};
+
+export { armRestore, readBookmark };

package/dist/packem_shared/backfillAggregateIndexes-BZsOqDXP.mjs

@@ -0,0 +1,81 @@
+import { sql } from 'drizzle-orm';
+import { matchesStaticWhere } from './AGGREGATE_SQL_FUNCTION-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 { sortColumnName, matchesRankStaticWhere, encodePartitionKey, rankTableName } from './RANK_TIEBREAK-CXhdcA1o.mjs';
+import { s as serializeSqlValue } from './serialize-sql-BlRUoiQe.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/buildFtsMatch-BLEMawrp.mjs

@@ -0,0 +1,38 @@
+const ftsTableName = (table, indexName) => `${table}__fts_${indexName}`;
+const tokenizeSearch = (query) => query.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
+const buildFtsMatch = (tokens) => tokens.map((token, index) => index === tokens.length - 1 ? `"${token}"*` : `"${token}"`).join(" AND ");
+const stringifySearchText = (value) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
+    return String(value);
+  }
+  return JSON.stringify(value) ?? "";
+};
+const scoreDocument = (text, tokens) => {
+  const documentTokens = tokenizeSearch(text);
+  if (documentTokens.length === 0) {
+    return 0;
+  }
+  let score = 0;
+  for (const [index, token] of tokens.entries()) {
+    const isLast = index === tokens.length - 1;
+    let occurrences = 0;
+    for (const documentToken of documentTokens) {
+      if (isLast ? documentToken.startsWith(token) : documentToken === token) {
+        occurrences += 1;
+      }
+    }
+    if (occurrences === 0) {
+      return 0;
+    }
+    score += occurrences;
+  }
+  return score;
+};
+
+export { buildFtsMatch, ftsTableName, scoreDocument, stringifySearchText, tokenizeSearch };

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 };