@lunora/do 1.0.0-alpha.32 → 1.0.0-alpha.33

package/dist/index.d.mts

@@ -2499,13 +2499,31 @@ interface ExternalSourceLike {
   softDeleteColumn?: string;
   tenantBy?: (shardKey: string) => ReadonlyArray<unknown>;
 }
+/**
+* Coerce a driver-native value that `stableStringify` can't represent (see
+* `shared/stable-key.ts`) into its JSON-safe form: a `Date` → its ISO string, a
+* `bigint` → its decimal string. Every other value passes through unchanged.
+*
+* node-pg / postgres-js / mysql2 return `timestamp`/`datetime` columns as JS
+* `Date` and `bigint`/`int8` columns as `bigint` — both throw a `TypeError` out of
+* `stableStringify` (used by the full-pull diff and the incremental content
+* short-circuit), which bricks ingest for any table with such a column (e.g. the
+* canonical `cursor: { column: "updated_at" }` incremental config). This is the
+* single boundary where driver-native types cross into DO SQLite JSON; a new
+* source driver (or a new non-JSON column type) must be normalized here too.
+* `shared/stable-key.ts`'s throw contract is intentionally left unchanged — this
+* normalizes the value *before* it can ever reach that encoder.
+*/
+
 /**
 * Lift an external row to a Lunora document: the `idColumn` value becomes a
 * stringified `_id`, then either `map` shapes the body or every other column is
 * copied verbatim. Throws on a missing/null id, and on a non-scalar id, so a
 * misconfigured query fails loudly instead of materializing rows under the literal
 * id `"undefined"` (or collapsing many rows onto one id). Shared with
-* `@lunora/hyperdrive`'s `projectSourceRow`.
+* `@lunora/hyperdrive`'s `projectSourceRow`. The returned document's values are
+* normalized (see {@link normalizeSourceValue}) so a `Date`/`bigint` column never
+* reaches `stableStringify` un-normalized.
 */
 declare const liftSourceId: (row: Record<string, unknown>, options?: {
   idColumn?: string;
@@ -4402,6 +4420,19 @@ declare abstract class ShardDO {
   private static rootSizeWarned;
   /** Test-only: reset the static "warned once" flag. */
   static resetRootSizeWarning(): void;
+  /**
+  * Compute the shared poll alarm's next wake time from both tiers' signals.
+  * Global shapes need the fixed `GLOBAL_SHAPE_POLL_INTERVAL_MS` floor whenever
+  * any are subscribed (a global table has no per-DO op-log, so it can only be
+  * polled). External-source ingest instead reports the earliest NEXT-DUE
+  * timestamp across its non-manual sources (or `undefined` when none exist) —
+  * a source with a large `refresh.everyMs` must sleep until it's actually due,
+  * not spin at the global-shape floor. Returns `undefined` when NEITHER tier
+  * has pending work, so the DO can go fully idle instead of re-arming for no
+  * reason; otherwise the earlier of the two candidate times (never later than
+  * `nowMs`, so a source that's already due arms essentially immediately).
+  */
+  private static nextPollAlarmTarget;
   protected state: ShardDOState;
   protected env: unknown;
   /**
@@ -4733,12 +4764,17 @@ declare abstract class ShardDO {
   /** Hibernation API: invoked on socket error. */
   webSocketError(_ws: WebSocket, _error: unknown): void;
   /**
-  * Durable Object alarm handler — the heartbeat for `.global()`-table shapes.
-  * The runtime wakes this when the poll alarm armed by `scheduleGlobalPoll`
-  * fires; it refreshes every subscribed global shape (diff-poke from the global
-  * backend) and re-arms while any remain. With no global subscribers left, the
-  * alarm is not re-armed and the DO goes idle. A base-only / global-free DO
-  * never arms it, so this stays dormant there.
+  * Durable Object alarm handler — the heartbeat for `.global()`-table shapes
+  * AND external-source (`.source(...)`) ingest, which share one alarm. The
+  * runtime wakes this when the poll alarm armed by `scheduleGlobalPoll` fires;
+  * it refreshes every subscribed global shape (diff-poke from the global
+  * backend), materializes any due sourced tables, and re-arms at
+  * {@link ShardDO.nextPollAlarmTarget} — the fixed floor while global shapes
+  * are subscribed, or the earliest source next-due time when only ingest
+  * remains (so a 1-hour-`refresh` source sleeps ~1 hour instead of waking
+  * every 2 s). With neither tier pending, the alarm is not re-armed and the DO
+  * goes idle. A base-only / global-free / source-free DO never arms it, so
+  * this stays dormant there.
   */
   alarm(): Promise<void>;
   /** Subclasses implement function dispatch. */
@@ -5405,16 +5441,23 @@ declare abstract class ShardDO {
   /**
   * Poll external-source (`.source(...)`) tables once (plan 077): materialize
   * each sourced table's freshly-pulled tenant slice into this DO's SQLite. The
-  * base `ShardDO` has no sourced tables, so it returns `0` and the ingest tier
-  * stays dormant — zero behavior change for every existing DO. The codegen
-  * subclass overrides it to, per sourced table, build a `createShardCtxDb`
-  * writer, read the tenant slice from Hyperdrive under this DO's shard key, and
-  * run `runExternalSourceTick` (read local baseline → diff → apply via the
-  * validated CDC writer). Returns the number of sourced tables still being
-  * polled, so the shared poll alarm ({@link ShardDO.alarm}) re-arms while ingest
-  * is active.
+  * base `ShardDO` has no sourced tables, so it returns `undefined` and the
+  * ingest tier stays dormant — zero behavior change for every existing DO. The
+  * codegen subclass overrides it to, per sourced table, build a
+  * `createShardCtxDb` writer, read the tenant slice from Hyperdrive under this
+  * DO's shard key, and run `runExternalSourceTick` (read local baseline → diff
+  * → apply via the validated CDC writer).
+  *
+  * Returns the EARLIEST next-due timestamp (absolute epoch ms) across every
+  * non-manual sourced table — `polledAt.get(table) ?? now` plus that source's
+  * `refresh.everyMs` — or `undefined` when every sourced table is
+  * `refresh: "manual"` (or there are none). NOT a bare active count: the
+  * shared poll alarm ({@link ShardDO.alarm}) uses this to re-arm at the exact
+  * next time ingest needs to run, instead of spinning at the fixed
+  * `GLOBAL_SHAPE_POLL_INTERVAL_MS` floor for a source whose `refresh.everyMs`
+  * is, say, an hour away.
   */
-  protected pollExternalSources(): Promise<number>;
+  protected pollExternalSources(): Promise<number | undefined>;
   /**
   * Arm the shared poll alarm for external-source ingest (plan 077). The alarm is
   * shared with the global-shape poll tier; the codegen subclass calls this once
@@ -6414,11 +6457,18 @@ declare abstract class ShardDO {
   */
   private saveGlobalSnapshot;
   /**
-  * Arm the poll alarm for `.global()` shapes if one isn't already pending.
-  * Idempotent — every global-shape seed calls it, but only the first arms the
-  * alarm. Degrades to a no-op when the runtime exposes no `setAlarm` (the unit
-  * harness): a global shape is then seed-only, which the poll-loop tests assert
-  * by driving {@link ShardDO.alarm} directly.
+  * Arm the poll alarm if one isn't already pending. Idempotent — every
+  * global-shape seed calls it, but only the first arms the alarm. Degrades to
+  * a no-op when the runtime exposes no `setAlarm` (the unit harness): a global
+  * shape is then seed-only, which the poll-loop tests assert by driving
+  * {@link ShardDO.alarm} directly.
+  *
+  * `atMs` lets {@link ShardDO.alarm} re-arm at a computed target — the
+  * earlier of the fixed global-shape floor and the earliest external-source
+  * next-due time — instead of always the fixed floor. Every OTHER caller
+  * (a fresh global-shape seed, {@link ShardDO.scheduleSourcePoll}'s initial
+  * kick) omits it and gets the original `GLOBAL_SHAPE_POLL_INTERVAL_MS`
+  * default, since neither knows a more precise due time yet.
   */
   private scheduleGlobalPoll;
   /**

package/dist/index.d.ts

@@ -2499,13 +2499,31 @@ interface ExternalSourceLike {
   softDeleteColumn?: string;
   tenantBy?: (shardKey: string) => ReadonlyArray<unknown>;
 }
+/**
+* Coerce a driver-native value that `stableStringify` can't represent (see
+* `shared/stable-key.ts`) into its JSON-safe form: a `Date` → its ISO string, a
+* `bigint` → its decimal string. Every other value passes through unchanged.
+*
+* node-pg / postgres-js / mysql2 return `timestamp`/`datetime` columns as JS
+* `Date` and `bigint`/`int8` columns as `bigint` — both throw a `TypeError` out of
+* `stableStringify` (used by the full-pull diff and the incremental content
+* short-circuit), which bricks ingest for any table with such a column (e.g. the
+* canonical `cursor: { column: "updated_at" }` incremental config). This is the
+* single boundary where driver-native types cross into DO SQLite JSON; a new
+* source driver (or a new non-JSON column type) must be normalized here too.
+* `shared/stable-key.ts`'s throw contract is intentionally left unchanged — this
+* normalizes the value *before* it can ever reach that encoder.
+*/
+
 /**
 * Lift an external row to a Lunora document: the `idColumn` value becomes a
 * stringified `_id`, then either `map` shapes the body or every other column is
 * copied verbatim. Throws on a missing/null id, and on a non-scalar id, so a
 * misconfigured query fails loudly instead of materializing rows under the literal
 * id `"undefined"` (or collapsing many rows onto one id). Shared with
-* `@lunora/hyperdrive`'s `projectSourceRow`.
+* `@lunora/hyperdrive`'s `projectSourceRow`. The returned document's values are
+* normalized (see {@link normalizeSourceValue}) so a `Date`/`bigint` column never
+* reaches `stableStringify` un-normalized.
 */
 declare const liftSourceId: (row: Record<string, unknown>, options?: {
   idColumn?: string;
@@ -4402,6 +4420,19 @@ declare abstract class ShardDO {
   private static rootSizeWarned;
   /** Test-only: reset the static "warned once" flag. */
   static resetRootSizeWarning(): void;
+  /**
+  * Compute the shared poll alarm's next wake time from both tiers' signals.
+  * Global shapes need the fixed `GLOBAL_SHAPE_POLL_INTERVAL_MS` floor whenever
+  * any are subscribed (a global table has no per-DO op-log, so it can only be
+  * polled). External-source ingest instead reports the earliest NEXT-DUE
+  * timestamp across its non-manual sources (or `undefined` when none exist) —
+  * a source with a large `refresh.everyMs` must sleep until it's actually due,
+  * not spin at the global-shape floor. Returns `undefined` when NEITHER tier
+  * has pending work, so the DO can go fully idle instead of re-arming for no
+  * reason; otherwise the earlier of the two candidate times (never later than
+  * `nowMs`, so a source that's already due arms essentially immediately).
+  */
+  private static nextPollAlarmTarget;
   protected state: ShardDOState;
   protected env: unknown;
   /**
@@ -4733,12 +4764,17 @@ declare abstract class ShardDO {
   /** Hibernation API: invoked on socket error. */
   webSocketError(_ws: WebSocket, _error: unknown): void;
   /**
-  * Durable Object alarm handler — the heartbeat for `.global()`-table shapes.
-  * The runtime wakes this when the poll alarm armed by `scheduleGlobalPoll`
-  * fires; it refreshes every subscribed global shape (diff-poke from the global
-  * backend) and re-arms while any remain. With no global subscribers left, the
-  * alarm is not re-armed and the DO goes idle. A base-only / global-free DO
-  * never arms it, so this stays dormant there.
+  * Durable Object alarm handler — the heartbeat for `.global()`-table shapes
+  * AND external-source (`.source(...)`) ingest, which share one alarm. The
+  * runtime wakes this when the poll alarm armed by `scheduleGlobalPoll` fires;
+  * it refreshes every subscribed global shape (diff-poke from the global
+  * backend), materializes any due sourced tables, and re-arms at
+  * {@link ShardDO.nextPollAlarmTarget} — the fixed floor while global shapes
+  * are subscribed, or the earliest source next-due time when only ingest
+  * remains (so a 1-hour-`refresh` source sleeps ~1 hour instead of waking
+  * every 2 s). With neither tier pending, the alarm is not re-armed and the DO
+  * goes idle. A base-only / global-free / source-free DO never arms it, so
+  * this stays dormant there.
   */
   alarm(): Promise<void>;
   /** Subclasses implement function dispatch. */
@@ -5405,16 +5441,23 @@ declare abstract class ShardDO {
   /**
   * Poll external-source (`.source(...)`) tables once (plan 077): materialize
   * each sourced table's freshly-pulled tenant slice into this DO's SQLite. The
-  * base `ShardDO` has no sourced tables, so it returns `0` and the ingest tier
-  * stays dormant — zero behavior change for every existing DO. The codegen
-  * subclass overrides it to, per sourced table, build a `createShardCtxDb`
-  * writer, read the tenant slice from Hyperdrive under this DO's shard key, and
-  * run `runExternalSourceTick` (read local baseline → diff → apply via the
-  * validated CDC writer). Returns the number of sourced tables still being
-  * polled, so the shared poll alarm ({@link ShardDO.alarm}) re-arms while ingest
-  * is active.
+  * base `ShardDO` has no sourced tables, so it returns `undefined` and the
+  * ingest tier stays dormant — zero behavior change for every existing DO. The
+  * codegen subclass overrides it to, per sourced table, build a
+  * `createShardCtxDb` writer, read the tenant slice from Hyperdrive under this
+  * DO's shard key, and run `runExternalSourceTick` (read local baseline → diff
+  * → apply via the validated CDC writer).
+  *
+  * Returns the EARLIEST next-due timestamp (absolute epoch ms) across every
+  * non-manual sourced table — `polledAt.get(table) ?? now` plus that source's
+  * `refresh.everyMs` — or `undefined` when every sourced table is
+  * `refresh: "manual"` (or there are none). NOT a bare active count: the
+  * shared poll alarm ({@link ShardDO.alarm}) uses this to re-arm at the exact
+  * next time ingest needs to run, instead of spinning at the fixed
+  * `GLOBAL_SHAPE_POLL_INTERVAL_MS` floor for a source whose `refresh.everyMs`
+  * is, say, an hour away.
   */
-  protected pollExternalSources(): Promise<number>;
+  protected pollExternalSources(): Promise<number | undefined>;
   /**
   * Arm the shared poll alarm for external-source ingest (plan 077). The alarm is
   * shared with the global-shape poll tier; the codegen subclass calls this once
@@ -6414,11 +6457,18 @@ declare abstract class ShardDO {
   */
   private saveGlobalSnapshot;
   /**
-  * Arm the poll alarm for `.global()` shapes if one isn't already pending.
-  * Idempotent — every global-shape seed calls it, but only the first arms the
-  * alarm. Degrades to a no-op when the runtime exposes no `setAlarm` (the unit
-  * harness): a global shape is then seed-only, which the poll-loop tests assert
-  * by driving {@link ShardDO.alarm} directly.
+  * Arm the poll alarm if one isn't already pending. Idempotent — every
+  * global-shape seed calls it, but only the first arms the alarm. Degrades to
+  * a no-op when the runtime exposes no `setAlarm` (the unit harness): a global
+  * shape is then seed-only, which the poll-loop tests assert by driving
+  * {@link ShardDO.alarm} directly.
+  *
+  * `atMs` lets {@link ShardDO.alarm} re-arm at a computed target — the
+  * earlier of the fixed global-shape floor and the earliest external-source
+  * next-due time — instead of always the fixed floor. Every OTHER caller
+  * (a fresh global-shape seed, {@link ShardDO.scheduleSourcePoll}'s initial
+  * kick) omits it and gets the original `GLOBAL_SHAPE_POLL_INTERVAL_MS`
+  * default, since neither knows a more precise due time yet.
   */
   private scheduleGlobalPoll;
   /**

package/dist/index.mjs

@@ -3,13 +3,13 @@ export { AGGREGATE_SQL_FUNCTION, aggregateSqlFunction, matchesStaticWhere, norma
 export { aggregateTableName, coerceAggregateNumber, encodeAggregateKey, foldAggregateTally, readAggregateValue } from './packem_shared/aggregateTableName-CxNqY1Sl.mjs';
 export { CountRlsUnsupportedError, mergeWhere, planAggregateLookup, selectIndexForAggregate, selectIndexForCount, selectIndexForGroupBy } from './packem_shared/CountRlsUnsupportedError-BGxj0pgS.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-BigrdT_W.mjs';
+export { NotUniqueError, assertValidClientId, createShardCtxDb, normalizeIdStructurally } from './packem_shared/NotUniqueError-Ca21uDuU.mjs';
 export { DATA_MIGRATION_STATE_TABLE, readMigrationStatus, runDataMigration } from './packem_shared/DATA_MIGRATION_STATE_TABLE-CYwBpyTr.mjs';
 export { SCAN_DEP, createDependencyTracker, depKey } from './packem_shared/SCAN_DEP-DLJF8dsj.mjs';
 export { renderSql } from './packem_shared/renderSql-D6eUcn2N.mjs';
 export { diffExternalSource } from './packem_shared/diffExternalSource-CovHfdyo.mjs';
-export { materializeExternalRows, materializeExternalRowsIncremental, readExternalSourceBaseline, runExternalSourceTick } from './packem_shared/materializeExternalRows-FyA5Rwn4.mjs';
-export { isSoftDeleted, isSourceDue, liftSourceId, pullExternalSourceIncrementalTick, pullExternalSourceTick } from './packem_shared/isSoftDeleted-i5kKh6Up.mjs';
+export { materializeExternalRows, materializeExternalRowsIncremental, readExternalSourceBaseline, runExternalSourceTick } from './packem_shared/materializeExternalRows-DlQWMlw_.mjs';
+export { isSoftDeleted, isSourceDue, liftSourceId, pullExternalSourceIncrementalTick, pullExternalSourceTick } from './packem_shared/isSoftDeleted-YLKR6JYw.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-CAHLZMj8.mjs';
 export { LogBuffer } from './packem_shared/LogBuffer-B_Ezju_N.mjs';
@@ -26,16 +26,16 @@ export { RLS_UNWRAP_SYMBOL, RlsRequiredError, guardWriter } from './packem_share
 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-BnSKgVO4.mjs';
-export { ROOT_DO_SIZE_WARN_BYTES, ROOT_SHARD_NAME, ShardDO } from './packem_shared/ROOT_DO_SIZE_WARN_BYTES-BWz51mpB.mjs';
+export { ROOT_DO_SIZE_WARN_BYTES, ROOT_SHARD_NAME, ShardDO } from './packem_shared/ROOT_DO_SIZE_WARN_BYTES-afQHUhyA.mjs';
 export { SHARD_REGISTRY_DO_NAME, ShardRegistryDO } from './packem_shared/SHARD_REGISTRY_DO_NAME-D99roc-r.mjs';
 export { MAX_SQL_ROWS, assertReadonly, runReadonlySql } from './packem_shared/MAX_SQL_ROWS-iFAA8FbD.mjs';
 export { createSystemReader } from './packem_shared/createSystemReader-D12eNH13.mjs';
 export { ConflictError } from './packem_shared/ConflictError-CLoq37xH.mjs';
 export { hasTrigger, runTriggers } from './packem_shared/hasTrigger-5N6_Fx0A.mjs';
 export { compileWhereSql } from './packem_shared/compileWhereSql-DE6yfRcQ.mjs';
-export { CDC_LOG_TABLE, applyCdcChanges, readCdcChanges, trimCdcChanges } from './packem_shared/CDC_LOG_TABLE-DjJEHiM2.mjs';
+export { CDC_LOG_TABLE, applyCdcChanges, readCdcChanges, trimCdcChanges } from './packem_shared/CDC_LOG_TABLE-uwOJxJJZ.mjs';
 export { backfillAggregateIndexes, backfillRankIndexes } from './packem_shared/backfillAggregateIndexes-DDoT-UUI.mjs';
-export { runShardMigrations } from './packem_shared/runShardMigrations-BGx4v2B6.mjs';
+export { runShardMigrations } from './packem_shared/runShardMigrations-DFzx6Qld.mjs';
 export { stableStringify } from './packem_shared/stableStringify-mC40mZts.mjs';
 export { stableWireKey } from './packem_shared/stableWireKey-DKuXO7T5.mjs';
 export { subscriptionListDeltas } from './packem_shared/subscriptionListDeltas-CT76bYny.mjs';

package/dist/packem_shared/{CDC_LOG_TABLE-DjJEHiM2.mjs → CDC_LOG_TABLE-uwOJxJJZ.mjs}

@@ -79,7 +79,7 @@ const bumpCdcEpoch = (sql$1) => {
 };
 const applyCdcChange = async (writer, change) => {
   if (change.op === "delete") {
-    await writer.delete(change.id);
+    await writer.delete(change.id, change.table);
     return;
   }
   const document = change.doc ?? {};

package/dist/packem_shared/{NotUniqueError-BigrdT_W.mjs → NotUniqueError-Ca21uDuU.mjs}

@@ -3,8 +3,8 @@ import { sql } from 'drizzle-orm';
 import { matchesStaticWhere, aggregateSqlFunction, normalizeCountArgument, throwingScheduler } from './AGGREGATE_SQL_FUNCTION-CQsu2Xga.mjs';
 import { encodeAggregateKey, foldAggregateTally, aggregateTableName, coerceAggregateNumber, readAggregateValue } from './aggregateTableName-CxNqY1Sl.mjs';
 import { mergeWhere, CountRlsUnsupportedError, selectIndexForGroupBy, selectIndexForCount, selectIndexForAggregate } from './CountRlsUnsupportedError-BGxj0pgS.mjs';
-import { appendCdcChange } from './CDC_LOG_TABLE-DjJEHiM2.mjs';
-export { CDC_LOG_TABLE, applyCdcChanges, bumpCdcEpoch, minCdcSeq, readCdcChanges, readCdcCursor, readCdcEpoch, trimCdcChanges } from './CDC_LOG_TABLE-DjJEHiM2.mjs';
+import { appendCdcChange } from './CDC_LOG_TABLE-uwOJxJJZ.mjs';
+export { CDC_LOG_TABLE, applyCdcChanges, bumpCdcEpoch, minCdcSeq, readCdcChanges, readCdcCursor, readCdcEpoch, trimCdcChanges } from './CDC_LOG_TABLE-uwOJxJJZ.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';
@@ -23,7 +23,7 @@ import { runTriggers } from './hasTrigger-5N6_Fx0A.mjs';
 import { compileWhereSql } from './compileWhereSql-DE6yfRcQ.mjs';
 export { backfillAggregateIndexes, backfillRankIndexes } from './backfillAggregateIndexes-DDoT-UUI.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-BGx4v2B6.mjs';
+export { runShardMigrations } from './runShardMigrations-DFzx6Qld.mjs';
 export { a as selectShapeMemberIds, s as selectShapeRows } from './ctx-db-shapes-Cz9dHyh1.mjs';
 
 const rankIndexFieldsUnchanged = (index, previous, next) => {

package/dist/packem_shared/{ROOT_DO_SIZE_WARN_BYTES-BWz51mpB.mjs → ROOT_DO_SIZE_WARN_BYTES-afQHUhyA.mjs}

@@ -21,7 +21,7 @@ import { i as isDevEnvironment, c as buildSettings, b as buildSecurityAudit } fr
 import { runReadonlySql } from './MAX_SQL_ROWS-iFAA8FbD.mjs';
 import { ConflictError } from './ConflictError-CLoq37xH.mjs';
 import { e as deleteGlobalShapeSnapshotsForConnection, g as readIdempotent, h as writeIdempotent, t as trimIdempotent, r as readClientWatermark, m as migrateClientWatermark, c as advanceClientWatermark, d as deleteGlobalShapeSnapshot, f as readGlobalShapeSnapshot, w as writeGlobalShapeSnapshot } from './ctx-db-idempotency-BdcNpvY4.mjs';
-import { CDC_LOG_TABLE, readCdcChanges, readCdcCursor, readCdcEpoch, minCdcSeq, bumpCdcEpoch } from './CDC_LOG_TABLE-DjJEHiM2.mjs';
+import { CDC_LOG_TABLE, readCdcChanges, readCdcCursor, readCdcEpoch, minCdcSeq, bumpCdcEpoch } from './CDC_LOG_TABLE-uwOJxJJZ.mjs';
 import { stableStringify } from './stableStringify-mC40mZts.mjs';
 import { a as selectShapeMemberIds, s as selectShapeRows } from './ctx-db-shapes-Cz9dHyh1.mjs';
 
@@ -2088,6 +2088,25 @@ class ShardDO {
   static resetRootSizeWarning() {
     ShardDO.rootSizeWarned = false;
   }
+  /**
+   * Compute the shared poll alarm's next wake time from both tiers' signals.
+   * Global shapes need the fixed `GLOBAL_SHAPE_POLL_INTERVAL_MS` floor whenever
+   * any are subscribed (a global table has no per-DO op-log, so it can only be
+   * polled). External-source ingest instead reports the earliest NEXT-DUE
+   * timestamp across its non-manual sources (or `undefined` when none exist) —
+   * a source with a large `refresh.everyMs` must sleep until it's actually due,
+   * not spin at the global-shape floor. Returns `undefined` when NEITHER tier
+   * has pending work, so the DO can go fully idle instead of re-arming for no
+   * reason; otherwise the earlier of the two candidate times (never later than
+   * `nowMs`, so a source that's already due arms essentially immediately).
+   */
+  static nextPollAlarmTarget(globalShapesRemaining, nextSourceDueAt, nowMs) {
+    const globalTarget = globalShapesRemaining > 0 ? nowMs + ShardDO.GLOBAL_SHAPE_POLL_INTERVAL_MS : void 0;
+    if (globalTarget === void 0) {
+      return nextSourceDueAt === void 0 ? void 0 : Math.max(nextSourceDueAt, nowMs);
+    }
+    return nextSourceDueAt === void 0 ? globalTarget : Math.min(globalTarget, nextSourceDueAt);
+  }
   state;
   env;
   /**
@@ -2709,31 +2728,38 @@ class ShardDO {
   webSocketError(_ws, _error) {
   }
   /**
-   * Durable Object alarm handler — the heartbeat for `.global()`-table shapes.
-   * The runtime wakes this when the poll alarm armed by `scheduleGlobalPoll`
-   * fires; it refreshes every subscribed global shape (diff-poke from the global
-   * backend) and re-arms while any remain. With no global subscribers left, the
-   * alarm is not re-armed and the DO goes idle. A base-only / global-free DO
-   * never arms it, so this stays dormant there.
+   * Durable Object alarm handler — the heartbeat for `.global()`-table shapes
+   * AND external-source (`.source(...)`) ingest, which share one alarm. The
+   * runtime wakes this when the poll alarm armed by `scheduleGlobalPoll` fires;
+   * it refreshes every subscribed global shape (diff-poke from the global
+   * backend), materializes any due sourced tables, and re-arms at
+   * {@link ShardDO.nextPollAlarmTarget} — the fixed floor while global shapes
+   * are subscribed, or the earliest source next-due time when only ingest
+   * remains (so a 1-hour-`refresh` source sleeps ~1 hour instead of waking
+   * every 2 s). With neither tier pending, the alarm is not re-armed and the DO
+   * goes idle. A base-only / global-free / source-free DO never arms it, so
+   * this stays dormant there.
    */
   async alarm() {
     this.globalPollScheduled = false;
-    let remaining;
+    let globalShapesRemaining;
     try {
-      remaining = await this.pollGlobalShapes();
+      globalShapesRemaining = await this.pollGlobalShapes();
     } catch (error) {
       this.recordShapeError("shape:poll", error);
-      remaining = 1;
+      globalShapesRemaining = 1;
     }
+    let nextSourceDueAt;
     try {
-      remaining += await this.pollExternalSources();
+      nextSourceDueAt = await this.pollExternalSources();
     } catch (error) {
       this.recordShapeError("source:poll", error);
-      remaining += 1;
+      nextSourceDueAt = Date.now() + ShardDO.GLOBAL_SHAPE_POLL_INTERVAL_MS;
     }
     await this.flushChangedTables();
-    if (remaining > 0) {
-      await this.scheduleGlobalPoll();
+    const nextAlarmAt = ShardDO.nextPollAlarmTarget(globalShapesRemaining, nextSourceDueAt, Date.now());
+    if (nextAlarmAt !== void 0) {
+      await this.scheduleGlobalPoll(nextAlarmAt);
     }
   }
   /**
@@ -3881,18 +3907,25 @@ class ShardDO {
   /**
    * Poll external-source (`.source(...)`) tables once (plan 077): materialize
    * each sourced table's freshly-pulled tenant slice into this DO's SQLite. The
-   * base `ShardDO` has no sourced tables, so it returns `0` and the ingest tier
-   * stays dormant — zero behavior change for every existing DO. The codegen
-   * subclass overrides it to, per sourced table, build a `createShardCtxDb`
-   * writer, read the tenant slice from Hyperdrive under this DO's shard key, and
-   * run `runExternalSourceTick` (read local baseline → diff → apply via the
-   * validated CDC writer). Returns the number of sourced tables still being
-   * polled, so the shared poll alarm ({@link ShardDO.alarm}) re-arms while ingest
-   * is active.
+   * base `ShardDO` has no sourced tables, so it returns `undefined` and the
+   * ingest tier stays dormant — zero behavior change for every existing DO. The
+   * codegen subclass overrides it to, per sourced table, build a
+   * `createShardCtxDb` writer, read the tenant slice from Hyperdrive under this
+   * DO's shard key, and run `runExternalSourceTick` (read local baseline → diff
+   * → apply via the validated CDC writer).
+   *
+   * Returns the EARLIEST next-due timestamp (absolute epoch ms) across every
+   * non-manual sourced table — `polledAt.get(table) ?? now` plus that source's
+   * `refresh.everyMs` — or `undefined` when every sourced table is
+   * `refresh: "manual"` (or there are none). NOT a bare active count: the
+   * shared poll alarm ({@link ShardDO.alarm}) uses this to re-arm at the exact
+   * next time ingest needs to run, instead of spinning at the fixed
+   * `GLOBAL_SHAPE_POLL_INTERVAL_MS` floor for a source whose `refresh.everyMs`
+   * is, say, an hour away.
    */
   // eslint-disable-next-line class-methods-use-this -- base-class override hook: the codegen subclass implements the real Hyperdrive-backed poll
   pollExternalSources() {
-    return Promise.resolve(0);
+    return Promise.resolve(void 0);
   }
   /**
    * Arm the shared poll alarm for external-source ingest (plan 077). The alarm is
@@ -6171,13 +6204,20 @@ class ShardDO {
     }
   }
   /**
-   * Arm the poll alarm for `.global()` shapes if one isn't already pending.
-   * Idempotent — every global-shape seed calls it, but only the first arms the
-   * alarm. Degrades to a no-op when the runtime exposes no `setAlarm` (the unit
-   * harness): a global shape is then seed-only, which the poll-loop tests assert
-   * by driving {@link ShardDO.alarm} directly.
-   */
-  async scheduleGlobalPoll() {
+   * Arm the poll alarm if one isn't already pending. Idempotent — every
+   * global-shape seed calls it, but only the first arms the alarm. Degrades to
+   * a no-op when the runtime exposes no `setAlarm` (the unit harness): a global
+   * shape is then seed-only, which the poll-loop tests assert by driving
+   * {@link ShardDO.alarm} directly.
+   *
+   * `atMs` lets {@link ShardDO.alarm} re-arm at a computed target — the
+   * earlier of the fixed global-shape floor and the earliest external-source
+   * next-due time — instead of always the fixed floor. Every OTHER caller
+   * (a fresh global-shape seed, {@link ShardDO.scheduleSourcePoll}'s initial
+   * kick) omits it and gets the original `GLOBAL_SHAPE_POLL_INTERVAL_MS`
+   * default, since neither knows a more precise due time yet.
+   */
+  async scheduleGlobalPoll(atMs) {
     if (this.globalPollScheduled) {
       return;
     }
@@ -6187,7 +6227,7 @@ class ShardDO {
     }
     this.globalPollScheduled = true;
     try {
-      await setAlarm.call(this.state.storage, Date.now() + ShardDO.GLOBAL_SHAPE_POLL_INTERVAL_MS);
+      await setAlarm.call(this.state.storage, atMs ?? Date.now() + ShardDO.GLOBAL_SHAPE_POLL_INTERVAL_MS);
     } catch {
       this.globalPollScheduled = false;
     }

package/dist/packem_shared/{isSoftDeleted-i5kKh6Up.mjs → isSoftDeleted-YLKR6JYw.mjs}

@@ -1,7 +1,7 @@
 import { LunoraError } from '@lunora/errors';
 import { sql } from 'drizzle-orm';
 import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
-import { runExternalSourceTick, materializeExternalRowsIncremental } from './materializeExternalRows-FyA5Rwn4.mjs';
+import { runExternalSourceTick, materializeExternalRowsIncremental } from './materializeExternalRows-DlQWMlw_.mjs';
 
 const SOURCE_CURSOR_TABLE = "__lunora_source_cursor";
 const serializeCursor = (value) => {
@@ -96,6 +96,28 @@ const writeSourceCursor = (sql$1, table, shardKey, state) => {
   );
 };
 
+const normalizeSourceValue = (value) => {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (typeof value === "bigint") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((element) => normalizeSourceValue(element));
+  }
+  if (value !== null && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+    return normalizeSourceDocument(value);
+  }
+  return value;
+};
+const normalizeSourceDocument = (document) => {
+  const normalized = {};
+  for (const [key, value] of Object.entries(document)) {
+    normalized[key] = normalizeSourceValue(value);
+  }
+  return normalized;
+};
 const liftSourceId = (row, options = {}) => {
   const { idColumn = "id", map } = options;
   const idValue = row[idColumn];
@@ -107,7 +129,7 @@ const liftSourceId = (row, options = {}) => {
   }
   const id = String(idValue);
   if (map) {
-    return { ...map(row), _id: id };
+    return normalizeSourceDocument({ ...map(row), _id: id });
   }
   const body = {};
   for (const [key, value] of Object.entries(row)) {
@@ -115,7 +137,7 @@ const liftSourceId = (row, options = {}) => {
       body[key] = value;
     }
   }
-  return { ...body, _id: id };
+  return normalizeSourceDocument({ ...body, _id: id });
 };
 const isSourceDue = (refresh, lastPolledMs, nowMs) => {
   if (refresh === "manual") {
@@ -157,7 +179,12 @@ const pullExternalSourceIncrementalTick = async (sql, writer, client, table, sou
   let applied;
   if (state.watermark === null || reconcileDue) {
     slice = await pullAndLift(client, source.query, tenantParameters, source);
-    ({ applied } = await runExternalSourceTick(sql, writer, slice.documents, { columns: source.columns, table }));
+    const { softDeleteColumn } = source;
+    const documents = softDeleteColumn ? slice.documents.filter((_document, index) => {
+      const row = slice.rows[index];
+      return !(row && isSoftDeleted(row, softDeleteColumn));
+    }) : slice.documents;
+    ({ applied } = await runExternalSourceTick(sql, writer, documents, { columns: source.columns, table }));
   } else {
     slice = await pullAndLift(client, cursor.query, [...tenantParameters, deserializeCursor(state.watermark)], source);
     const { softDeleteColumn } = source;
@@ -176,8 +203,15 @@ const pullExternalSourceIncrementalTick = async (sql, writer, client, table, sou
       `external-source: table "${table}" (mode "incremental") pulled ${String(slice.rows.length)} rows but none carry the cursor column "${cursor.column}" — the seed \`query\` must project it (matching \`cursor.query\`'s alias), or the watermark can never advance.`
     );
   }
+  const noRowCarriesCursor = slice.rows.length > 0 && slice.rows.every((row) => row[cursor.column] === null || row[cursor.column] === void 0);
+  if (!fullPull && noRowCarriesCursor) {
+    throw new LunoraError(
+      "INTERNAL",
+      `external-source: table "${table}" (mode "incremental") pulled ${String(slice.rows.length)} rows but none carry the cursor column "${cursor.column}" — \`cursor.query\` must project it (matching the seed \`query\`'s alias), or the watermark can never advance and every tick re-pulls the same stranded slice.`
+    );
+  }
   writeSourceCursor(sql, table, shardKey, { lastReconcileMs: fullPull ? nowMs : state.lastReconcileMs, watermark });
   return { applied };
 };
 
-export { isSoftDeleted, isSourceDue, liftSourceId, pullExternalSourceIncrementalTick, pullExternalSourceTick };
+export { isSoftDeleted, isSourceDue, liftSourceId, normalizeSourceValue, pullExternalSourceIncrementalTick, pullExternalSourceTick };

package/dist/packem_shared/{materializeExternalRows-FyA5Rwn4.mjs → materializeExternalRows-DlQWMlw_.mjs}

@@ -1,4 +1,4 @@
-import { applyCdcChanges } from './CDC_LOG_TABLE-DjJEHiM2.mjs';
+import { applyCdcChanges } from './CDC_LOG_TABLE-uwOJxJJZ.mjs';
 import { s as selectShapeRows } from './ctx-db-shapes-Cz9dHyh1.mjs';
 import { diffExternalSource, projectExternalSourceRow } from './diffExternalSource-CovHfdyo.mjs';
 import { stableStringify } from './stableStringify-mC40mZts.mjs';
@@ -15,7 +15,10 @@ const materializeExternalRowsIncremental = async (writer, pulled, options) => {
     const value = projectExternalSourceRow(source, columns);
     const id = String(value._id);
     if (deletedIds?.has(id)) {
-      changes.push({ id, op: "delete", seq: 0, table, ts: 0 });
+      const existing = await writer.get(id, table);
+      if (existing) {
+        changes.push({ id, op: "delete", seq: 0, table, ts: 0 });
+      }
       continue;
     }
     const stored = await writer.get(id, table);

package/dist/packem_shared/{runShardMigrations-BGx4v2B6.mjs → runShardMigrations-DFzx6Qld.mjs}

@@ -1,6 +1,6 @@
 import { sql } from 'drizzle-orm';
 import { aggregateTableName } from './aggregateTableName-CxNqY1Sl.mjs';
-import { migrateCdcLog, migrateCdcMeta } from './CDC_LOG_TABLE-DjJEHiM2.mjs';
+import { migrateCdcLog, migrateCdcMeta } from './CDC_LOG_TABLE-uwOJxJJZ.mjs';
 import { m as migrateClientWatermark, a as migrateIdempotency, b as migrateGlobalShapeSnapshot } from './ctx-db-idempotency-BdcNpvY4.mjs';
 import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
 import { D as DOC_COLUMN, j as jsonPathSql, c as createIndexSql, t as tableColumns, i as isFtsAvailable, A as AGG_KEY, a as AGG_VALUE, b as AGG_COUNT } from './do-sql-BCHCWtrD.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/do",
-  "version": "1.0.0-alpha.32",
+  "version": "1.0.0-alpha.33",
   "description": "Lunora Durable Objects: ShardDO (SQLite, OCC, hibernated WebSocket subscriptions) and SessionDO",
   "keywords": [
     "cloudflare",
@@ -47,7 +47,7 @@
   },
   "dependencies": {
     "@lunora/errors": "1.0.0-alpha.5",
-    "@lunora/fingerprint": "1.0.0-alpha.2",
+    "@lunora/fingerprint": "1.0.0-alpha.3",
     "@visulima/redact": "3.0.0",
     "drizzle-orm": "^0.45.2"
   },