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

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

@@ -0,0 +1,277 @@
+import { isPreparedArtifact } from '@astrale-os/sdk/deployment/verify';
+import { createHash } from 'node:crypto';
+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 gateway = executable(artifact, manifest.gateway, claimed, 'gateway');
+    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),
+        });
+    });
+    return Object.freeze({
+        origin,
+        revision,
+        release,
+        gateway,
+        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',
+        'release',
+        'gateway',
+        '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))) {
+        invalid();
+    }
+    const release = admitExecutable(value.release);
+    const gateway = admitExecutable(value.gateway);
+    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,
+        release,
+        gateway,
+        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,47 @@
+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 = 1;
+export interface WorkerArtifactManifestV1 {
+    readonly format: typeof WORKER_ARTIFACT_FORMAT;
+    readonly version: typeof WORKER_ARTIFACT_VERSION;
+    readonly origin: string;
+    readonly revision: string;
+    readonly release: ManifestExecutable;
+    readonly gateway: 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<WorkerArtifactManifestV1, '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 = 1;
+const encoder = new TextEncoder();
+export function encodeWorkerArtifactManifest(input) {
+    const manifest = {
+        format: WORKER_ARTIFACT_FORMAT,
+        version: WORKER_ARTIFACT_VERSION,
+        origin: input.origin,
+        revision: input.revision,
+        release: canonicalExecutable(input.release),
+        gateway: canonicalExecutable(input.gateway),
+        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,15 @@
+import type { BuildMaterial } from '@astrale-os/sdk/deployment/build';
+export interface ExecutionCodegenOptions {
+    readonly origin: string;
+    readonly runtimeSpecifier: string;
+    readonly workerSpecifier?: string;
+    readonly material: BuildMaterial;
+    readonly maximumRequestBytes?: 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,46 @@
+export function generateExecutionService(options) {
+    const workerSpecifier = options.workerSpecifier ?? '@astrale-os/adapter-cloudflare/worker';
+    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 ${JSON.stringify(workerSpecifier)}
+
+import { cloudflareWorkerEntry } 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 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.maximumRequestBytes === undefined ? '' : `maximumRequestBytes: ${options.maximumRequestBytes},`}
+  ${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>;

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

@@ -0,0 +1,108 @@
+import { material } from '@astrale-os/sdk/deployment/build';
+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 { admitWorkerBundle } from '../bundle/admit.js';
+import { generateExecutionEntry, generateExecutionService } from '../codegen/execution.js';
+import { generateWranglerConfig } from '../codegen/wrangler.js';
+import { 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';
+export async function prepareExecution(input) {
+    const runtimePath = resolve(input.context.projectDir, input.context.runtime.reference.path);
+    const runtimeSpecifier = moduleSpecifier(relative(input.directory, runtimePath));
+    const workerSpecifier = workerModuleSpecifier();
+    const maximumRequestBytes = workerRequestLimit(input.params.maximumRequestBytes);
+    const serviceSource = generateExecutionService({
+        origin: input.context.build.schema.compiled.root.origin,
+        runtimeSpecifier,
+        workerSpecifier,
+        material: material(input.context.build),
+        ...(maximumRequestBytes === undefined ? {} : { maximumRequestBytes }),
+        ...(input.configuredIssuer === undefined && input.direct
+            ? { providerAssignedWorker: input.name }
+            : {}),
+        ...(input.router === undefined
+            ? {}
+            : {
+                router: {
+                    binding: input.router.binding,
+                    hostSuffix: input.router.hostSuffix,
+                    minLabels: input.router.minLabels,
+                },
+            }),
+    });
+    const serviceSourcePath = join(input.directory, 'service.gen.ts');
+    await writeFile(serviceSourcePath, serviceSource);
+    const serviceConfigPath = join(input.directory, 'wrangler.service.prepare.jsonc');
+    await writeFile(serviceConfigPath, generateWranglerConfig({
+        workerName: input.name,
+        main: './service.gen.ts',
+        vars: runtimeVars(input.params, input.configuredIssuer),
+        secretBindings: [SIGNING_IDENTITY_BINDING],
+        ...(input.router === undefined
+            ? {}
+            : { router: { binding: input.router.binding, service: input.router.service } }),
+        ...(input.params.wrangler === undefined ? {} : { wrangler: input.params.wrangler }),
+        selfBinding: false,
+    }));
+    const serviceOutput = join(input.directory, 'dist-service');
+    await rm(serviceOutput, { recursive: true, force: true });
+    const emittedService = await runWranglerBundle({
+        projectDir: input.context.projectDir,
+        configPath: serviceConfigPath,
+        outDir: serviceOutput,
+    });
+    await qualifyWorkerBundle({
+        metafilePath: emittedService.metafilePath,
+        inputRoot: dirname(serviceConfigPath),
+    });
+    await admitWorkerBundle(emittedService.bundlePath);
+    const service = new Uint8Array(await readFile(emittedService.bundlePath));
+    await mkdir(dirname(join(input.directory, RELEASE_SERVICE)), { recursive: true });
+    await writeFile(join(input.directory, RELEASE_SERVICE), service);
+    const sourcePath = join(input.directory, 'worker.gen.ts');
+    await writeFile(sourcePath, generateExecutionEntry('./service.mjs', workerSpecifier));
+    const configPath = join(input.directory, 'wrangler.prepare.jsonc');
+    await writeFile(configPath, generateWranglerConfig({
+        workerName: input.name,
+        ...(input.params.route === undefined ? {} : { route: input.params.route }),
+        vars: runtimeVars(input.params, input.configuredIssuer),
+        secretBindings: [SIGNING_IDENTITY_BINDING],
+        modules: { baseDir: '.', rules: [{ type: 'ESModule', globs: [RELEASE_SERVICE] }] },
+        ...(input.router === undefined
+            ? {}
+            : { router: { binding: input.router.binding, service: input.router.service } }),
+        ...(input.params.wrangler === undefined ? {} : { wrangler: input.params.wrangler }),
+        selfBinding: false,
+    }));
+    const output = join(input.directory, 'dist-prepare');
+    await rm(output, { recursive: true, force: true });
+    const emitted = await runWranglerBundle({
+        projectDir: input.context.projectDir,
+        configPath,
+        outDir: output,
+    });
+    await qualifyWorkerBundle({
+        metafilePath: emitted.metafilePath,
+        inputRoot: dirname(configPath),
+    });
+    await admitWorkerBundle(emitted.bundlePath);
+    return Object.freeze({
+        entry: new Uint8Array(await readFile(emitted.bundlePath)),
+        service,
+    });
+}
+export function runtimeVars(params, configuredIssuer) {
+    return {
+        ...params.vars,
+        ...(configuredIssuer === undefined ? {} : { WORKER_URL: configuredIssuer }),
+    };
+}
+function moduleSpecifier(input) {
+    const normalized = input.split('\\').join('/');
+    return normalized.startsWith('.') ? normalized : `./${normalized}`;
+}

package/dist/build/worker/index.d.ts

@@ -0,0 +1,2 @@
+export { loadWorkerArtifact } from './artifact.load.js';
+export type { WorkerArtifact } from './artifact.js';

package/dist/build/worker/index.js

@@ -0,0 +1 @@
+export { loadWorkerArtifact } from './artifact.load.js';