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

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-B5c6kQIN.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-B5c6kQIN.mjs}

@@ -21,12 +21,36 @@ 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';
 
 const MAX_BATCH_ENTRIES = 500;
 
+const BUFFER_LEVEL = {
+  debug: "debug",
+  error: "error",
+  fatal: "error",
+  info: "info",
+  log: "info",
+  trace: "debug",
+  warn: "warn"
+};
+
+const HEX_ONLY = /^[0-9a-f]+$/;
+const parseTraceparent = (header) => {
+  if (header === null || header === void 0) {
+    return void 0;
+  }
+  const parts = header.trim().toLowerCase().split("-");
+  const [version, traceId, parentSpanId, flags] = parts;
+  if (parts.length < 4 || version === void 0 || version.length !== 2 || !HEX_ONLY.test(version) || version === "ff" || // Version 00 forbids trailing fields; only a future version may carry them.
+  version === "00" && parts.length !== 4 || traceId === void 0 || parentSpanId === void 0 || flags === void 0 || flags.length !== 2 || !HEX_ONLY.test(flags) || traceId.length !== 32 || parentSpanId.length !== 16 || !HEX_ONLY.test(traceId) || !HEX_ONLY.test(parentSpanId) || traceId === "00000000000000000000000000000000" || parentSpanId === "0000000000000000") {
+    return void 0;
+  }
+  return { parentSpanId, traceId };
+};
+
 const evictOldestEntry = (map, capacity) => {
   if (map.size < capacity) {
     return;
@@ -1158,6 +1182,35 @@ const createRelayLink = (host) => {
   return parsed === void 0 ? new OwnerRelay(host, name) : new RelayMember(host, parsed.ownerKey, parsed.relayIndex);
 };
 
+const stringifyFieldValue = (value) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+};
+const coerceFieldValue = (value) => typeof value === "boolean" || typeof value === "number" || typeof value === "string" ? value : stringifyFieldValue(value);
+const normalizeLogFields = (perCall, bound) => {
+  if (perCall === void 0 && bound === void 0) {
+    return void 0;
+  }
+  const merged = {};
+  if (bound !== void 0) {
+    for (const [key, value] of Object.entries(bound)) {
+      merged[key] = coerceFieldValue(value);
+    }
+  }
+  if (perCall !== void 0) {
+    for (const [key, value] of Object.entries(perCall)) {
+      merged[key] = coerceFieldValue(value);
+    }
+  }
+  return Object.keys(merged).length === 0 ? void 0 : merged;
+};
+
 const REQUEST_LOG_TABLE = "__lunora_reqlog__";
 const REQUEST_LOG_RETENTION = 1e3;
 const REQUEST_LOG_EVENT_SOURCE = "lunora";
@@ -1271,18 +1324,40 @@ const renderLogMessage = (args) => args.map((value) => {
     return String(value);
   }
 }).join(" ");
+const isLogFields = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+};
+const parseLogArgs = (args, boundFields) => {
+  if (args.length === 2 && typeof args[0] === "string" && isLogFields(args[1])) {
+    return { fields: normalizeLogFields(args[1], boundFields), message: args[0] };
+  }
+  return { fields: normalizeLogFields(void 0, boundFields), message: renderLogMessage(args) };
+};
 const emitLogEvent = (input) => {
-  const line = JSON.stringify({
+  const payload = {
+    fields: input.fields,
     function: input.functionPath,
     level: input.level,
     message: input.message,
     shard: input.shardKey,
     source: REQUEST_LOG_EVENT_SOURCE,
+    spanId: input.spanId,
+    traceId: input.traceId,
     ts: input.ts,
     type: LOG_EVENT_TYPE,
     userId: input.userId
-  });
-  if (input.level === "error") {
+  };
+  let line;
+  try {
+    line = JSON.stringify(payload);
+  } catch {
+    line = JSON.stringify({ ...payload, fields: void 0 });
+  }
+  if (input.level === "error" || input.level === "fatal") {
     console.error(line);
   } else if (input.level === "warn") {
     console.warn(line);
@@ -2088,6 +2163,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 +2803,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 +3982,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
@@ -4049,28 +4157,55 @@ class ShardDO {
    * Unlike request-log args, `ctx.log` args are NOT redacted: the developer
    * chose to log them, exactly like a raw `console.log`.
    */
-  recordUserLog(functionPath, level, args, sink) {
+  recordUserLog(functionPath, level, args, message, fields, sink) {
+    const trace = parseTraceparent(this.getCurrentTraceparent());
     const event = {
       args,
+      fields,
       functionPath,
       level,
-      message: renderLogMessage(args),
+      message,
       shardKey: this.state.id?.name,
+      spanId: trace?.parentSpanId,
+      traceId: trace?.traceId,
       ts: Date.now(),
       userId: this.getCurrentUserId()
     };
-    this.logs.push({ functionPath, level: level === "log" ? "info" : level, message: event.message, timestamp: event.ts });
+    this.logs.push({ fields, functionPath, level: BUFFER_LEVEL[level], message, timestamp: event.ts });
     try {
       emitLogEvent(event);
     } catch {
     }
     if (sink?.onLog) {
       try {
-        sink.onLog(event);
+        sink.onLog(event, { waitUntil: this.state.waitUntil?.bind(this.state) });
       } catch {
       }
     }
   }
+  /**
+   * Build the `ctx.log` logger for one dispatched function. Each severity method
+   * accepts either the structured form (`(message, fields)`) or console-style
+   * varargs (see {@link parseLogArgs}); `with(fields)` returns a child that
+   * stamps `fields` onto every line. The generated `buildCtx` calls this once
+   * per dispatch and assigns the result to `ctx.log`.
+   */
+  makeLogger(functionPath, sink, boundFields) {
+    const emit = (level, args) => {
+      const { fields, message } = parseLogArgs(args, boundFields);
+      this.recordUserLog(functionPath, level, args, message, fields, sink);
+    };
+    return {
+      debug: (...args) => emit("debug", args),
+      error: (...args) => emit("error", args),
+      fatal: (...args) => emit("fatal", args),
+      info: (...args) => emit("info", args),
+      log: (...args) => emit("log", args),
+      trace: (...args) => emit("trace", args),
+      warn: (...args) => emit("warn", args),
+      with: (fields) => this.makeLogger(functionPath, sink, boundFields ? { ...boundFields, ...fields } : fields)
+    };
+  }
   /**
    * Assemble the per-socket {@link LifecycleDispatchInfo} from its attachment:
    * the verified identity to replay and the {@link LifecycleEvent} the hooks
@@ -6171,13 +6306,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 +6329,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.34",
   "description": "Lunora Durable Objects: ShardDO (SQLite, OCC, hibernated WebSocket subscriptions) and SessionDO",
   "keywords": [
     "cloudflare",
@@ -46,8 +46,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/errors": "1.0.0-alpha.5",
-    "@lunora/fingerprint": "1.0.0-alpha.2",
+    "@lunora/errors": "1.0.0-alpha.6",
+    "@lunora/fingerprint": "1.0.0-alpha.3",
     "@visulima/redact": "3.0.0",
     "drizzle-orm": "^0.45.2"
   },