@rikalabs/akter 0.1.0-alpha.4 → 0.1.0-alpha.6

package/dist/runtime/turn/execute.js

@@ -1,4 +1,4 @@
-import { Cause, Clock, Crypto, Effect, Exit, Option, Predicate, Result, Schema, Scope, } from "effect";
+import { Cause, Clock, Context, Crypto, Effect, Exit, Option, Predicate, Result, Schema, Scope, } from "effect";
 import { SqlClient, SqlError } from "effect/sql";
 import { ActorError, CommandExpired, NotCreated, Unauthorized } from "../../errors/actor.js";
 import {} from "../members.js";
@@ -12,7 +12,8 @@ import { eventsStatement, notifyEvents } from "../events/append.js";
 import { COMMIT_VERSION } from "../database/replica.js";
 import { isPoolRefusal } from "../database/bounded.js";
 import { compress, decompress } from "../storage/codec.js";
-import { Metrics, record } from "../telemetry/metrics.js";
+import { ColdTier, FetchCold } from "../storage/cold-tier.js";
+import { count, Metrics, record } from "../telemetry/metrics.js";
 import { SpanNames } from "../telemetry/spans.js";
 import { receiptMarginMs } from "../storage/retention.js";
 import { hashedPayload } from "../subscriptions/identity.js";
@@ -26,6 +27,10 @@ import { asSqlConnection, awaitReplies, queueStatements, sendPipelined, sendSequ
 import { MERGE_CAP, merges } from "../entity/mailbox.js";
 import { checkReceipt, encodeOutcome, hashCanonical } from "./receipt.js";
 const isSystem = Schema.is(System);
+/** Tests can exercise the ordinary admission pipeline independently of warm speculation. */
+export const WarmTurnFastPath = Context.Reference("akter/WarmTurnFastPath", {
+    defaultValue: () => true,
+});
 /**
  * The cursor row once `delivery` applied, as its commit writes it: a routed
  * delivery creates the epoch-0 row or raises its position, a dynamic one moves
@@ -210,9 +215,12 @@ export const executeBatches = Effect.fnUntraced(function* (run, cache, routingKe
     const sql = yield* SqlClient.SqlClient;
     const hooks = yield* TurnHooks;
     const clock = yield* FrameworkClock;
+    const tier = yield* ColdTier;
     const scope = yield* TenantScope;
+    const warmTurns = yield* WarmTurnFastPath;
     const { ref } = run.first[0].request;
     const { tenant, actor, id } = ref;
+    let coldStartedAtMs;
     const role = scope.role ?? (scope.adoption?.enforced.has(actor) === true ? scope.adoption.role : undefined);
     const actorRow = rowOf({ sql, actor: { key: routingKey, ref } });
     const canonicalsOf = (batch) => Effect.forEach(batch, ({ request }) => hashedPayload(request));
@@ -239,10 +247,10 @@ export const executeBatches = Effect.fnUntraced(function* (run, cache, routingKe
         role === undefined ? "-" : `+${encodeURIComponent(role)}`,
         role === undefined ? "-" : `+${encodeURIComponent(tenant)}`,
     ].join(":");
-    const admit = (batch, canonicals, view, session, begin, grouped = false) => {
+    const admit = (batch, canonicals, view, session, begin, grouped = false, optimistic) => {
         const cold = view.generation === undefined;
         const readsState = cold || view.state === undefined;
-        let admissions = [];
+        let admissions = optimistic === undefined ? [] : [optimistic];
         let bumped;
         let stored = [];
         const subscribed = batch.some(({ request }) => request.delivery !== undefined);
@@ -278,7 +286,8 @@ export const executeBatches = Effect.fnUntraced(function* (run, cache, routingKe
             Effect.map(sql `
           WITH locked AS MATERIALIZED (
             SELECT g.routing_key, g.tenant_id, g.actor_type, g.actor_id,
-              g.generation, g.created, g.event_sequence
+              g.generation, g.created, g.event_sequence,
+              g.cold_ref, g.cold_digest, g.cold_state_version
             FROM actor_generations g
             WHERE ${rowOf({ sql, actor: { key: routingKey, ref }, alias: "g" })}
             FOR UPDATE OF g ${grouped ? sql.literal("SKIP LOCKED") : sql.literal("")}
@@ -286,7 +295,8 @@ export const executeBatches = Effect.fnUntraced(function* (run, cache, routingKe
           SELECT floor(extract(epoch FROM clock_timestamp()) * 1000)::text AS now,
             g.generation::text AS generation, g.created,
             c.payload::jsonb::text AS canonical,
-            r.caller_key, r.command, r.payload_hash, r.outcome, g.event_sequence::text AS head
+            r.caller_key, r.command, r.payload_hash, r.outcome, g.event_sequence::text AS head,
+            g.cold_ref, g.cold_digest, g.cold_state_version
             ${cursorColumns}
           FROM locked g
           CROSS JOIN ${values}
@@ -303,6 +313,7 @@ export const executeBatches = Effect.fnUntraced(function* (run, cache, routingKe
                 RETURNING generation::text AS generation`, (rows) => {
                         bumped = rows[0]?.generation;
                     }),
+                    Effect.asVoid(sql `DELETE FROM actor_outbox WHERE ${actorRow} AND timer_key = '$cold'`),
                 ]
                 : []),
             ...(readsState
@@ -325,6 +336,9 @@ export const executeBatches = Effect.fnUntraced(function* (run, cache, routingKe
             }
             const current = cold ? bumped : first.generation;
             const now = Number(first.now) + clock.offsetMillis();
+            if (first.cold_ref === null)
+                cache.cold = undefined;
+            let restored = false;
             const { retryWindowMs } = yield* OutboxRuntime;
             const expiryMarginMs = receiptMarginMs({
                 keepReceiptsMs: policy.keepReceiptsMs,
@@ -342,6 +356,7 @@ export const executeBatches = Effect.fnUntraced(function* (run, cache, routingKe
             let creates = false;
             let replayed = false;
             let wake = false;
+            let needsAdmissionClock = false;
             const broadcasts = [];
             let events = 0;
             let intents = 0;
@@ -430,6 +445,8 @@ export const executeBatches = Effect.fnUntraced(function* (run, cache, routingKe
                     : Effect.map(committedMintIntent(request, parent), (committed) => committed ? hash : refuse());
             };
             const admitOne = (index) => {
+                if (optimistic !== undefined)
+                    return admitHashed(index, "");
                 const request = batch[index].request;
                 const identityNow = Number(admissions[index].now) + (request.clockOffset ?? clock.offsetMillis());
                 const hashed = Effect.flatMap(hashCanonical(admissions[index].canonical), (hash) => admitHashed(index, hash));
@@ -453,6 +470,19 @@ export const executeBatches = Effect.fnUntraced(function* (run, cache, routingKe
                     index += 1;
                     continue;
                 }
+                if (first.cold_ref !== null)
+                    coldStartedAtMs ??= Number(first.now);
+                if (first.cold_ref !== null &&
+                    (cache.cold?.ref !== first.cold_ref ||
+                        cache.cold.digest !== first.cold_digest ||
+                        cache.cold.version !== first.cold_state_version))
+                    return yield* Effect.die(new FetchCold({
+                        pointer: {
+                            ref: first.cold_ref,
+                            digest: first.cold_digest,
+                            version: first.cold_state_version,
+                        },
+                    }));
                 const start = index;
                 const members = [{ index, request, hash }];
                 index += 1;
@@ -465,23 +495,35 @@ export const executeBatches = Effect.fnUntraced(function* (run, cache, routingKe
                     index += 1;
                 }
                 next ??= readsState
-                    ? new Map(stored.map(({ key, value }) => [key, decompress(value)]))
+                    ? new Map(first.cold_ref === null
+                        ? stored.map(({ key, value }) => [key, decompress(value)])
+                        : cache.cold.envelope.state)
                     : new Map(view.state);
                 const given = next;
                 const head = String(BigInt(first.head) + BigInt(events));
                 const savepoint = `SAVEPOINT ${HANDLER_SAVEPOINT}`;
-                if (statements && start > 0)
+                const restoring = first.cold_ref !== null && !restored;
+                const savepoints = statements || restoring;
+                if (savepoints && (start > 0 || !statements))
                     yield* session.defer(savepoint);
+                if (restoring) {
+                    if (tier === undefined)
+                        return yield* Effect.die(new Error("Cold actor needs coldStorage"));
+                    yield* tier.restore({ key: routingKey, ref }, cache.cold);
+                    yield* hooks.at("afterColdWriteBack", request);
+                }
                 const business = yield* hooks.at("beforeHandler", request).pipe(Effect.andThen(() => members.length === 1
                     ? command.run(request, [...given], { head, connections })
                     : command.merge(members.map((member) => member.request), [...given])), Effect.catchIf(SqlError.isSqlError, Effect.die), Effect.result);
                 const result = Result.isSuccess(business)
                     ? business.success
                     : business.failure;
-                if (statements && (start === 0 || !session.withdraw(savepoint)))
+                if (savepoints && ((statements && start === 0) || !session.withdraw(savepoint)))
                     yield* session.defer(Result.isSuccess(business)
                         ? `RELEASE SAVEPOINT ${HANDLER_SAVEPOINT}`
                         : `ROLLBACK TO SAVEPOINT ${HANDLER_SAVEPOINT}`);
+                if (restoring && Result.isSuccess(business))
+                    restored = true;
                 const written = new Map(result.state);
                 if (result.complete)
                     for (const key of given.keys())
@@ -514,6 +556,10 @@ export const executeBatches = Effect.fnUntraced(function* (run, cache, routingKe
                     blobs.add(blob);
                 intents += result.outbox.intents.length;
                 jobs += result.outbox.jobs.length;
+                needsAdmissionClock ||=
+                    result.outbox.intents.length > 0 ||
+                        result.outbox.jobs.length > 0 ||
+                        result.outbox.subscriptions.length > 0;
                 if (Outcome.guards.Success(result.outcome))
                     broadcasts.push(...(result.broadcasts ?? []));
                 if (yield* notifyEvents(request, routingKey, result.events, waited))
@@ -563,6 +609,8 @@ export const executeBatches = Effect.fnUntraced(function* (run, cache, routingKe
                     settled,
                     generation: current,
                     state: view.state,
+                    created,
+                    needsAdmissionClock,
                     wake: false,
                     broadcasts: [],
                     head: first.head,
@@ -591,7 +639,15 @@ export const executeBatches = Effect.fnUntraced(function* (run, cache, routingKe
             if (creates)
                 writes.push(Effect.asVoid(sql `UPDATE actor_generations SET created = true WHERE ${actorRow}`));
             if (receipts.length > 0) {
-                writes.push(Effect.asVoid(sql `INSERT INTO actor_receipts ${sql.insert(receipts)}`));
+                const receipt = receipts[0];
+                writes.push(Effect.asVoid(optimistic === undefined
+                    ? sql `INSERT INTO actor_receipts ${sql.insert(receipts)}`
+                    : sql `INSERT INTO actor_receipts (routing_key, tenant_id, actor_type, actor_id,
+                  command_id, command, payload_hash, caller_key, outcome, expires_at_ms, started_at_ms)
+                VALUES (${routingKey}, ${tenant}, ${actor}, ${id}, ${receipt.command_id},
+                  ${receipt.command}, encode(sha256(convert_to(${batch[0].request.payload}::jsonb::text, 'UTF8')), 'hex'),
+                  ${receipt.caller_key}, ${receipt.outcome}, ${receipt.expires_at_ms},
+                  current_setting('durable.admitted_at_ms')::bigint)`));
                 if (accounting !== undefined)
                     writes.push(accounting.commands({
                         ref,
@@ -602,9 +658,12 @@ export const executeBatches = Effect.fnUntraced(function* (run, cache, routingKe
             writes.push(...(yield* ticks));
             return {
                 writes,
+                restored,
                 settled,
                 generation: current,
-                state: next,
+                state: first.cold_ref !== null && !restored ? undefined : next,
+                created,
+                needsAdmissionClock,
                 wake,
                 broadcasts,
                 head: String(BigInt(first.head) + BigInt(events)),
@@ -645,9 +704,40 @@ export const executeBatches = Effect.fnUntraced(function* (run, cache, routingKe
         if (plan.writes !== undefined) {
             cache.generation = plan.generation;
             cache.state = plan.state;
+            if (plan.restored === true)
+                cache.cold = undefined;
+            if (plan.state !== undefined) {
+                const previous = cache.committed;
+                const receipts = previous?.generation === plan.generation ? previous.receipts : new Set();
+                let replayBefore = previous?.generation === plan.generation
+                    ? previous.replayBefore
+                    : plan.startedAtMs + clock.offsetMillis();
+                for (const [index, settled] of plan.settled.entries())
+                    if (Result.isSuccess(settled))
+                        receipts.add(batch[index].request.commandId);
+                while (receipts.size > 1_024) {
+                    const oldest = receipts.values().next().value;
+                    replayBefore = Math.max(replayBefore, commandTimes(oldest).issuedAt);
+                    receipts.delete(oldest);
+                }
+                cache.committed = {
+                    generation: plan.generation,
+                    state: plan.state,
+                    created: plan.created,
+                    head: plan.head,
+                    now: endedAtMs,
+                    replayBefore,
+                    receipts,
+                };
+            }
+            else
+                cache.committed = undefined;
         }
+        const coldStarted = coldStartedAtMs;
+        coldStartedAtMs = undefined;
         answering = true;
-        return run.committed(batch, {
+        return run
+            .committed(batch, {
             settled: plan.settled,
             broadcasts: plan.broadcasts,
             head: plan.head,
@@ -667,7 +757,15 @@ export const executeBatches = Effect.fnUntraced(function* (run, cache, routingKe
                 plan.outbox.some((replies) => replies.wake) ||
                 plan.emitted.some((stamp) => stamp.fed),
             cancelled: plan.outbox.some((replies) => replies.cancelled),
-        });
+        })
+            .pipe(Effect.tap(() => Effect.all([
+            plan.restored === true
+                ? count(Metrics.coldRestorations, { actor_type: actor }, 1)
+                : Effect.void,
+            coldStarted === undefined
+                ? Effect.void
+                : record(Metrics.coldWakeDuration, { actor_type: actor }, endedAtMs - coldStarted),
+        ], { discard: true })));
     }).pipe(Effect.andThen(Effect.sync(() => {
         answering = false;
     })));
@@ -810,8 +908,118 @@ export const executeBatches = Effect.fnUntraced(function* (run, cache, routingKe
                 }));
             });
         };
-        const alone = (batch, { admission, admitted }, taken) => awaitReplies(admitted).pipe(Effect.andThen(() => admission.resume()), Effect.flatMap((plan) => Effect.flatMap(taken === undefined ? run.next : Effect.succeed(taken), (following) => commitPlan(batch, plan, following))), inTurn, bounded, Effect.filterOrElse((stepped) => stepped.ending !== "COMMIT" || stepped.tag === "COMMIT", () => Effect.die(RetryTurn.make({ message: "Turn commit rolled back" }))), Effect.tap((stepped) => (stepped.chained === undefined ? release : Effect.void)));
+        const alone = (batch, { admission, admitted }, taken) => awaitReplies(admitted).pipe(Effect.andThen(() => admission.resume()), Effect.flatMap((plan) => Effect.flatMap(taken === undefined ? run.next : Effect.succeed(taken), (following) => commitPlan(batch, plan, following))), inTurn, bounded, Effect.filterOrElse((stepped) => stepped.ending !== "COMMIT" || stepped.tag === "COMMIT", () => Effect.die(RetryTurn.make({ message: "Turn commit rolled back" }))), Effect.tap((stepped) => (stepped.chained === undefined ? release : Effect.void)), Effect.catchCause((cause) => {
+            const fetching = Cause.squash(cause);
+            if (!(fetching instanceof FetchCold))
+                return Effect.failCause(cause);
+            return Effect.gen(function* () {
+                deferred.length = 0;
+                const rollback = yield* control("ROLLBACK");
+                if (rollback.command !== "ROLLBACK")
+                    return yield* Effect.die(RetryTurn.make({ message: "Cold admission rollback unconfirmed" }));
+                open = false;
+                yield* release;
+                yield* hooks.at("afterColdRollback", batch[0].request);
+                if (tier === undefined)
+                    return yield* Effect.die(new Error("Cold actor needs coldStorage"));
+                cache.state = undefined;
+                cache.committed = undefined;
+                cache.cold = yield* tier
+                    .fetch({ key: routingKey, ref }, fetching.pointer)
+                    .pipe(Effect.catch((error) => Effect.die(RetryTurn.make({ message: error.message }))));
+                yield* hooks.at("afterColdFetch", batch[0].request);
+                return yield* alone(batch, yield* openAlone(batch), taken);
+            });
+        }));
         const openAlone = (batch) => leased.pipe(Effect.andThen(queue(batch, view(), []).pipe(inTurn)), Effect.map(({ admission, flight }) => ({ admission, admitted: flight })));
+        /**
+         * A speculative plan uses only an already committed snapshot. The
+         * guard's deliberate division by zero aborts every pipelined write on
+         * a miss; the receipt's unique constraint also catches a commit that
+         * became visible after the guard's statement snapshot. Recovery then
+         * uses ordinary admission, never trusting an unconfirmed outcome.
+         */
+        const optimistic = (batch, admitting, committed) => {
+            const { request } = batch[0];
+            const { issuedAt, expiresAt } = commandTimes(request.commandId);
+            const identityOffset = request.clockOffset ?? clock.offsetMillis();
+            const ordinary = () => Effect.flatMap(openAlone(batch), (opened) => alone(batch, opened));
+            return admitting.admission.resume().pipe(Effect.catchDefect((defect) => Schema.is(RetryTurn)(defect) || SqlError.isSqlError(defect)
+                ? Effect.die(defect)
+                : Effect.void), Effect.flatMap((plan) => {
+                if (plan === undefined || plan.writes === undefined || plan.needsAdmissionClock)
+                    return ordinary();
+                let missed = false;
+                let tag = "";
+                let version = "";
+                let endedAtMs = 0;
+                let startedAtMs = 0;
+                const guard = sql `
+                WITH locked AS MATERIALIZED (
+                  SELECT g.generation, g.created, g.event_sequence,
+                    to_jsonb(g)->>'cold_ref' AS cold_ref
+                  FROM actor_generations g
+                  WHERE ${rowOf({ sql, actor: { key: routingKey, ref }, alias: "g" })}
+                  FOR UPDATE OF g
+                ), checked AS MATERIALIZED (
+                  SELECT *, floor(extract(epoch FROM clock_timestamp()) * 1000)::bigint AS now
+                  FROM locked
+                )
+                SELECT 1 / CASE WHEN EXISTS (
+                  SELECT 1 FROM checked g
+                  WHERE g.generation = ${committed.generation} AND g.created = ${committed.created}
+                    AND g.event_sequence = ${committed.head}
+                    AND g.cold_ref IS NULL
+                    AND NOT EXISTS (SELECT 1 FROM actor_receipts WHERE ${actorRow}
+                      AND command_id = ${request.commandId})
+                    AND (${request.external !== true} OR
+                      (g.now + ${identityOffset} >= ${issuedAt} AND g.now + ${identityOffset} < ${expiresAt}))
+                ) THEN 1 ELSE 0 END AS accepted,
+                (SELECT set_config('durable.admitted_at_ms', now::text, true) FROM checked) AS now`;
+                const flight = [
+                    begin,
+                    Effect.asVoid(sql `SELECT ${timeouts}`),
+                    Effect.map(guard, (rows) => {
+                        startedAtMs = Number(rows[0].now);
+                        if (request.external === true)
+                            batch[0].admitted = true;
+                    }).pipe(Effect.tapError((error) => Effect.sync(() => {
+                        missed = Schema.is(Schema.Struct({ code: Schema.Literal("22012") }))(error.reason.cause);
+                    }))),
+                    ...plan.writes,
+                    Effect.map(control("COMMIT"), (result) => {
+                        tag = result.command;
+                        open = false;
+                    }),
+                    Effect.map(session().query(COMMIT_VERSION, [], true), (result) => {
+                        const ended = result.rows[0];
+                        version = ended.version;
+                        endedAtMs = Number(ended.now);
+                    }),
+                ];
+                return sendPipelined(flight).pipe(Effect.withSpan(SpanNames.commit), Effect.as(true), Effect.catch((error) => {
+                    const duplicate = Schema.is(Schema.Struct({
+                        code: Schema.Literal("23505"),
+                        constraint: Schema.Literal("actor_receipts_pkey"),
+                    }))(error.reason.cause);
+                    return (missed || duplicate) && tag === "ROLLBACK"
+                        ? Effect.succeed(false)
+                        : Effect.fail(error);
+                }), Effect.flatMap((accepted) => {
+                    if (!accepted) {
+                        forget(cache);
+                        return ordinary();
+                    }
+                    if (tag !== "COMMIT")
+                        return Effect.die(RetryTurn.make({ message: "Warm turn commit rolled back" }));
+                    return Effect.as(release, {
+                        plan: { ...plan, startedAtMs },
+                        version,
+                        endedAtMs,
+                    });
+                }));
+            }), inTurn, bounded);
+        };
         const onMember = (member) => (effect) => Effect.suspend(() => Effect.provideService(effect, sql.transactionService, [
             asSqlConnection({ connection: member.connection(), send: member.send }),
             0,
@@ -906,17 +1114,60 @@ export const executeBatches = Effect.fnUntraced(function* (run, cache, routingKe
                 };
             }).pipe(Effect.catchDefect((defect) => defect instanceof Unseated ? Effect.undefined : Effect.die(defect)), Effect.onExit(() => member.leave(false)), bounded, Effect.map((ended) => ({ ended, following })));
         };
-        const transact = (batch, admitting) => admitting.member === undefined
-            ? alone(batch, admitting)
-            : Effect.flatMap(grouped(batch, admitting.admission, admitting.member), (outcome) => outcome.ended !== undefined
-                ? Effect.succeed(outcome.ended)
-                : Effect.flatMap(openAlone(batch), (opened) => alone(batch, opened, outcome.following)));
+        const transact = (batch, admitting) => admitting.optimistic !== undefined
+            ? optimistic(batch, admitting, admitting.optimistic)
+            : admitting.member === undefined
+                ? alone(batch, admitting)
+                : Effect.flatMap(grouped(batch, admitting.admission, admitting.member), (outcome) => outcome.ended !== undefined
+                    ? Effect.succeed(outcome.ended)
+                    : Effect.flatMap(openAlone(batch), (opened) => alone(batch, opened, outcome.following)));
         let first = true;
         return yield* drive((batch) => {
-            const joining = first && view().generation !== undefined && view().state !== undefined
+            const snapshot = cache.committed;
+            const { request, command } = batch[0];
+            const fast = warmTurns &&
+                batch.length === 1 &&
+                cache.cold === undefined &&
+                snapshot !== undefined &&
+                snapshot.generation === cache.generation &&
+                snapshot.state === cache.state &&
+                !statements &&
+                waited.size === 0 &&
+                connections === undefined &&
+                !run.publishesUnderLock(batch) &&
+                !command.handler &&
+                (!command.internal || isSystem(request.caller)) &&
+                request.delivery === undefined &&
+                request.redelivered !== true &&
+                commandTimes(request.commandId).issuedAt > snapshot.replayBefore &&
+                !snapshot.receipts.has(request.commandId) &&
+                (policy.createdBy === undefined || snapshot.created);
+            const joining = first &&
+                cache.cold === undefined &&
+                view().generation !== undefined &&
+                view().state !== undefined
                 ? groups
                 : undefined;
             first = false;
+            if (fast)
+                return leased.pipe(Effect.map(() => ({
+                    admission: admit(batch, [], view(), pipeline, [], false, {
+                        now: String(snapshot.now),
+                        generation: snapshot.generation,
+                        created: snapshot.created,
+                        cold_ref: null,
+                        cold_digest: null,
+                        cold_state_version: null,
+                        canonical: request.payload,
+                        caller_key: null,
+                        command: null,
+                        payload_hash: null,
+                        outcome: null,
+                        head: snapshot.head,
+                    }),
+                    admitted: [],
+                    optimistic: snapshot,
+                })));
             return joining === undefined ? openAlone(batch) : openGrouped(batch, joining);
         }, transact).pipe(Effect.onExit((exit) => {
             if (Exit.isSuccess(exit) || !open)
@@ -960,6 +1211,7 @@ export const executeBatches = Effect.fnUntraced(function* (run, cache, routingKe
         : Option.getOrUndefined(yield* Effect.serviceOption(TurnGroups));
     const exit = yield* (Option.isSome(turns) ? pipelined(turns.value) : sequential).pipe(Effect.onError(() => Effect.sync(() => {
         cache.state = undefined;
+        cache.committed = undefined;
     })), Effect.exit);
     if (Exit.isSuccess(exit))
         return undefined;

package/dist/runtime/turn/hooks.d.ts

@@ -4,7 +4,7 @@ import type { Request } from "../request.ts";
  * A named moment in command delivery, turn execution, and the outbox and
  * subscription relays where a test can pause, fail, or crash the runtime.
  */
-export type TurnPoint = "beforeDelivery" | "queued" | "beforeHandler" | "beforeCommit" | "afterCommit" | "beforeFlush" | "afterClaim" | "beforeOutboxDelete" | "beforeExecute" | "afterExecute" | "beforeRenew" | "beforeDeadLetterCommit" | "beforeSettle" | "afterSettleSnapshot" | "afterExpand" | "beforeWorkflowSuspend";
+export type TurnPoint = "beforeDelivery" | "queued" | "beforeHandler" | "afterColdRollback" | "afterColdFetch" | "afterColdWriteBack" | "beforeCommit" | "afterCommit" | "beforeFlush" | "afterClaim" | "beforeOutboxDelete" | "beforeExecute" | "afterExecute" | "beforeRenew" | "beforeDeadLetterCommit" | "beforeSettle" | "afterSettleSnapshot" | "afterExpand" | "beforeWorkflowSuspend";
 declare const RetryTurn_base: Schema.Class<RetryTurn, Schema.TaggedStruct<"RetryTurn", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;

package/dist/runtime/turn/outbox.d.ts

@@ -53,7 +53,7 @@ export declare const ControlPayload: Schema.fromJsonString<Schema.Struct<{
 export declare const CallerJson: Schema.fromJsonString<Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"User", {
     readonly subject: Schema.NonEmptyString;
 }>, Schema.TaggedStruct<"Anonymous", {}>, Schema.TaggedStruct<"System", {
-    readonly source: Schema.Literals<readonly ["process", "actor", "timer", "cron", "workflow", "job", "subscription"]>;
+    readonly source: Schema.Literals<readonly ["process", "actor", "timer", "cron", "workflow", "job", "subscription", "cold"]>;
     readonly ref: Schema.optional<Schema.Struct<{
         readonly tenant: Schema.NonEmptyString;
         readonly actor: Schema.NonEmptyString;

package/dist/runtime/turn/receipt.d.ts

@@ -28,7 +28,7 @@ export declare const checkReceipt: (request: {
         readonly _tag: "Anonymous";
     } | {
         readonly _tag: "System";
-        readonly source: "actor" | "cron" | "job" | "process" | "subscription" | "timer" | "workflow";
+        readonly source: "actor" | "cold" | "cron" | "job" | "process" | "subscription" | "timer" | "workflow";
         readonly ref?: {
             readonly tenant: string;
             readonly actor: string;

package/dist/runtime/turn/relay.d.ts

@@ -44,7 +44,7 @@ interface LocalExecutor {
  * subscription work in `work`.
  */
 interface ClaimedRow extends ClaimedJob {
-    readonly kind: "intent" | "job" | "skipped-intent" | "skipped-job" | "work";
+    readonly kind: "intent" | "job" | "cold" | "skipped-intent" | "skipped-job" | "skipped-cold" | "work";
     readonly target_type: string;
     readonly target_id: string;
     readonly timer_key: string | null;
@@ -62,7 +62,7 @@ interface ClaimedRow extends ClaimedJob {
  */
 export declare const candidates: ({ sql, kind, now, limit, only, range, }: {
     readonly sql: SqlClient.SqlClient;
-    readonly kind: "intent" | "job" | "feed" | "control";
+    readonly kind: "intent" | "job" | "feed" | "control" | "cold";
     readonly now: Statement.Fragment;
     readonly limit: number;
     readonly only?: Statement.Fragment;