@astrale-os/adapter-cloudflare 0.5.0-beta.4 → 0.5.0-beta.41

package/README.md

@@ -0,0 +1,11 @@
+# `@astrale-os/adapter-cloudflare`
+
+Cloudflare Worker deployment adapter for Astrale Domains.
+
+During the SDK beta program, install the beta package set explicitly:
+
+```bash
+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.

package/dist/adapter.d.ts

@@ -0,0 +1,17 @@
+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 { signingIdentity } from './identity/source.js';
+export interface CloudflareDependencies extends CloudflareDeployDependencies {
+    readonly artifact: typeof artifact;
+    readonly runWranglerDev: typeof runWranglerDev;
+    readonly startFrontend: typeof startFrontend;
+    readonly signingIdentity: typeof signingIdentity;
+}
+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, signal?: AbortSignal): Promise<void>;

package/dist/adapter.js

@@ -0,0 +1,178 @@
+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 { ensureWranglerDispatchNamespace, runWranglerDeploymentStatus, runWranglerDeploy, runWranglerDev, runWranglerReleaseDeploy, } from './build/wrangler-cli.js';
+import { deployCloudflare } from './deploy/index.js';
+import { signingIdentitySecrets } from './identity/secret.js';
+import { signingIdentity } from './identity/source.js';
+const packageVersion = createRequire(import.meta.url)('../package.json')
+    .version;
+export function cloudflare(environments) {
+    return cloudflareWithDependencies(environments, {
+        artifact,
+        materialize,
+        ensureWranglerDispatchNamespace,
+        runWranglerDeploy,
+        runWranglerReleaseDeploy,
+        runWranglerDeploymentStatus,
+        runWranglerDev,
+        startFrontend,
+        signingIdentity,
+        waitForReadiness: (release, signal) => waitForReadiness(verifyReadiness, release, signal),
+    });
+}
+export function cloudflareWithDependencies(environments, dependencies) {
+    return defineAdapter({
+        name: 'cloudflare',
+        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,
+                    ...(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.');
+                    }
+                },
+            });
+        },
+        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;
+    while (Date.now() < deadline) {
+        throwIfAborted(signal);
+        try {
+            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 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

@@ -0,0 +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>;
+/** 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

@@ -0,0 +1,151 @@
+import { addressing } from '@astrale-os/sdk/deployment/release';
+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 { generateWranglerConfig } from './codegen/wrangler.js';
+import { deploymentAddressing, resolveRouter, workerName } from './configuration.js';
+import { frontendFiles } from './frontend-v1.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();
+/** 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 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 execution = await prepareExecution({
+        params,
+        context,
+        directory,
+        name,
+        direct,
+        configuredIssuer,
+        router,
+    });
+    const frontend = await frontendFiles({
+        frontend: context.build.frontend,
+        projectDir: context.projectDir,
+    });
+    const gatewayBundle = await prepareGateway({
+        projectDir: context.projectDir,
+        directory,
+        name,
+        ...(params.route === undefined ? {} : { route: params.route }),
+        namespace,
+        revision,
+    });
+    const releaseConfig = generateWranglerConfig({
+        workerName: target,
+        main: `./${RELEASE_ENTRY}`,
+        vars: runtimeVars(params, configuredIssuer),
+        secretBindings: [SIGNING_IDENTITY_BINDING],
+        modules: { baseDir: './bundle', rules: [{ type: 'ESModule', globs: ['service.mjs'] }] },
+        ...(context.build.frontend?.source.kind === 'vite'
+            ? {
+                frontend: {
+                    directory: './frontend',
+                    routes: frontendRoutes(context.build.frontend),
+                    dev: false,
+                },
+            }
+            : {}),
+        ...(router === undefined
+            ? {}
+            : { router: { binding: router.binding, service: router.service } }),
+        ...(params.wrangler === undefined ? {} : { wrangler: params.wrangler }),
+        selfBinding: false,
+    });
+    const gatewayConfig = generateWranglerConfig({
+        workerName: name,
+        main: './gateway/index.mjs',
+        ...(params.route === undefined ? {} : { route: params.route }),
+        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,
+                    htmlHandling: 'none',
+                },
+            }),
+    });
+    const files = [
+        { 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,
+        files: Object.freeze(files),
+        addressing: configuredIssuer === undefined
+            ? Object.freeze({ kind: 'provider-assigned', claim: name })
+            : Object.freeze({ kind: 'configured', addressing: addressing(configuredIssuer) }),
+    });
+}

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/closure.d.ts

@@ -0,0 +1,2 @@
+/** Prove emitted Worker reachability excludes authoring, compilation, and broad Core Schema owners. */
+export declare function assertRuntimeClosure(metafilePath: string): Promise<void>;

package/dist/build/closure.js

@@ -0,0 +1,22 @@
+import { readWranglerMetafile } from './metafile.js';
+const FORBIDDEN_RUNTIME_INPUTS = [
+    '/v1/builder/',
+    '/v1/compiled/compiler/',
+    '/node_modules/ajv/',
+    '/node_modules/re2js/',
+    '/kernel-core/domain/',
+    '/core/domain/',
+    '/kernel-core/schema/index.',
+    '/core/schema/index.',
+];
+/** Prove emitted Worker reachability excludes authoring, compilation, and broad Core Schema owners. */
+export async function assertRuntimeClosure(metafilePath) {
+    const metafile = await readWranglerMetafile(metafilePath);
+    const forbidden = Object.keys(metafile.inputs).filter((input) => {
+        const normalized = `/${input.replaceAll('\\', '/')}`.replace(/(\/node_modules\/@astrale-os\/kernel-[^/]+)\/dist\//gu, '$1/');
+        return FORBIDDEN_RUNTIME_INPUTS.some((fragment) => normalized.includes(fragment));
+    });
+    if (forbidden.length > 0) {
+        throw new Error(`Cloudflare Worker reaches build-side modules: ${forbidden.sort().join(', ')}.`);
+    }
+}

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,2 @@
+export { generateExecutionEntry } from '../worker/codegen/entry.js';
+export { generateExecutionService } from '../worker/codegen/service.js';

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

@@ -0,0 +1 @@
+export { generateGatewayEntry } from '../gateway/source.js';

package/dist/build/codegen/gateway.js

@@ -0,0 +1 @@
+export { generateGatewayEntry } from '../gateway/source.js';

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

@@ -17,4 +17,3 @@
  * the caller (`generateWranglerConfig`), not here — this stays a generic merge.
  */
 export declare function deepMergeConfig(base: Record<string, unknown>, overlay: Record<string, unknown>): Record<string, unknown>;
-//# sourceMappingURL=merge.d.ts.map

package/dist/build/codegen/merge.js

@@ -88,4 +88,3 @@ function isPlainObject(v) {
 function isPrimitive(v) {
     return v === null || (typeof v !== 'object' && typeof v !== 'function');
 }
-//# sourceMappingURL=merge.js.map

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

@@ -13,17 +13,35 @@
  */
 export interface WranglerCodegenOptions {
     workerName: string;
+    /** Provider-ready entrypoint relative to the generated config. */
+    main?: string;
     /** Full custom hostname for a routed deploy (e.g. 'crm.acme.dev'). */
     route?: string;
     /** Exact materialized local frontend; absence means no ASSETS binding. */
     frontend?: {
         readonly directory: string;
         readonly routes: readonly string[];
+        readonly dev: boolean;
     };
     /** Plain (non-secret) vars to bake in. */
     vars?: Record<string, string>;
+    /** Secret binding names required by generated Worker code. */
+    secretBindings?: readonly string[];
+    /** Modules retained outside the startup entry and loaded on demand. */
+    modules?: {
+        readonly baseDir: string;
+        readonly rules: readonly {
+            readonly type: 'ESModule' | 'CompiledWasm' | 'Text' | 'Data';
+            readonly globs: readonly string[];
+        }[];
+    };
     /** Add the SELF service binding (autobinding). */
     selfBinding: boolean;
+    /** Bind the stable gateway to its private revision namespace. */
+    releases?: {
+        readonly binding: string;
+        readonly namespace: string;
+    };
     /**
      * Add a service binding to a router Worker for instance-host subrequest
      * routing (see `CloudflareParams.router`). Pairs with the worker
@@ -43,4 +61,3 @@ export interface WranglerCodegenOptions {
     wrangler?: Record<string, unknown>;
 }
 export declare function generateWranglerConfig(opts: WranglerCodegenOptions): string;
-//# sourceMappingURL=wrangler.d.ts.map

package/dist/build/codegen/wrangler.js

@@ -12,15 +12,15 @@
  * (extra bindings: KV, R2, D1, queues, …) — see `mergeUserConfig`.
  */
 import { deepMergeConfig } from './merge.js';
-// Wrangler 4.121.0's pinned workerd accepts dates through 2026-08-11.
+// Keep the generated date on the runtime baseline qualified with Wrangler 4.123.0.
 const COMPATIBILITY_DATE = '2026-08-11';
 export function generateWranglerConfig(opts) {
     const config = {
         name: opts.workerName,
-        main: './worker.gen.ts',
+        main: opts.main ?? './worker.gen.ts',
         compatibility_date: COMPATIBILITY_DATE,
         compatibility_flags: ['nodejs_compat'],
-        workers_dev: true,
+        workers_dev: opts.route === undefined,
         version_metadata: { binding: 'ASTRALE_VERSION_METADATA' },
         observability: { enabled: true },
     };
@@ -31,19 +31,20 @@ export function generateWranglerConfig(opts) {
         config.assets = {
             directory: opts.frontend.directory,
             binding: 'ASSETS',
-            run_worker_first: [
-                '/invoke',
-                '/invoke/*',
-                '/install',
-                '/install/*',
-                '/health',
-                '/health/*',
-                '/meta',
-                '/meta/*',
-                '/.well-known',
-                '/.well-known/*',
-                ...opts.frontend.routes,
-            ],
+            html_handling: 'none',
+            run_worker_first: opts.frontend.dev
+                ? true
+                : [
+                    '/releases',
+                    '/releases/*',
+                    '/install',
+                    '/install/*',
+                    '/health',
+                    '/health/*',
+                    '/.well-known',
+                    '/.well-known/*',
+                    ...opts.frontend.routes,
+                ],
         };
     }
     const services = [];
@@ -57,6 +58,21 @@ export function generateWranglerConfig(opts) {
     if (opts.vars && Object.keys(opts.vars).length > 0) {
         config.vars = opts.vars;
     }
+    if (opts.secretBindings && opts.secretBindings.length > 0) {
+        config.secrets = { required: [...opts.secretBindings] };
+    }
+    if (opts.modules !== undefined) {
+        config.find_additional_modules = true;
+        config.base_dir = opts.modules.baseDir;
+        config.rules = opts.modules.rules.map((rule) => ({
+            type: rule.type,
+            globs: [...rule.globs],
+            fallthrough: true,
+        }));
+    }
+    if (opts.releases !== undefined) {
+        config.dispatch_namespaces = [opts.releases];
+    }
     const merged = opts.wrangler ? mergeUserConfig(config, opts.wrangler) : config;
     return JSON.stringify(merged, null, 2) + '\n';
 }
@@ -67,7 +83,11 @@ const ADAPTER_OWNED_KEYS = [
     'assets',
     'routes',
     'compatibility_date',
+    'workers_dev',
     'version_metadata',
+    'secrets',
+    'find_additional_modules',
+    'base_dir',
 ];
 /**
  * Deep-merge the dev's raw wrangler overlay over the generated config, after
@@ -83,4 +103,3 @@ function mergeUserConfig(base, user) {
     }
     return deepMergeConfig(base, user);
 }
-//# sourceMappingURL=wrangler.js.map

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/request-limit.d.ts

@@ -0,0 +1,2 @@
+import type { CloudflareParams } from '../../params.js';
+export declare function workerRequestLimit(value: CloudflareParams['maximumRequestBytes']): number | undefined;

package/dist/build/configuration/request-limit.js

@@ -0,0 +1,9 @@
+const MAXIMUM_REQUEST_BYTES = 16 * 1024 * 1024;
+export function workerRequestLimit(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isSafeInteger(value) || value <= 0 || value > MAXIMUM_REQUEST_BYTES) {
+        throw new TypeError('Cloudflare maximumRequestBytes must be a positive integer at most 16 MiB.');
+    }
+    return value;
+}

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

@@ -0,0 +1,4 @@
+export { deploymentAddressing } from './configuration/addressing.js';
+export { workerRequestLimit } from './configuration/request-limit.js';
+export { resolveRouter } from './configuration/router.js';
+export { workerName } from './configuration/worker-name.js';