@astralarium/repo-deploy-workflows 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Astralarium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,4 @@
-# Temporary Holding Version
+# `@astralarium/repo-deploy-workflows`
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The blue/green deploy worker for `@astralarium/repo-deploy-release`:
+cutover, settle and drain workflows.

package/dist/src/cutover.d.ts

@@ -0,0 +1,81 @@
+/** Cutover, settle and drain workflow timelines, over the slots' ops
+ *  controls and the Cloudflare API. */
+import { type CfApi, type CutoverOutcome, type CutoverParams, type Deployment, type DEPLOYMENT_VAR, type DeploymentVersion, type DrainParams, type OpsControlRpc, type SettleParams, type Slot } from "@astralarium/repo-deploy-info";
+import type { WorkflowStep, WorkflowStepConfig } from "cloudflare:workers";
+/** A precondition failed; the cutover makes no change. */
+export declare class PreconditionError extends Error {
+    constructor(message: string);
+}
+/** Narrows a workflow payload to `CutoverParams`; throws
+ *  `PreconditionError` on a malformed one. */
+export declare function parseParams(payload: unknown): CutoverParams;
+/** Narrows a workflow payload to `SettleParams`; throws
+ *  `PreconditionError` on a malformed one. */
+export declare function parseSettleParams(payload: unknown): SettleParams;
+/** Narrows a workflow payload to `DrainParams`; throws
+ *  `PreconditionError` on a malformed one. */
+export declare function parseDrainParams(payload: unknown): DrainParams;
+/** The deployer env's vars and secrets the timelines read. */
+export interface SlotDeployerEnv {
+    /** Scripts and site of the deploy. */
+    [DEPLOYMENT_VAR]: Deployment;
+    /** Short-lived "Workers Scripts: Edit" token `deploy-release` puts
+     *  before each cutover. */
+    CLOUDFLARE_API_TOKEN?: string;
+}
+/** `env`'s Cloudflare API over `params.accountId`; throws
+ *  `PreconditionError` while the token is unset. */
+export declare function deployerApi(env: SlotDeployerEnv, params: CutoverParams): CfApi;
+/** The web deployment before the switch: live@100, next@0. */
+export declare const preSwitch: (params: CutoverParams) => DeploymentVersion[];
+/** Resolves to the live slot's crons once the web deployment is
+ *  live@100 + next@0, next names `params.build`, and the live slot holds
+ *  crons; throws `PreconditionError` otherwise. */
+export declare function verifyCutover(api: CfApi, deployment: Deployment, params: CutoverParams): Promise<string[]>;
+/** Throws unless the public site answers `build` on every `paths` path. */
+export declare function checkSite(fetchFn: typeof fetch, siteOrigin: string, paths: readonly string[], build: string): Promise<void>;
+/** Slot control RPCs: seconds to minutes. */
+export declare const RPC_STEP: WorkflowStepConfig;
+/** Release: the next build already serves the site, so it retries ~30 min. */
+export declare const CONVERGE_STEP: WorkflowStepConfig;
+/** Draining the live slot: short budget ahead of the token-bound steps. */
+export declare const DRAIN_STEP: WorkflowStepConfig;
+/** The site check: retries while the switch propagates. */
+export declare const SITE_STEP: WorkflowStepConfig;
+/** Cloudflare API calls. */
+export declare const API_STEP: WorkflowStepConfig;
+/** Database-clock step: retries up to an hour while that clock trails the
+ *  deployer's. */
+export declare const CLOCK_STEP: WorkflowStepConfig;
+/** What a timeline acts through. */
+export interface TimelineDeps {
+    deployment: Deployment;
+    /** Each slot's ops controls. */
+    controls: Record<Slot, OpsControlRpc>;
+    api: CfApi;
+    /** Reaches the public site. */
+    fetch: typeof fetch;
+}
+/**
+ * Hands the site to the next build at `cutoverAt`. Closes the live build's
+ * queues; publishes the notice `UPDATE_NOTICE_LEAD_MS` ahead; at the
+ * cutover (database clock) verifies (fence included), drains the live
+ * slot (`params.drain`), adds crons to the idle slot, deploys the next web
+ * version, checks the site (`params.buildPaths`),
+ * releases (names the build live + withdraws the update in one
+ * transaction), and clears the live slot's crons. Both slots hold crons
+ * across the release; the live-build gate runs one. Steps are idempotent.
+ *
+ * `run` (workflow instance) owns the update until a later run's close takes
+ * it over. A refused close or superseded update ends the run unchanged. A
+ * failure before the release restores the web, clears idle crons, withdraws
+ * the update, and rethrows. Past the release, cron clear and publish are
+ * best effort.
+ */
+export declare function runCutover(run: string, params: CutoverParams, step: WorkflowStep, deps: TimelineDeps): Promise<CutoverOutcome>;
+/** Names the live build and withdraws any update in one write, reopening
+ *  every queue. `deploy-release` moves the crons. */
+export declare function runSettle(params: SettleParams, step: WorkflowStep, deps: Pick<TimelineDeps, "controls">): Promise<void>;
+/** Ends the ongoing work of `params.slot`'s build in one step
+ *  (`drainSlot`); a failed precondition fails it without retries. */
+export declare function runDrain(params: DrainParams, step: WorkflowStep, deps: Pick<TimelineDeps, "controls">): Promise<void>;

package/dist/src/cutover.js

@@ -0,0 +1,316 @@
+/** Cutover, settle and drain workflow timelines, over the slots' ops
+ *  controls and the Cloudflare API. */
+import { buildOf, cfApi, deployScript, isForeignBuild, isSlot, putScriptCrons, scriptCrons, scriptDeployments, scriptVersion, SLOTS, UPDATE_NOTICE_LEAD_MS, } from "@astralarium/repo-deploy-info";
+import { log } from "@astralarium/repo-telemetry";
+import { NonRetryableError } from "cloudflare:workflows";
+/** A precondition failed; the cutover makes no change. */
+export class PreconditionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "PreconditionError";
+    }
+}
+/** Narrows a workflow payload to `CutoverParams`; throws
+ *  `PreconditionError` on a malformed one. */
+export function parseParams(payload) {
+    const p = (payload ?? {});
+    const strings = [
+        p.accountId,
+        p.liveVersion,
+        p.nextVersion,
+        p.build,
+        p.cutoverAt,
+    ];
+    if (!strings.every((s) => typeof s === "string" && s !== ""))
+        throw new PreconditionError("cutover params: missing field");
+    if (!isSlot(p.liveSlot) || !isSlot(p.idleSlot))
+        throw new PreconditionError("cutover params: unknown slot");
+    if (p.liveSlot === p.idleSlot)
+        throw new PreconditionError("cutover params: idle slot is the live slot");
+    if (Number.isNaN(Date.parse(p.cutoverAt ?? "")))
+        throw new PreconditionError("cutover params: malformed cutoverAt");
+    if (!Array.isArray(p.buildPaths) ||
+        p.buildPaths.length === 0 ||
+        !p.buildPaths.every((path) => typeof path === "string" && path.startsWith("/")))
+        throw new PreconditionError("cutover params: malformed buildPaths");
+    if (typeof p.drain !== "boolean")
+        throw new PreconditionError("cutover params: missing drain");
+    return p;
+}
+/** Narrows a workflow payload to `SettleParams`; throws
+ *  `PreconditionError` on a malformed one. */
+export function parseSettleParams(payload) {
+    const { slot, build } = (payload ?? {});
+    if (!isSlot(slot))
+        throw new PreconditionError("settle params: unknown slot");
+    if (typeof build !== "string" || build === "")
+        throw new PreconditionError("settle params: missing build");
+    return { slot, build };
+}
+/** Narrows a workflow payload to `DrainParams`; throws
+ *  `PreconditionError` on a malformed one. */
+export function parseDrainParams(payload) {
+    const { slot } = (payload ?? {});
+    if (!isSlot(slot))
+        throw new PreconditionError("drain params: unknown slot");
+    return { slot };
+}
+/** `env`'s Cloudflare API over `params.accountId`; throws
+ *  `PreconditionError` while the token is unset. */
+export function deployerApi(env, params) {
+    const token = env.CLOUDFLARE_API_TOKEN;
+    if (!token)
+        throw new PreconditionError("CLOUDFLARE_API_TOKEN is unset");
+    return cfApi(token, params.accountId);
+}
+/** `versions` as a comparable `id@percent` list. */
+const splitOf = (versions) => versions
+    .map((v) => `${v.version_id}@${v.percentage}`)
+    .sort()
+    .join(" ");
+/** The web script's live deployment as `splitOf` reads it. */
+async function liveSplit(api, webScript) {
+    const [latest] = await scriptDeployments(api, webScript);
+    return splitOf(latest?.versions ?? []);
+}
+/** The web deployment before the switch: live@100, next@0. */
+export const preSwitch = (params) => [
+    { version_id: params.liveVersion, percentage: 100 },
+    { version_id: params.nextVersion, percentage: 0 },
+];
+/** Resolves to the live slot's crons once the web deployment is
+ *  live@100 + next@0, next names `params.build`, and the live slot holds
+ *  crons; throws `PreconditionError` otherwise. */
+export async function verifyCutover(api, deployment, params) {
+    const web = deployment.webScript;
+    const split = await liveSplit(api, web);
+    const expected = splitOf(preSwitch(params));
+    if (split !== expected)
+        throw new PreconditionError(`${web} deploys ${split || "nothing"}, expected ${expected}`);
+    const build = buildOf(await scriptVersion(api, web, params.nextVersion));
+    if (build !== params.build)
+        throw new PreconditionError(`next version ${params.nextVersion} is build "${build}", expected "${params.build}"`);
+    const liveScript = deployment.slotScripts[params.liveSlot];
+    const crons = await scriptCrons(api, liveScript);
+    if (crons.length === 0)
+        throw new PreconditionError(`${liveScript} holds no crons`);
+    return crons;
+}
+/** Restores `webScript`'s pre-switch deployment; no-op if already there. */
+async function restoreWeb(api, webScript, params) {
+    const before = preSwitch(params);
+    if ((await liveSplit(api, webScript)) === splitOf(before))
+        return;
+    await deployScript(api, webScript, before, `cutover to ${params.build} failed; back to the live version`);
+}
+/** Throws unless the public site answers `build` on every `paths` path. */
+export async function checkSite(fetchFn, siteOrigin, paths, build) {
+    for (const path of paths) {
+        const url = new URL(path, siteOrigin);
+        url.searchParams.set("cutover", build);
+        const res = await fetchFn(url, {
+            headers: { "Cache-Control": "no-cache" },
+        });
+        const body = (await res.json().catch(() => null));
+        if (!res.ok || body?.build !== build)
+            throw new Error(`${path} answers ${res.status} build "${String(body?.build)}", expected "${build}"`);
+    }
+}
+/** Slot control RPCs: seconds to minutes. */
+export const RPC_STEP = {
+    retries: { limit: 5, delay: "15 seconds", backoff: "exponential" },
+    timeout: "10 minutes",
+};
+/** Release: the next build already serves the site, so it retries ~30 min. */
+export const CONVERGE_STEP = {
+    retries: { limit: 15, delay: "1 minute", backoff: "constant" },
+    timeout: "1 minute",
+};
+/** Draining the live slot: short budget ahead of the token-bound steps. */
+export const DRAIN_STEP = {
+    retries: { limit: 3, delay: "10 seconds", backoff: "exponential" },
+    timeout: "2 minutes",
+};
+/** The site check: retries while the switch propagates. */
+export const SITE_STEP = {
+    retries: { limit: 6, delay: "10 seconds", backoff: "exponential" },
+    timeout: "1 minute",
+};
+/** Cloudflare API calls. */
+export const API_STEP = {
+    retries: { limit: 5, delay: "10 seconds", backoff: "exponential" },
+    timeout: "1 minute",
+};
+/** Database-clock step: retries up to an hour while that clock trails the
+ *  deployer's. */
+export const CLOCK_STEP = {
+    retries: { limit: 60, delay: "1 minute", backoff: "constant" },
+    timeout: "10 minutes",
+};
+/** Ends the ongoing work of `slot`'s build through its control's `drain`;
+ *  resolves to the count ended. Throws `PreconditionError` on an
+ *  in-process control lacking `drain`; an RPC stub answers every method,
+ *  so `BlueGreenEnv.drain` gates RPC controls. */
+function drainSlot(controls, slot) {
+    const control = controls[slot];
+    if (!control.drain)
+        throw new PreconditionError(`slot ${slot} has no drain`);
+    return control.drain();
+}
+/** Throws `PreconditionError` unless `slot`'s worker reports `build`
+ *  (trusted over version annotations). */
+async function expectBuild(controls, slot, build) {
+    const actual = await controls[slot].build();
+    if (actual !== build)
+        throw new PreconditionError(`slot ${slot} runs build "${actual}", expected "${build}"`);
+}
+/** Runs `fn`, failing its step without retries on a `PreconditionError`
+ *  or a slot's `ForeignBuildError`. */
+async function precondition(fn) {
+    try {
+        return await fn();
+    }
+    catch (e) {
+        if (e instanceof PreconditionError || isForeignBuild(e))
+            throw new NonRetryableError(e.message);
+        throw e;
+    }
+}
+/** Publishes the deploy state on every slot. */
+async function publishSlots(controls) {
+    await Promise.all(SLOTS.map((s) => controls[s].publish()));
+}
+/** Publishes the deploy state on both slots in one step. */
+async function publishBoth(step, name, { controls }) {
+    await step.do(name, RPC_STEP, () => publishSlots(controls));
+}
+/** Database-clock step: false once another run took over `run`'s update;
+ *  retries until `reached`; then runs `then` and returns true. */
+async function awaitClock(step, name, live, run, reached, then = () => Promise.resolve()) {
+    return step.do(name, CLOCK_STEP, async () => {
+        // The taking-over run publishes its own update.
+        if (!(await live.scheduledFor(run)))
+            return false;
+        if (!(await reached(run)))
+            throw new Error(`the ${name} is not due`);
+        await then();
+        return true;
+    });
+}
+/** Sleeps until `at`; skips a passed `at` (replays included). */
+async function sleepUntilAhead(step, name, at) {
+    if (at > Date.now())
+        await step.sleepUntil(name, at);
+}
+/**
+ * Hands the site to the next build at `cutoverAt`. Closes the live build's
+ * queues; publishes the notice `UPDATE_NOTICE_LEAD_MS` ahead; at the
+ * cutover (database clock) verifies (fence included), drains the live
+ * slot (`params.drain`), adds crons to the idle slot, deploys the next web
+ * version, checks the site (`params.buildPaths`),
+ * releases (names the build live + withdraws the update in one
+ * transaction), and clears the live slot's crons. Both slots hold crons
+ * across the release; the live-build gate runs one. Steps are idempotent.
+ *
+ * `run` (workflow instance) owns the update until a later run's close takes
+ * it over. A refused close or superseded update ends the run unchanged. A
+ * failure before the release restores the web, clears idle crons, withdraws
+ * the update, and rethrows. Past the release, cron clear and publish are
+ * best effort.
+ */
+export async function runCutover(run, params, step, deps) {
+    const cutoverAt = Date.parse(params.cutoverAt);
+    const live = deps.controls[params.liveSlot];
+    const idle = deps.controls[params.idleSlot];
+    const { api, deployment } = deps;
+    const { buildPaths } = params;
+    const { webScript, slotScripts, siteOrigin } = deployment;
+    const liveScript = slotScripts[params.liveSlot];
+    const idleScript = slotScripts[params.idleSlot];
+    // Set before their steps, so a replay rebuilds them.
+    // Compensation clears the idle slot's crons.
+    let added = false;
+    // Compensation switches the web back.
+    let switched = false;
+    try {
+        // Refused while another run's update is due.
+        if (!(await step.do("close", RPC_STEP, () => live.close(run, cutoverAt))))
+            return "refused";
+        await publishBoth(step, "publish close", deps);
+        await sleepUntilAhead(step, "until notice", cutoverAt - UPDATE_NOTICE_LEAD_MS);
+        const noticed = await awaitClock(step, "notice", live, run, (r) => live.noticed(r), () => publishSlots(deps.controls));
+        if (!noticed)
+            return "superseded";
+        await sleepUntilAhead(step, "until cutover", cutoverAt);
+        // Once due, no later run's close takes the update over.
+        if (!(await awaitClock(step, "cutover", live, run, (r) => live.due(r))))
+            return "superseded";
+        const crons = await step.do("verify", API_STEP, () => precondition(async () => {
+            if (!(await live.scheduledFor(run)))
+                return null;
+            await expectBuild(deps.controls, params.idleSlot, params.build);
+            const crons = await verifyCutover(api, deployment, params);
+            // Site answers the live build now, so a later failed check blames
+            // the switch.
+            await checkSite(deps.fetch, siteOrigin, buildPaths, await live.build());
+            return crons;
+        }));
+        if (!crons)
+            return "superseded";
+        if (params.drain)
+            await step.do("drain", DRAIN_STEP, () => precondition(() => drainSlot(deps.controls, params.liveSlot)));
+        added = true;
+        await step.do("add crons", API_STEP, () => putScriptCrons(api, idleScript, crons));
+        // The slot may have changed since the verify; the switch rechecks.
+        switched = true;
+        await step.do("deploy next web", API_STEP, () => precondition(async () => {
+            await expectBuild(deps.controls, params.idleSlot, params.build);
+            await deployScript(api, webScript, [{ version_id: params.nextVersion, percentage: 100 }], `cutover to ${params.build}`);
+        }));
+        await step.do("check site", SITE_STEP, () => checkSite(deps.fetch, siteOrigin, buildPaths, params.build));
+    }
+    catch (e) {
+        // Best effort, token-bound steps first (`CUTOVER_TOKEN_MARGIN_MS`);
+        // `settle` realigns leftovers.
+        const attempt = (p) => p.catch(() => undefined);
+        if (switched)
+            await attempt(step.do("restore web", API_STEP, () => restoreWeb(api, webScript, params)));
+        if (added)
+            await attempt(step.do("clear idle crons", API_STEP, () => putScriptCrons(api, idleScript, [])));
+        await attempt(step.do("reopen after failure", RPC_STEP, () => live.reopen(run)));
+        await attempt(publishBoth(step, "publish reopen", deps));
+        throw e;
+    }
+    await step.do("release", CONVERGE_STEP, () => precondition(async () => {
+        await expectBuild(deps.controls, params.idleSlot, params.build);
+        // The build lands either way; another run's update stays.
+        if (!(await idle.release(params.build, run)))
+            log.warn("cutover.release_left_update", "release left another run's update", {
+                run,
+                build: params.build,
+            });
+    }));
+    // Next build is live; the rest is best effort, `settle` finishing it.
+    await step
+        .do("clear old crons", API_STEP, () => putScriptCrons(api, liveScript, []))
+        .catch((e) => log.warn("cutover.clear_old_crons_failed", "the old slot keeps its crons, gated off", { run, exception: e }));
+    await publishBoth(step, "publish release", deps).catch((e) => log.warn("cutover.publish_release_failed", "release publish failed", {
+        run,
+        exception: e,
+    }));
+    return "released";
+}
+/** Names the live build and withdraws any update in one write, reopening
+ *  every queue. `deploy-release` moves the crons. */
+export async function runSettle(params, step, deps) {
+    await step.do("release", RPC_STEP, () => precondition(async () => {
+        await expectBuild(deps.controls, params.slot, params.build);
+        await deps.controls[params.slot].release(params.build, null);
+    }));
+    await publishBoth(step, "publish release", deps);
+}
+/** Ends the ongoing work of `params.slot`'s build in one step
+ *  (`drainSlot`); a failed precondition fails it without retries. */
+export async function runDrain(params, step, deps) {
+    await step.do("drain", RPC_STEP, () => precondition(() => drainSlot(deps.controls, params.slot)));
+}

package/dist/src/deployer.d.ts

@@ -0,0 +1,29 @@
+/** A blue/green deployer worker, complete: the cutover, settle and drain
+ *  workflows over the slot controls its env binds, and the 404 fetch
+ *  handler. `deploy-release` deploys it per blue/green env under a
+ *  generated wrangler config (`deployerConfig`). */
+import { type ControlBinding, type CutoverParams, type DrainParams, type OpsControlRpc, type SettleParams } from "@astralarium/repo-deploy-info";
+import { WorkflowEntrypoint, type WorkflowEvent, type WorkflowStep } from "cloudflare:workers";
+import { type SlotDeployerEnv } from "./cutover.ts";
+/** The deployer worker's env: `SlotDeployerEnv` plus each slot's control
+ *  (`controlBinding`: a service binding to the slotted worker's
+ *  `CONTROL_ENTRYPOINT`). */
+type DeployerEnv = SlotDeployerEnv & Record<ControlBinding, OpsControlRpc>;
+/** `DEPLOYER_FLOWS.cutover`: `runCutover` over `env`; a malformed payload
+ *  or absent token fails before any step. */
+export declare class CutoverWorkflow extends WorkflowEntrypoint<DeployerEnv, CutoverParams> {
+    run(event: WorkflowEvent<CutoverParams>, step: WorkflowStep): Promise<import("@astralarium/repo-deploy-info").CutoverOutcome>;
+}
+/** `DEPLOYER_FLOWS.settle`: `runSettle` over `env`. */
+export declare class SettleWorkflow extends WorkflowEntrypoint<DeployerEnv, SettleParams> {
+    run(event: WorkflowEvent<SettleParams>, step: WorkflowStep): Promise<void>;
+}
+/** `DEPLOYER_FLOWS.drain`: `runDrain` over `env`. */
+export declare class DrainWorkflow extends WorkflowEntrypoint<DeployerEnv, DrainParams> {
+    run(event: WorkflowEvent<DrainParams>, step: WorkflowStep): Promise<void>;
+}
+/** Reached only through the Workflows API. */
+declare const _default: {
+    fetch: () => Response;
+};
+export default _default;

package/dist/src/deployer.js

@@ -0,0 +1,44 @@
+/** A blue/green deployer worker, complete: the cutover, settle and drain
+ *  workflows over the slot controls its env binds, and the 404 fetch
+ *  handler. `deploy-release` deploys it per blue/green env under a
+ *  generated wrangler config (`deployerConfig`). */
+import { controlBinding, DEPLOYMENT_VAR, SLOTS, } from "@astralarium/repo-deploy-info";
+import { WorkflowEntrypoint, } from "cloudflare:workers";
+import { deployerApi, parseDrainParams, parseParams, parseSettleParams, runCutover, runDrain, runSettle, } from "./cutover.js";
+/** Each slot's control, as `env` binds it. */
+const controlsOf = (env) => Object.fromEntries(SLOTS.map((slot) => [slot, env[controlBinding(slot)]]));
+/** `DEPLOYER_FLOWS.cutover`: `runCutover` over `env`; a malformed payload
+ *  or absent token fails before any step. */
+export class CutoverWorkflow extends WorkflowEntrypoint {
+    async run(event, step) {
+        const params = parseParams(event.payload);
+        return runCutover(event.instanceId, params, step, {
+            deployment: this.env[DEPLOYMENT_VAR],
+            controls: controlsOf(this.env),
+            api: deployerApi(this.env, params),
+            fetch: (input, init) => fetch(input, init),
+        });
+    }
+}
+/** `DEPLOYER_FLOWS.settle`: `runSettle` over `env`. */
+export class SettleWorkflow extends WorkflowEntrypoint {
+    async run(event, step) {
+        const params = parseSettleParams(event.payload);
+        await runSettle(params, step, {
+            controls: controlsOf(this.env),
+        });
+    }
+}
+/** `DEPLOYER_FLOWS.drain`: `runDrain` over `env`. */
+export class DrainWorkflow extends WorkflowEntrypoint {
+    async run(event, step) {
+        const params = parseDrainParams(event.payload);
+        await runDrain(params, step, {
+            controls: controlsOf(this.env),
+        });
+    }
+}
+/** Reached only through the Workflows API. */
+export default {
+    fetch: () => new Response("Not found", { status: 404 }),
+};

package/package.json

@@ -1,6 +1,46 @@
 {
   "name": "@astralarium/repo-deploy-workflows",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "license": "MIT",
+  "homepage": "https://github.com/astralarium/repo/tree/main/packages/repo-deploy-workflows#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/astralarium/repo.git",
+    "directory": "packages/repo-deploy-workflows"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    "./deployer": "./dist/src/deployer.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@astralarium/repo-telemetry": "^0.2.0",
+    "@astralarium/repo-deploy-info": "^0.1.1"
+  },
+  "devDependencies": {
+    "@cloudflare/vitest-plugin": "^1.4.9",
+    "@types/node": "^24.2.0",
+    "eslint": "^10.2.1",
+    "typescript": "^6.0.3",
+    "vitest": "^5.0.3",
+    "wrangler": "^4.132.0",
+    "@astralarium/repo-config-typescript": "^0.1.0",
+    "@astralarium/repo-config-eslint": "^0.3.0",
+    "@astralarium/repo-package-files": "^0.1.0"
+  },
+  "engines": {
+    "node": ">=24.2"
+  },
+  "scripts": {
+    "cf-typegen": "wrangler types -c test/wrangler.jsonc",
+    "check-types": "tsc --noEmit && tsc -p tsconfig.build.json --noEmit",
+    "lint": "eslint",
+    "test": "vitest"
+  }
 }