@johannc-dev/zyrk 0.0.0-stage → 0.2.1

package/dist/client.js

@@ -0,0 +1,909 @@
+import { Cause, Config, Context, Effect, Exit, Layer, Option, Redacted, Result, Schema, } from "effect";
+import { decode, Job, Json, 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({
+    error: Schema.Union([Schema.String, Failure]),
+    message: Schema.optionalKey(Schema.String),
+});
+const apiError = (status, body) => {
+    const parsed = Schema.decodeUnknownOption(ServerError)(body);
+    if (Option.isNone(parsed))
+        return new ApiError({
+            status,
+            code: `http_${status}`,
+            message: `HTTP ${status}`,
+            body,
+        });
+    const { error, message } = parsed.value;
+    return typeof error === "string"
+        ? new ApiError({ status, code: error, message: message ?? error, body })
+        : new ApiError({
+            status,
+            code: error.code,
+            message: error.message,
+            failure: error,
+            body,
+        });
+};
+const parseJson = (text) => {
+    if (text === "")
+        return Option.some(null);
+    try {
+        return Option.some(JSON.parse(text));
+    }
+    catch {
+        return Option.none();
+    }
+};
+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 send = Effect.fnUntraced(function* (method, path, body) {
+        const url = base + path;
+        const response = yield* Effect.tryPromise({
+            try: async (signal) => {
+                const response = await fetch(url, {
+                    method,
+                    headers: {
+                        authorization: `Bearer ${config.apiKey}`,
+                        "content-type": "application/json",
+                    },
+                    ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+                    redirect: "error",
+                    signal,
+                });
+                return {
+                    status: response.status,
+                    ok: response.ok,
+                    waited: response.headers?.get?.(WAITED_HEADER) === "1",
+                    text: await response.text(),
+                };
+            },
+            catch: (cause) => new NetworkError({
+                url,
+                message: `${method} ${url}: ${messageOf(cause)}`,
+                cause,
+            }),
+        });
+        const parsed = parseJson(response.text);
+        if (!response.ok)
+            return yield* apiError(response.status, Option.getOrElse(parsed, () => response.text));
+        if (Option.isNone(parsed))
+            return yield* new DecodeError({
+                what: `${method} ${path}`,
+                message: "Response body is not JSON",
+            });
+        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 poll = (check, options, onTimeout) => {
+        const deadline = options.timeoutMs === undefined
+            ? Infinity
+            : Date.now() + options.timeoutMs;
+        const step = check.pipe(Effect.flatMap(Option.match({
+            onSome: Effect.succeed,
+            onNone: () => {
+                const left = deadline - Date.now();
+                if (left <= 0)
+                    return onTimeout();
+                return Effect.sleep(Math.min(options.pollMs ?? 1000, left)).pipe(Effect.flatMap(() => step));
+            },
+        })));
+        return step;
+    };
+    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));
+            case "failed":
+                return Effect.fail(new ExecutionFailed({ executionId: id, failure: r.error }));
+            case "cancelled":
+            case "expired":
+            case "acknowledged":
+                return Effect.fail(new ExecutionEnded({ executionId: id, status: r.status }));
+            case "queued":
+            case "running":
+                return Effect.succeed(Option.none());
+        }
+    };
+    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(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,
+        requestId: input.requestId ?? crypto.randomUUID(),
+    }).pipe(Effect.flatMap(decode(Started, "start response")), Effect.map((started) => started.id));
+    return {
+        request,
+        deploy: (program, code, options = {}) => request("PUT", `programs/${segment(program)}`, {
+            code,
+            force: options.force ?? false,
+        }),
+        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 }),
+        executions: (program) => request("GET", `programs/${segment(program)}/executions`),
+        start,
+        execution,
+        result,
+        wait,
+        waitAll,
+        run: (program, input, options) => start(program, input).pipe(Effect.flatMap((id) => wait(id, options))),
+        acknowledge: (id) => request("POST", `executions/${segment(id)}/ack`, {}),
+        cancel: (id) => request("POST", `executions/${segment(id)}/cancel`, {}),
+        events: (afterSeq) => request("GET", afterSeq === undefined ? "events" : `events?after_seq=${afterSeq}`),
+        measurements: () => request("GET", "measurements"),
+        webhook: () => request("GET", "webhook"),
+        setWebhook: (config) => request("PUT", "webhook", config),
+        deleteWebhook: () => request("DELETE", "webhook"),
+        rotateWebhookSecret: (options = {}) => request("POST", "webhook/rotate", options),
+        testWebhook: () => request("POST", "webhook/test", {}),
+        webhookDeliveries: (limit) => request("GET", limit === undefined
+            ? "webhook/deliveries"
+            : `webhook/deliveries?limit=${limit}`),
+    };
+};
+export const clientConfig = Config.all({
+    url: Config.String("TH_API_URL"),
+    apiKey: Config.Redacted("TH_API_KEY"),
+}).pipe(Effect.map(({ url, apiKey }) => ({ url, apiKey: Redacted.value(apiKey) })), Effect.mapError((error) => new ConfigError({
+    message: `Set TH_API_URL and TH_API_KEY: ${error.message.split("\n")[0]}`,
+})));
+export class ZyrkClient extends Context.Service()("@johannc-dev/zyrk/ZyrkClient") {
+    static layer = (config) => Layer.succeed(ZyrkClient, make(config));
+    static layerConfig = Layer.effect(ZyrkClient, Effect.map(clientConfig, make));
+}
+const runPromise = async (effect, signal) => {
+    signal?.throwIfAborted();
+    const exit = await Effect.runPromiseExit(effect, { signal });
+    if (Exit.isSuccess(exit))
+        return exit.value;
+    if (signal?.aborted && Cause.hasInterrupts(exit.cause))
+        throw signal.reason;
+    throw Cause.squash(exit.cause);
+};
+export class FunctionsClient {
+    client;
+    config;
+    constructor(config) {
+        this.client = make(config);
+        this.config = config;
+    }
+    storage(area) {
+        return httpStorageArea(this.config, area);
+    }
+    request(method, path, body, signal) {
+        return runPromise(this.client.request(method, path, body), signal);
+    }
+    deploy(program, code, options = {}) {
+        return runPromise(this.client.deploy(program, code, options), options.signal);
+    }
+    programs(signal) {
+        return runPromise(this.client.programs(), signal);
+    }
+    inspect(program, signal) {
+        return runPromise(this.client.inspect(program), signal);
+    }
+    pause(program, paused = true, signal) {
+        return runPromise(this.client.pause(program, paused), signal);
+    }
+    executions(program, signal) {
+        return runPromise(this.client.executions(program), signal);
+    }
+    start(program, input, signal) {
+        return runPromise(this.client.start(program, input), signal);
+    }
+    execution(id, signal) {
+        return runPromise(this.client.execution(id), signal);
+    }
+    result(id, signal) {
+        return runPromise(this.client.result(id), signal);
+    }
+    wait(id, options = {}) {
+        return runPromise(this.client.wait(id, options), options.signal);
+    }
+    waitAll(ids, options = {}) {
+        return runPromise(this.client.waitAll(ids, options), options.signal);
+    }
+    run(program, input, options = {}) {
+        return runPromise(this.client.run(program, input, options), options.signal);
+    }
+    acknowledge(id, signal) {
+        return runPromise(this.client.acknowledge(id), signal);
+    }
+    cancel(id, signal) {
+        return runPromise(this.client.cancel(id), signal);
+    }
+    events(afterSeq, signal) {
+        return runPromise(this.client.events(afterSeq), signal);
+    }
+    measurements(signal) {
+        return runPromise(this.client.measurements(), signal);
+    }
+    webhook(signal) {
+        return runPromise(this.client.webhook(), signal);
+    }
+    setWebhook(config, signal) {
+        return runPromise(this.client.setWebhook(config), signal);
+    }
+    deleteWebhook(signal) {
+        return runPromise(this.client.deleteWebhook(), signal);
+    }
+    rotateWebhookSecret(options = {}, signal) {
+        return runPromise(this.client.rotateWebhookSecret(options), signal);
+    }
+    testWebhook(signal) {
+        return runPromise(this.client.testWebhook(), signal);
+    }
+    webhookDeliveries(limit, signal) {
+        return runPromise(this.client.webhookDeliveries(limit), signal);
+    }
+    replay(program, request, signal) {
+        return this.request("POST", `programs/${encodeURIComponent(program)}/replay`, request, signal);
+    }
+    replayStatus(id, signal) {
+        return this.request("GET", `replays/${encodeURIComponent(id)}`, undefined, signal);
+    }
+    cancelReplay(id, signal) {
+        return this.request("POST", `replays/${encodeURIComponent(id)}/cancel`, {}, signal);
+    }
+    replayExecutions(id, after = 0, signal) {
+        return this.request("GET", `replays/${encodeURIComponent(id)}/executions?after=${after}`, undefined, signal);
+    }
+    replayEmits(id, afterSeq = 0, signal) {
+        return this.request("GET", `replays/${encodeURIComponent(id)}/emits?after_seq=${afterSeq}`, undefined, signal);
+    }
+}
+export const storageKeyPath = (key) => {
+    const parts = key.split("/");
+    if (key === "" || parts.some((p) => p === "" || p === "." || p === ".."))
+        throw new ApiError({
+            status: 400,
+            code: "invalid_request",
+            message: "Over HTTP, a key cannot have empty, '.' or '..' parts",
+            body: null,
+        });
+    return parts.map(encodeURIComponent).join("/");
+};
+const httpStorageArea = (config, area) => {
+    const base = `${config.url.replace(/\/$/, "")}/v1/functions/storage/`;
+    const call = async (method, path, init = {}) => {
+        const url = base + path;
+        try {
+            return await fetch(url, {
+                method,
+                headers: { authorization: `Bearer ${config.apiKey}`, ...init.headers },
+                ...(init.body === undefined ? {} : { body: init.body }),
+                redirect: "error",
+                ...(init.signal ? { signal: init.signal } : {}),
+            });
+        }
+        catch (cause) {
+            throw new NetworkError({
+                url,
+                message: `${method} ${url}: ${messageOf(cause)}`,
+                cause,
+            });
+        }
+    };
+    const fail = async (response) => {
+        const text = await response.text();
+        throw apiError(response.status, Option.getOrElse(parseJson(text), () => text));
+    };
+    const json = async (response) => {
+        if (!response.ok)
+            return fail(response);
+        return (await response.json());
+    };
+    const headOf = (key, response) => {
+        const h = response.headers;
+        const metadata = {};
+        h.forEach((value, name) => {
+            if (name.startsWith("x-meta-"))
+                metadata[name.slice(7)] = value;
+        });
+        const range = h.get("content-range");
+        const total = range
+            ? Number(range.split("/")[1])
+            : Number(h.get("content-length") ?? 0);
+        return {
+            key,
+            size: total,
+            contentType: h.get("content-type") ?? "application/octet-stream",
+            metadata,
+            lastModified: h.get("last-modified") ?? "",
+            expiresAt: h.get("x-expires-at"),
+            etag: (h.get("etag") ?? "").replace(/^"|"$/g, ""),
+        };
+    };
+    const objectPath = (key) => `${area}/${storageKeyPath(key)}`;
+    return {
+        get: async (key, options = {}) => {
+            if (options.length === 0) {
+                const response = await call("HEAD", objectPath(key), {
+                    signal: options.signal,
+                });
+                if (response.status === 404)
+                    return null;
+                if (!response.ok)
+                    return fail(response);
+                return { ...headOf(key, response), body: new Uint8Array(0) };
+            }
+            const headers = {};
+            if (options.offset !== undefined || options.length !== undefined) {
+                const start = options.offset ?? 0;
+                headers.range =
+                    options.length === undefined
+                        ? `bytes=${start}-`
+                        : `bytes=${start}-${start + options.length - 1}`;
+            }
+            const response = await call("GET", objectPath(key), {
+                headers,
+                signal: options.signal,
+            });
+            if (response.status === 404)
+                return null;
+            if (!response.ok)
+                return fail(response);
+            return {
+                ...headOf(key, response),
+                body: new Uint8Array(await response.arrayBuffer()),
+            };
+        },
+        head: async (key, signal) => {
+            const response = await call("HEAD", objectPath(key), { signal });
+            if (response.status === 404)
+                return null;
+            if (!response.ok)
+                return fail(response);
+            return headOf(key, response);
+        },
+        put: async (key, body, options = {}) => {
+            const headers = {
+                "content-type": options.contentType ??
+                    (typeof body === "string"
+                        ? "text/plain; charset=utf-8"
+                        : "application/octet-stream"),
+            };
+            for (const [name, value] of Object.entries(options.metadata ?? {}))
+                headers[`x-meta-${name}`] = value;
+            if (options.ifAbsent)
+                headers["if-none-match"] = "*";
+            if (options.ifMatch !== undefined)
+                headers["if-match"] = `"${options.ifMatch}"`;
+            return json(await call("PUT", objectPath(key), {
+                headers,
+                body: body,
+                signal: options.signal,
+            }));
+        },
+        delete: async (key, options = {}) => {
+            const headers = {};
+            if (options.ifMatch !== undefined)
+                headers["if-match"] = `"${options.ifMatch}"`;
+            const response = await call("DELETE", objectPath(key), {
+                headers,
+                signal: options.signal,
+            });
+            if (!response.ok)
+                await fail(response);
+        },
+        list: async (prefix = "", options = {}) => {
+            const query = new URLSearchParams({ prefix });
+            if (options.cursor)
+                query.set("cursor", options.cursor);
+            if (options.limit !== undefined)
+                query.set("limit", String(options.limit));
+            return (await json(await call("GET", `${area}?${query}`, { signal: options.signal })));
+        },
+        usage: async (signal) => json(await call("GET", "usage", { signal })),
+    };
+};