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

package/dist/build/worker/artifact.load.js

@@ -0,0 +1,308 @@
+import { isPreparedArtifact } from '@astrale-os/sdk/deployment/verify';
+import { createHash } from 'node:crypto';
+import { workerDeployment } from '../../release/deployment.js';
+import { WORKER_ARTIFACT_FORMAT, WORKER_ARTIFACT_VERSION } from './artifact.manifest.js';
+import { artifactPath, assetPath, comparePath, WORKER_MANIFEST_PATH } from './artifact.paths.js';
+const decoder = new TextDecoder('utf-8', { fatal: true });
+const REVISION = /^sha256:[0-9a-f]{64}$/u;
+const BINDING = /^[A-Za-z_$][A-Za-z0-9_$]{0,127}$/u;
+const DATE = /^\d{4}-\d{2}-\d{2}$/u;
+const KINDS = new Set(['esm', 'wasm', 'text', 'data']);
+export function loadWorkerArtifact(artifact) {
+    if (!isPreparedArtifact(artifact))
+        throw new TypeError('PreparedArtifact is not admitted.');
+    const manifestFile = requiredFile(artifact, WORKER_MANIFEST_PATH);
+    let decoded;
+    try {
+        decoded = JSON.parse(decoder.decode(manifestFile.bytes()));
+    }
+    catch (cause) {
+        throw new TypeError('Cloudflare Worker artifact manifest is invalid JSON.', { cause });
+    }
+    const manifest = admitManifest(decoded);
+    if (artifact.entrypoint !== manifest.release.entrypoint) {
+        throw new TypeError('Cloudflare Worker artifact entrypoint differs from its manifest.');
+    }
+    const origin = artifact.build.schema.compiled.root.origin;
+    const revision = artifact.build.schema.compiled.root.revision;
+    if (manifest.origin !== origin || manifest.revision !== revision) {
+        throw new TypeError('Cloudflare Worker artifact identity differs from its Build.');
+    }
+    const claimed = new Set([WORKER_MANIFEST_PATH]);
+    const release = executable(artifact, manifest.release, claimed, 'release');
+    const assets = manifest.assets?.files.map((file) => {
+        claim(claimed, file.artifactPath);
+        const source = requiredFile(artifact, file.artifactPath);
+        const content = source.bytes();
+        verifyContent(content, file.digest, file.artifactPath);
+        return Object.freeze({
+            path: file.path,
+            artifactPath: file.artifactPath,
+            ...(file.contentType === undefined ? {} : { contentType: file.contentType }),
+            bytes: () => new Uint8Array(content),
+        });
+    });
+    const deployment = workerDeployment({
+        release: {
+            entrypoint: release.entrypoint,
+            modules: release.modules.map((module) => ({
+                path: module.path,
+                kind: module.kind,
+                content: module.bytes(),
+            })),
+        },
+        runtime: manifest.runtime,
+        bindings: manifest.bindings,
+        ...(manifest.assets === undefined
+            ? {}
+            : {
+                assets: {
+                    files: assets.map((file) => ({
+                        path: file.path,
+                        content: file.bytes(),
+                        ...(file.contentType === undefined ? {} : { contentType: file.contentType }),
+                    })),
+                    notFound: manifest.assets.notFound,
+                    runWorkerFirst: manifest.assets.runWorkerFirst,
+                    ...(manifest.assets.htmlHandling === undefined
+                        ? {}
+                        : { htmlHandling: manifest.assets.htmlHandling }),
+                },
+            }),
+    });
+    if (deployment !== manifest.deployment) {
+        throw new TypeError('Cloudflare Worker deployment identity differs from its material.');
+    }
+    return Object.freeze({
+        origin,
+        revision,
+        deployment,
+        release,
+        runtime: Object.freeze({
+            compatibilityDate: manifest.runtime.compatibilityDate,
+            compatibilityFlags: Object.freeze([...manifest.runtime.compatibilityFlags]),
+        }),
+        bindings: Object.freeze({
+            vars: Object.freeze({ ...manifest.bindings.vars }),
+            services: Object.freeze(manifest.bindings.services.map((binding) => Object.freeze({ ...binding }))),
+            requiredSecrets: Object.freeze([...manifest.bindings.requiredSecrets]),
+        }),
+        ...(manifest.assets === undefined
+            ? {}
+            : {
+                assets: Object.freeze({
+                    files: Object.freeze(assets),
+                    notFound: manifest.assets.notFound,
+                    runWorkerFirst: manifest.assets.runWorkerFirst,
+                    ...(manifest.assets.htmlHandling === undefined
+                        ? {}
+                        : { htmlHandling: manifest.assets.htmlHandling }),
+                }),
+            }),
+    });
+}
+function executable(artifact, manifest, claimed, label) {
+    const modules = manifest.modules.map((module) => {
+        claim(claimed, module.path);
+        const source = requiredFile(artifact, module.path);
+        const content = source.bytes();
+        verifyContent(content, module.digest, module.path);
+        return Object.freeze({
+            path: module.path,
+            kind: module.kind,
+            bytes: () => new Uint8Array(content),
+        });
+    });
+    if (!manifest.modules.some((module) => module.path === manifest.entrypoint)) {
+        throw new TypeError(`Cloudflare Worker ${label} entrypoint is not a module.`);
+    }
+    if (manifest.modules.find((module) => module.path === manifest.entrypoint)?.kind !== 'esm') {
+        throw new TypeError(`Cloudflare Worker ${label} entrypoint is not an ES module.`);
+    }
+    return Object.freeze({ entrypoint: manifest.entrypoint, modules: Object.freeze(modules) });
+}
+function admitManifest(input) {
+    const value = record(input, [
+        'format',
+        'version',
+        'origin',
+        'revision',
+        'deployment',
+        'release',
+        'runtime',
+        'bindings',
+        'assets',
+    ]);
+    if (value.format !== WORKER_ARTIFACT_FORMAT || value.version !== WORKER_ARTIFACT_VERSION) {
+        throw new TypeError('Cloudflare Worker artifact format or version is unsupported.');
+    }
+    if (typeof value.origin !== 'string' ||
+        value.origin.length === 0 ||
+        !REVISION.test(String(value.revision)) ||
+        !REVISION.test(String(value.deployment))) {
+        invalid();
+    }
+    const release = admitExecutable(value.release);
+    const runtime = record(value.runtime, ['compatibilityDate', 'compatibilityFlags']);
+    if (typeof runtime.compatibilityDate !== 'string' || !DATE.test(runtime.compatibilityDate))
+        invalid();
+    const compatibilityFlags = uniqueStrings(runtime.compatibilityFlags, 'compatibility flag');
+    const bindings = record(value.bindings, ['vars', 'services', 'requiredSecrets']);
+    const vars = stringRecord(bindings.vars);
+    const services = admitServices(bindings.services);
+    const requiredSecrets = uniqueStrings(bindings.requiredSecrets, 'secret binding');
+    const names = new Set();
+    for (const name of [
+        ...Object.keys(vars),
+        ...services.map((item) => item.name),
+        ...requiredSecrets,
+    ]) {
+        if (!BINDING.test(name) || names.has(name))
+            throw new TypeError(`Worker binding ${name} is invalid or duplicated.`);
+        names.add(name);
+    }
+    const assets = value.assets === undefined ? undefined : admitAssets(value.assets);
+    return Object.freeze({
+        format: WORKER_ARTIFACT_FORMAT,
+        version: WORKER_ARTIFACT_VERSION,
+        origin: value.origin,
+        revision: value.revision,
+        deployment: value.deployment,
+        release,
+        runtime: Object.freeze({
+            compatibilityDate: runtime.compatibilityDate,
+            compatibilityFlags,
+        }),
+        bindings: Object.freeze({ vars, services, requiredSecrets }),
+        ...(assets === undefined ? {} : { assets }),
+    });
+}
+function admitExecutable(input) {
+    const value = record(input, ['entrypoint', 'modules']);
+    const entrypoint = artifactPath(value.entrypoint, 'Worker entrypoint');
+    if (!Array.isArray(value.modules) || value.modules.length === 0)
+        invalid();
+    const paths = new Set();
+    const modules = value.modules.map((input) => {
+        const module = record(input, ['path', 'kind', 'digest']);
+        const path = artifactPath(module.path, 'Worker module path');
+        if (paths.has(path) ||
+            !KINDS.has(module.kind) ||
+            typeof module.digest !== 'string' ||
+            !REVISION.test(module.digest))
+            invalid();
+        paths.add(path);
+        return Object.freeze({ path, kind: module.kind, digest: module.digest });
+    });
+    canonical(modules.map((module) => module.path));
+    return Object.freeze({ entrypoint, modules: Object.freeze(modules) });
+}
+function admitServices(input) {
+    if (!Array.isArray(input))
+        invalid();
+    const names = new Set();
+    const services = input.map((item) => {
+        const value = record(item, ['name', 'service']);
+        if (typeof value.name !== 'string' ||
+            typeof value.service !== 'string' ||
+            value.service.length === 0 ||
+            names.has(value.name))
+            invalid();
+        names.add(value.name);
+        return Object.freeze({ name: value.name, service: value.service });
+    });
+    canonical(services.map((service) => service.name));
+    return Object.freeze(services);
+}
+function admitAssets(input) {
+    const value = record(input, ['files', 'notFound', 'runWorkerFirst', 'htmlHandling']);
+    if (!Array.isArray(value.files) ||
+        !['none', '404-page', 'single-page-application'].includes(String(value.notFound)) ||
+        typeof value.runWorkerFirst !== 'boolean' ||
+        (value.htmlHandling !== undefined && value.htmlHandling !== 'none'))
+        invalid();
+    const paths = new Set();
+    const files = value.files.map((input) => {
+        const file = record(input, ['path', 'artifactPath', 'digest', 'contentType']);
+        const path = assetPath(file.path);
+        if (paths.has(path))
+            invalid();
+        paths.add(path);
+        if (file.contentType !== undefined &&
+            (typeof file.contentType !== 'string' ||
+                file.contentType.length === 0 ||
+                file.contentType.length > 256))
+            invalid();
+        if (typeof file.digest !== 'string' || !REVISION.test(file.digest))
+            invalid();
+        return Object.freeze({
+            path,
+            artifactPath: artifactPath(file.artifactPath, 'Worker asset artifact path'),
+            digest: file.digest,
+            ...(file.contentType === undefined ? {} : { contentType: file.contentType }),
+        });
+    });
+    canonical(files.map((file) => file.path));
+    return Object.freeze({
+        files: Object.freeze(files),
+        notFound: value.notFound,
+        runWorkerFirst: value.runWorkerFirst,
+        ...(value.htmlHandling === undefined ? {} : { htmlHandling: 'none' }),
+    });
+}
+function record(input, allowed) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid();
+    const value = input;
+    if (Reflect.ownKeys(value).some((key) => typeof key !== 'string' || !allowed.includes(key)))
+        invalid();
+    return value;
+}
+function stringRecord(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid();
+    const value = input;
+    if (Reflect.ownKeys(value).some((key) => typeof key !== 'string'))
+        invalid();
+    if (Object.values(value).some((item) => typeof item !== 'string'))
+        invalid();
+    const entries = Object.entries(value);
+    canonical(entries.map(([name]) => name));
+    return Object.freeze(Object.fromEntries(entries));
+}
+function uniqueStrings(input, label) {
+    if (!Array.isArray(input) || input.some((item) => typeof item !== 'string' || item.length === 0))
+        invalid();
+    const values = input;
+    if (new Set(values).size !== values.length)
+        throw new TypeError(`Worker ${label} is duplicated.`);
+    canonical(values);
+    return Object.freeze([...values]);
+}
+function canonical(values) {
+    const sorted = [...values].sort(comparePath);
+    if (values.some((value, index) => value !== sorted[index])) {
+        throw new TypeError('Cloudflare Worker artifact manifest is not canonical.');
+    }
+}
+function claim(claimed, path) {
+    if (path === WORKER_MANIFEST_PATH || claimed.has(path)) {
+        throw new TypeError(`Cloudflare Worker artifact file ${path} has conflicting roles.`);
+    }
+    claimed.add(path);
+}
+function requiredFile(artifact, path) {
+    const file = artifact.files.find((candidate) => candidate.path === path);
+    if (file === undefined)
+        throw new TypeError(`Cloudflare Worker artifact is missing ${path}.`);
+    return file;
+}
+function verifyContent(content, expected, path) {
+    const digest = `sha256:${createHash('sha256').update(content).digest('hex')}`;
+    if (digest !== expected) {
+        throw new TypeError(`Cloudflare Worker artifact content differs at ${path}.`);
+    }
+}
+function invalid() {
+    throw new TypeError('Cloudflare Worker artifact manifest is invalid.');
+}

package/dist/build/worker/artifact.manifest.d.ts

@@ -0,0 +1,48 @@
+import type { WorkerDeploymentId } from '../../release/deployment.js';
+import type { WorkerModuleKind } from './artifact.js';
+import { WORKER_MANIFEST_PATH } from './artifact.paths.js';
+export declare const WORKER_ARTIFACT_FORMAT = "astrale.cloudflare.worker";
+export declare const WORKER_ARTIFACT_VERSION = 2;
+export interface WorkerArtifactManifestV2 {
+    readonly format: typeof WORKER_ARTIFACT_FORMAT;
+    readonly version: typeof WORKER_ARTIFACT_VERSION;
+    readonly origin: string;
+    readonly revision: string;
+    readonly deployment: WorkerDeploymentId;
+    readonly release: ManifestExecutable;
+    readonly runtime: {
+        readonly compatibilityDate: string;
+        readonly compatibilityFlags: readonly string[];
+    };
+    readonly bindings: {
+        readonly vars: Readonly<Record<string, string>>;
+        readonly services: readonly {
+            readonly name: string;
+            readonly service: string;
+        }[];
+        readonly requiredSecrets: readonly string[];
+    };
+    readonly assets?: {
+        readonly files: readonly {
+            readonly path: string;
+            readonly artifactPath: string;
+            readonly digest: string;
+            readonly contentType?: string;
+        }[];
+        readonly notFound: 'none' | '404-page' | 'single-page-application';
+        readonly runWorkerFirst: boolean;
+        readonly htmlHandling?: 'none';
+    };
+}
+interface ManifestExecutable {
+    readonly entrypoint: string;
+    readonly modules: readonly {
+        readonly path: string;
+        readonly kind: WorkerModuleKind;
+        readonly digest: string;
+    }[];
+}
+export declare function encodeWorkerArtifactManifest(input: Omit<WorkerArtifactManifestV2, 'format' | 'version'>): Uint8Array;
+export declare function workerContentDigest(input: Uint8Array): string;
+export declare function inferMediaType(path: string): string | undefined;
+export { WORKER_MANIFEST_PATH };

package/dist/build/worker/artifact.manifest.js

@@ -0,0 +1,87 @@
+import { createHash } from 'node:crypto';
+import { artifactPath, assetPath, comparePath, WORKER_MANIFEST_PATH } from './artifact.paths.js';
+export const WORKER_ARTIFACT_FORMAT = 'astrale.cloudflare.worker';
+export const WORKER_ARTIFACT_VERSION = 2;
+const encoder = new TextEncoder();
+export function encodeWorkerArtifactManifest(input) {
+    const manifest = {
+        format: WORKER_ARTIFACT_FORMAT,
+        version: WORKER_ARTIFACT_VERSION,
+        origin: input.origin,
+        revision: input.revision,
+        deployment: input.deployment,
+        release: canonicalExecutable(input.release),
+        runtime: {
+            compatibilityDate: input.runtime.compatibilityDate,
+            compatibilityFlags: Object.freeze([...input.runtime.compatibilityFlags].sort()),
+        },
+        bindings: {
+            vars: Object.fromEntries(Object.entries(input.bindings.vars).sort(([a], [b]) => comparePath(a, b))),
+            services: Object.freeze([...input.bindings.services].sort((a, b) => comparePath(a.name, b.name))),
+            requiredSecrets: Object.freeze([...input.bindings.requiredSecrets].sort(comparePath)),
+        },
+        ...(input.assets === undefined
+            ? {}
+            : {
+                assets: {
+                    files: Object.freeze([...input.assets.files]
+                        .map((file) => ({
+                        path: assetPath(file.path),
+                        artifactPath: artifactPath(file.artifactPath, 'Worker asset artifact path'),
+                        digest: contentDigest(file.digest),
+                        ...(file.contentType === undefined ? {} : { contentType: file.contentType }),
+                    }))
+                        .sort((a, b) => comparePath(a.path, b.path))),
+                    notFound: input.assets.notFound,
+                    runWorkerFirst: input.assets.runWorkerFirst,
+                    ...(input.assets.htmlHandling === undefined
+                        ? {}
+                        : { htmlHandling: input.assets.htmlHandling }),
+                },
+            }),
+    };
+    return encoder.encode(`${JSON.stringify(manifest)}\n`);
+}
+function canonicalExecutable(input) {
+    const modules = [...input.modules]
+        .map((module) => ({
+        path: artifactPath(module.path, 'Worker module path'),
+        kind: module.kind,
+        digest: contentDigest(module.digest),
+    }))
+        .sort((a, b) => comparePath(a.path, b.path));
+    return {
+        entrypoint: artifactPath(input.entrypoint, 'Worker entrypoint'),
+        modules: Object.freeze(modules),
+    };
+}
+export function workerContentDigest(input) {
+    return `sha256:${createHash('sha256').update(input).digest('hex')}`;
+}
+function contentDigest(input) {
+    if (!/^sha256:[0-9a-f]{64}$/u.test(input)) {
+        throw new TypeError('Worker artifact content digest is invalid.');
+    }
+    return input;
+}
+export function inferMediaType(path) {
+    const extension = path.split('.').at(-1)?.toLowerCase();
+    return extension === undefined ? undefined : MEDIA_TYPES[extension];
+}
+const MEDIA_TYPES = Object.freeze({
+    html: 'text/html; charset=utf-8',
+    js: 'text/javascript; charset=utf-8',
+    mjs: 'text/javascript; charset=utf-8',
+    css: 'text/css; charset=utf-8',
+    json: 'application/json; charset=utf-8',
+    svg: 'image/svg+xml',
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    webp: 'image/webp',
+    ico: 'image/x-icon',
+    woff: 'font/woff',
+    woff2: 'font/woff2',
+    wasm: 'application/wasm',
+});
+export { WORKER_MANIFEST_PATH };

package/dist/build/worker/artifact.paths.d.ts

@@ -0,0 +1,4 @@
+export declare const WORKER_MANIFEST_PATH = "worker/manifest.json";
+export declare function artifactPath(input: unknown, label: string): string;
+export declare function assetPath(input: unknown): string;
+export declare function comparePath(left: string, right: string): number;

package/dist/build/worker/artifact.paths.js

@@ -0,0 +1,25 @@
+export const WORKER_MANIFEST_PATH = 'worker/manifest.json';
+export function artifactPath(input, label) {
+    if (typeof input !== 'string' ||
+        input.length === 0 ||
+        input.startsWith('/') ||
+        input.includes('\\') ||
+        input.split('/').some((segment) => segment === '' || segment === '.' || segment === '..')) {
+        throw new TypeError(`${label} must be a canonical relative POSIX path.`);
+    }
+    return input;
+}
+export function assetPath(input) {
+    if (typeof input !== 'string' ||
+        !input.startsWith('/') ||
+        input.length > 1024 ||
+        input.includes('\\') ||
+        Array.from(input).some((character) => character.codePointAt(0) <= 0x1f) ||
+        input.split('/').some((segment) => segment === '.' || segment === '..')) {
+        throw new TypeError('Worker asset path is invalid.');
+    }
+    return input;
+}
+export function comparePath(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/build/worker/codegen/entry.d.ts

@@ -0,0 +1,2 @@
+/** Generate the isolate-startup entry that realizes the heavy Service on first request. */
+export declare function generateExecutionEntry(serviceSpecifier: string, workerSpecifier?: string): string;

package/dist/build/worker/codegen/entry.js

@@ -0,0 +1,28 @@
+/** Generate the isolate-startup entry that realizes the heavy Service on first request. */
+export function generateExecutionEntry(serviceSpecifier, workerSpecifier = '@astrale-os/adapter-cloudflare/worker') {
+    return `// AUTO-GENERATED by @astrale-os/adapter-cloudflare — do not edit.
+import type { CloudflareWorker } from ${JSON.stringify(workerSpecifier)}
+
+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.')
+}
+`;
+}

package/dist/build/worker/codegen/service.d.ts

@@ -0,0 +1,16 @@
+import type { Build } from '@astrale-os/sdk/deployment/build';
+export interface ExecutionCodegenOptions {
+    readonly origin: string;
+    readonly runtimeSpecifier: string;
+    readonly workerSpecifier?: string;
+    readonly build: Build;
+    readonly maximumRequestBytes?: number;
+    readonly invocationTimeoutMs?: number;
+    readonly providerAssignedWorker?: string;
+    readonly router?: {
+        readonly binding: string;
+        readonly hostSuffix: string;
+        readonly minLabels: number;
+    };
+}
+export declare function generateExecutionService(options: ExecutionCodegenOptions): string;

package/dist/build/worker/codegen/service.js

@@ -0,0 +1,52 @@
+import { generatedMaterial } from '@astrale-os/sdk/deployment/build';
+export function generateExecutionService(options) {
+    const workerSpecifier = options.workerSpecifier ?? '@astrale-os/adapter-cloudflare/worker';
+    const generated = generatedMaterial(options.build);
+    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
+  },`;
+    const frontend = generated.material.frontend === undefined
+        ? ''
+        : `  frontend: ${JSON.stringify(generated.material.frontend)} as const satisfies NonNullable<BuildMaterial['frontend']>,\n`;
+    return `// AUTO-GENERATED by @astrale-os/adapter-cloudflare — do not edit.
+// Domain origin: ${options.origin}
+import type { BuildMaterial, GeneratedBuildMaterial } from '@astrale-os/sdk/deployment/build'
+import type { CloudflareAdapterBindings } from ${JSON.stringify(workerSpecifier)}
+
+import { generatedCloudflareWorkerEntry } from ${JSON.stringify(workerSpecifier)}
+import { decodeSigningIdentity, runtimeBindings } from ${JSON.stringify(workerSpecifier)}
+
+type WorkerEnv = CloudflareEnv & CloudflareAdapterBindings & {
+  readonly ASTRALE_SIGNING_IDENTITY: string
+}
+type RuntimeEnv = Omit<WorkerEnv, 'ASTRALE_SIGNING_IDENTITY'>
+${routerPredicate}
+export default generatedCloudflareWorkerEntry<WorkerEnv, RuntimeEnv>()({
+${frontend}  load: async () => ({
+    runtime: (await import(${JSON.stringify(options.runtimeSpecifier)})).default,
+    material: ${JSON.stringify(generated)} as unknown as GeneratedBuildMaterial,
+  }),
+  privateKey: (env) => decodeSigningIdentity(env.ASTRALE_SIGNING_IDENTITY),
+  resolveEnvironment: runtimeBindings,
+  resolveUrl: (env, requestOrigin) => env.WORKER_URL ?? env.IDENTITY_ISS ?? requestOrigin,
+  ${options.maximumRequestBytes === undefined ? '' : `maximumRequestBytes: ${options.maximumRequestBytes},`}
+  ${options.invocationTimeoutMs === undefined ? '' : `invocationTimeoutMs: ${options.invocationTimeoutMs},`}
+  ${options.providerAssignedWorker === undefined ? '' : `providerAssignedWorker: ${JSON.stringify(options.providerAssignedWorker)},`}
+  selfBinding: (env) => env.SELF,${routeSubrequest}
+})
+`;
+}

package/dist/build/worker/execution.prepare.d.ts

@@ -0,0 +1,18 @@
+import type { PrepareContext } from '@astrale-os/sdk/deployment/adapter';
+import type { CloudflareParams } from '../../params.js';
+import type { resolveRouter } from '../configuration.js';
+export declare const RELEASE_ENTRY = "bundle/index.mjs";
+export declare const RELEASE_SERVICE = "bundle/service.mjs";
+export declare function prepareExecution(input: {
+    readonly params: CloudflareParams;
+    readonly context: PrepareContext;
+    readonly directory: string;
+    readonly name: string;
+    readonly direct: boolean;
+    readonly configuredIssuer?: string;
+    readonly router: ReturnType<typeof resolveRouter>;
+}): Promise<{
+    readonly entry: Uint8Array;
+    readonly service: Uint8Array;
+}>;
+export declare function runtimeVars(params: CloudflareParams, configuredIssuer: string | undefined): Record<string, string>;