effect 4.0.5 → 4.0.6

package/dist/persistence/PersistedQueue.js

@@ -514,7 +514,7 @@ export const makeStoreRedis = /*#__PURE__*/Effect.fnUntraced(function* (options)
     module: "effect/persistence/PersistedQueue",
     fiber: "refreshLocks"
   }));
-  const scanKeys = pattern => Effect.gen(function* () {
+  const scanKeys = Effect.fnUntraced(function* (pattern) {
     const keys = [];
     let cursor = "0";
     do {
@@ -533,6 +533,9 @@ export const makeStoreRedis = /*#__PURE__*/Effect.fnUntraced(function* (options)
       name
     }) => {
       const keys = keysFor(name);
+      // replace lone surrogates like Redis' UTF-8 encoding does, so the id in
+      // the payload matches the id keys
+      id = id.replace(/[\uD800-\uDFFF]/gu, "\uFFFD");
       const payload = JSON.stringify({
         id,
         element
@@ -608,10 +611,10 @@ export const makeStoreRedis = /*#__PURE__*/Effect.fnUntraced(function* (options)
         }));
       }));
     }),
-    cleanup: ({
+    cleanup: Effect.fnUntraced(function* ({
       failedTimeToLive,
       timeToLive
-    }) => Effect.gen(function* () {
+    }) {
       const now = clock.currentTimeMillisUnsafe();
       const idsKeys = yield* scanKeys(`${prefix}*:ids`);
       const cutoff = now - Duration.toMillis(timeToLive);
@@ -631,7 +634,7 @@ export const makeStoreRedis = /*#__PURE__*/Effect.fnUntraced(function* (options)
           discard: true
         });
       }
-    }).pipe(Effect.mapError(({
+    }, Effect.mapError(({
       cause
     }) => new PersistedQueueError({
       message: "Failed to clean up persisted queue",
@@ -778,6 +781,26 @@ redis.call("ZADD", key_ids, "XX", "+inf", id)
 `,
   numberOfKeys: 5
 });
+// Every record starts with {"id":"...". Decode only the id, since Redis cjson
+// rejects lone UTF-16 surrogates that JSON.stringify can emit in the element.
+const queueRecordIdRedis = `
+local function record_id(payload)
+  assert(string.sub(payload, 1, 7) == '{"id":"', "Invalid queue record id")
+  local i = 8
+  while i <= #payload do
+    local byte = string.byte(payload, i)
+    if byte == 92 then
+      -- Skip escaped characters, including escaped quotes and backslashes.
+      i = i + 2
+    elseif byte == 34 then
+      return cjson.decode(string.sub(payload, 7, i))
+    else
+      i = i + 1
+    end
+  end
+  error("Unterminated queue record id")
+end
+`;
 const takeRedis = /*#__PURE__*/Redis.script((...args) => args, {
   lua: `
 local key_queue = KEYS[1]
@@ -790,6 +813,8 @@ local batch_size = tonumber(ARGV[3])
 local pttl = ARGV[4]
 local now = ARGV[5]
 
+${queueRecordIdRedis}
+
 local due = redis.call("ZRANGEBYSCORE", key_delayed, "-inf", now, "LIMIT", 0, 100)
 if #due > 0 then
   for i, payload in ipairs(due) do
@@ -798,14 +823,21 @@ if #due > 0 then
   redis.call("ZREM", key_delayed, unpack(due))
 end
 
-local payloads = redis.call("LPOP", key_queue, batch_size)
-if not payloads then
+local payloads = redis.call("LRANGE", key_queue, 0, batch_size - 1)
+if #payloads == 0 then
   return nil
 end
 
-local result = {}
+-- read every id before removing the batch, as script errors do not roll back
+local ids = {}
 for i, payload in ipairs(payloads) do
-  local id = cjson.decode(payload).id
+  ids[i] = record_id(payload)
+end
+redis.call("LTRIM", key_queue, #payloads, -1)
+
+local result = {}
+for i, id in ipairs(ids) do
+  local payload = payloads[i]
   local key_lock = prefix .. id .. ":lock"
   redis.call("SET", key_lock, worker_id, "PX", pttl)
   redis.call("HSET", key_pending, id, payload)
@@ -835,21 +867,20 @@ local key_ids = KEYS[2]
 local cutoff = tonumber(ARGV[1])
 local removed = 0
 
+${queueRecordIdRedis}
+
 while removed < ${trimFailedBatchSize} do
   local head = redis.call("LINDEX", key_failed, 0)
   if not head then break end
-  local ok, decoded = pcall(cjson.decode, head)
+  local ok, id = pcall(record_id, head)
   if ok then
-    local failed_at = tonumber(decoded.failedAt)
+    -- failedAt is always the last field of a failed record
+    local failed_at = tonumber(string.match(head, ',"failedAt":([^,}]+)%}$'))
     if failed_at ~= nil and failed_at >= cutoff then break end
-    redis.call("LPOP", key_failed)
-    if decoded.id ~= nil then
-      redis.call("ZREM", key_ids, decoded.id)
-    end
-  else
-    -- a corrupt head would otherwise block trimming of the whole list
-    redis.call("LPOP", key_failed)
+    redis.call("ZREM", key_ids, id)
   end
+  -- a corrupt head would otherwise block trimming of the whole list
+  redis.call("LPOP", key_failed)
   removed = removed + 1
 end
 
@@ -871,8 +902,12 @@ export const layerStoreRedis = /*#__PURE__*/flow(makeStoreRedis, /*#__PURE__*/La
  * **Details**
  *
  * The store creates the queue table and indexes, acquires rows with
- * per-worker locks, refreshes active locks while scoped takes are running, and
- * retries or completes rows according to the processing exit.
+ * per-acquisition locks, refreshes active locks while scoped takes are running,
+ * and retries or completes rows according to the processing exit.
+ *
+ * Settlements and refreshes only apply to the acquisition a handler received,
+ * so a handler whose lock lapsed can still settle or renew its claim until
+ * another poll re-claims the row.
  *
  * Offer and retry delays are measured with the database clock and rounded up
  * to whole seconds.
@@ -888,7 +923,6 @@ export const makeStoreSql = /*#__PURE__*/Effect.fnUntraced(function* (options) {
   const pollInterval = Duration.max(options?.pollInterval ? Duration.fromInputUnsafe(options.pollInterval) : Duration.millis(1000), Duration.millis(1));
   const lockRefreshInterval = Duration.max(options?.lockRefreshInterval ? Duration.fromInputUnsafe(options.lockRefreshInterval) : Duration.seconds(30), Duration.millis(1));
   const lockExpiration = Duration.max(options?.lockExpiration ? Duration.fromInputUnsafe(options.lockExpiration) : Duration.minutes(2), Duration.millis(1));
-  const workerId = crypto.randomUUID();
   const ackRetrySchedule = makeAckRetrySchedule(lockExpiration);
   yield* Effect.orDie(Migrator.make({})({
     loader: sqlMigrations(tableName),
@@ -938,14 +972,43 @@ export const makeStoreSql = /*#__PURE__*/Effect.fnUntraced(function* (options) {
         INSERT IGNORE INTO ${tableNameSql} (id, queue_name, element, state, attempts, visible_at, created_at, updated_at)
         VALUES (${id}, ${name}, ${element}, 'pending', 0, ${visibleAt}, ${sqlNow}, ${sqlNow})
       `,
-    mssql: () => (id, name, element, visibleAt) => sql`
-        MERGE ${tableNameSql} WITH (HOLDLOCK) AS target
-        USING (SELECT ${id} AS id, ${name} AS queue_name) AS source
-        ON target.id = source.id AND target.queue_name = source.queue_name
-        WHEN NOT MATCHED THEN
-          INSERT (id, queue_name, element, state, attempts, visible_at, created_at, updated_at)
-          VALUES (source.id, source.queue_name, ${element}, 'pending', 0, ${visibleAt}, ${sqlNow}, ${sqlNow});
-      `,
+    // Avoids MERGE WITH (HOLDLOCK), whose range locks deadlock concurrent offers.
+    // - READCOMMITTEDLOCK makes the check wait for an uncommitted duplicate, even
+    //   under read committed snapshot.
+    // - A duplicate inserted after the check raises 2601/2627. XACT_ABORT is off
+    //   so that error doesn't doom the caller's transaction; it is restored
+    //   before rethrowing any other error.
+    // - The nested sp_executesql restores XACT_ABORT on exit, including on
+    //   cancellation.
+    mssql: () => {
+      // matches the SQL Server compiler's identifier escaping
+      const escape = name => `[${name.replace(/\]/g, "]]").replace(/\./g, "].[")}]`;
+      const table = escape(tableName);
+      const offerSql = `
+        SET XACT_ABORT OFF;
+        BEGIN TRY
+          IF NOT EXISTS (
+            SELECT 1 FROM ${table} WITH (READCOMMITTEDLOCK, FORCESEEK, INDEX(${escape(`idx_${tableName}_id`)}))
+            WHERE id = @id AND queue_name = @name
+          )
+            INSERT INTO ${table} (id, queue_name, element, state, attempts, visible_at, created_at, updated_at)
+            VALUES (@id, @name, @element, 'pending', 0, @visible_at, SYSDATETIME(), SYSDATETIME());
+        END TRY
+        BEGIN CATCH
+          IF ERROR_NUMBER() NOT IN (2601, 2627) OR XACT_STATE() = -1
+          BEGIN
+            IF @xact_abort <> 0 SET XACT_ABORT ON;
+            THROW;
+          END
+        END CATCH`;
+      return (id, name, element, visibleAt) => sql`
+          DECLARE @visible_at DATETIME2 = ${visibleAt};
+          DECLARE @xact_abort INT = @@OPTIONS & 16384;
+          EXEC sp_executesql ${offerSql},
+            N'@id NVARCHAR(MAX), @name NVARCHAR(MAX), @element NVARCHAR(MAX), @visible_at DATETIME2, @xact_abort INT',
+            @id = ${id}, @name = ${name}, @element = ${element}, @visible_at = @visible_at, @xact_abort = @xact_abort;
+        `;
+    },
     // sqlite
     orElse: () => (id, name, element, visibleAt) => sql`
         INSERT OR IGNORE INTO ${tableNameSql} (id, queue_name, element, state, attempts, visible_at, created_at, updated_at)
@@ -957,47 +1020,55 @@ export const makeStoreSql = /*#__PURE__*/Effect.fnUntraced(function* (options) {
     orElse: () => s => `'${s}'`
   });
   const stringLiteral = s => sql.literal(wrapString(s));
-  const workerIdSql = stringLiteral(workerId);
-  const elementIds = new Set();
+  // Elements this store has claimed and not yet settled. Each poll claims its
+  // rows under a fresh lock, so a settlement only matches the acquisition it
+  // belongs to, even after the same store re-claims a lapsed row.
+  const held = new Set();
   const refreshLocks = Effect.suspend(() => {
-    if (elementIds.size === 0) return Effect.void;
-    const ids = Array.from(elementIds);
+    if (held.size === 0) return Effect.void;
+    const sequences = new Set();
+    const locks = new Set();
+    for (const element of held) {
+      sequences.add(element.sequence);
+      locks.add(wrapString(element.lock));
+    }
+    // A row only ever carries the lock of the poll that claimed it, so matching
+    // every held sequence against every live lock renews just this store's own
+    // claims while keeping the statement flat
     return sql`
       UPDATE ${tableNameSql}
       SET acquired_at = ${sqlNow}
-      WHERE sequence IN (${sql.literal(ids.join(","))})
-      AND acquired_by = ${workerIdSql}
+      WHERE sequence IN (${sql.literal(Array.from(sequences).join(","))})
+      AND acquired_by IN (${sql.literal(Array.from(locks).join(","))})
     `;
   });
-  const ack = (statement, sequences) => statement.pipe(Effect.retry(ackRetrySchedule), Effect.orDie, Effect.ensuring(Effect.sync(() => {
-    for (const sequence of sequences) {
-      elementIds.delete(sequence);
-    }
+  const ack = (statement, element) => statement.pipe(Effect.retry(ackRetrySchedule), Effect.orDie, Effect.ensuring(Effect.sync(() => {
+    held.delete(element);
   })), Effect.asVoid);
-  const complete = sequence => ack(sql`
+  const complete = element => ack(sql`
         UPDATE ${tableNameSql}
         SET acquired_at = NULL, acquired_by = NULL, updated_at = ${sqlNow}, state = 'completed'
-        WHERE sequence = ${sequence}
-        AND acquired_by = ${workerIdSql}
-      `, [sequence]);
-  const fail = (sequence, cause) => ack(sql`
+        WHERE sequence = ${element.sequence}
+        AND acquired_by = ${stringLiteral(element.lock)}
+      `, element);
+  const fail = (element, cause) => ack(sql`
         UPDATE ${tableNameSql}
         SET acquired_at = NULL, acquired_by = NULL, updated_at = ${sqlNow}, state = 'failed', last_failure = ${Cause.pretty(cause)}
-        WHERE sequence = ${sequence}
-        AND acquired_by = ${workerIdSql}
-      `, [sequence]);
-  const retry = (sequence, delay, cause) => ack(sql`
+        WHERE sequence = ${element.sequence}
+        AND acquired_by = ${stringLiteral(element.lock)}
+      `, element);
+  const retry = (element, delay, cause) => ack(sql`
         UPDATE ${tableNameSql}
         SET acquired_at = NULL, acquired_by = NULL, updated_at = ${sqlNow}, visible_at = ${secondsFromNow(Duration.toSeconds(delay))}, last_failure = ${Cause.pretty(cause)}
-        WHERE sequence = ${sequence}
-        AND acquired_by = ${workerIdSql}
-      `, [sequence]);
-  const interrupt = ids => ack(sql`
+        WHERE sequence = ${element.sequence}
+        AND acquired_by = ${stringLiteral(element.lock)}
+      `, element);
+  const interrupt = element => ack(sql`
         UPDATE ${tableNameSql}
         SET acquired_at = NULL, acquired_by = NULL, attempts = attempts - 1
-        WHERE sequence IN (${sql.literal(ids.join(","))})
-        AND acquired_by = ${workerIdSql}
-      `, ids);
+        WHERE sequence = ${element.sequence}
+        AND acquired_by = ${stringLiteral(element.lock)}
+      `, element);
   yield* refreshLocks.pipe(Effect.tapCause(Effect.logWarning), Effect.retry(Schedule.spaced(500)), Effect.schedule(Schedule.fixed(lockRefreshInterval)), Effect.annotateLogs({
     package: "@effect/sql",
     module: "SqlPersistedQueue",
@@ -1013,10 +1084,10 @@ export const makeStoreSql = /*#__PURE__*/Effect.fnUntraced(function* (options) {
       const pollLatch = Latch.makeUnsafe();
       const takenLatch = Latch.makeUnsafe();
       const nudge = state.nudge;
-      yield* Effect.addFinalizer(() => Effect.flatMap(Queue.clear(queue), elements => {
-        if (elements.length === 0) return Effect.void;
-        return interrupt(Array.from(elements, e => e.sequence));
-      }));
+      yield* Effect.addFinalizer(() => Effect.flatMap(Queue.clear(queue), elements => Effect.forEach(elements, interrupt, {
+        concurrency: "unbounded",
+        discard: true
+      })));
       // flip exhausted rows whose lock expired (worker crashed on the final
       // attempt) to failed, since no finalizer will ever run for them
       yield* sql`
@@ -1029,10 +1100,10 @@ export const makeStoreSql = /*#__PURE__*/Effect.fnUntraced(function* (options) {
         AND (acquired_at IS NULL OR acquired_at < ${expiresAt})
       `.pipe(Effect.tapCause(Effect.logWarning), Effect.ignore, Effect.schedule(Schedule.spaced(lockRefreshInterval)), Effect.forkScoped, Effect.interruptible);
       const poll = sql.onDialectOrElse({
-        pg: () => size => sql`
+        pg: () => (size, lockSql) => sql`
             WITH cte AS (
               UPDATE ${tableNameSql}
-              SET acquired_at = ${sqlNow}, acquired_by = ${workerIdSql}, attempts = attempts + 1
+              SET acquired_at = ${sqlNow}, acquired_by = ${lockSql}, attempts = attempts + 1
               WHERE sequence IN (
                 SELECT sequence FROM ${tableNameSql}
                 WHERE queue_name = ${name}
@@ -1049,7 +1120,7 @@ export const makeStoreSql = /*#__PURE__*/Effect.fnUntraced(function* (options) {
             SELECT sequence, id, element, attempts FROM cte
             ORDER BY visible_at ASC, sequence ASC
           `,
-        mysql: () => size => sql`
+        mysql: () => (size, lockSql) => sql`
             SELECT sequence, id, element, attempts FROM ${tableNameSql} q
             WHERE queue_name = ${name}
             AND state = 'pending'
@@ -1063,7 +1134,7 @@ export const makeStoreSql = /*#__PURE__*/Effect.fnUntraced(function* (options) {
           if (rows.length === 0) return Effect.void;
           return sql`
                 UPDATE ${tableNameSql}
-                SET acquired_at = ${sqlNow}, acquired_by = ${workerIdSql}, attempts = attempts + 1
+                SET acquired_at = ${sqlNow}, acquired_by = ${lockSql}, attempts = attempts + 1
                 WHERE sequence IN (${sql.literal(rows.map(r => r.sequence).join(","))})
               `.unprepared;
         }), Effect.map(rows => {
@@ -1072,9 +1143,12 @@ export const makeStoreSql = /*#__PURE__*/Effect.fnUntraced(function* (options) {
           }
           return rows;
         }), sql.withTransaction),
-        mssql: () => size => sql`
+        // READPAST skips rows locked by another claim or a settlement instead
+        // of deadlocking with them
+        mssql: () => (size, lockSql) => sql`
             WITH cte AS (
-              SELECT TOP ${sql.literal(size.toString())} sequence FROM ${tableNameSql}
+              SELECT TOP ${sql.literal(size.toString())} sequence
+              FROM ${tableNameSql} WITH (UPDLOCK, READPAST, ROWLOCK)
               WHERE queue_name = ${name}
               AND state = 'pending'
               AND attempts < ${maxAttempts}
@@ -1083,15 +1157,15 @@ export const makeStoreSql = /*#__PURE__*/Effect.fnUntraced(function* (options) {
               ORDER BY visible_at ASC, sequence ASC
             )
             UPDATE q
-            SET acquired_at = ${sqlNow}, acquired_by = ${workerIdSql}, attempts = q.attempts + 1
+            SET acquired_at = ${sqlNow}, acquired_by = ${lockSql}, attempts = q.attempts + 1
             OUTPUT inserted.sequence, inserted.id, inserted.element, inserted.attempts
             FROM ${tableNameSql} AS q
             INNER JOIN cte ON q.sequence = cte.sequence
           `,
         // sqlite
-        orElse: () => size => sql`
+        orElse: () => (size, lockSql) => sql`
             UPDATE ${tableNameSql}
-            SET acquired_at = ${sqlNow}, acquired_by = ${workerIdSql}, attempts = attempts + 1
+            SET acquired_at = ${sqlNow}, acquired_by = ${lockSql}, attempts = attempts + 1
             WHERE sequence IN (
               SELECT sequence FROM ${tableNameSql}
               WHERE queue_name = ${name}
@@ -1110,7 +1184,8 @@ export const makeStoreSql = /*#__PURE__*/Effect.fnUntraced(function* (options) {
           yield* pollLatch.await;
           yield* Effect.yieldNow;
           nudge.closeUnsafe();
-          const results = takers.current === 0 ? [] : yield* poll(takers.current);
+          const lock = crypto.randomUUID();
+          const results = takers.current === 0 ? [] : yield* poll(takers.current, stringLiteral(lock));
           if (results.length === 0) {
             yield* Effect.race(Effect.sleep(pollInterval), nudge.await);
             continue;
@@ -1118,7 +1193,8 @@ export const makeStoreSql = /*#__PURE__*/Effect.fnUntraced(function* (options) {
           takenLatch.closeUnsafe();
           for (const row of results) {
             row.attempts = Number(row.attempts);
-            elementIds.add(row.sequence);
+            row.lock = lock;
+            held.add(row);
           }
           yield* Queue.offerAll(queue, results);
           yield* takenLatch.await;
@@ -1187,9 +1263,11 @@ export const makeStoreSql = /*#__PURE__*/Effect.fnUntraced(function* (options) {
     }) => Effect.catchCause(Effect.suspend(() => offer(id, name, JSON.stringify(element), delay === undefined ? sqlNow : delayedVisibleAt(delay))), cause => Effect.fail(new PersistedQueueError({
       message: "Failed to offer element to persisted queue",
       cause
-    }))).pipe(Effect.tap(() => Effect.sync(() => {
+    }))).pipe(
+    // Wake takers once the offer is committed.
+    Effect.tap(() => sql.afterCommit(Effect.sync(() => {
       queueStates.peek(name)?.nudge.openUnsafe();
-    }))),
+    })))),
     take: options => {
       queueStates.get(options.name).maxAttempts = options.maxAttempts;
       const loop = Effect.uninterruptibleMask(restore => RcMap.get(mailboxes, options.name).pipe(Effect.flatMap(({
@@ -1221,23 +1299,23 @@ export const makeStoreSql = /*#__PURE__*/Effect.fnUntraced(function* (options) {
         } catch (defect) {
           // a row that cannot be parsed will never succeed, so dead-letter
           // it and take the next element
-          return Effect.andThen(fail(element.sequence, Cause.die(defect)), loop);
+          return Effect.andThen(fail(element, Cause.die(defect)), loop);
         }
         return Effect.as(Effect.addFinalizer(exit => {
           if (exit._tag === "Success") {
-            return complete(element.sequence);
+            return complete(element);
           }
           const dead = deadLetterFromCause(exit.cause);
           if (dead !== undefined) {
-            return fail(element.sequence, dead.cause);
+            return fail(element, dead.cause);
           }
           if (Cause.hasInterruptsOnly(exit.cause)) {
-            return interrupt([element.sequence]);
+            return interrupt(element);
           }
           if (element.attempts >= options.maxAttempts) {
-            return fail(element.sequence, exit.cause);
+            return fail(element, exit.cause);
           }
-          return Effect.flatMap(options.retryDelay(element.attempts), delay => retry(element.sequence, delay, exit.cause));
+          return Effect.flatMap(options.retryDelay(element.attempts), delay => retry(element, delay, exit.cause));
         }), {
           id: element.id,
           attempts: element.attempts,
@@ -1246,15 +1324,15 @@ export const makeStoreSql = /*#__PURE__*/Effect.fnUntraced(function* (options) {
       })));
       return loop;
     },
-    cleanup: ({
+    cleanup: Effect.fnUntraced(function* ({
       failedTimeToLive,
       timeToLive
-    }) => Effect.gen(function* () {
+    }) {
       yield* cleanupState("completed", timeToLive);
       if (failedTimeToLive !== undefined) {
         yield* cleanupState("failed", failedTimeToLive);
       }
-    }).pipe(Effect.catchCause(cause => Effect.fail(new PersistedQueueError({
+    }, Effect.catchCause(cause => Effect.fail(new PersistedQueueError({
       message: "Failed to clean up persisted queue",
       cause
     }))))
@@ -1344,7 +1422,7 @@ const sqlMigrations = tableName => Migrator.fromRecord({
     const tableNameSql = sql(tableName);
     const takeIndex = sql(`idx_${tableName}_take`);
     yield* sql.onDialectOrElse({
-      pg: () => Effect.gen(function* () {
+      pg: Effect.fnUntraced(function* () {
         yield* sql`DROP INDEX IF EXISTS ${takeIndex}`;
         yield* sql`ALTER TABLE ${tableNameSql}
               ADD COLUMN state VARCHAR(10),
@@ -1360,7 +1438,7 @@ const sqlMigrations = tableName => Migrator.fromRecord({
               ALTER COLUMN visible_at SET NOT NULL,
               DROP COLUMN completed`;
       }),
-      mysql: () => Effect.gen(function* () {
+      mysql: Effect.fnUntraced(function* () {
         yield* sql`DROP INDEX ${takeIndex} ON ${tableNameSql}`;
         yield* sql`ALTER TABLE ${tableNameSql}
               MODIFY COLUMN id VARCHAR(255) NOT NULL,
@@ -1377,7 +1455,7 @@ const sqlMigrations = tableName => Migrator.fromRecord({
               MODIFY COLUMN visible_at DATETIME NOT NULL,
               DROP COLUMN completed`;
       }),
-      mssql: () => Effect.gen(function* () {
+      mssql: Effect.fnUntraced(function* () {
         const upgradedTableName = `${tableName}_upgrade`;
         const upgradedTable = sql(upgradedTableName);
         yield* sql`CREATE TABLE ${upgradedTable} (
@@ -1410,7 +1488,7 @@ const sqlMigrations = tableName => Migrator.fromRecord({
       }),
       // sqlite rebuilds the table because altering or dropping constrained
       // columns is not portable across supported SQLite versions.
-      orElse: () => Effect.gen(function* () {
+      orElse: Effect.fnUntraced(function* () {
         const upgradedTableName = `${tableName}_upgrade`;
         const upgradedTable = sql(upgradedTableName);
         yield* sql`DROP INDEX IF EXISTS ${takeIndex}`;