@johannc-dev/zyrk 0.2.0 → 0.2.2

package/dist/client.js

@@ -1,5 +1,5 @@
-import { Cause, Config, Context, Effect, Exit, Layer, Option, Redacted, Schema, } from "effect";
-import { decode, Job, Json, ProgramSummary, Started, toJobResult, } from "./contracts.js";
+import { Cause, Config, Context, Effect, Exit, Layer, Option, Redacted, Result, Schema, } from "effect";
+import { decode, Job, Json, ProgramDeleted, ProgramSummary, Started, toJobResult, } from "./contracts.js";
 import { ApiError, ConfigError, DecodeError, ExecutionEnded, ExecutionFailed, Failure, messageOf, NetworkError, WaitTimeout, } from "./errors.js";
 export * from "./errors.js";
 const ServerError = Schema.Struct({
@@ -38,9 +38,50 @@ const parseJson = (text) => {
 };
 const segment = encodeURIComponent;
 const isFinal = (r) => r.status !== "queued" && r.status !== "running";
+const MAX_HOLD_MS = 10_000;
+const POLL_MS = 1_000;
+const FOLLOW_SLACK_MS = 25;
+const MAX_WAIT_IDS = 100;
+const WAITED_HEADER = "x-functions-waited";
+const rhythmFrom = (start) => ({
+    anchor: start,
+    last: start,
+    rtt: undefined,
+});
+const periodOf = (rhythm) => POLL_MS + (rhythm.rtt ?? 0);
+const tickFrom = (rhythm, t) => {
+    const period = periodOf(rhythm);
+    const from = Math.max(t, rhythm.last + 1);
+    const k = Math.max(0, Math.ceil((from - rhythm.anchor) / period));
+    return rhythm.anchor + k * period;
+};
+const tickBefore = (rhythm, t) => t < rhythm.anchor
+    ? -Infinity
+    : rhythm.anchor +
+        Math.floor((t - rhythm.anchor) / periodOf(rhythm)) * periodOf(rhythm);
+const answered = (rhythm, sentAt, now, tick = sentAt) => {
+    rhythm.rtt = now - sentAt;
+    rhythm.anchor = tick + rhythm.rtt + POLL_MS;
+};
+const planFor = (rhythm, sentAt, rtt, offset, cap) => {
+    if (!(cap >= POLL_MS))
+        return undefined;
+    const cappedAt = Math.min(cap, MAX_HOLD_MS);
+    const tick = tickBefore(rhythm, sentAt + rtt + cappedAt - offset);
+    const waitMs = tick + offset - sentAt - rtt;
+    return tick > rhythm.last && waitMs >= POLL_MS
+        ? { waitMs, tick }
+        : { waitMs: cappedAt, tick: undefined };
+};
+const transient = (error) => error instanceof NetworkError ||
+    (error instanceof ApiError && [502, 503, 504].includes(error.status));
+const sleepUntil = (t) => Effect.suspend(() => {
+    const ms = t - Date.now();
+    return ms > 0 ? Effect.sleep(ms) : Effect.void;
+});
 export const make = (config) => {
     const base = `${config.url.replace(/\/$/, "")}/v1/functions/`;
-    const request = Effect.fnUntraced(function* (method, path, body) {
+    const send = Effect.fnUntraced(function* (method, path, body) {
         const url = base + path;
         const response = yield* Effect.tryPromise({
             try: async (signal) => {
@@ -57,6 +98,7 @@ export const make = (config) => {
                 return {
                     status: response.status,
                     ok: response.ok,
+                    waited: response.headers?.get?.(WAITED_HEADER) === "1",
                     text: await response.text(),
                 };
             },
@@ -74,15 +116,53 @@ export const make = (config) => {
                 what: `${method} ${path}`,
                 message: "Response body is not JSON",
             });
-        return yield* decode(Json, `${method} ${path}`)(parsed.value);
+        const json = yield* decode(Json, `${method} ${path}`)(parsed.value);
+        return { json, waited: response.waited };
+    });
+    const request = (method, path, body) => send(method, path, body).pipe(Effect.map((r) => r.json));
+    const executionAt = (id, query = "") => send("GET", `executions/${segment(id)}${query}`).pipe(Effect.flatMap((reply) => decode(Job, "execution")(reply.json).pipe(Effect.map((job) => ({ job, waited: reply.waited })))));
+    const execution = (id) => executionAt(id).pipe(Effect.map((r) => r.job));
+    const followWith = (id, cursor, query) => Effect.suspend(() => executionAt(cursor.current, query()).pipe(Effect.flatMap(({ job, waited }) => {
+        if (job.status !== "continued" || cursor.hops >= 10_000)
+            return Effect.succeed({
+                result: { ...toJobResult(job), id },
+                waited,
+            });
+        cursor.current = job.nextExecutionId;
+        cursor.hops++;
+        return followWith(id, cursor, query);
+    })));
+    const follow = (id, cursor) => followWith(id, cursor, () => "").pipe(Effect.map((r) => r.result));
+    const cursorAt = (id) => ({ current: id, hops: 0 });
+    const result = (id) => follow(id, cursorAt(id));
+    const deadlineOf = (options) => options.timeoutMs === undefined ? Infinity : Date.now() + options.timeoutMs;
+    const waitQuery = (plan) => plan === undefined ? "" : `?waitMs=${plan.waitMs}`;
+    const guarded = (check, held, deadline) => held && deadline !== Infinity
+        ? check.pipe(Effect.timeoutOption(Math.max(0, deadline - Date.now())))
+        : check.pipe(Effect.map(Option.some));
+    const recover = (rhythm, failedAt, deadline, check, one = rhythm.rtt, offset = 0) => Effect.gen(function* () {
+        if (failedAt >= deadline)
+            return Option.none();
+        const safe = failedAt + POLL_MS;
+        const due = one === undefined
+            ? undefined
+            : tickFrom(rhythm, failedAt - one - offset);
+        const at = Math.min(due === undefined ? safe : Math.max(due + offset, failedAt), deadline);
+        const tick = due !== undefined && due < deadline ? due : undefined;
+        yield* sleepUntil(at);
+        rhythm.last = Math.max(rhythm.last, tick ?? at);
+        const sentAt = Date.now();
+        const first = yield* Effect.result(check);
+        if (Result.isSuccess(first))
+            return Option.some({ value: first.success, sentAt, tick });
+        if (!transient(first.failure) || sentAt >= safe || Date.now() >= deadline)
+            return yield* Effect.fail(first.failure);
+        yield* sleepUntil(Math.min(safe, deadline));
+        const again = Date.now();
+        rhythm.last = Math.max(rhythm.last, again);
+        const value = yield* check;
+        return Option.some({ value, sentAt: again, tick: undefined });
     });
-    const execution = (id) => request("GET", `executions/${segment(id)}`).pipe(Effect.flatMap(decode(Job, "execution")));
-    const result = (id) => {
-        const follow = (current, hops) => execution(current).pipe(Effect.flatMap((job) => job.status === "continued" && hops < 10_000
-            ? follow(job.nextExecutionId, hops + 1)
-            : Effect.succeed({ ...toJobResult(job), id })));
-        return follow(id, 0);
-    };
     const poll = (check, options, onTimeout) => {
         const deadline = options.timeoutMs === undefined
             ? Infinity
@@ -98,7 +178,10 @@ export const make = (config) => {
         })));
         return step;
     };
-    const wait = (id, options = {}) => poll(result(id).pipe(Effect.flatMap((r) => {
+    const wait = (id, options = {}) => Effect.suspend(() => options.pollMs === undefined
+        ? waitHeld(id, cursorAt(id), options)
+        : waitFrom(id, cursorAt(id), options));
+    const outcome = (id, r) => {
         switch (r.status) {
             case "succeeded":
                 return Effect.succeed(Option.some(r.result));
@@ -112,17 +195,427 @@ export const make = (config) => {
             case "running":
                 return Effect.succeed(Option.none());
         }
-    })), options, () => Effect.fail(new WaitTimeout({
-        executionId: id,
-        timeoutMs: options.timeoutMs ?? 0,
-    })));
-    const waitAll = (ids, options = {}) => {
+    };
+    const timedOut = (id, options) => Effect.fail(new WaitTimeout({ executionId: id, timeoutMs: options.timeoutMs ?? 0 }));
+    const waitFrom = (id, cursor, options) => poll(follow(id, cursor).pipe(Effect.flatMap((r) => outcome(id, r))), options, () => timedOut(id, options));
+    const holdOne = (id, cursor, options) => Effect.gen(function* () {
+        const start = Date.now();
+        const deadline = deadlineOf(options);
+        const rhythm = rhythmFrom(start);
+        const plain = followWith(id, cursor, () => "");
+        let failures = 0;
+        let polling = false;
+        let at = start;
+        let tick = start;
+        let sentAt = start;
+        let plan;
+        const planNow = () => {
+            sentAt = Date.now();
+            const rtt = rhythm.rtt ?? 0;
+            plan = polling
+                ? undefined
+                : planFor(rhythm, sentAt, rtt, 0, deadline - sentAt - rtt);
+        };
+        for (;;) {
+            yield* sleepUntil(at);
+            if (tick !== undefined)
+                rhythm.last = Math.max(rhythm.last, tick);
+            planNow();
+            const held = plan !== undefined;
+            const read = Effect.suspend(() => executionAt(cursor.current, waitQuery(plan)));
+            const tried = yield* Effect.result(guarded(read, held, deadline));
+            let result;
+            let now;
+            if (Result.isFailure(tried)) {
+                if (!held || !transient(tried.failure))
+                    return yield* Effect.fail(tried.failure);
+                if (++failures >= 2)
+                    polling = true;
+                const recovered = yield* recover(rhythm, Date.now(), deadline, plain);
+                if (Option.isNone(recovered))
+                    return { latest: undefined };
+                const { value, sentAt: s, tick: due } = recovered.value;
+                now = Date.now();
+                result = value.result;
+                if (due !== undefined)
+                    answered(rhythm, s, now, due);
+                else if (rhythm.rtt === undefined)
+                    rhythm.rtt = now - s;
+                const lag = due === undefined ? 0 : s - due;
+                tick = tickFrom(rhythm, now - lag);
+                at = Math.max(tick, now);
+            }
+            else if (Option.isNone(tried.success)) {
+                const { result: last } = yield* plain;
+                return { latest: last };
+            }
+            else {
+                const { job, waited } = tried.success.value;
+                now = Date.now();
+                const asked = plan?.waitMs ?? 0;
+                const heldMs = now - sentAt;
+                const full = asked > 0 && heldMs >= Math.max(POLL_MS, 0.9 * asked);
+                if (job.status === "continued" && cursor.hops < 10_000) {
+                    cursor.current = job.nextExecutionId;
+                    cursor.hops++;
+                    if (!waited || heldMs <= (rhythm.rtt ?? 0) + FOLLOW_SLACK_MS) {
+                        if (tick !== undefined) {
+                            if (!waited)
+                                rhythm.rtt = heldMs;
+                            rhythm.anchor = now + (rhythm.rtt ?? 0) + POLL_MS;
+                        }
+                        at = now;
+                    }
+                    else {
+                        failures = 0;
+                        const rtt = rhythm.rtt ?? 0;
+                        tick = tickFrom(rhythm, now - rtt);
+                        at = tick + rtt;
+                        rhythm.anchor = at + rtt + POLL_MS;
+                    }
+                    if (at >= deadline) {
+                        at = deadline;
+                        tick = undefined;
+                    }
+                    continue;
+                }
+                result = { ...toJobResult(job), id };
+                if (!waited) {
+                    if (tick !== undefined)
+                        answered(rhythm, sentAt, now);
+                    else if (rhythm.rtt === undefined)
+                        rhythm.rtt = heldMs;
+                    tick = at = tickFrom(rhythm, now);
+                }
+                else if (!full) {
+                    rhythm.anchor = now + POLL_MS;
+                    tick = at = rhythm.anchor;
+                }
+                else {
+                    failures = 0;
+                    if (rhythm.rtt === undefined) {
+                        rhythm.rtt = Math.max(0, heldMs - asked);
+                        tick = at = tickFrom(rhythm, now);
+                    }
+                    else if (plan?.tick !== undefined) {
+                        tick = plan.tick;
+                        at = Math.max(now, plan.tick);
+                    }
+                    else
+                        tick = at = tickFrom(rhythm, now);
+                }
+            }
+            if (isFinal(result) || now >= deadline)
+                return { latest: result };
+            if (at >= deadline) {
+                at = deadline;
+                tick = undefined;
+            }
+        }
+    });
+    const waitHeld = (id, cursor, options) => holdOne(id, cursor, options).pipe(Effect.flatMap(({ latest }) => latest === undefined
+        ? timedOut(id, options)
+        : outcome(id, latest).pipe(Effect.flatMap(Option.match({
+            onSome: Effect.succeed,
+            onNone: () => timedOut(id, options),
+        })))));
+    const waitAll = (ids, options = {}) => options.pollMs === undefined
+        ? waitAllHeld(ids, options)
+        : waitAllPolled(ids, options);
+    const waitAllPolled = (ids, options) => Effect.suspend(() => {
         const latest = new Map();
+        const entries = ids.map((id) => ({ id, cursor: cursorAt(id) }));
         const snapshot = () => ids.map((id) => latest.get(id));
-        const check = Effect.forEach(ids.filter((id) => !latest.has(id) || !isFinal(latest.get(id))), (id) => result(id).pipe(Effect.tap((r) => Effect.sync(() => latest.set(id, r)))), { concurrency: 8 }).pipe(Effect.map(() => ids.every((id) => isFinal(latest.get(id)))
+        const check = Effect.forEach(entries, ({ id, cursor }) => follow(id, cursor).pipe(Effect.tap((r) => Effect.sync(() => latest.set(id, r)))), { concurrency: 8 }).pipe(Effect.map(() => ids.every((id) => isFinal(latest.get(id)))
             ? Option.some(snapshot())
             : Option.none()));
         return poll(check, options, () => Effect.sync(snapshot));
+    });
+    const waitAllHeld = (ids, options) => Effect.suspend(() => {
+        if (ids.length === 1) {
+            const id = ids[0];
+            const cursor = cursorAt(id);
+            return holdOne(id, cursor, options).pipe(Effect.flatMap(({ latest }) => latest === undefined ? follow(id, cursor) : Effect.succeed(latest)), Effect.map((r) => [r]));
+        }
+        return waitMany(ids, options);
+    });
+    const waitMany = (ids, options) => Effect.gen(function* () {
+        const start = Date.now();
+        const deadline = deadlineOf(options);
+        const rhythm = rhythmFrom(start);
+        const latest = new Map();
+        const entries = ids.map((id) => ({ id, cursor: cursorAt(id) }));
+        const snapshot = () => ids.map((id) => latest.get(id));
+        const allFinal = () => ids.every((id) => isFinal(latest.get(id)));
+        const seen = (entry, r) => {
+            latest.set(entry.id, r);
+            entry.readAt = entry.cursor.current;
+        };
+        let sent = 0;
+        const pollingSent = (t) => Math.max(Math.min(ids.length, 8), (ids.length * (t - start)) / periodOf(rhythm));
+        let rtt1;
+        const pool = (walks) => {
+            const slots = Array(Math.min(8, entries.length)).fill(0);
+            const starts = entries.map((_, j) => {
+                const i = slots.indexOf(Math.min(...slots));
+                const startsAt = slots[i];
+                slots[i] = startsAt + (1 + (walks?.[j] ?? 0)) * (rtt1 ?? 0);
+                return startsAt;
+            });
+            return { starts, length: Math.max(0, ...slots) };
+        };
+        const roundTime = (walks) => pool(walks).length;
+        const roundEnded = (sentAt, now, tick = sentAt) => {
+            answered(rhythm, sentAt, now, tick);
+            rhythm.rtt = roundTime();
+        };
+        const offsetOf = () => Math.max(0, (rhythm.rtt ?? 0) - (rtt1 ?? 0));
+        const round = (list, query) => Effect.suspend(() => {
+            sent += list.length;
+            return Effect.forEach(list, (entry) => Effect.suspend(() => {
+                const t = Date.now();
+                return followWith(entry.id, entry.cursor, query).pipe(Effect.tap((r) => Effect.sync(() => seen(entry, r.result))), Effect.map((r) => ({
+                    waited: r.waited,
+                    took: Date.now() - t,
+                })));
+            }), { concurrency: 8 });
+        }).pipe(Effect.map((reads) => {
+            for (const r of reads)
+                rtt1 = Math.min(rtt1 ?? Infinity, r.took);
+            return reads.some((r) => r.waited);
+        }));
+        const plainRound = () => round(entries, () => "");
+        const fresh = Effect.suspend(() => {
+            const stale = entries.filter((e) => e.readAt !== e.cursor.current);
+            return stale.length === 0
+                ? Effect.sync(snapshot)
+                : round(stale, () => "").pipe(Effect.map(snapshot));
+        });
+        const multi = (waitMs) => {
+            const distinct = [...new Set(entries.map((e) => e.cursor.current))];
+            const chunks = [];
+            for (let i = 0; i < distinct.length; i += MAX_WAIT_IDS)
+                chunks.push(distinct.slice(i, i + MAX_WAIT_IDS));
+            sent += chunks.length;
+            return Effect.forEach(chunks, (chunk) => send("POST", "executions/wait", { ids: chunk, waitMs }).pipe(Effect.flatMap((reply) => readMulti(chunk, reply))), { concurrency: 8 }).pipe(Effect.catchIf((e) => e instanceof ApiError && [400, 404, 405].includes(e.status), () => Effect.succeed(null)), Effect.flatMap((answers) => {
+                if (answers === null)
+                    return Effect.succeed(null);
+                const records = new Map();
+                for (const answer of answers)
+                    for (const [id, record] of answer.records)
+                        records.set(id, record);
+                let advanced = false;
+                let progressed = false;
+                const walks = entries.map(() => 0);
+                for (const [j, entry] of entries.entries()) {
+                    const { cursor } = entry;
+                    const record = records.get(cursor.current);
+                    if (record instanceof ApiError)
+                        return Effect.fail(record);
+                    if (record.status === "continued" && cursor.hops < 10_000) {
+                        cursor.current = record.nextExecutionId;
+                        cursor.hops++;
+                        advanced = true;
+                        walks[j] = 1;
+                    }
+                    else {
+                        const r = { ...toJobResult(record), id: entry.id };
+                        const before = latest.get(entry.id);
+                        if (before !== undefined && !isFinal(before) && isFinal(r))
+                            progressed = true;
+                        seen(entry, r);
+                    }
+                }
+                return Effect.succeed({
+                    waited: answers.every((a) => a.waited),
+                    advanced,
+                    progressed,
+                    walks,
+                });
+            }));
+        };
+        if (ids.length === 0)
+            return [];
+        let mode = "probe";
+        let failures = 0;
+        let at = start;
+        let tick = start;
+        let capped = false;
+        let current = start;
+        let onRound = true;
+        let following = false;
+        let roundWalks = entries.map(() => 0);
+        let nextWalks;
+        for (;;) {
+            yield* sleepUntil(at);
+            if (tick !== undefined) {
+                rhythm.last = current = tick;
+                roundWalks = nextWalks ?? entries.map(() => 0);
+                nextWalks = undefined;
+            }
+            onRound = tick !== undefined || (following && onRound);
+            following = false;
+            const checkAt = Date.now();
+            const offset = capped ? offsetOf() : 0;
+            let now;
+            if (mode !== "multi") {
+                const waited = yield* round(entries, mode === "probe" ? () => "?waitMs=0" : () => "");
+                now = Date.now();
+                if (tick !== undefined)
+                    roundEnded(checkAt, now);
+                if (mode === "probe" && waited)
+                    mode = "multi";
+                if (allFinal() || now >= deadline)
+                    return yield* fresh;
+                tick = tickFrom(rhythm, now);
+                at = tick;
+            }
+            else {
+                const one = rtt1 ?? 0;
+                const plan = planFor(rhythm, checkAt, one, offset, deadline - checkAt - one);
+                const tried = yield* Effect.result(guarded(multi(plan?.waitMs ?? 0), plan !== undefined, deadline));
+                now = Date.now();
+                if (Result.isFailure(tried)) {
+                    if (plan === undefined || !transient(tried.failure))
+                        return yield* Effect.fail(tried.failure);
+                    if (++failures >= 2)
+                        mode = "rounds";
+                    const late = offsetOf();
+                    const recovered = yield* recover(rhythm, now, deadline, multi(0), one, late);
+                    if (Option.isNone(recovered))
+                        return yield* fresh;
+                    now = Date.now();
+                    const { value: r, sentAt, tick: due } = recovered.value;
+                    if (r === null) {
+                        mode = "rounds";
+                        yield* plainRound();
+                        now = Date.now();
+                    }
+                    if (due !== undefined)
+                        rhythm.anchor = due + roundTime() + POLL_MS;
+                    if ((r === null || !r.advanced) && allFinal())
+                        return yield* fresh;
+                    if (now >= deadline)
+                        return yield* fresh;
+                    if (r !== null && r.advanced) {
+                        tick = undefined;
+                        at = now;
+                        following = due !== undefined;
+                    }
+                    else {
+                        const lag = due === undefined ? 0 : sentAt - (due + late);
+                        tick = tickFrom(rhythm, now - lag);
+                        at = Math.max(tick, now);
+                    }
+                }
+                else if (Option.isNone(tried.success)) {
+                    yield* multi(0);
+                    return yield* fresh;
+                }
+                else if (tried.success.value === null) {
+                    mode = "rounds";
+                    yield* plainRound();
+                    const end = Date.now();
+                    roundEnded(now, end);
+                    if (allFinal() || end >= deadline)
+                        return yield* fresh;
+                    tick = tickFrom(rhythm, end);
+                    at = tick;
+                }
+                else {
+                    const r = tried.success.value;
+                    if (!r.advanced && allFinal())
+                        return yield* fresh;
+                    if (now >= deadline)
+                        return yield* fresh;
+                    const asked = plan?.waitMs ?? 0;
+                    const heldMs = now - checkAt;
+                    const full = r.waited && asked > 0 && heldMs >= Math.max(POLL_MS, 0.9 * asked);
+                    if (full || (r.waited && (r.progressed || r.advanced)))
+                        failures = 0;
+                    capped = !r.waited;
+                    const after = capped ? offsetOf() : 0;
+                    const walked = r.advanced && r.waited && heldMs > one + FOLLOW_SLACK_MS;
+                    if (onRound && !walked)
+                        r.walks.forEach((w, j) => (roundWalks[j] += w));
+                    const last = current + Math.max(0, roundTime(roundWalks) - one);
+                    const again = capped && onRound && !r.advanced && last > now;
+                    if (capped && onRound && !r.advanced && !again)
+                        rhythm.anchor = now + POLL_MS;
+                    const next = again ? current : tickFrom(rhythm, now);
+                    const nextAt = again ? last : next + after;
+                    if (walked && entries.length > 8) {
+                        const { starts } = pool(roundWalks);
+                        r.walks.forEach((w, j) => {
+                            if (w === 0)
+                                return;
+                            if (current + starts[j] + one >= now)
+                                roundWalks[j] += w;
+                            else
+                                (nextWalks ??= entries.map(() => 0))[j] += w;
+                        });
+                        rhythm.anchor = current + roundTime(roundWalks) + POLL_MS;
+                    }
+                    if (walked && entries.length <= 8) {
+                        const length = roundTime(r.walks);
+                        tick = tickFrom(rhythm, now - one);
+                        at = tick + Math.max(0, length - one);
+                        rhythm.anchor = tick + length + POLL_MS;
+                        nextWalks = r.walks;
+                    }
+                    else if (r.advanced ||
+                        (r.waited && r.progressed) ||
+                        (full && plan?.tick === undefined)) {
+                        if (r.advanced && onRound && r.waited && !walked)
+                            rhythm.anchor = now + one + POLL_MS;
+                        const chunks = Math.ceil(entries.length / MAX_WAIT_IDS);
+                        if (sent + chunks <= pollingSent(now)) {
+                            tick = undefined;
+                            at = now;
+                            following = r.advanced;
+                        }
+                        else {
+                            tick = next;
+                            at = nextAt;
+                        }
+                    }
+                    else if (full && plan?.tick !== undefined) {
+                        tick = plan.tick;
+                        at = Math.max(now, plan.tick + offset);
+                    }
+                    else {
+                        tick = next;
+                        at = nextAt;
+                    }
+                }
+            }
+            if (at >= deadline) {
+                at = deadline;
+                tick = undefined;
+            }
+        }
+    });
+    const readMulti = (chunk, reply) => {
+        const body = reply.json;
+        const list = body?.executions;
+        if (!Array.isArray(list) || list.length !== chunk.length)
+            return Effect.fail(new DecodeError({
+                what: "POST executions/wait",
+                message: "expected one record per id",
+            }));
+        return Effect.forEach(list, (item, i) => {
+            const missing = typeof item === "object" &&
+                item !== null &&
+                item.error !== undefined;
+            if (missing) {
+                const error = { error: item.error };
+                return Effect.succeed([chunk[i], apiError(404, error)]);
+            }
+            return decode(Job, "execution")(item).pipe(Effect.map((job) => [chunk[i], job]));
+        }).pipe(Effect.map((pairs) => ({
+            records: new Map(pairs),
+            waited: reply.waited && body?.waited === true,
+        })));
     };
     const start = (program, input) => request("POST", `programs/${segment(program)}/invoke`, {
         ...input,
@@ -137,6 +630,7 @@ export const make = (config) => {
         programs: () => request("GET", "programs").pipe(Effect.flatMap(decode(Schema.Array(ProgramSummary), "programs"))),
         inspect: (program) => request("GET", `programs/${segment(program)}`),
         pause: (program, paused = true) => request("POST", `programs/${segment(program)}/pause`, { paused }),
+        delete: (program) => request("DELETE", `programs/${segment(program)}`).pipe(Effect.flatMap(decode(ProgramDeleted, "delete response"))),
         executions: (program) => request("GET", `programs/${segment(program)}/executions`),
         start,
         execution,
@@ -202,6 +696,9 @@ export class FunctionsClient {
     pause(program, paused = true, signal) {
         return runPromise(this.client.pause(program, paused), signal);
     }
+    delete(program, signal) {
+        return runPromise(this.client.delete(program), signal);
+    }
     executions(program, signal) {
         return runPromise(this.client.executions(program), signal);
     }

package/dist/contracts.d.ts

@@ -277,6 +277,22 @@ export declare const ProgramSummary: Schema.Struct<{
     readonly paused: Schema.Boolean;
 }>;
 export type ProgramSummary = typeof ProgramSummary.Type;
+/** What `DELETE programs/{program}` removed (counts). */
+export declare const ProgramDeleted: Schema.Struct<{
+    readonly deleted: Schema.Boolean;
+    readonly program: Schema.String;
+    readonly removed: Schema.Struct<{
+        readonly versions: Schema.Number;
+        readonly stateKeys: Schema.Number;
+        readonly subscriptions: Schema.Number;
+        readonly executions: Schema.Number;
+        readonly cancelledExecutions: Schema.Number;
+        readonly replays: Schema.Number;
+        readonly cancelledReplays: Schema.Number;
+        readonly streamEvents: Schema.Number;
+    }>;
+}>;
+export type ProgramDeleted = typeof ProgramDeleted.Type;
 /** A schema that decodes without Effect services, so decoding is synchronous. */
 export type Decodable = Schema.Top & {
     readonly DecodingServices: never;

package/dist/contracts.js

@@ -111,6 +111,20 @@ export const ProgramSummary = Schema.Struct({
     stateVersion: Schema.Number,
     paused: Schema.Boolean,
 });
+export const ProgramDeleted = Schema.Struct({
+    deleted: Schema.Boolean,
+    program: Schema.String,
+    removed: Schema.Struct({
+        versions: Schema.Number,
+        stateKeys: Schema.Number,
+        subscriptions: Schema.Number,
+        executions: Schema.Number,
+        cancelledExecutions: Schema.Number,
+        replays: Schema.Number,
+        cancelledReplays: Schema.Number,
+        streamEvents: Schema.Number,
+    }),
+});
 export const NonNegativeInt = Schema.Number.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0));
 export const decodeWith = (schema, options, onError) => {
     const parse = Schema.decodeUnknownResult(schema);

package/dist/errors.d.ts

@@ -20,8 +20,16 @@ declare const NetworkError_base: Schema.Class<NetworkError, Schema.TaggedStruct<
     readonly url: Schema.String;
     readonly message: Schema.String;
     readonly cause: Schema.Unknown;
+    readonly reason: Schema.optional<Schema.String>;
 }>, import("effect/Cause").YieldableError>;
-/** The service could not be reached (DNS, TLS, connection reset, abort). */
+/**
+ * The service could not be reached (DNS, TLS, connection reset, abort), or
+ * it ended a live stream. `reason` is set by the stream:
+ * - `functions_disabled`: Functions access was removed from the account;
+ * - `channel_closed`: the server closed the stream (subscribe again with
+ *   `afterSeq`);
+ * - the server's reason of a refused join (e.g. `functions_unavailable`).
+ */
 export declare class NetworkError extends NetworkError_base {
 }
 declare const ApiError_base: Schema.Class<ApiError, Schema.TaggedStruct<"ApiError", {

package/dist/errors.js

@@ -13,7 +13,12 @@ export const Failure = Schema.Struct({
 export const messageOf = (cause) => cause instanceof Error ? cause.message : String(cause);
 export class ConfigError extends Schema.TaggedError()("ConfigError", { message: Schema.String }) {
 }
-export class NetworkError extends Schema.TaggedError()("NetworkError", { url: Schema.String, message: Schema.String, cause: Schema.Unknown }) {
+export class NetworkError extends Schema.TaggedError()("NetworkError", {
+    url: Schema.String,
+    message: Schema.String,
+    cause: Schema.Unknown,
+    reason: Schema.optional(Schema.String),
+}) {
 }
 export class ApiError extends Schema.TaggedError()("ApiError", {
     status: Schema.Number,