@astrale-os/adapter-cloudflare 0.5.0-beta.3 → 0.5.0-beta.30

package/dist/build/wrangler-cli.d.ts

@@ -1,86 +1,8 @@
-/**
- * Thin wrapper around the `wrangler` binary — the only place the adapter shells
- * out. `watch` runs `wrangler dev` (local workerd) and resolves once the worker
- * reports its local URL; `deploy` runs `wrangler deploy` and parses the
- * authoritative public URL from the output; secrets go through `wrangler secret
- * bulk`. The wrangler binary is resolved from the project's `node_modules/.bin`,
- * falling back to `npx wrangler`.
- */
-export interface DevHandle {
-    url: string;
-    stop(): Promise<void>;
-}
-export declare function runWranglerDev(args: {
-    projectDir: string;
-    configPath: string;
-    port: number;
-    remote: boolean;
-    /** Bind address — '0.0.0.0' for tunneled/proxied dev (`--host`). Default loopback. */
-    ip?: string;
-    /** When the port was NOT explicitly chosen, dodge a taken one automatically. */
-    autoPickPort?: boolean;
-    onReload: () => void;
-    onLog?: (line: string) => void;
-}): Promise<DevHandle>;
-export interface DeployArgs {
-    configPath: string;
-    /** SELF-less config for the first-deploy two-pass (see `deployWithSelfFallback`). */
-    fallbackConfigPath?: string;
-    /** The worker's own name, to scope the self-binding-missing detection. */
-    workerName?: string;
-    route?: string;
-    onLog?: (line: string) => void;
-}
-export declare function runWranglerDeploy(args: DeployArgs & {
-    projectDir: string;
-}): Promise<{
-    url: string;
-    raw: string;
-    deploymentVersion?: string;
-}>;
-/**
- * Deploy with a one-time SELF-binding first-deploy recovery. A fresh worker that
- * declares a `services: SELF` binding can't deploy (its own script doesn't exist
- * yet); on THAT specific failure we deploy the SELF-less fallback to create the
- * script, then redeploy WITH SELF so autobinding works. Steady state (every
- * deploy after the first) is a single pass. The `deploy` runner is injected so
- * the orchestration is unit-testable without shelling out.
- */
-export declare function deployWithSelfFallback(deploy: (configPath: string) => Promise<{
-    code: number;
-    out: string;
-}>, args: DeployArgs): Promise<{
-    url: string;
-    raw: string;
-    deploymentVersion?: string;
-}>;
-/**
- * True when wrangler failed specifically because the worker's OWN `SELF` service
- * binding can't resolve yet (first deploy of a fresh script). Requires the
- * worker name so an unrelated missing-service error doesn't trigger the two-pass.
- */
-export declare function isSelfBindingMissing(out: string, workerName?: string): boolean;
-export declare function bulkPutSecrets(args: {
-    projectDir: string;
-    configPath: string;
-    secrets: Record<string, string>;
-    onLog?: (line: string) => void;
-}): Promise<void>;
-/**
- * Build the single-module worker bundle WITHOUT deploying — `wrangler deploy
- * --dry-run --outdir` (no Cloudflare auth required). Returns the path of the
- * bundled .js module (the managed adapter publishes its bytes).
- */
-export declare function runWranglerBundle(args: {
-    projectDir: string;
-    configPath: string;
-    outDir: string;
-    onLog?: (line: string) => void;
-}): Promise<string>;
-/** Generate the exact binding and runtime types selected by the generated config. */
-export declare function runWranglerTypes(args: {
-    readonly projectDir: string;
-    readonly configPath: string;
-    readonly onLog?: (line: string) => void;
-}): Promise<string>;
-//# sourceMappingURL=wrangler-cli.d.ts.map
+export { runWranglerBundle } from './wrangler/bundle.js';
+export { runWranglerDeploy, WranglerDeployError, type DeployArgs } from './wrangler/deploy.js';
+export { runWranglerDev, type DevHandle } from './wrangler/development.js';
+export { ensureWranglerDispatchNamespace, WranglerDispatchNamespaceError, } from './wrangler/namespace.js';
+export { wranglerProcessEnv } from './wrangler/process.js';
+export { runWranglerReleaseDeploy } from './wrangler/release.js';
+export { admitWranglerDeploymentStatus, runWranglerDeploymentStatus, type WranglerDeploymentStatus, } from './wrangler/status.js';
+export { runWranglerTypes } from './wrangler/type-generation.js';

package/dist/build/wrangler-cli.js

@@ -1,275 +1,8 @@
-/**
- * Thin wrapper around the `wrangler` binary — the only place the adapter shells
- * out. `watch` runs `wrangler dev` (local workerd) and resolves once the worker
- * reports its local URL; `deploy` runs `wrangler deploy` and parses the
- * authoritative public URL from the output; secrets go through `wrangler secret
- * bulk`. The wrangler binary is resolved from the project's `node_modules/.bin`,
- * falling back to `npx wrangler`.
- */
-import { spawn } from 'node:child_process';
-import { existsSync, readdirSync } from 'node:fs';
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { createServer } from 'node:net';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { parseDeployUrl, parseDeployVersionId, parseDevReadyUrl } from './parse-output.js';
-function wranglerCommand(projectDir) {
-    const local = join(projectDir, 'node_modules', '.bin', 'wrangler');
-    if (existsSync(local))
-        return { cmd: local, prefix: [] };
-    return { cmd: 'npx', prefix: ['--yes', 'wrangler'] };
-}
-/**
- * True when `port` is free on `host`. A taken port previously made `wrangler
- * dev` either die ("Address already in use") or — worse — a FIRST probe hit a
- * DIFFERENT project's dev server on the same port (observed in agent runs:
- * every reader of the docs converges on 8787/8899).
- */
-function portFree(port, host) {
-    return new Promise((resolve) => {
-        const srv = createServer();
-        srv.once('error', () => resolve(false));
-        srv.once('listening', () => srv.close(() => resolve(true)));
-        srv.listen(port, host);
-    });
-}
-/** An OS-assigned free port. */
-function ephemeralPort(host) {
-    return new Promise((resolve, reject) => {
-        const srv = createServer();
-        srv.once('error', reject);
-        srv.listen(0, host, () => {
-            const addr = srv.address();
-            const port = typeof addr === 'object' && addr ? addr.port : 0;
-            srv.close(() => resolve(port));
-        });
-    });
-}
-export async function runWranglerDev(args) {
-    await runWranglerTypes(args);
-    const { cmd, prefix } = wranglerCommand(args.projectDir);
-    const bindHost = args.ip ?? '127.0.0.1';
-    if (args.autoPickPort && !(await portFree(args.port, bindHost))) {
-        const picked = await ephemeralPort(bindHost);
-        args.onLog?.(`port ${args.port} is taken — using ${picked} instead (pass --port to pin one)`);
-        args = { ...args, port: picked };
-    }
-    const wranglerArgs = [
-        ...prefix,
-        'dev',
-        '--config',
-        args.configPath,
-        '--port',
-        String(args.port),
-        '--local-protocol',
-        'http',
-        '--ip',
-        args.ip ?? '127.0.0.1',
-        ...(args.remote ? ['--remote'] : []),
-    ];
-    const child = spawn(cmd, wranglerArgs, {
-        cwd: args.projectDir,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        env: { ...process.env, WRANGLER_SEND_METRICS: 'false' },
-    });
-    const fallbackUrl = `http://localhost:${args.port}`;
-    // (args.port may have been re-picked above — everything below reads args.port)
-    let resolved = false;
-    // Wrangler's watch mode STAYS ALIVE on a build failure (listener up, worker
-    // never answers) — the classic silent hang. Track build errors so the
-    // safety net can fail LOUD instead of resolving a dead URL.
-    let buildErrorTail = '';
-    let outputTail = '';
-    const url = await new Promise((resolve, reject) => {
-        const onData = (buf) => {
-            const text = buf.toString();
-            outputTail = (outputTail + text).slice(-3000);
-            for (const line of text.split('\n')) {
-                if (line.trim())
-                    args.onLog?.(line);
-            }
-            if (/✘ \[ERROR\]|Build failed|Could not resolve "/.test(text)) {
-                buildErrorTail = (buildErrorTail + text).slice(-2000);
-            }
-            if (!resolved) {
-                const ready = parseDevReadyUrl(text, args.port);
-                if (ready) {
-                    resolved = true;
-                    resolve(ready);
-                }
-            }
-            else if (/Reloading|Detected changes|Updated/i.test(text)) {
-                args.onReload();
-            }
-        };
-        child.stdout?.on('data', onData);
-        child.stderr?.on('data', onData);
-        child.on('exit', (code) => {
-            if (!resolved) {
-                resolved = true;
-                reject(new Error(`wrangler dev exited before becoming ready (code ${code ?? 'null'}).\n${outputTail}`));
-            }
-        });
-        child.on('error', (err) => {
-            if (!resolved) {
-                resolved = true;
-                reject(err);
-            }
-        });
-        // Safety net: if we never matched a URL but the process is alive, assume the
-        // conventional localhost URL after a grace period — UNLESS the build
-        // failed, in which case a listener may be up but the worker will never
-        // answer: fail loud with the build output instead of handing back a dead
-        // URL.
-        setTimeout(() => {
-            if (!resolved && child.exitCode === null) {
-                resolved = true;
-                if (buildErrorTail) {
-                    void stopChild(child);
-                    reject(new Error(`worker build failed — the dev server would hang silently.\n${buildErrorTail}`));
-                }
-                else {
-                    resolve(fallbackUrl);
-                }
-            }
-        }, 15_000).unref?.();
-    });
-    return { url, stop: () => stopChild(child) };
-}
-export async function runWranglerDeploy(args) {
-    await runWranglerTypes(args);
-    const { cmd, prefix } = wranglerCommand(args.projectDir);
-    const deploy = (configPath) => runCapture(cmd, [...prefix, 'deploy', '--config', configPath], args.projectDir, args.onLog);
-    return deployWithSelfFallback(deploy, args);
-}
-/**
- * Deploy with a one-time SELF-binding first-deploy recovery. A fresh worker that
- * declares a `services: SELF` binding can't deploy (its own script doesn't exist
- * yet); on THAT specific failure we deploy the SELF-less fallback to create the
- * script, then redeploy WITH SELF so autobinding works. Steady state (every
- * deploy after the first) is a single pass. The `deploy` runner is injected so
- * the orchestration is unit-testable without shelling out.
- */
-export async function deployWithSelfFallback(deploy, args) {
-    let { code, out } = await deploy(args.configPath);
-    if (code !== 0 && args.fallbackConfigPath && isSelfBindingMissing(out, args.workerName)) {
-        args.onLog?.('SELF service binding not resolvable yet (first deploy) — creating the worker, then re-binding SELF');
-        const first = await deploy(args.fallbackConfigPath);
-        if (first.code !== 0) {
-            throw new Error(`wrangler deploy (no-self pass) failed (code ${first.code}):\n${first.out.slice(-2000)}`);
-        }
-        ;
-        ({ code, out } = await deploy(args.configPath));
-    }
-    if (code !== 0) {
-        throw new Error(`wrangler deploy failed (code ${code}):\n${out.slice(-2000)}`);
-    }
-    const url = parseDeployUrl(out, args.route);
-    if (!url) {
-        throw new Error(`could not determine deployed URL from wrangler output:\n${out.slice(-2000)}`);
-    }
-    const deploymentVersion = parseDeployVersionId(out);
-    return { url, raw: out, ...(deploymentVersion === undefined ? {} : { deploymentVersion }) };
-}
-/**
- * True when wrangler failed specifically because the worker's OWN `SELF` service
- * binding can't resolve yet (first deploy of a fresh script). Requires the
- * worker name so an unrelated missing-service error doesn't trigger the two-pass.
- */
-export function isSelfBindingMissing(out, workerName) {
-    const bindingError = /could not resolve binding/i.test(out) ||
-        /service\b[^\n]*\bnot found/i.test(out) ||
-        /script\b[^\n]*\bnot found/i.test(out);
-    if (!bindingError || !/\bSELF\b/.test(out))
-        return false;
-    return workerName ? out.includes(workerName) : true;
-}
-export async function bulkPutSecrets(args) {
-    const names = Object.keys(args.secrets);
-    if (names.length === 0)
-        return;
-    const { cmd, prefix } = wranglerCommand(args.projectDir);
-    const dir = await mkdtemp(join(tmpdir(), 'astrale-secrets-'));
-    const file = join(dir, 'secrets.json');
-    try {
-        await writeFile(file, JSON.stringify(args.secrets));
-        const { code, out } = await runCapture(cmd, [...prefix, 'secret', 'bulk', file, '--config', args.configPath], args.projectDir, args.onLog);
-        if (code !== 0) {
-            throw new Error(`wrangler secret bulk failed (code ${code}):\n${out.slice(-1500)}`);
-        }
-    }
-    finally {
-        await rm(dir, { recursive: true, force: true });
-    }
-}
-// ── internals ──────────────────────────────────────────────────────────────
-function runCapture(cmd, args, cwd, onLog) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(cmd, args, {
-            cwd,
-            stdio: ['ignore', 'pipe', 'pipe'],
-            env: { ...process.env, WRANGLER_SEND_METRICS: 'false' },
-        });
-        let out = '';
-        const onData = (buf) => {
-            const text = buf.toString();
-            out += text;
-            for (const line of text.split('\n'))
-                if (line.trim())
-                    onLog?.(line);
-        };
-        child.stdout?.on('data', onData);
-        child.stderr?.on('data', onData);
-        child.on('exit', (code) => resolve({ code: code ?? 1, out }));
-        child.on('error', reject);
-    });
-}
-async function stopChild(child) {
-    if (child.exitCode !== null)
-        return;
-    await new Promise((resolve) => {
-        child.on('exit', () => resolve());
-        child.kill('SIGTERM');
-        setTimeout(() => {
-            if (child.exitCode === null)
-                child.kill('SIGKILL');
-            resolve();
-        }, 4000).unref?.();
-    });
-}
-/**
- * Build the single-module worker bundle WITHOUT deploying — `wrangler deploy
- * --dry-run --outdir` (no Cloudflare auth required). Returns the path of the
- * bundled .js module (the managed adapter publishes its bytes).
- */
-export async function runWranglerBundle(args) {
-    await runWranglerTypes(args);
-    const { cmd, prefix } = wranglerCommand(args.projectDir);
-    const { code, out } = await runCapture(cmd, [...prefix, 'deploy', '--dry-run', '--outdir', args.outDir, '--config', args.configPath], args.projectDir, args.onLog);
-    if (code !== 0)
-        throw new Error(`wrangler bundle failed (exit ${code}): ${out.slice(-400)}`);
-    const js = readdirSync(args.outDir).filter((f) => f.endsWith('.js'));
-    if (js.length === 0)
-        throw new Error(`wrangler bundle produced no .js in ${args.outDir}`);
-    const preferred = js.find((f) => f.startsWith('worker')) ?? js[0];
-    return join(args.outDir, preferred);
-}
-/** Generate the exact binding and runtime types selected by the generated config. */
-export async function runWranglerTypes(args) {
-    const { cmd, prefix } = wranglerCommand(args.projectDir);
-    const outputPath = join(dirname(args.configPath), 'worker-configuration.d.ts');
-    const { code, out } = await runCapture(cmd, [
-        ...prefix,
-        'types',
-        outputPath,
-        '--env-interface',
-        'CloudflareEnv',
-        '--config',
-        args.configPath,
-    ], args.projectDir, args.onLog);
-    if (code !== 0) {
-        throw new Error(`wrangler types failed (code ${code}):\n${out.slice(-2000)}`);
-    }
-    return outputPath;
-}
-//# sourceMappingURL=wrangler-cli.js.map
+export { runWranglerBundle } from './wrangler/bundle.js';
+export { runWranglerDeploy, WranglerDeployError } from './wrangler/deploy.js';
+export { runWranglerDev } from './wrangler/development.js';
+export { ensureWranglerDispatchNamespace, WranglerDispatchNamespaceError, } from './wrangler/namespace.js';
+export { wranglerProcessEnv } from './wrangler/process.js';
+export { runWranglerReleaseDeploy } from './wrangler/release.js';
+export { admitWranglerDeploymentStatus, runWranglerDeploymentStatus, } from './wrangler/status.js';
+export { runWranglerTypes } from './wrangler/type-generation.js';

package/dist/cloudflare.d.ts

@@ -1,34 +1 @@
-/**
- * `cloudflare(envs)` — the Cloudflare deployment adapter.
- *
- * Owns everything target-specific: it codegens the Worker entry + wrangler
- * config (the dev never sees a `wrangler.jsonc`), materializes the optional frontend
- * SPA, and shells out to `wrangler`. `watch` → `wrangler dev` (local URL);
- * `deploy` → `wrangler deploy` (workers.dev or a custom-domain URL); secrets →
- * `wrangler secret bulk`. Both `watch` and `deploy` return the URL the CLI
- * prints and `astrale domain install <url>` consumes.
- */
-import type { DomainAdapter } from '@astrale-os/sdk';
-import type { CloudflareParams } from './params.js';
-import { bulkPutSecrets, buildCloudflareWorker, buildFrontend, logTo, prepare, runWranglerDeploy, runWranglerDev, runWranglerTypes, watchFrontend } from './build/index.js';
-export declare function cloudflare(envs: Record<string, CloudflareParams>): DomainAdapter<CloudflareParams>;
-interface CloudflareAdapterDependencies {
-    readonly bulkPutSecrets: typeof bulkPutSecrets;
-    readonly buildCloudflareWorker: typeof buildCloudflareWorker;
-    readonly buildFrontend: typeof buildFrontend;
-    readonly logTo: typeof logTo;
-    readonly prepare: typeof prepare;
-    readonly runWranglerDeploy: typeof runWranglerDeploy;
-    readonly runWranglerDev: typeof runWranglerDev;
-    readonly runWranglerTypes: typeof runWranglerTypes;
-    readonly watchFrontend: typeof watchFrontend;
-    readonly waitUntilLive: typeof waitUntilLive;
-}
-/** Exact orchestration seam used by adapter-level deployment qualification. */
-export declare function cloudflareWithDependencies(envs: Record<string, CloudflareParams>, dependencies: CloudflareAdapterDependencies): DomainAdapter<CloudflareParams>;
-/**
- * Poll until the deployed Worker health endpoint returns exactly 200.
- */
-declare function waitUntilLive(url: string, onLog: (line: string) => void, expectedDeploymentVersion?: string, timeoutMs?: number): Promise<void>;
-export {};
-//# sourceMappingURL=cloudflare.d.ts.map
+export { cloudflare } from './adapter.js';

package/dist/cloudflare.js

@@ -1,205 +1 @@
-/**
- * `cloudflare(envs)` — the Cloudflare deployment adapter.
- *
- * Owns everything target-specific: it codegens the Worker entry + wrangler
- * config (the dev never sees a `wrangler.jsonc`), materializes the optional frontend
- * SPA, and shells out to `wrangler`. `watch` → `wrangler dev` (local URL);
- * `deploy` → `wrangler deploy` (workers.dev or a custom-domain URL); secrets →
- * `wrangler secret bulk`. Both `watch` and `deploy` return the URL the CLI
- * prints and `astrale domain install <url>` consumes.
- */
-import { defineAdapter } from '@astrale-os/sdk';
-import { bulkPutSecrets, buildCloudflareWorker, buildFrontend, logTo, prepare, runWranglerDeploy, runWranglerDev, runWranglerTypes, watchFrontend, } from './build/index.js';
-export function cloudflare(envs) {
-    return cloudflareWithDependencies(envs, {
-        bulkPutSecrets,
-        buildCloudflareWorker,
-        buildFrontend,
-        logTo,
-        prepare,
-        runWranglerDeploy,
-        runWranglerDev,
-        runWranglerTypes,
-        watchFrontend,
-        waitUntilLive,
-    });
-}
-/** Exact orchestration seam used by adapter-level deployment qualification. */
-export function cloudflareWithDependencies(envs, dependencies) {
-    return defineAdapter({
-        name: 'cloudflare',
-        envs,
-        async build(params, ctx) {
-            await dependencies.buildCloudflareWorker({
-                params,
-                context: ctx,
-                onLog: dependencies.logTo(),
-            });
-        },
-        async watch(params, ctx) {
-            const onLog = dependencies.logTo();
-            const frontend = await dependencies.buildFrontend({
-                definition: ctx.definition,
-                projectDir: ctx.projectDir,
-                onLog,
-            });
-            const { configPath, port } = await dependencies.prepare(params, ctx, 'dev', frontend);
-            const handle = await dependencies.runWranglerDev({
-                projectDir: ctx.projectDir,
-                configPath,
-                port,
-                remote: Boolean(params.remote),
-                autoPickPort: params.port === undefined,
-                ...(params.host ? { ip: '0.0.0.0' } : {}),
-                onReload: ctx.onReload,
-                onLog,
-            });
-            let frontendWatch;
-            try {
-                frontendWatch = dependencies.watchFrontend({
-                    definition: ctx.definition,
-                    projectDir: ctx.projectDir,
-                    onLog,
-                    // Routes and source recipes are immutable for this watch generation.
-                    // Wrangler already observes the atomically swapped asset stage, so a
-                    // source rebuild needs no config regeneration.
-                    onRebuild: ctx.onReload,
-                });
-            }
-            catch (error) {
-                try {
-                    await handle.stop();
-                }
-                catch (cleanupError) {
-                    throw new AggregateError([error, cleanupError], 'cloudflare frontend watcher startup failed and Wrangler cleanup also failed');
-                }
-                throw error;
-            }
-            // With --host the actionable URL is the PUBLIC one (the tunnel/proxy
-            // front), not the local bind — print and spec-stamp that.
-            return {
-                url: params.host ?? handle.url,
-                async stop() {
-                    const errors = [];
-                    try {
-                        await frontendWatch?.stop();
-                    }
-                    catch (error) {
-                        errors.push(error);
-                    }
-                    try {
-                        await handle.stop();
-                    }
-                    catch (error) {
-                        errors.push(error);
-                    }
-                    if (errors.length === 1)
-                        throw errors[0];
-                    if (errors.length > 1) {
-                        throw new AggregateError(errors, 'cloudflare development cleanup failed');
-                    }
-                },
-            };
-        },
-        // Config hot-regen: rewrite the generated files only — the running
-        // `wrangler dev` watches its `--config` (and the worker entry) and reloads
-        // them itself, so a `astrale.config.ts` edit lands without a restart.
-        // Mirrors `watch`'s prep exactly (codegen + frontend build), minus the spawn.
-        async regenerate(params, ctx) {
-            const frontend = await dependencies.buildFrontend({
-                definition: ctx.definition,
-                projectDir: ctx.projectDir,
-                onLog: dependencies.logTo(),
-            });
-            const { configPath } = await dependencies.prepare(params, ctx, 'dev', frontend);
-            await dependencies.runWranglerTypes({
-                projectDir: ctx.projectDir,
-                configPath,
-                onLog: dependencies.logTo(),
-            });
-        },
-        async deploy(params, ctx) {
-            const frontend = await dependencies.buildFrontend({
-                definition: ctx.definition,
-                projectDir: ctx.projectDir,
-                onLog: dependencies.logTo(),
-            });
-            const { configPath, fallbackConfigPath, workerName: name, } = await dependencies.prepare(params, ctx, 'deploy', frontend);
-            const { url, deploymentVersion } = await dependencies.runWranglerDeploy({
-                projectDir: ctx.projectDir,
-                configPath,
-                workerName: name,
-                ...(fallbackConfigPath ? { fallbackConfigPath } : {}),
-                ...(params.route ? { route: params.route } : {}),
-                onLog: dependencies.logTo(),
-            });
-            if (Object.keys(ctx.secrets).length > 0) {
-                await dependencies.bulkPutSecrets({
-                    projectDir: ctx.projectDir,
-                    configPath,
-                    secrets: ctx.secrets,
-                    onLog: dependencies.logTo(),
-                });
-            }
-            // A first deploy on a fresh `*.workers.dev` host can take ~30-60s to
-            // propagate; an `astrale domain install <url>` issued right away would
-            // 404 (Cloudflare 1042). Block until the URL actually serves so the
-            // install line we print is immediately actionable.
-            await dependencies.waitUntilLive(url, dependencies.logTo(), deploymentVersion);
-            return { url };
-        },
-        secretsFile(params) {
-            return params.secrets;
-        },
-    });
-}
-/**
- * Poll until the deployed Worker health endpoint returns exactly 200.
- */
-async function waitUntilLive(url, onLog, expectedDeploymentVersion, timeoutMs = 90_000) {
-    const probe = new URL('/health', url);
-    const metadata = new URL('/meta', url);
-    const deadline = Date.now() + timeoutMs;
-    let waited = false;
-    let lastStatus;
-    let lastDeploymentVersion;
-    for (;;) {
-        try {
-            const res = await fetch(probe, { redirect: 'manual' });
-            lastStatus = res.status;
-            await res.body?.cancel();
-            if (res.status === 200) {
-                if (expectedDeploymentVersion === undefined)
-                    return;
-                const meta = await fetch(metadata, { redirect: 'manual' });
-                if (meta.status === 200) {
-                    const body = (await meta.json());
-                    lastDeploymentVersion =
-                        typeof body.deploymentVersion === 'string' ? body.deploymentVersion : undefined;
-                    if (lastDeploymentVersion === expectedDeploymentVersion)
-                        return;
-                }
-                else {
-                    await meta.body?.cancel();
-                }
-            }
-        }
-        catch {
-            // Network hiccup — treat like "not live yet" and keep polling.
-        }
-        if (Date.now() >= deadline) {
-            throw new Error(`deployed Worker health did not reach HTTP 200 within ${Math.round(timeoutMs / 1000)}s` +
-                (lastStatus === undefined ? '' : ` (last status ${lastStatus})`) +
-                (expectedDeploymentVersion === undefined
-                    ? ''
-                    : `; deployment version ${JSON.stringify(lastDeploymentVersion)} ` +
-                        `did not reach ${JSON.stringify(expectedDeploymentVersion)}`));
-        }
-        if (!waited) {
-            waited = true;
-            onLog('waiting for the URL to go live (first deploys can take ~30-60s)…');
-        }
-        await new Promise((r) => setTimeout(r, 3000));
-    }
-}
-//# sourceMappingURL=cloudflare.js.map
+export { cloudflare } from './adapter.js';

package/dist/deploy/deploy.d.ts

@@ -0,0 +1,17 @@
+import type { DeployContext, DeployResult } from '@astrale-os/sdk/deployment/adapter';
+import type { Release } from '@astrale-os/sdk/deployment/release';
+import type { materialize } from '../build/artifact.js';
+import type { ensureWranglerDispatchNamespace, runWranglerDeploy, runWranglerDeploymentStatus, runWranglerReleaseDeploy } from '../build/wrangler-cli.js';
+import type { signingIdentity } from '../identity/source.js';
+import type { CloudflareParams } from '../params.js';
+export interface CloudflareDeployDependencies {
+    readonly materialize: typeof materialize;
+    readonly ensureWranglerDispatchNamespace: typeof ensureWranglerDispatchNamespace;
+    readonly runWranglerDeploy: typeof runWranglerDeploy;
+    readonly runWranglerReleaseDeploy: typeof runWranglerReleaseDeploy;
+    readonly runWranglerDeploymentStatus: typeof runWranglerDeploymentStatus;
+    readonly waitForReadiness: (release: Release, signal: AbortSignal) => Promise<void>;
+    readonly signingIdentity: typeof signingIdentity;
+}
+/** Establish private placement and place one revision before advancing the public gateway. */
+export declare function deployCloudflare(parameters: CloudflareParams, context: DeployContext, dependencies: CloudflareDeployDependencies): Promise<DeployResult>;