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

package/dist/adapter.d.ts

@@ -14,4 +14,4 @@ export interface CloudflareDependencies extends CloudflareDeployDependencies {
 }
 export declare function cloudflare(environments: Readonly<Record<string, CloudflareParams>>): import("@astrale-os/sdk/deployment/adapter").Adapter<CloudflareParams>;
 export declare function cloudflareWithDependencies(environments: Readonly<Record<string, CloudflareParams>>, dependencies: CloudflareDependencies): import("@astrale-os/sdk/deployment/adapter").Adapter<CloudflareParams>;
-export declare function waitForReadiness(verify: typeof verifyReadiness, release: Release): Promise<void>;
+export declare function waitForReadiness(verify: typeof verifyReadiness, release: Release, signal?: AbortSignal): Promise<void>;

package/dist/adapter.js

@@ -24,7 +24,7 @@ export function cloudflare(environments) {
         runWranglerDev,
         startFrontend,
         signingIdentity,
-        waitForReadiness: (release) => waitForReadiness(verifyReadiness, release),
+        waitForReadiness: (release, signal) => waitForReadiness(verifyReadiness, release, signal),
     });
 }
 export function cloudflareWithDependencies(environments, dependencies) {
@@ -57,6 +57,7 @@ export function cloudflareWithDependencies(environments, dependencies) {
             const configPath = join(directory, 'wrangler.watch.jsonc');
             await writeFile(configPath, generateWranglerConfig({
                 workerName: name,
+                main: `./${context.artifact.entrypoint}`,
                 vars: {
                     ...parameters.vars,
                     ...(parameters.host === undefined ? {} : { WORKER_URL: parameters.host }),
@@ -128,18 +129,46 @@ function frontendRoutes(artifact) {
             : [route.path])
         .sort());
 }
-export async function waitForReadiness(verify, release) {
+export async function waitForReadiness(verify, release, signal) {
     const deadline = Date.now() + 90_000;
     let last;
     while (Date.now() < deadline) {
+        throwIfAborted(signal);
         try {
-            await verify(release, { signal: AbortSignal.timeout(5_000) });
+            await verify(release, {
+                signal: signal === undefined
+                    ? AbortSignal.timeout(5_000)
+                    : AbortSignal.any([signal, AbortSignal.timeout(5_000)]),
+            });
             return;
         }
         catch (cause) {
+            throwIfAborted(signal);
             last = cause;
-            await new Promise((resolve) => setTimeout(resolve, 1_000));
+            await pause(signal);
         }
     }
     throw last instanceof Error ? last : new Error('Cloudflare Release did not become ready.');
 }
+function pause(signal) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(done, 1_000);
+        const abort = () => done(abortError(signal));
+        signal?.addEventListener('abort', abort, { once: true });
+        function done(cause) {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', abort);
+            if (cause === undefined)
+                resolve();
+            else
+                reject(cause);
+        }
+    });
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw abortError(signal);
+}
+function abortError(signal) {
+    return signal?.reason instanceof Error ? signal.reason : new Error('Deployment interrupted.');
+}

package/dist/build/artifact.d.ts

@@ -1,8 +1,7 @@
 import type { ArtifactSource, PrepareContext } from '@astrale-os/sdk/deployment/adapter';
 import type { CloudflareParams } from '../params.js';
+export { materialize } from './materialize.js';
 /** Prepare one revision Service and its stateless gateway without provider mutation. */
 export declare function artifact(params: CloudflareParams, context: PrepareContext): Promise<ArtifactSource>;
-export declare function materialize(root: string, files: readonly {
-    readonly path: string;
-    bytes(): Uint8Array;
-}[]): Promise<void>;
+/** Prepare the complete portable Cloudflare Worker without direct Wrangler placement files. */
+export declare function prepareWorkerArtifact(params: CloudflareParams, context: PrepareContext): Promise<ArtifactSource>;

package/dist/build/artifact.js

@@ -1,146 +1,61 @@
-import { material } from '@astrale-os/sdk/deployment/build';
 import { addressing } from '@astrale-os/sdk/deployment/release';
-import { readFile, writeFile, mkdir, rm } from 'node:fs/promises';
-import { dirname, join, relative, resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
+import { mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
 import { SIGNING_IDENTITY_BINDING } from '../identity/binding.js';
 import { releaseNamespace, releaseWorkerName } from '../release/index.js';
-import { generateExecutionEntry, generateExecutionService } from './codegen/execution.js';
-import { generateGatewayEntry } from './codegen/gateway.js';
 import { generateWranglerConfig } from './codegen/wrangler.js';
 import { deploymentAddressing, resolveRouter, workerName } from './configuration.js';
 import { frontendFiles } from './frontend-v1.js';
-import { qualifyWorkerBundle } from './qualification.js';
-import { runWranglerBundle } from './wrangler-cli.js';
+import { frontendRoutes } from './frontend/routes.js';
+import { prepareGateway } from './gateway/prepare.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';
+import { admitWorkerRuntimeConfiguration } from './worker/runtime.js';
+export { materialize } from './materialize.js';
 const encoder = new TextEncoder();
-const SERVICE_MODULE = 'service.mjs';
-const RELEASE_ENTRY = 'bundle/index.mjs';
-const RELEASE_SERVICE = `bundle/${SERVICE_MODULE}`;
 /** Prepare one revision Service and its stateless gateway without provider mutation. */
 export async function artifact(params, context) {
+    return prepare(params, context, true);
+}
+/** Prepare the complete portable Cloudflare Worker without direct Wrangler placement files. */
+export async function prepareWorkerArtifact(params, context) {
+    return prepare(params, context, false);
+}
+async function prepare(params, context, direct) {
     const stateDirectory = join(context.projectDir, '.astrale');
     const directory = join(stateDirectory, 'runtime');
     await mkdir(directory, { recursive: true });
-    const runtimePath = resolve(context.projectDir, context.runtime.reference.path);
-    const runtimeSpecifier = moduleSpecifier(relative(directory, runtimePath));
     const router = resolveRouter(params.router);
     const name = workerName(params, context.build.schema.compiled.root.origin);
     const revision = context.build.schema.compiled.root.revision;
     const namespace = releaseNamespace(name);
     const target = releaseWorkerName(revision);
     const configuredIssuer = deploymentAddressing(params);
-    const serviceSource = generateExecutionService({
-        origin: context.build.schema.compiled.root.origin,
-        runtimeSpecifier,
-        material: material(context.build),
-        ...(configuredIssuer === undefined ? { providerAssignedWorker: name } : {}),
-        ...(router === undefined
-            ? {}
-            : {
-                router: {
-                    binding: router.binding,
-                    hostSuffix: router.hostSuffix,
-                    minLabels: router.minLabels,
-                },
-            }),
-    });
-    const serviceSourcePath = join(directory, 'service.gen.ts');
-    await writeFile(serviceSourcePath, serviceSource);
-    const serviceConfigPath = join(directory, 'wrangler.service.prepare.jsonc');
-    await writeFile(serviceConfigPath, generateWranglerConfig({
-        workerName: name,
-        main: './service.gen.ts',
-        vars: {
-            ...params.vars,
-            ...(configuredIssuer === undefined ? {} : { WORKER_URL: configuredIssuer }),
-        },
-        secretBindings: [SIGNING_IDENTITY_BINDING],
-        ...(router === undefined
-            ? {}
-            : { router: { binding: router.binding, service: router.service } }),
-        ...(params.wrangler === undefined ? {} : { wrangler: params.wrangler }),
-        selfBinding: false,
-    }));
-    const serviceOutput = join(directory, 'dist-service');
-    await rm(serviceOutput, { recursive: true, force: true });
-    const emittedService = await runWranglerBundle({
-        projectDir: context.projectDir,
-        configPath: serviceConfigPath,
-        outDir: serviceOutput,
-    });
-    await qualifyWorkerBundle({
-        metafilePath: emittedService.metafilePath,
-        inputRoot: dirname(serviceConfigPath),
-    });
-    await admitBundle(emittedService.bundlePath);
-    const serviceBundle = await readFile(emittedService.bundlePath);
-    await mkdir(dirname(join(directory, RELEASE_SERVICE)), { recursive: true });
-    await writeFile(join(directory, RELEASE_SERVICE), serviceBundle);
-    const sourcePath = join(directory, 'worker.gen.ts');
-    await writeFile(sourcePath, generateExecutionEntry(`./${RELEASE_SERVICE}`));
-    const configPath = join(directory, 'wrangler.prepare.jsonc');
-    await writeFile(configPath, generateWranglerConfig({
-        workerName: name,
-        ...(params.route === undefined ? {} : { route: params.route }),
-        vars: {
-            ...params.vars,
-            ...(configuredIssuer === undefined ? {} : { WORKER_URL: configuredIssuer }),
-        },
-        secretBindings: [SIGNING_IDENTITY_BINDING],
-        modules: { baseDir: '.', globs: [RELEASE_SERVICE] },
-        ...(router === undefined
-            ? {}
-            : { router: { binding: router.binding, service: router.service } }),
-        ...(params.wrangler === undefined ? {} : { wrangler: params.wrangler }),
-        selfBinding: false,
-    }));
-    const output = join(directory, 'dist-prepare');
-    await rm(output, { recursive: true, force: true });
-    const emitted = await runWranglerBundle({
-        projectDir: context.projectDir,
-        configPath,
-        outDir: output,
+    const execution = await prepareExecution({
+        params,
+        context,
+        directory,
+        name,
+        direct,
+        configuredIssuer,
+        router,
     });
     const frontend = await frontendFiles({
         frontend: context.build.frontend,
         projectDir: context.projectDir,
     });
-    await qualifyWorkerBundle({
-        metafilePath: emitted.metafilePath,
-        inputRoot: dirname(configPath),
-    });
-    await admitBundle(emitted.bundlePath);
-    const bundle = await readFile(emitted.bundlePath);
-    const gatewaySource = join(directory, 'gateway.gen.ts');
-    await writeFile(gatewaySource, generateGatewayEntry(revision));
-    const gatewayPrepareConfig = join(directory, 'wrangler.gateway.prepare.jsonc');
-    await writeFile(gatewayPrepareConfig, generateWranglerConfig({
-        workerName: name,
-        main: './gateway.gen.ts',
-        ...(params.route === undefined ? {} : { route: params.route }),
-        releases: { binding: 'RELEASES', namespace },
-        selfBinding: false,
-    }));
-    const gatewayOutput = join(directory, 'dist-gateway');
-    await rm(gatewayOutput, { recursive: true, force: true });
-    const gateway = await runWranglerBundle({
+    const gatewayBundle = await prepareGateway({
         projectDir: context.projectDir,
-        configPath: gatewayPrepareConfig,
-        outDir: gatewayOutput,
-    });
-    await qualifyWorkerBundle({
-        metafilePath: gateway.metafilePath,
-        inputRoot: dirname(gatewayPrepareConfig),
+        directory,
+        name,
+        ...(params.route === undefined ? {} : { route: params.route }),
+        namespace,
+        revision,
     });
-    await admitBundle(gateway.bundlePath);
-    const gatewayBundle = await readFile(gateway.bundlePath);
     const releaseConfig = generateWranglerConfig({
         workerName: target,
         main: `./${RELEASE_ENTRY}`,
-        vars: {
-            ...params.vars,
-            ...(configuredIssuer === undefined ? {} : { WORKER_URL: configuredIssuer }),
-        },
+        vars: runtimeVars(params, configuredIssuer),
         secretBindings: [SIGNING_IDENTITY_BINDING],
         modules: { baseDir: '.', globs: [RELEASE_SERVICE] },
         ...(context.build.frontend?.source.kind === 'vite'
@@ -165,16 +80,65 @@ export async function artifact(params, context) {
         releases: { binding: 'RELEASES', namespace },
         selfBinding: false,
     });
+    const runtime = admitWorkerRuntimeConfiguration(releaseConfig);
+    const manifest = encodeWorkerArtifactManifest({
+        origin: context.build.schema.compiled.root.origin,
+        revision,
+        release: {
+            entrypoint: RELEASE_ENTRY,
+            modules: [
+                { path: RELEASE_ENTRY, kind: 'esm', digest: workerContentDigest(execution.entry) },
+                { path: RELEASE_SERVICE, kind: 'esm', digest: workerContentDigest(execution.service) },
+            ],
+        },
+        gateway: {
+            entrypoint: 'gateway/index.mjs',
+            modules: [
+                { path: 'gateway/index.mjs', kind: 'esm', digest: workerContentDigest(gatewayBundle) },
+            ],
+        },
+        runtime: {
+            compatibilityDate: runtime.compatibilityDate,
+            compatibilityFlags: runtime.compatibilityFlags,
+        },
+        bindings: {
+            vars: runtime.vars,
+            services: runtime.services,
+            requiredSecrets: [SIGNING_IDENTITY_BINDING],
+        },
+        ...(frontend.length === 0
+            ? {}
+            : {
+                assets: {
+                    files: frontend.map((file) => {
+                        const contentType = file.mediaType ?? inferMediaType(file.path);
+                        return {
+                            path: `/${file.path}`,
+                            artifactPath: `frontend/${file.path}`,
+                            digest: workerContentDigest(file.bytes()),
+                            ...(contentType === undefined ? {} : { contentType }),
+                        };
+                    }),
+                    notFound: 'none',
+                    runWorkerFirst: true,
+                },
+            }),
+    });
     const files = [
-        { path: 'wrangler.release.jsonc', content: encoder.encode(releaseConfig) },
-        { path: 'wrangler.gateway.jsonc', content: encoder.encode(gatewayConfig) },
-        { path: RELEASE_ENTRY, content: new Uint8Array(bundle) },
-        { path: RELEASE_SERVICE, content: new Uint8Array(serviceBundle) },
-        { path: 'gateway/index.mjs', content: new Uint8Array(gatewayBundle) },
+        { path: RELEASE_ENTRY, content: execution.entry },
+        { path: RELEASE_SERVICE, content: execution.service },
+        { path: 'gateway/index.mjs', content: gatewayBundle },
+        { path: WORKER_MANIFEST_PATH, content: manifest },
         ...frontend.map((file) => ({
             path: `frontend/${file.path}`,
             content: file.bytes(),
         })),
+        ...(direct
+            ? [
+                { path: 'wrangler.release.jsonc', content: encoder.encode(releaseConfig) },
+                { path: 'wrangler.gateway.jsonc', content: encoder.encode(gatewayConfig) },
+            ]
+            : []),
     ];
     return Object.freeze({
         entrypoint: RELEASE_ENTRY,
@@ -184,34 +148,3 @@ export async function artifact(params, context) {
             : Object.freeze({ kind: 'configured', addressing: addressing(configuredIssuer) }),
     });
 }
-async function admitBundle(path) {
-    const loaded = (await import(`${pathToFileURL(path).href}?admit=${Date.now()}`));
-    if (loaded.default === null ||
-        typeof loaded.default !== 'object' ||
-        typeof Reflect.get(loaded.default, 'fetch') !== 'function') {
-        throw new TypeError('Generated Worker bundle does not export a Fetch handler.');
-    }
-}
-function frontendRoutes(frontend) {
-    if (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 materialize(root, files) {
-    await rm(root, { recursive: true, force: true });
-    for (const file of files) {
-        const path = join(root, file.path);
-        await mkdir(dirname(path), { recursive: true });
-        await writeFile(path, file.bytes());
-    }
-}
-function moduleSpecifier(input) {
-    const normalized = input.split('\\').join('/');
-    return normalized.startsWith('.') ? normalized : `./${normalized}`;
-}

package/dist/build/bundle/admit.d.ts

@@ -0,0 +1 @@
+export declare function admitWorkerBundle(path: string): Promise<void>;

package/dist/build/bundle/admit.js

@@ -0,0 +1,9 @@
+import { pathToFileURL } from 'node:url';
+export async function admitWorkerBundle(path) {
+    const loaded = (await import(`${pathToFileURL(path).href}?admit=${Date.now()}`));
+    if (loaded.default === null ||
+        typeof loaded.default !== 'object' ||
+        typeof Reflect.get(loaded.default, 'fetch') !== 'function') {
+        throw new TypeError('Generated Worker bundle does not export a Fetch handler.');
+    }
+}

package/dist/build/codegen/execution.d.ts

@@ -1,15 +1,3 @@
-import type { BuildMaterial } from '@astrale-os/sdk/deployment/build';
-export interface ExecutionCodegenOptions {
-    readonly origin: string;
-    readonly runtimeSpecifier: string;
-    readonly material: BuildMaterial;
-    readonly providerAssignedWorker?: string;
-    readonly router?: {
-        readonly binding: string;
-        readonly hostSuffix: string;
-        readonly minLabels: number;
-    };
-}
-export declare function generateExecutionService(options: ExecutionCodegenOptions): string;
-/** Generate the isolate-startup entry that realizes the heavy Service on first request. */
-export declare function generateExecutionEntry(serviceSpecifier: string): string;
+export { generateExecutionEntry } from '../worker/codegen/entry.js';
+export { generateExecutionService } from '../worker/codegen/service.js';
+export type { ExecutionCodegenOptions } from '../worker/codegen/service.js';

package/dist/build/codegen/execution.js

@@ -1,72 +1,2 @@
-export function generateExecutionService(options) {
-    const router = options.router;
-    const routerPredicate = router === undefined
-        ? ''
-        : `
-function isInstanceHost(host: string): boolean {
-  return host.endsWith(${JSON.stringify(router.hostSuffix)}) && host.split('.').length >= ${router.minLabels}
-}
-`;
-    const routeSubrequest = router === undefined
-        ? ''
-        : `
-  routeSubrequest: (url, env) => {
-    const labels = url.hostname.split('.')
-    if (env.DISPATCHER && labels[1] === 'svc') return env.DISPATCHER.get(labels[0]!)
-    if (env.${router.binding} && isInstanceHost(url.hostname)) return env.${router.binding}
-    return null
-  },`;
-    return `// AUTO-GENERATED by @astrale-os/adapter-cloudflare — do not edit.
-// Domain origin: ${options.origin}
-import type { BuildMaterial } from '@astrale-os/sdk/deployment/build'
-import type { CloudflareAdapterBindings } from '@astrale-os/adapter-cloudflare/worker'
-
-import { cloudflareWorkerEntry } from '@astrale-os/adapter-cloudflare/worker'
-import { decodeSigningIdentity, runtimeBindings } from '@astrale-os/adapter-cloudflare/worker'
-
-type WorkerEnv = CloudflareEnv & CloudflareAdapterBindings & {
-  readonly ASTRALE_SIGNING_IDENTITY: string
-}
-type RuntimeEnv = Omit<WorkerEnv, 'ASTRALE_SIGNING_IDENTITY'>
-${routerPredicate}
-export default cloudflareWorkerEntry<WorkerEnv, RuntimeEnv>()({
-  load: async () => ({
-    runtime: (await import(${JSON.stringify(options.runtimeSpecifier)})).default,
-    material: ${JSON.stringify(options.material)} as const satisfies BuildMaterial,
-  }),
-  privateKey: (env) => decodeSigningIdentity(env.ASTRALE_SIGNING_IDENTITY),
-  resolveEnvironment: runtimeBindings,
-  resolveUrl: (env, requestOrigin) => env.WORKER_URL ?? env.IDENTITY_ISS ?? requestOrigin,
-  ${options.providerAssignedWorker === undefined ? '' : `providerAssignedWorker: ${JSON.stringify(options.providerAssignedWorker)},`}
-  selfBinding: (env) => env.SELF,${routeSubrequest}
-})
-`;
-}
-/** Generate the isolate-startup entry that realizes the heavy Service on first request. */
-export function generateExecutionEntry(serviceSpecifier) {
-    return `// AUTO-GENERATED by @astrale-os/adapter-cloudflare — do not edit.
-import type { CloudflareWorker } from '@astrale-os/adapter-cloudflare/worker'
-
-const SERVICE_SPECIFIER = ${JSON.stringify(serviceSpecifier)}
-let servicePromise: Promise<CloudflareWorker<CloudflareEnv>> | undefined
-
-export default {
-  async fetch(request: Request, environment: CloudflareEnv, context: ExecutionContext) {
-    return (await service()).fetch(request, environment, context)
-  },
-}
-
-function service(): Promise<CloudflareWorker<CloudflareEnv>> {
-  return (servicePromise ??= import(SERVICE_SPECIFIER).then((loaded: unknown) => {
-    if (loaded === null || typeof loaded !== 'object') invalid()
-    const worker = Reflect.get(loaded, 'default') as unknown
-    if (worker === null || typeof worker !== 'object' || typeof Reflect.get(worker, 'fetch') !== 'function') invalid()
-    return worker as CloudflareWorker<CloudflareEnv>
-  }))
-}
-
-function invalid(): never {
-  throw new TypeError('Cloudflare execution Service module is invalid.')
-}
-`;
-}
+export { generateExecutionEntry } from '../worker/codegen/entry.js';
+export { generateExecutionService } from '../worker/codegen/service.js';

package/dist/build/codegen/gateway.d.ts

@@ -1 +1 @@
-export declare function generateGatewayEntry(revision: string): string;
+export { generateGatewayEntry } from '../gateway/source.js';

package/dist/build/codegen/gateway.js

@@ -1,7 +1 @@
-export function generateGatewayEntry(revision) {
-    return `// AUTO-GENERATED by @astrale-os/adapter-cloudflare — do not edit.
-import { cloudflareGatewayEntry } from '@astrale-os/adapter-cloudflare/worker'
-
-export default cloudflareGatewayEntry({ current: ${JSON.stringify(revision)} })
-`;
-}
+export { generateGatewayEntry } from '../gateway/source.js';

package/dist/build/configuration/addressing.d.ts

@@ -0,0 +1,2 @@
+import type { CloudflareParams } from '../../params.js';
+export declare function deploymentAddressing(parameters: CloudflareParams): string | undefined;

package/dist/build/configuration/addressing.js

@@ -0,0 +1,11 @@
+import { addressing } from '@astrale-os/sdk/deployment/release';
+export function deploymentAddressing(parameters) {
+    const routed = parameters.route === undefined ? undefined : addressing(`https://${parameters.route}`).issuer;
+    if (parameters.addressing === undefined)
+        return routed;
+    const configured = addressing(parameters.addressing).issuer;
+    if (routed !== undefined && configured !== routed) {
+        throw new TypeError('Cloudflare route and addressing identify different origins.');
+    }
+    return configured;
+}

package/dist/build/configuration/router.d.ts

@@ -0,0 +1,7 @@
+import type { CloudflareParams } from '../../params.js';
+export declare function resolveRouter(input: CloudflareParams['router']): {
+    readonly binding: string;
+    readonly service: string;
+    readonly hostSuffix: string;
+    readonly minLabels: number;
+} | undefined;

package/dist/build/configuration/router.js

@@ -0,0 +1,11 @@
+export function resolveRouter(input) {
+    if (input === false)
+        return undefined;
+    const value = input ?? {};
+    return Object.freeze({
+        binding: value.binding ?? 'ROUTER',
+        service: value.service ?? 'admin-router',
+        hostSuffix: value.hostSuffix ?? '.astrale.ai',
+        minLabels: value.minLabels ?? 4,
+    });
+}

package/dist/build/configuration/worker-name.d.ts

@@ -0,0 +1,2 @@
+import type { CloudflareParams } from '../../params.js';
+export declare function workerName(parameters: CloudflareParams, origin: string): string;

package/dist/build/configuration/worker-name.js

@@ -0,0 +1,18 @@
+import { createHash } from 'node:crypto';
+const WORKER_NAME = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/u;
+export function workerName(parameters, origin) {
+    if (parameters.workerName !== undefined) {
+        if (!WORKER_NAME.test(parameters.workerName) || parameters.workerName.length > 63) {
+            throw new TypeError('Cloudflare workerName is invalid.');
+        }
+        return parameters.workerName;
+    }
+    const readable = origin
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/gu, '-')
+        .slice(0, 12)
+        .replace(/^-+|-+$/gu, '') || 'domain';
+    const hexadecimal = createHash('sha256').update(origin).digest('hex');
+    const identity = BigInt(`0x${hexadecimal}`).toString(36).padStart(50, '0');
+    return `${readable}-${identity}`;
+}

package/dist/build/configuration.d.ts

@@ -1,9 +1,3 @@
-import type { CloudflareParams } from '../params.js';
-export declare function deploymentAddressing(parameters: CloudflareParams): string | undefined;
-export declare function workerName(parameters: CloudflareParams, origin: string): string;
-export declare function resolveRouter(input: CloudflareParams['router']): {
-    readonly binding: string;
-    readonly service: string;
-    readonly hostSuffix: string;
-    readonly minLabels: number;
-} | undefined;
+export { deploymentAddressing } from './configuration/addressing.js';
+export { resolveRouter } from './configuration/router.js';
+export { workerName } from './configuration/worker-name.js';

package/dist/build/configuration.js

@@ -1,40 +1,3 @@
-import { addressing } from '@astrale-os/sdk/deployment/release';
-import { createHash } from 'node:crypto';
-const WORKER_NAME = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/u;
-export function deploymentAddressing(parameters) {
-    const routed = parameters.route === undefined ? undefined : addressing(`https://${parameters.route}`).issuer;
-    if (parameters.addressing === undefined)
-        return routed;
-    const configured = addressing(parameters.addressing).issuer;
-    if (routed !== undefined && configured !== routed) {
-        throw new TypeError('Cloudflare route and addressing identify different origins.');
-    }
-    return configured;
-}
-export function workerName(parameters, origin) {
-    if (parameters.workerName !== undefined) {
-        if (!WORKER_NAME.test(parameters.workerName) || parameters.workerName.length > 63) {
-            throw new TypeError('Cloudflare workerName is invalid.');
-        }
-        return parameters.workerName;
-    }
-    const readable = origin
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/gu, '-')
-        .slice(0, 12)
-        .replace(/^-+|-+$/gu, '') || 'domain';
-    const hexadecimal = createHash('sha256').update(origin).digest('hex');
-    const identity = BigInt(`0x${hexadecimal}`).toString(36).padStart(50, '0');
-    return `${readable}-${identity}`;
-}
-export function resolveRouter(input) {
-    if (input === false)
-        return undefined;
-    const value = input ?? {};
-    return Object.freeze({
-        binding: value.binding ?? 'ROUTER',
-        service: value.service ?? 'admin-router',
-        hostSuffix: value.hostSuffix ?? '.astrale.ai',
-        minLabels: value.minLabels ?? 4,
-    });
-}
+export { deploymentAddressing } from './configuration/addressing.js';
+export { resolveRouter } from './configuration/router.js';
+export { workerName } from './configuration/worker-name.js';

package/dist/build/direct.d.ts

@@ -0,0 +1,4 @@
+import type { PreparedArtifact } from '@astrale-os/sdk/deployment/adapter';
+import type { CloudflareParams } from '../params.js';
+import type { WorkerArtifact } from './worker/index.js';
+export declare function admitDirectPlacement(artifact: PreparedArtifact, worker: WorkerArtifact, parameters: CloudflareParams): void;