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

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [0.5.0-beta.73](https://github.com/astrale-os/sdk/compare/adapter-cloudflare-v0.5.0-beta.72...adapter-cloudflare-v0.5.0-beta.73) (2026-08-28)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @astrale-os/sdk bumped to 0.5.0-beta.70
+
+## [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>;