@lunora/do 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/index.mjs

@@ -1,35 +1,40 @@
 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/matchesStaticWhere-CFk6adSu.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_BUCKET_MS-CiHHYeJi.mjs';
-export { NotUniqueError, assertValidClientId, createShardCtxDb, normalizeIdStructurally } from './packem_shared/assertValidClientId-CBZ1zC96.mjs';
-export { DATA_MIGRATION_STATE_TABLE, readMigrationStatus, runDataMigration } from './packem_shared/DATA_MIGRATION_STATE_TABLE-PTtTiQ7U.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-Do5h_jiW.mjs';
+export { DATA_MIGRATION_STATE_TABLE, readMigrationStatus, runDataMigration } from './packem_shared/DATA_MIGRATION_STATE_TABLE-DfPxn8I0.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/ensureFunctionMetricsTables-UDNVD7FS.mjs';
-export { ADMIN_FUNCTIONS, ADMIN_FUNCTION_PREFIX, RELATION_FUNCTION_PREFIX, facetColumn, listTables, readTablePage, selectMatchingIds } from './packem_shared/ADMIN_FUNCTION_PREFIX-Dzdqq5J2.mjs';
+export { diffExternalSource } from './packem_shared/diffExternalSource-Cx9HUPJj.mjs';
+export { materializeExternalRows, readExternalSourceBaseline, runExternalSourceTick } from './packem_shared/materializeExternalRows-Bj6EXy50.mjs';
+export { isSourceDue, liftSourceId, pullExternalSourceTick } from './packem_shared/isSourceDue-9mJRJ9Ld.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-DSUQ5fX9.mjs';
 export { LogBuffer } from './packem_shared/LogBuffer-B_Ezju_N.mjs';
-export { MAIL_RETENTION, MAIL_TABLE, clearCapturedMail, ensureMailTable, readCapturedMail, recordCapturedMail } from './packem_shared/clearCapturedMail-CPpgl-dX.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 { buildSeekWhere, decodeCursor, encodeCursor, normalizeOrderKeys } from './packem_shared/buildSeekWhere-lVsNXSLy.mjs';
-export { R as RANK_TIEBREAK, e as encodePartitionKey, m as matchesRankStaticWhere, r as rankTableName, a as resolveRankPartition, s as sortColumnName } from './packem_shared/rank-CrkEIpF4.mjs';
-export { ReactiveCache, reactiveCacheKey, stableStringify } from './packem_shared/ReactiveCache-ByVzgH3d.mjs';
-export { serveRelationFanout } from './packem_shared/serveRelationFanout-Clr1a05L.mjs';
-export { DEFAULT_MAX_RELATION_KEYS, assertFlatPredicate, containsRelationPredicate, isRelationPredicate, resolveRelationPredicates } from './packem_shared/assertFlatPredicate-DyVYReuT.mjs';
-export { applyOnDelete, resolveWith, runRowValidators } from './packem_shared/applyOnDelete-CMif2RKw.mjs';
-export { RLS_UNWRAP_SYMBOL, RlsRequiredError, guardWriter } from './packem_shared/guardWriter-u3UlnCH5.mjs';
-export { buildFtsMatch, ftsTableName, scoreDocument, stringifySearchText, tokenizeSearch } from './packem_shared/ftsTableName-BLEMawrp.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-BYlSGY0N.mjs';
+export { serveRelationFanout } from './packem_shared/serveRelationFanout-C5axmGDj.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, subscriptionListDeltas } from './packem_shared/ROOT_DO_SIZE_WARN_BYTES-DQkmGiCS.mjs';
+export { ROOT_DO_SIZE_WARN_BYTES, ROOT_SHARD_NAME, ShardDO } from './packem_shared/ROOT_DO_SIZE_WARN_BYTES-BfPNp3Jh.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/assertReadonly-dDcFE1YZ.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/runTriggers-5N6_Fx0A.mjs';
-export { compileWhereSql } from './packem_shared/compileWhereSql-CXrhFA3G.mjs';
-export { CDC_LOG_TABLE, applyCdcChanges, readCdcChanges, trimCdcChanges } from './packem_shared/applyCdcChanges-Ctdmxmrv.mjs';
-export { backfillAggregateIndexes, backfillRankIndexes } from './packem_shared/backfillAggregateIndexes-BF5eL7kW.mjs';
-export { runShardMigrations } from './packem_shared/runShardMigrations-C3bn5r93.mjs';
+export { hasTrigger, runTriggers } from './packem_shared/hasTrigger-5N6_Fx0A.mjs';
+export { compileWhereSql } from './packem_shared/compileWhereSql-MW_Lk8nJ.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-MydiuScU.mjs';
+export { s as subscriptionListDeltas } from './packem_shared/subscription-delivery-CK8qga-k.mjs';

package/dist/packem_shared/{ADMIN_FUNCTION_PREFIX-Dzdqq5J2.mjs → ADMIN_FUNCTIONS-DSUQ5fX9.mjs}

@@ -1,5 +1,8 @@
+const quoteIdentifier = (name) => `"${name.replaceAll('"', '""')}"`;
+
 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",
@@ -15,6 +18,7 @@ const ADMIN_FUNCTIONS = {
   getAuditLog: "__lunora_admin__:getAuditLog",
   getAuthMetrics: "__lunora_admin__:getAuthMetrics",
   getCapturedMail: "__lunora_admin__:getCapturedMail",
+  getFanoutMetrics: "__lunora_admin__:getFanoutMetrics",
   getFunctionStats: "__lunora_admin__:getFunctionStats",
   listSubscriptions: "__lunora_admin__:listSubscriptions",
   listTableIndexes: "__lunora_admin__:listTableIndexes",
@@ -27,6 +31,8 @@ const ADMIN_FUNCTIONS = {
   // 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",
@@ -91,7 +97,6 @@ const expandDocumentRows = (columns, rows) => {
 };
 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();
@@ -195,7 +200,10 @@ const readTablePage = (sql, options) => {
   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);
+  let total;
+  if (!options.skipCount) {
+    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 });
 };
@@ -309,5 +317,43 @@ const summarizeSubscriptions = (attachments) => {
   const totalSubscriptions = connections.reduce((sum, connection) => sum + connection.subscriptions.length, 0);
   return { connections, totalConnections: connections.length, totalSubscriptions };
 };
+const DEFAULT_FANOUT_TOPIC_LIMIT = 20;
+const createFanoutCounters = () => {
+  return { maxMs: 0, passes: 0, peakSocketsIterated: 0, socketsDelivered: 0, socketsIterated: 0, totalMs: 0 };
+};
+const recordFanoutPass = (counters, iterated, delivered, ms) => {
+  return {
+    maxMs: Math.max(counters.maxMs, ms),
+    passes: counters.passes + 1,
+    peakSocketsIterated: Math.max(counters.peakSocketsIterated, iterated),
+    socketsDelivered: counters.socketsDelivered + delivered,
+    socketsIterated: counters.socketsIterated + iterated,
+    totalMs: counters.totalMs + ms
+  };
+};
+const summarizeFanoutTopics = (attachments, limit = DEFAULT_FANOUT_TOPIC_LIMIT) => {
+  const shapeCounts = /* @__PURE__ */ new Map();
+  const whisperCounts = /* @__PURE__ */ new Map();
+  for (const attachment of attachments) {
+    for (const shape of Object.values(attachment.shapes ?? {})) {
+      const key = shape.name ?? "(unknown shape)";
+      shapeCounts.set(key, (shapeCounts.get(key) ?? 0) + 1);
+    }
+    for (const topic of attachment.whispers ?? []) {
+      whisperCounts.set(topic, (whisperCounts.get(topic) ?? 0) + 1);
+    }
+  }
+  const topics = [
+    ...[...shapeCounts].map(([topic, subscribers]) => {
+      return { kind: "shape", subscribers, topic };
+    }),
+    ...[...whisperCounts].map(([topic, subscribers]) => {
+      return { kind: "whisper", subscribers, topic };
+    })
+  ];
+  topics.sort((a, b) => b.subscribers - a.subscribers || a.topic.localeCompare(b.topic));
+  const peakSubscribers = topics[0]?.subscribers ?? 0;
+  return { peakSubscribers, topics: topics.slice(0, limit), totalConnections: attachments.length };
+};
 
-export { ADMIN_FUNCTIONS, ADMIN_FUNCTION_PREFIX, MAX_PAGE_SIZE, RELATION_FUNCTION_PREFIX, facetColumn, findStorageReferences, listTables, readTablePage, selectMatchingIds, summarizeSubscriptions };
+export { ADMIN_FUNCTIONS, ADMIN_FUNCTION_PREFIX, DEFAULT_FANOUT_TOPIC_LIMIT, FLAGS_FUNCTION_PREFIX, MAX_PAGE_SIZE, RELATION_FUNCTION_PREFIX, createFanoutCounters, facetColumn, findStorageReferences, listTables, readTablePage, recordFanoutPass, selectMatchingIds, summarizeFanoutTopics, summarizeSubscriptions };

package/dist/packem_shared/{applyCdcChanges-Ctdmxmrv.mjs → CDC_LOG_TABLE-DSycmnDf.mjs}

@@ -26,9 +26,13 @@ const appendCdcChange = (sql$1, ts, table, id, op, doc) => {
 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} ORDER BY seq ASC LIMIT ${limit}`
+    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 };

package/dist/packem_shared/{DATA_MIGRATION_STATE_TABLE-PTtTiQ7U.mjs → DATA_MIGRATION_STATE_TABLE-DfPxn8I0.mjs}

@@ -229,7 +229,11 @@ const runDataMigration = async (options) => {
     throw error;
   }
   if (!dryRun && !isDone) {
-    releaseClaim(sql, migration.id);
+    try {
+      releaseClaim(sql, migration.id);
+    } catch (error) {
+      console.warn(`data migration "${migration.id}": releaseClaim failed`, error);
+    }
   }
   return { changed, cursor: isDone ? null : cursor, direction, dryRun, id: migration.id, processed, status: isDone ? "completed" : "in_progress" };
 };

package/dist/packem_shared/{assertFlatPredicate-DyVYReuT.mjs → DEFAULT_MAX_RELATION_KEYS-DU-Y4-LJ.mjs}

@@ -1,4 +1,4 @@
-import { distinctValues } from './applyOnDelete-CMif2RKw.mjs';
+import { distinctValues } from './applyOnDelete-BQ-8ZlZ1.mjs';
 
 const RELATION_EXISTS_KEY = "__relationExists";
 
@@ -156,5 +156,54 @@ const resolveRelationPredicates = async (where, options) => {
     schema: options.schema
   });
 };
+const firstShardedHit = (branches, schema, tableName) => {
+  for (const branch of branches) {
+    const hit = findShardedRelationTarget(branch, schema, tableName);
+    if (hit) {
+      return hit;
+    }
+  }
+  return void 0;
+};
+const inspectKey = (key, value, schema, tableName) => {
+  if (key === "AND" || key === "OR") {
+    return firstShardedHit(branchesOf(value), schema, tableName);
+  }
+  if (key === "NOT") {
+    return firstShardedHit([value ?? {}], schema, tableName);
+  }
+  const relation = schema.tables[tableName]?.relationMap?.[key];
+  if (!relation || !isRelationPredicate(value)) {
+    return void 0;
+  }
+  if (schema.tables[relation.table]?.shardMode?.kind === "shardBy") {
+    return { relation: key, target: relation.table };
+  }
+  return firstShardedHit(Object.values(value), schema, relation.table);
+};
+const findShardedRelationTarget = (where, schema, tableName) => {
+  for (const key of Object.keys(where)) {
+    const hit = inspectKey(key, where[key], schema, tableName);
+    if (hit) {
+      return hit;
+    }
+  }
+  return void 0;
+};
+const assertShapeShardable = (effectiveWhere, schema, table) => {
+  if (!effectiveWhere) {
+    return;
+  }
+  const offending = findShardedRelationTarget(effectiveWhere, schema, table);
+  if (!offending) {
+    return;
+  }
+  throw Object.assign(
+    new Error(
+      `shape on "${table}" joins the sharded table "${offending.target}" via relation "${offending.relation}" — a live shape cannot replicate rows that live in another shard's Durable Object. Fix it by (a) denormalizing the joined columns into "${table}", or (b) moving "${offending.target}" to .global() so it is served through the latency-tiered D1 shape tier.`
+    ),
+    { code: "SHAPE_CROSS_SHARD_JOIN", name: "LunoraError", status: 400 }
+  );
+};
 
-export { DEFAULT_MAX_RELATION_KEYS, assertFlatPredicate, containsRelationPredicate, isRelationPredicate, resolveRelationPredicates };
+export { DEFAULT_MAX_RELATION_KEYS, assertFlatPredicate, assertShapeShardable, containsRelationPredicate, isRelationPredicate, resolveRelationPredicates };

package/dist/packem_shared/{assertValidClientId-CBZ1zC96.mjs → NotUniqueError-Do5h_jiW.mjs}

@@ -1,27 +1,29 @@
 import { sql } from 'drizzle-orm';
-import { matchesStaticWhere, aggregateSqlFunction, normalizeCountArgument, throwingScheduler } from './matchesStaticWhere-CFk6adSu.mjs';
+import { matchesStaticWhere, aggregateSqlFunction, normalizeCountArgument, throwingScheduler } from './AGGREGATE_SQL_FUNCTION-CFk6adSu.mjs';
 import { encodeAggregateKey, foldAggregateTally, aggregateTableName, coerceAggregateNumber, readAggregateValue } from './aggregateTableName-CxNqY1Sl.mjs';
 import { mergeWhere, CountRlsUnsupportedError, selectIndexForGroupBy, selectIndexForCount, selectIndexForAggregate } from './CountRlsUnsupportedError-28ZvvwKS.mjs';
-import { appendCdcChange } from './applyCdcChanges-Ctdmxmrv.mjs';
-export { CDC_LOG_TABLE, CDC_META_TABLE, applyCdcChanges, bumpCdcEpoch, migrateCdcLog, migrateCdcMeta, minCdcSeq, readCdcChanges, readCdcCursor, readCdcEpoch, trimCdcChanges } from './applyCdcChanges-Ctdmxmrv.mjs';
+import { appendCdcChange } from './CDC_LOG_TABLE-DSycmnDf.mjs';
+export { CDC_LOG_TABLE, applyCdcChanges, bumpCdcEpoch, minCdcSeq, readCdcChanges, readCdcCursor, readCdcEpoch, trimCdcChanges } from './CDC_LOG_TABLE-DSycmnDf.mjs';
 import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
 import { i as isFtsAvailable, D as DOC_COLUMN$1, r as rowToDocument, A as AGG_KEY, a as AGG_VALUE, b as AGG_COUNT, d as aggUpsertSql, j as jsonPathSql, q as quoteIdentifier, t as tableColumns, e as qualifiedJsonPathSql } from './do-sql-BCHCWtrD.mjs';
 import { param } from './renderSql-D6eUcn2N.mjs';
-import { s as sortColumnName, m as matchesRankStaticWhere, e as encodePartitionKey, b as serializeSqlValue, r as rankTableName, a as resolveRankPartition, R as RANK_TIEBREAK } from './rank-CrkEIpF4.mjs';
-import { stringifySearchText, ftsTableName, tokenizeSearch, buildFtsMatch, scoreDocument } from './ftsTableName-BLEMawrp.mjs';
+import { sortColumnName, matchesRankStaticWhere, encodePartitionKey, rankTableName, resolveRankPartition, RANK_TIEBREAK } from './RANK_TIEBREAK-CXhdcA1o.mjs';
+import { stringifySearchText, ftsTableName, tokenizeSearch, buildFtsMatch, scoreDocument } from './buildFtsMatch-BLEMawrp.mjs';
+import { s as serializeSqlValue } from './serialize-sql-BlRUoiQe.mjs';
 import { SCAN_DEP } from './SCAN_DEP-DLJF8dsj.mjs';
-import { decodeCursor, normalizeOrderKeys, buildSeekWhere, encodeCursor, buildSeekBeforeWhere } from './buildSeekWhere-lVsNXSLy.mjs';
+import { decodeCursor, normalizeOrderKeys, buildSeekWhere, applySelect, encodeCursor, softDeleteScope, buildSeekBeforeWhere } from './applySelect-BvZdFUBT.mjs';
 import NotFoundError from './NotFoundError-CMuMZt81.mjs';
-import { assertFlatPredicate, resolveRelationPredicates } from './assertFlatPredicate-DyVYReuT.mjs';
-import { runRowValidators, resolveWith, applyOnDelete } from './applyOnDelete-CMif2RKw.mjs';
-import { guardWriter } from './guardWriter-u3UlnCH5.mjs';
+import { assertFlatPredicate, resolveRelationPredicates } from './DEFAULT_MAX_RELATION_KEYS-DU-Y4-LJ.mjs';
+import { runRowValidators, resolveWith, applyOnDelete, fanOutScalarCounts } from './applyOnDelete-BQ-8ZlZ1.mjs';
+import { guardWriter } from './RLS_UNWRAP_SYMBOL-EtGQdC9d.mjs';
 import { createSystemReader } from './createSystemReader-8CzSZP9V.mjs';
 import { ConflictError } from './ConflictError-C0STs6bU.mjs';
-import { runTriggers } from './runTriggers-5N6_Fx0A.mjs';
-import { compileWhereSql } from './compileWhereSql-CXrhFA3G.mjs';
-export { backfillAggregateIndexes, backfillRankIndexes } from './backfillAggregateIndexes-BF5eL7kW.mjs';
-export { I as IDEMPOTENCY_TABLE, m as migrateIdempotency, r as readIdempotent, t as trimIdempotent, w as writeIdempotent } from './ctx-db-idempotency-DkC9rP91.mjs';
-export { runShardMigrations } from './runShardMigrations-C3bn5r93.mjs';
+import { runTriggers } from './hasTrigger-5N6_Fx0A.mjs';
+import { compileWhereSql } from './compileWhereSql-MW_Lk8nJ.mjs';
+export { backfillAggregateIndexes, backfillRankIndexes } from './backfillAggregateIndexes-BZsOqDXP.mjs';
+export { C as CLIENT_WATERMARK_TABLE, G as GLOBAL_SHAPE_SNAPSHOT_TABLE, I as IDEMPOTENCY_TABLE, c as advanceClientWatermark, d as deleteGlobalShapeSnapshot, e as deleteGlobalShapeSnapshotsForConnection, m as migrateClientWatermark, b as migrateGlobalShapeSnapshot, r as readClientWatermark, f as readGlobalShapeSnapshot, g as readIdempotent, t as trimIdempotent, w as writeGlobalShapeSnapshot, h as writeIdempotent } from './ctx-db-idempotency-BdcNpvY4.mjs';
+export { runShardMigrations } from './runShardMigrations-nIwoQeOK.mjs';
+export { a as selectShapeMemberIds, s as selectShapeRows } from './ctx-db-shapes-0RaIOy7J.mjs';
 
 const rankIndexFieldsUnchanged = (index, previous, next) => {
   const fields = [...index.partitionBy ?? [], ...index.sortBy.map((key) => key.field), ...index.where ? Object.keys(index.where) : []];
@@ -534,7 +536,7 @@ const createSearchBuilder = (search, tableName) => {
   };
   return builder;
 };
-const searchViaFts = (sql$1, tableName, search, limit) => {
+const searchViaFts = (sql$1, tableName, search, limit, scopeCondition) => {
   const tokens = tokenizeSearch(search.query);
   if (tokens.length === 0) {
     return [];
@@ -544,6 +546,9 @@ const searchViaFts = (sql$1, tableName, search, limit) => {
   for (const filter of search.filters) {
     whereClauses.push(sql`${jsonPathSql(filter.field)} = ${serializeSqlValue(filter.value)}`);
   }
+  if (scopeCondition) {
+    whereClauses.push(scopeCondition);
+  }
   let query = sql`SELECT m.id, m._creationTime, m.${sql.identifier(DOC_COLUMN$1)} FROM ${sql.identifier(ftName)} f JOIN ${sql.identifier(tableName)} m ON m.id = f.${sql.identifier("__id__")} WHERE ${sql.join(whereClauses, sql` AND `)} ORDER BY f.rank, m._creationTime DESC`;
   if (typeof limit === "number") {
     query = sql`${query} LIMIT ${sql.raw(String(Math.max(0, Math.floor(limit))))}`;
@@ -558,7 +563,7 @@ const searchViaFts = (sql$1, tableName, search, limit) => {
   }
   return docs;
 };
-const searchViaScan = (sql$1, tableName, search, limit) => {
+const searchViaScan = (sql$1, tableName, search, limit, scopeCondition) => {
   const tokens = tokenizeSearch(search.query);
   if (tokens.length === 0) {
     return [];
@@ -567,6 +572,9 @@ const searchViaScan = (sql$1, tableName, search, limit) => {
   for (const filter of search.filters) {
     whereClauses.push(sql`${jsonPathSql(filter.field)} = ${serializeSqlValue(filter.value)}`);
   }
+  if (scopeCondition) {
+    whereClauses.push(scopeCondition);
+  }
   let query = sql`SELECT id, _creationTime, ${sql.identifier(DOC_COLUMN$1)} FROM ${sql.identifier(tableName)}`;
   if (whereClauses.length > 0) {
     query = sql`${query} WHERE ${sql.join(whereClauses, sql` AND `)}`;
@@ -660,11 +668,12 @@ const scanDocs = (rows, filters, cap) => {
   }
   return docs;
 };
-const paginateStage = (sql$1, tableName, stage, options) => {
+const paginateStage = (sql$1, tableName, stage, options, scopeCondition) => {
   const numberItems = Math.max(0, Math.floor(options.numItems));
   const orderKeys = paginateOrderKeys(stage);
   const bounded = typeof options.endCursor === "string";
-  const whereCondition = compileWhereSql(paginateWhere(stage, orderKeys, options.cursor, options.endCursor), doWhereSqlStrategy);
+  const pageWhere = compileWhereSql(paginateWhere(stage, orderKeys, options.cursor, options.endCursor), doWhereSqlStrategy);
+  const whereCondition = scopeCondition && pageWhere ? sql`${pageWhere} AND ${scopeCondition}` : scopeCondition ?? pageWhere;
   let query = sql`SELECT id, _creationTime, ${sql.identifier(DOC_COLUMN$1)} FROM ${sql.identifier(tableName)}`;
   if (whereCondition) {
     query = sql`${query} WHERE ${whereCondition}`;
@@ -721,6 +730,8 @@ const buildReader = (sql$1, schema, tableName, onIndexUse = () => void 0) => {
   if (!tableDefinition) {
     throw new Error(`unknown table: ${tableName}`);
   }
+  const scopeWhere = softDeleteScope(tableDefinition.softDeleteMode, void 0);
+  const scopeCondition = scopeWhere ? compileWhereSql(scopeWhere, doWhereSqlStrategy) : void 0;
   const stage = {
     indexFields: [],
     indexName: void 0,
@@ -735,7 +746,7 @@ const buildReader = (sql$1, schema, tableName, onIndexUse = () => void 0) => {
     }
     const filtered = stage.inMemoryFilters.length > 0;
     const engineLimit = filtered ? void 0 : limit;
-    const docs = isFtsAvailable(sql$1) ? searchViaFts(sql$1, tableName, search, engineLimit) : searchViaScan(sql$1, tableName, search, engineLimit);
+    const docs = isFtsAvailable(sql$1) ? searchViaFts(sql$1, tableName, search, engineLimit, scopeCondition) : searchViaScan(sql$1, tableName, search, engineLimit, scopeCondition);
     if (!filtered) {
       return docs;
     }
@@ -766,6 +777,9 @@ const buildReader = (sql$1, schema, tableName, onIndexUse = () => void 0) => {
     for (const condition of stage.sqlConditions) {
       whereClauses.push(sql`${jsonPathSql(condition.field)} ${sql.raw(condition.comparator)} ${serializeSqlValue(condition.value)}`);
     }
+    if (scopeCondition) {
+      whereClauses.push(scopeCondition);
+    }
     let query = sql`SELECT id, _creationTime, ${sql.identifier(DOC_COLUMN$1)} FROM ${sql.identifier(tableName)}`;
     if (whereClauses.length > 0) {
       query = sql`${query} WHERE ${sql.join(whereClauses, sql` AND `)}`;
@@ -813,7 +827,7 @@ const buildReader = (sql$1, schema, tableName, onIndexUse = () => void 0) => {
       if (stage.search) {
         throw new Error("pagination is not supported on search queries; use .take(n) or .collect()");
       }
-      return paginateStage(sql$1, tableName, stage, options);
+      return paginateStage(sql$1, tableName, stage, options, scopeCondition);
     },
     // eslint-disable-next-line @typescript-eslint/require-await -- TableReaderLike returns Promises (the D1 twin awaits real I/O); the DO impl is synchronous over local SQLite
     async take(limit) {
@@ -997,7 +1011,6 @@ const createShardCtxDb = (options) => {
   };
   const globalFallback = () => globalDb;
   const relationFetcher = (relationTable, relationArgs) => routeBackend(relationTable, "relation load").findMany(relationTable, relationArgs);
-  const relationCounter = (relationTable, relationWhere) => routeBackend(relationTable, "relation load").count(relationTable, relationWhere);
   const relationPredicateFetcher = (relationTable, relationArgs) => {
     if (isGlobalTable(relationTable)) {
       onRead(relationTable, SCAN_DEP);
@@ -1015,6 +1028,31 @@ const createShardCtxDb = (options) => {
     schema,
     tableName: predicateTable
   });
+  const relationGroupedCounter = async (relationTable, whereField, values, policyWhere) => {
+    const globalWriter = globalWriterFor(relationTable, "relation grouped count");
+    if (globalWriter) {
+      onRead(relationTable, SCAN_DEP);
+      return fanOutScalarCounts((t, w) => globalWriter.count(t, w), relationTable, whereField, values, policyWhere);
+    }
+    const definition = schema.tables[relationTable];
+    if (!definition) {
+      throw new Error(`unknown table: ${relationTable}`);
+    }
+    onRead(relationTable, SCAN_DEP);
+    const softScope = softDeleteScope(definition.softDeleteMode, void 0);
+    const inFilter = { [whereField]: { in: values } };
+    const combined = mergeWhere(mergeWhere(inFilter, policyWhere), softScope);
+    const resolvedCombined = await resolveAggregateRelations(combined, relationTable, void 0);
+    const whereCondition = compileWhereSql(resolvedCombined, doWhereSqlStrategy);
+    const fieldSql = jsonPathSql(whereField);
+    let query = sql`SELECT ${fieldSql} AS __fk__, COUNT(*) AS count FROM ${sql.identifier(relationTable)}`;
+    if (whereCondition) {
+      query = sql`${query} WHERE ${whereCondition}`;
+    }
+    query = sql`${query} GROUP BY ${fieldSql}`;
+    const rows = runDrizzle(sql$1, query).toArray();
+    return new Map(rows.map((row) => [row["__fk__"], row.count]));
+  };
   let triggerDepth = 0;
   const triggerMatchers = /* @__PURE__ */ new Set();
   for (const [tableName, definition] of Object.entries(schema.tables)) {
@@ -1130,10 +1168,11 @@ const createShardCtxDb = (options) => {
         throw new Error(`aggregate(${tableName}, { op: "${aggOptions.op}" }): "field" is required for non-count reducers`);
       }
       onRead(tableName, SCAN_DEP);
-      const effective = mergeWhere(aggOptions.baseWhere, aggOptions.where);
+      const aggScope = softDeleteScope(definition.softDeleteMode, void 0);
+      const effective = mergeWhere(mergeWhere(aggOptions.baseWhere, aggOptions.where), aggScope);
       const resolved = await resolveAggregateRelations(effective, tableName, aggOptions.relationBaseWhere);
       const hasRelation = resolved !== effective;
-      if (definition.aggregateIndexes && !aggOptions.baseWhere && !hasRelation) {
+      if (definition.aggregateIndexes && !aggOptions.baseWhere && !hasRelation && !aggScope) {
         const planned = selectIndexForAggregate(definition.aggregateIndexes, aggOptions.op, aggOptions.field, aggOptions.where);
         if (planned) {
           ensureBackfilled(tableName, planned.index);
@@ -1175,10 +1214,11 @@ const createShardCtxDb = (options) => {
         throw new CountRlsUnsupportedError(tableName);
       }
       onRead(tableName, SCAN_DEP);
-      const effective = mergeWhere(countOptions.baseWhere, countOptions.where);
+      const countScope = softDeleteScope(definition.softDeleteMode, void 0);
+      const effective = mergeWhere(mergeWhere(countOptions.baseWhere, countOptions.where), countScope);
       const resolved = await resolveAggregateRelations(effective, tableName, countOptions.relationBaseWhere);
       const hasRelation = resolved !== effective;
-      if (definition.aggregateIndexes && !countOptions.baseWhere && !hasRelation) {
+      if (definition.aggregateIndexes && !countOptions.baseWhere && !hasRelation && !countScope) {
         const planned = selectIndexForCount(definition.aggregateIndexes, countOptions.where);
         if (planned) {
           ensureBackfilled(tableName, planned.index);
@@ -1199,16 +1239,22 @@ const createShardCtxDb = (options) => {
       const row = runDrizzle(sql$1, query).one();
       return row.count;
     },
-    async delete(id, expectedTable) {
+    async delete(id, expectedTable, deleteOptions) {
       const located = locateRowById(id, expectedTable);
       if (!located) {
         const global = expectedTable === void 0 ? globalFallback() : void 0;
         if (global) {
-          await global.delete(id);
+          await global.delete(id, void 0, deleteOptions);
         }
         return;
       }
       const { docJson: existingJson, row: existing, tableName } = located;
+      const definition = schema.tables[tableName];
+      const hard = deleteOptions?.hard === true;
+      const softField = !hard && definition?.softDeleteMode ? definition.softDeleteMode.field : void 0;
+      if (softField && existing[softField] !== null && existing[softField] !== void 0) {
+        return;
+      }
       if (hasMatchingTrigger(tableName, "before", "delete")) {
         await fireTriggers("before", "delete", { id, op: "delete", previous: existing, table: tableName });
       }
@@ -1216,10 +1262,10 @@ const createShardCtxDb = (options) => {
         deletedId: id,
         deletedReference: (references) => existing[references],
         findHolders: async (holderTable, field, value) => {
-          const holders = await routeForHolder(holderTable).findMany(holderTable, { where: { [field]: value } });
+          const holders = await routeForHolder(holderTable).findMany(holderTable, { includeDeleted: hard, where: { [field]: value } });
           return holders.page;
         },
-        onCascade: (holderTable, holderId) => routeForHolder(holderTable).delete(holderId),
+        onCascade: (holderTable, holderId) => routeForHolder(holderTable).delete(holderId, void 0, deleteOptions),
         onRestrict: (message) => {
           throw new ConflictError(message, "restrict");
         },
@@ -1230,6 +1276,25 @@ const createShardCtxDb = (options) => {
       });
       ensureBackfilledForTable(tableName);
       ensureRankBackfilledForTable(tableName);
+      if (softField) {
+        const merged = { ...existing, [softField]: clock(), _id: id };
+        runGuardedWrite(
+          sql$1,
+          tableName,
+          sql`UPDATE ${sql.identifier(tableName)} SET ${sql.identifier(DOC_COLUMN$1)} = ${JSON.stringify(merged)} WHERE id = ${id} AND ${sql.identifier(DOC_COLUMN$1)} = ${existingJson}`
+        );
+        syncSearch(tableName, id, merged);
+        syncAggregates(tableName, existing, merged);
+        syncRanks(tableName, id, existing, void 0);
+        cache?.invalidate(tableName, id);
+        recordCdc(tableName, id, "update", merged);
+        broadcast({ key: id, op: "update", row: merged, table: tableName });
+        if (hasMatchingTrigger(tableName, "after", "delete")) {
+          await fireTriggers("after", "delete", { id, op: "delete", previous: existing, table: tableName });
+        }
+        await onWrite({ id, op: "delete", table: tableName });
+        return;
+      }
       runGuardedWrite(
         sql$1,
         tableName,
@@ -1271,7 +1336,8 @@ const createShardCtxDb = (options) => {
         onRead(tableName, SCAN_DEP);
         return global.findMany(tableName, args);
       }
-      if (!schema.tables[tableName]) {
+      const findManyDefinition = schema.tables[tableName];
+      if (!findManyDefinition) {
         throw new Error(`unknown table: ${tableName}`);
       }
       const isFullScan = !args.where && !args.baseWhere;
@@ -1283,6 +1349,7 @@ const createShardCtxDb = (options) => {
       const orderKeys = normalizeOrderKeys(args.orderBy);
       const seek = args.cursor ? buildSeekWhere(orderKeys, decodeCursor(args.cursor)) : void 0;
       let predicate = mergeWhere(args.baseWhere, args.where);
+      predicate = mergeWhere(predicate, softDeleteScope(findManyDefinition.softDeleteMode, args.includeDeleted));
       predicate = await resolveRelationPredicates(predicate, {
         canPushExists: relationExistsPushDownEnabled ? canPushRelationExists : void 0,
         existsPushMode: relationExistsPushDown === "always" ? "always" : "auto",
@@ -1320,7 +1387,7 @@ const createShardCtxDb = (options) => {
       if (limit === void 0) {
         if (args.with) {
           await resolveWith({
-            counter: relationCounter,
+            groupedCounter: relationGroupedCounter,
             fetcher: relationFetcher,
             parents: docs,
             relationBaseWhere: args.relationBaseWhere,
@@ -1329,15 +1396,15 @@ const createShardCtxDb = (options) => {
             with: args.with
           });
         }
-        return { continueCursor: null, isDone: true, page: docs };
+        return { continueCursor: null, isDone: true, page: applySelect(docs, args.select, args.with) };
       }
       const hasMore = docs.length > limit;
       const page = hasMore ? docs.slice(0, limit) : docs;
       const last = page.at(-1);
       if (args.with) {
         await resolveWith({
-          counter: relationCounter,
           fetcher: relationFetcher,
+          groupedCounter: relationGroupedCounter,
           parents: page,
           relationBaseWhere: args.relationBaseWhere,
           schema,
@@ -1346,10 +1413,12 @@ const createShardCtxDb = (options) => {
         });
       }
       return {
+        // The cursor is encoded from `last` (the full, unprojected row) above,
+        // so `applySelect` only trims the returned payload — paging is intact.
         // eslint-disable-next-line unicorn/no-null -- QueryPage.continueCursor is `null | string`: null is the documented "no further page" cursor on the wire
         continueCursor: hasMore && last ? encodeCursor(last, orderKeys) : null,
         isDone: !hasMore,
-        page
+        page: applySelect(page, args.select, args.with)
       };
     },
     async get(id, expectedTable) {
@@ -1390,10 +1459,11 @@ const createShardCtxDb = (options) => {
       if (agg.op !== "count" && !agg.field) {
         throw new Error(`groupBy(${tableName}, { agg: { op: "${agg.op}" } }): "field" is required for non-count reducers`);
       }
-      const effective = mergeWhere(groupOptions.baseWhere, groupOptions.where);
+      const groupScope = softDeleteScope(definition.softDeleteMode, void 0);
+      const effective = mergeWhere(mergeWhere(groupOptions.baseWhere, groupOptions.where), groupScope);
       const resolved = await resolveAggregateRelations(effective, tableName, groupOptions.relationBaseWhere);
       const hasRelation = resolved !== effective;
-      if (definition.aggregateIndexes && !groupOptions.baseWhere && !hasRelation) {
+      if (definition.aggregateIndexes && !groupOptions.baseWhere && !hasRelation && !groupScope) {
         const planned = selectIndexForGroupBy(definition.aggregateIndexes, agg.op, agg.field, groupOptions.by, groupOptions.where);
         if (planned) {
           ensureBackfilled(tableName, planned.index);
@@ -1696,6 +1766,26 @@ const createShardCtxDb = (options) => {
       const { directions, hasMore, rows } = computeRankPage(rankPageDeps, tableName, indexName, rankPageOptions);
       return { directions, hasMore, rows };
     },
+    async restore(id, expectedTable) {
+      const located = locateRowById(id, expectedTable);
+      if (!located) {
+        const global = expectedTable === void 0 ? globalFallback() : void 0;
+        if (global?.restore) {
+          await global.restore(id);
+          return;
+        }
+        throw new Error(`document not found: ${id}`);
+      }
+      const field = schema.tables[located.tableName]?.softDeleteMode?.field;
+      if (!field) {
+        throw new Error(`ctx.db.restore: table "${located.tableName}" is not a .softDelete() table`);
+      }
+      const wasDeleted = located.row[field] !== null && located.row[field] !== void 0;
+      await writer.patch(id, { [field]: null }, expectedTable);
+      if (wasDeleted) {
+        syncRanks(located.tableName, id, void 0, located.row);
+      }
+    },
     async replace(id, document, expectedTable) {
       const located = locateRowById(id, expectedTable);
       if (!located) {
@@ -1742,4 +1832,4 @@ const createShardCtxDb = (options) => {
   return options.enforceRls === true ? guardWriter(writer, schema, (id, expectedTable) => locateRowById(id, expectedTable)?.tableName) : writer;
 };
 
-export { NotUniqueError, appendCdcChange, assertValidClientId, createShardCtxDb, normalizeIdStructurally };
+export { NotUniqueError, assertValidClientId, createShardCtxDb, normalizeIdStructurally };

package/dist/packem_shared/{rank-CrkEIpF4.mjs → RANK_TIEBREAK-CXhdcA1o.mjs}

@@ -1,15 +1,4 @@
-const serializeSqlValue = (value) => {
-  if (typeof value === "boolean") {
-    return value ? 1 : 0;
-  }
-  if (value === null || typeof value === "string" || typeof value === "number") {
-    return value;
-  }
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-  return JSON.stringify(value);
-};
+import { s as serializeSqlValue } from './serialize-sql-BlRUoiQe.mjs';
 
 const compareStrings = (a, b) => {
   if (a < b) {
@@ -99,4 +88,4 @@ const rankKeyFromDocument = (index, document_) => {
   };
 };
 
-export { RANK_TIEBREAK as R, resolveRankPartition as a, serializeSqlValue as b, rankKeyFromDocument as c, encodePartitionKey as e, matchesRankStaticWhere as m, rankTableName as r, sortColumnName as s };
+export { RANK_TIEBREAK, encodePartitionKey, matchesRankStaticWhere, rankKeyFromDocument as rankKeyFromDoc, rankTableName, resolveRankPartition, sortColumnName };