@astrale-os/adapter-cloudflare 0.5.0-beta.71 → 0.5.0-beta.72

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.5.0-beta.72](https://github.com/astrale-os/sdk/compare/adapter-cloudflare-v0.5.0-beta.71...adapter-cloudflare-v0.5.0-beta.72) (2026-08-28)
+
+
+### Features
+
+* add coordinated Domain development sessions ([#300](https://github.com/astrale-os/sdk/issues/300)) ([102104f](https://github.com/astrale-os/sdk/commit/102104f1ed55333f5892db23c036578aa0ffd2e1))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @astrale-os/sdk bumped to 0.5.0-beta.69
+
 ## [0.5.0-beta.71](https://github.com/astrale-os/sdk/compare/adapter-cloudflare-v0.5.0-beta.70...adapter-cloudflare-v0.5.0-beta.71) (2026-08-28)
 
 

package/README.md

@@ -10,6 +10,10 @@ npm install @astrale-os/sdk@beta @astrale-os/adapter-cloudflare@beta
 
 Bare installs return to stable releases when the package set is promoted and npm `latest` advances.
 
+`pnpm dev` starts the Worker and optional Vite frontend with hot reload on collision-free allocated
+ports. It does not own Kernel installation or public ingress; the managed Astrale adapter composes
+those lifecycle responsibilities around this provider-local session.
+
 ## Provider-local staging
 
 Managed Cloudflare providers may stage immutable implementation candidates without exposing their

package/dist/adapter.d.ts

@@ -2,14 +2,12 @@ import type { Release } from '@astrale-os/sdk/deployment/release';
 import { verifyReadiness } from '@astrale-os/sdk/deployment/verify';
 import type { CloudflareParams } from './params.js';
 import { artifact } from './build/artifact.js';
-import { startFrontend } from './build/frontend-v1.js';
-import { runWranglerDev } from './build/wrangler-cli.js';
 import { type CloudflareDeployDependencies } from './deploy/index.js';
+import { developCloudflare } from './development/develop.js';
 import { signingIdentity } from './identity/source.js';
 export interface CloudflareDependencies extends CloudflareDeployDependencies {
     readonly artifact: typeof artifact;
-    readonly runWranglerDev: typeof runWranglerDev;
-    readonly startFrontend: typeof startFrontend;
+    readonly develop: typeof developCloudflare;
     readonly signingIdentity: typeof signingIdentity;
 }
 export declare function cloudflare(environments: Readonly<Record<string, CloudflareParams>>): import("@astrale-os/sdk/deployment/adapter").Adapter<CloudflareParams>;

package/dist/adapter.js

@@ -1,18 +1,12 @@
 import { defineAdapter } from '@astrale-os/sdk/deployment/adapter';
 import { verifyReadiness } from '@astrale-os/sdk/deployment/verify';
-import { writeFile } from 'node:fs/promises';
 import { createRequire } from 'node:module';
-import { join } from 'node:path';
 import { artifact, materialize } from './build/artifact.js';
-import { generateWranglerConfig } from './build/codegen/wrangler.js';
-import { resolveRouter, workerName } from './build/configuration.js';
-import { startFrontend } from './build/frontend-v1.js';
-import { loadWorkerArtifact } from './build/worker/index.js';
-import { workerModules } from './build/worker/modules.js';
-import { runWranglerDeploymentStatus, runWranglerDeploy, runWranglerDev, } from './build/wrangler-cli.js';
 import { deployCloudflare } from './deploy/index.js';
-import { signingIdentitySecrets } from './identity/secret.js';
+import { developCloudflare } from './development/develop.js';
 import { signingIdentity } from './identity/source.js';
+import { runWranglerDeploy } from './wrangler/deploy.js';
+import { runWranglerDeploymentStatus } from './wrangler/status.js';
 const packageVersion = createRequire(import.meta.url)('../package.json')
     .version;
 export function cloudflare(environments) {
@@ -21,8 +15,7 @@ export function cloudflare(environments) {
         materialize,
         runWranglerDeploy,
         runWranglerDeploymentStatus,
-        runWranglerDev,
-        startFrontend,
+        develop: developCloudflare,
         signingIdentity,
         waitForReadiness: (release, signal) => waitForReadiness(verifyReadiness, release, signal),
     });
@@ -33,105 +26,11 @@ export function cloudflareWithDependencies(environments, dependencies) {
         version: packageVersion,
         environments,
         prepare: dependencies.artifact,
-        async watch(parameters, context) {
-            const workerArtifact = loadWorkerArtifact(context.artifact);
-            const identity = await dependencies.signingIdentity({
-                projectDir: context.projectDir,
-                source: parameters.signingIdentity,
-                origin: context.artifact.build.schema.compiled.root.origin,
-                mode: 'local',
-            });
-            const secrets = signingIdentitySecrets(context.secrets, identity);
-            const directory = join(context.projectDir, '.astrale', 'runtime');
-            await dependencies.materialize(directory, context.artifact.files);
-            const frontend = await dependencies.startFrontend({
-                frontend: context.artifact.build.frontend,
-                projectDir: context.projectDir,
-            });
-            const name = workerName(parameters, context.artifact.build.schema.compiled.root.origin);
-            // A local workerd cannot reach the default deployed router Worker through a service
-            // binding. Keep it for remote isolates and explicit multi-Worker development; ordinary
-            // local execution falls back to the admitted fetch path when ROUTER is absent.
-            const router = parameters.remote === true || parameters.router !== undefined
-                ? resolveRouter(parameters.router)
-                : undefined;
-            const configPath = join(directory, 'wrangler.watch.jsonc');
-            await writeFile(configPath, generateWranglerConfig({
-                workerName: name,
-                main: `./${workerArtifact.release.entrypoint}`,
-                modules: workerModules(workerArtifact.release),
-                vars: {
-                    ...parameters.vars,
-                    ...(parameters.host === undefined ? {} : { WORKER_URL: parameters.host }),
-                    ...(frontend === undefined ? {} : { FRONTEND_DEV_URL: frontend.url }),
-                },
-                secretBindings: Object.keys(secrets).sort(),
-                ...(context.artifact.build.frontend?.source.kind === 'vite'
-                    ? {
-                        frontend: {
-                            directory: './frontend',
-                            routes: frontendRoutes(context.artifact),
-                            dev: true,
-                        },
-                    }
-                    : {}),
-                ...(router === undefined
-                    ? {}
-                    : { router: { binding: router.binding, service: router.service } }),
-                ...(parameters.wrangler === undefined ? {} : { wrangler: parameters.wrangler }),
-                selfBinding: true,
-            }));
-            let worker;
-            try {
-                worker = await dependencies.runWranglerDev({
-                    projectDir: context.projectDir,
-                    configPath,
-                    port: parameters.port ?? 8787,
-                    remote: parameters.remote ?? false,
-                    secrets,
-                    autoPickPort: parameters.port === undefined,
-                    pinLocalOrigin: parameters.host === undefined && parameters.remote !== true,
-                    ...(parameters.host === undefined ? {} : { ip: '0.0.0.0' }),
-                    onReload: context.onReload,
-                });
-            }
-            catch (cause) {
-                await frontend?.stop().catch(() => undefined);
-                throw cause;
-            }
-            return Object.freeze({
-                url: parameters.host ?? worker.url,
-                localUrl: worker.url,
-                async stop() {
-                    const results = await Promise.allSettled([
-                        worker.stop(),
-                        frontend?.stop() ?? Promise.resolve(),
-                    ]);
-                    const failures = results.filter((result) => result.status === 'rejected');
-                    if (failures.length === 1)
-                        throw failures[0].reason;
-                    if (failures.length > 1) {
-                        throw new AggregateError(failures.map((failure) => failure.reason), 'Cloudflare development cleanup failed.');
-                    }
-                },
-            });
-        },
+        develop: (parameters, context) => dependencies.develop(parameters, context),
         deploy: (parameters, context) => deployCloudflare(parameters, context, dependencies),
         secretsFile: (parameters) => parameters.secrets,
     });
 }
-function frontendRoutes(artifact) {
-    const frontend = artifact.build.frontend;
-    if (frontend === undefined || frontend.source.kind !== 'vite')
-        return [];
-    return Object.freeze(frontend.routes
-        .flatMap((route) => frontend.source.kind === 'vite' && frontend.source.spa && route.path !== '/'
-        ? [route.path, `${route.path}/*`]
-        : route.path === '/'
-            ? ['/*']
-            : [route.path])
-        .sort());
-}
 export async function waitForReadiness(verify, release, signal) {
     const deadline = Date.now() + 90_000;
     let last;

package/dist/build/artifact.js

@@ -5,7 +5,7 @@ import { SIGNING_IDENTITY_BINDING } from '../identity/binding.js';
 import { workerDeployment } from '../release/index.js';
 import { generateWranglerConfig } from './codegen/wrangler.js';
 import { deploymentAddressing, resolveRouter, workerName } from './configuration.js';
-import { frontendFiles } from './frontend-v1.js';
+import { frontendFiles } from './frontend/files.js';
 import { frontendRoutes } from './frontend/routes.js';
 import { encodeWorkerArtifactManifest, inferMediaType, workerContentDigest, WORKER_MANIFEST_PATH, } from './worker/artifact.manifest.js';
 import { prepareExecution, RELEASE_ENTRY, RELEASE_SERVICE, runtimeVars, } from './worker/execution.prepare.js';
@@ -38,10 +38,12 @@ async function prepare(params, context, direct) {
             configuredIssuer,
             router,
         });
-        const frontend = await frontendFiles({
-            frontend: context.build.frontend,
-            projectDir: context.projectDir,
-        });
+        const frontend = context.mode === 'development'
+            ? []
+            : await frontendFiles({
+                frontend: context.build.frontend,
+                projectDir: context.projectDir,
+            });
         const releaseConfig = generateWranglerConfig({
             workerName: name,
             main: `./${RELEASE_ENTRY}`,

package/dist/build/{frontend-v1.d.ts → frontend/files.d.ts}

@@ -1,16 +1,7 @@
 import type { Build } from '@astrale-os/sdk/deployment/build';
 import { frontend as frontendBuild } from '@astrale-os/sdk/deployment/build';
-export interface FrontendDevHandle {
-    readonly url: string;
-    stop(): Promise<void>;
-}
 export declare function frontendFiles(input: {
     readonly frontend: Build['frontend'];
     readonly projectDir: string;
     readonly onLog?: (line: string) => void;
 }): Promise<readonly frontendBuild.FrontendFile[]>;
-export declare function startFrontend(input: {
-    readonly frontend: Build['frontend'];
-    readonly projectDir: string;
-    readonly onLog?: (line: string) => void;
-}): Promise<FrontendDevHandle | undefined>;

package/dist/build/frontend/files.js

@@ -0,0 +1,60 @@
+import { frontend as frontendBuild } from '@astrale-os/sdk/deployment/build';
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { readFile, readdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+export async function frontendFiles(input) {
+    const frontend = input.frontend;
+    if (frontend === undefined)
+        return [];
+    if (frontend.source.kind === 'external')
+        return frontendBuild.files(frontend, []);
+    const output = join(input.projectDir, '.astrale', 'frontend-build');
+    await rm(output, { recursive: true, force: true });
+    await run(viteCommand(input.projectDir), [
+        'build',
+        '--outDir',
+        output,
+        '--emptyOutDir',
+        ...(frontend.source.config === undefined ? [] : ['--config', frontend.source.config]),
+    ], input.projectDir, input.onLog);
+    return frontendBuild.files(frontend, await readFiles(output));
+}
+async function readFiles(root, current = '') {
+    const entries = await readdir(join(root, current), { withFileTypes: true });
+    const files = [];
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+        const path = current === '' ? entry.name : `${current}/${entry.name}`;
+        if (entry.isDirectory())
+            files.push(...(await readFiles(root, path)));
+        else if (entry.isFile()) {
+            files.push({ path, content: new Uint8Array(await readFile(join(root, path))) });
+        }
+    }
+    return files;
+}
+function viteCommand(projectDir) {
+    const command = join(projectDir, 'node_modules', '.bin', 'vite');
+    if (!existsSync(command))
+        throw new TypeError('Vite frontend requires a project-local vite binary.');
+    return command;
+}
+function run(command, args, cwd, onLog) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+        let output = '';
+        const collect = (buffer) => {
+            const value = buffer.toString();
+            output += value;
+            for (const line of value.split('\n'))
+                if (line.trim() !== '')
+                    onLog?.(line);
+        };
+        child.stdout?.on('data', collect);
+        child.stderr?.on('data', collect);
+        child.on('error', reject);
+        child.on('exit', (code) => code === 0
+            ? resolve()
+            : reject(new Error(`Vite failed (code ${code ?? 1}):\n${output.slice(-1500)}`)));
+    });
+}

package/dist/build/index.d.ts

@@ -2,9 +2,9 @@ export { artifact, materialize, prepareWorkerArtifact } from './artifact.js';
 export { loadWorkerArtifact } from './worker/index.js';
 export type { WorkerArtifact } from './worker/index.js';
 export { resolveRouter, workerName } from './configuration.js';
-export { frontendFiles, startFrontend, type FrontendDevHandle } from './frontend-v1.js';
+export { frontendFiles } from './frontend/files.js';
 export { qualifyWorkerBundle } from './qualification.js';
 export { assertSingletonRuntimeRoots } from './roots.js';
 export { signingIdentity } from '../identity/source.js';
 export { signingIdentitySecrets } from '../identity/secret.js';
-export { runWranglerBundle, runWranglerDeploy, runWranglerDeploymentStatus, runWranglerDev, runWranglerTypes, } from './wrangler-cli.js';
+export { runWranglerBundle, runWranglerDeploy, runWranglerDeploymentStatus, runWranglerTypes, } from '../wrangler/index.js';

package/dist/build/index.js

@@ -1,9 +1,9 @@
 export { artifact, materialize, prepareWorkerArtifact } from './artifact.js';
 export { loadWorkerArtifact } from './worker/index.js';
 export { resolveRouter, workerName } from './configuration.js';
-export { frontendFiles, startFrontend } from './frontend-v1.js';
+export { frontendFiles } from './frontend/files.js';
 export { qualifyWorkerBundle } from './qualification.js';
 export { assertSingletonRuntimeRoots } from './roots.js';
 export { signingIdentity } from '../identity/source.js';
 export { signingIdentitySecrets } from '../identity/secret.js';
-export { runWranglerBundle, runWranglerDeploy, runWranglerDeploymentStatus, runWranglerDev, runWranglerTypes, } from './wrangler-cli.js';
+export { runWranglerBundle, runWranglerDeploy, runWranglerDeploymentStatus, runWranglerTypes, } from '../wrangler/index.js';

package/dist/build/worker/execution.prepare.js

@@ -1,12 +1,12 @@
 import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { dirname, join, relative, resolve } from 'node:path';
 import { SIGNING_IDENTITY_BINDING } from '../../identity/binding.js';
+import { runWranglerBundle } from '../../wrangler/bundle.js';
 import { admitWorkerBundle } from '../bundle/admit.js';
 import { generateExecutionEntry, generateExecutionService } from '../codegen/execution.js';
 import { generateWranglerConfig } from '../codegen/wrangler.js';
 import { workerInvocationTimeout, workerRequestLimit } from '../configuration.js';
 import { qualifyWorkerBundle } from '../qualification.js';
-import { runWranglerBundle } from '../wrangler-cli.js';
 import { workerModuleSpecifier } from './specifier.js';
 export const RELEASE_ENTRY = 'bundle/index.mjs';
 export const RELEASE_SERVICE = 'bundle/service.mjs';

package/dist/deploy/deploy.d.ts

@@ -1,9 +1,10 @@
 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 { runWranglerDeploy, runWranglerDeploymentStatus } from '../build/wrangler-cli.js';
 import type { signingIdentity } from '../identity/source.js';
 import type { CloudflareParams } from '../params.js';
+import type { runWranglerDeploy } from '../wrangler/deploy.js';
+import type { runWranglerDeploymentStatus } from '../wrangler/status.js';
 export interface CloudflareDeployDependencies {
     readonly materialize: typeof materialize;
     readonly runWranglerDeploy: typeof runWranglerDeploy;

package/dist/deploy/deploy.js

@@ -4,8 +4,8 @@ import { join } from 'node:path';
 import { workerName } from '../build/configuration.js';
 import { admitDirectPlacement } from '../build/direct.js';
 import { loadWorkerArtifact } from '../build/worker/index.js';
-import { WranglerDeployError } from '../build/wrangler-cli.js';
 import { signingIdentitySecrets } from '../identity/secret.js';
+import { WranglerDeployError } from '../wrangler/deploy.js';
 const NONE = Object.freeze({ kind: 'none' });
 /** Atomically advance one stable Worker address to the prepared implementation. */
 export async function deployCloudflare(parameters, context, dependencies) {

package/dist/deploy/output.d.ts

@@ -0,0 +1,2 @@
+export declare function parseDeployUrl(text: string, route?: string): string | undefined;
+export declare function parseDeployVersionId(text: string): string | undefined;

package/dist/deploy/output.js

@@ -0,0 +1,10 @@
+const WORKERS_DEV_RE = /(https:\/\/[^\s]+\.workers\.dev)/iu;
+const VERSION_ID_RE = /(?:Current\s+)?Version ID:\s*([a-z0-9_-]+)/iu;
+export function parseDeployUrl(text, route) {
+    if (route !== undefined)
+        return `https://${route.replace(/\/.*$/u, '')}`;
+    return WORKERS_DEV_RE.exec(text)?.[1];
+}
+export function parseDeployVersionId(text) {
+    return VERSION_ID_RE.exec(text)?.[1];
+}

package/dist/development/develop.d.ts

@@ -0,0 +1,15 @@
+import type { DevelopmentContext, DevelopmentSession } from '@astrale-os/sdk/deployment/adapter';
+import type { CloudflareParams } from '../params.js';
+import { signingIdentity } from '../identity/source.js';
+import { startFrontend } from './frontend.js';
+import { allocatePort } from './port.js';
+import { verifyDevelopmentRelease } from './readiness.js';
+import { startWorker } from './worker.js';
+export interface CloudflareDevelopmentDependencies {
+    readonly signingIdentity: typeof signingIdentity;
+    readonly startFrontend: typeof startFrontend;
+    readonly startWorker: typeof startWorker;
+    readonly allocatePort: typeof allocatePort;
+    readonly verify: typeof verifyDevelopmentRelease;
+}
+export declare function developCloudflare(parameters: CloudflareParams, context: DevelopmentContext, dependencies?: CloudflareDevelopmentDependencies): Promise<DevelopmentSession>;

package/dist/development/develop.js

@@ -0,0 +1,267 @@
+import { addressing, assemble } from '@astrale-os/sdk/deployment/release';
+import { mkdir, rename, rm, unlink, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { generateWranglerConfig } from '../build/codegen/wrangler.js';
+import { resolveRouter, workerName } from '../build/configuration.js';
+import { loadWorkerArtifact } from '../build/worker/index.js';
+import { workerModules } from '../build/worker/modules.js';
+import { signingIdentitySecrets } from '../identity/secret.js';
+import { signingIdentity } from '../identity/source.js';
+import { startFrontend } from './frontend.js';
+import { admitHost } from './host.js';
+import { allocatePort } from './port.js';
+import { verifyDevelopmentRelease } from './readiness.js';
+import { startWorker } from './worker.js';
+export async function developCloudflare(parameters, context, dependencies = {
+    signingIdentity,
+    startFrontend,
+    startWorker,
+    allocatePort,
+    verify: verifyDevelopmentRelease,
+}) {
+    const hostSource = context.overrides.publicUrl ?? parameters.host;
+    const host = hostSource === undefined ? undefined : admitHost(hostSource);
+    const configuredPort = context.overrides.localPort ?? parameters.port;
+    if (host !== undefined && configuredPort === undefined) {
+        throw new TypeError('Cloudflare development with a public host requires a strict local port.');
+    }
+    const port = configuredPort ?? (await dependencies.allocatePort());
+    const directory = join(context.projectDir, '.astrale', 'development', context.environment, 'cloudflare');
+    await mkdir(directory, { recursive: true });
+    const configPath = join(directory, 'wrangler.development.jsonc');
+    const identity = await dependencies.signingIdentity({
+        projectDir: context.projectDir,
+        source: parameters.signingIdentity,
+        origin: context.artifact.build.schema.compiled.root.origin,
+        mode: 'local',
+    });
+    let current = Object.freeze({ artifact: context.artifact, secrets: context.secrets });
+    let artifactPaths = new Set();
+    let resources;
+    let stopping = false;
+    let resolveFinished;
+    let rejectFinished;
+    const finished = new Promise((resolve, reject) => {
+        resolveFinished = resolve;
+        rejectFinished = reject;
+    });
+    const realize = async (input) => {
+        artifactPaths = await applyArtifact(directory, artifactPaths, input.artifact);
+        if (input.artifact.build.frontend?.source.kind === 'vite') {
+            await mkdir(join(directory, 'frontend'), { recursive: true });
+        }
+        const frontend = await dependencies.startFrontend({
+            frontend: input.artifact.build.frontend,
+            projectDir: context.projectDir,
+        });
+        try {
+            await writeFile(configPath, configuration(parameters, input.artifact, frontend?.url, host, Object.keys(signingIdentitySecrets(input.secrets, identity)).sort()));
+            const worker = await dependencies.startWorker({
+                projectDir: context.projectDir,
+                configPath,
+                port,
+                remote: parameters.remote ?? false,
+                secrets: signingIdentitySecrets(input.secrets, identity),
+                autoPickPort: false,
+                pinLocalOrigin: host === undefined && parameters.remote !== true,
+                ...(host === undefined ? {} : { ip: '0.0.0.0' }),
+            });
+            const value = Object.freeze({ ...(frontend === undefined ? {} : { frontend }), worker });
+            supervise(value);
+            return value;
+        }
+        catch (cause) {
+            await frontend?.stop().catch(() => undefined);
+            throw cause;
+        }
+    };
+    const supervise = (selected) => {
+        for (const child of [selected.worker.finished, selected.frontend?.finished]) {
+            child?.catch((cause) => {
+                if (!stopping && resources === selected)
+                    rejectFinished(cause);
+            });
+        }
+    };
+    const placementFor = (selected) => Object.freeze({ releaseUrl: host ?? selected.worker.url, localUrl: selected.worker.url });
+    const verify = async (input, selected) => {
+        const placement = placementFor(selected);
+        const release = assemble(input.artifact.build, addressing(placement.releaseUrl));
+        await dependencies.verify({ release, localUrl: placement.localUrl, signal: context.signal });
+        await context.onPlacement(placement);
+    };
+    try {
+        resources = await realize(current);
+        await verify(current, resources);
+    }
+    catch (cause) {
+        stopping = true;
+        if (resources !== undefined)
+            await stopResources(resources).catch(() => undefined);
+        await rm(directory, { recursive: true, force: true }).catch(() => undefined);
+        throw cause;
+    }
+    let updateTail = Promise.resolve();
+    const session = Object.freeze({
+        current: () => placementFor(resources),
+        update(next) {
+            if (stopping)
+                return Promise.reject(new Error('Cloudflare development session is stopping.'));
+            const operation = updateTail.then(async () => {
+                if (stopping)
+                    throw new Error('Cloudflare development session is stopping.');
+                sameDomain(current.artifact, next.artifact);
+                const previous = current;
+                const previousResources = resources;
+                const restart = frontendSignature(previous.artifact) !== frontendSignature(next.artifact) ||
+                    stable(previous.secrets) !== stable(next.secrets);
+                if (!restart) {
+                    try {
+                        artifactPaths = await applyArtifact(directory, artifactPaths, next.artifact);
+                        await writeFile(configPath, configuration(parameters, next.artifact, resources.frontend?.url, host, Object.keys(signingIdentitySecrets(next.secrets, identity)).sort()));
+                        await verify(next, resources);
+                        current = Object.freeze({ artifact: next.artifact, secrets: next.secrets });
+                    }
+                    catch (cause) {
+                        artifactPaths = await applyArtifact(directory, artifactPaths, previous.artifact);
+                        await writeFile(configPath, configuration(parameters, previous.artifact, resources.frontend?.url, host, Object.keys(signingIdentitySecrets(previous.secrets, identity)).sort()));
+                        throw cause;
+                    }
+                    return;
+                }
+                try {
+                    await stopResources(previousResources);
+                }
+                catch (cause) {
+                    rejectFinished(cause);
+                    throw cause;
+                }
+                let replacement;
+                try {
+                    replacement = await realize(next);
+                    await verify(next, replacement);
+                    resources = replacement;
+                    current = Object.freeze({ artifact: next.artifact, secrets: next.secrets });
+                }
+                catch (cause) {
+                    if (replacement !== undefined)
+                        await stopResources(replacement).catch(() => undefined);
+                    try {
+                        resources = await realize(previous);
+                        await verify(previous, resources);
+                    }
+                    catch (rollback) {
+                        rejectFinished(new AggregateError([cause, rollback], 'Cloudflare development update and rollback failed.'));
+                    }
+                    throw cause;
+                }
+            });
+            updateTail = operation.catch(() => undefined);
+            return operation;
+        },
+        finished,
+        async stop() {
+            if (stopping)
+                return finished.catch(() => undefined);
+            stopping = true;
+            await updateTail;
+            try {
+                try {
+                    await stopResources(resources);
+                }
+                finally {
+                    await rm(directory, { recursive: true, force: true });
+                }
+                resolveFinished();
+            }
+            catch (cause) {
+                rejectFinished(cause);
+                throw cause;
+            }
+        },
+    });
+    return session;
+}
+function configuration(parameters, artifact, frontendUrl, host, secretBindings) {
+    const worker = loadWorkerArtifact(artifact);
+    const router = parameters.remote === true || parameters.router !== undefined
+        ? resolveRouter(parameters.router)
+        : undefined;
+    return generateWranglerConfig({
+        workerName: workerName(parameters, artifact.build.schema.compiled.root.origin),
+        main: `./${worker.release.entrypoint}`,
+        modules: workerModules(worker.release),
+        vars: {
+            ...parameters.vars,
+            ...(host === undefined ? {} : { WORKER_URL: host }),
+            ...(frontendUrl === undefined ? {} : { FRONTEND_DEV_URL: frontendUrl }),
+        },
+        secretBindings,
+        ...(artifact.build.frontend?.source.kind === 'vite'
+            ? { frontend: { directory: './frontend', routes: frontendRoutes(artifact), dev: true } }
+            : {}),
+        ...(router === undefined
+            ? {}
+            : { router: { binding: router.binding, service: router.service } }),
+        ...(parameters.wrangler === undefined ? {} : { wrangler: parameters.wrangler }),
+        selfBinding: true,
+    });
+}
+async function applyArtifact(root, previous, artifact) {
+    const next = new Set(artifact.files.map((file) => file.path));
+    for (const file of artifact.files) {
+        const path = join(root, file.path);
+        const staging = `${path}.next`;
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(staging, file.bytes());
+        await rename(staging, path);
+    }
+    for (const path of previous) {
+        if (!next.has(path))
+            await unlink(join(root, path)).catch(() => undefined);
+    }
+    return next;
+}
+async function stopResources(resources) {
+    const results = await Promise.allSettled([
+        resources.worker.stop(),
+        resources.frontend?.stop() ?? Promise.resolve(),
+    ]);
+    const failures = results.filter((result) => result.status === 'rejected');
+    if (failures.length === 1)
+        throw failures[0].reason;
+    if (failures.length > 1) {
+        throw new AggregateError(failures.map((failure) => failure.reason), 'Cloudflare development cleanup failed.');
+    }
+}
+function frontendRoutes(artifact) {
+    const frontend = artifact.build.frontend;
+    if (frontend === undefined || frontend.source.kind !== 'vite')
+        return [];
+    return Object.freeze(frontend.routes
+        .flatMap((route) => frontend.source.kind === 'vite' && frontend.source.spa && route.path !== '/'
+        ? [route.path, `${route.path}/*`]
+        : route.path === '/'
+            ? ['/*']
+            : [route.path])
+        .sort());
+}
+function frontendSignature(artifact) {
+    return stable(artifact.build.frontend);
+}
+function sameDomain(previous, next) {
+    if (previous.build.schema.compiled.root.origin !== next.build.schema.compiled.root.origin) {
+        throw new TypeError('Cloudflare development update changed the Domain origin.');
+    }
+}
+function stable(input) {
+    if (input === null || typeof input !== 'object')
+        return JSON.stringify(input);
+    if (Array.isArray(input))
+        return `[${input.map(stable).join(',')}]`;
+    const value = input;
+    return `{${Object.keys(value)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${stable(value[key])}`)
+        .join(',')}}`;
+}