@astrale-os/adapter-cloudflare 0.5.0-beta.9 → 0.5.0-beta.91

package/dist/build/direct.js

@@ -0,0 +1,93 @@
+import { isDeepStrictEqual } from 'node:util';
+import { generateWranglerConfig } from './codegen/wrangler.js';
+import { resolveRouter, workerName } from './configuration.js';
+import { frontendRoutes } from './frontend/routes.js';
+import { workerModules } from './worker/modules.js';
+export function admitDirectPlacement(artifact, worker, parameters) {
+    const name = workerName(parameters, worker.origin);
+    const release = config(artifact, 'wrangler.jsonc');
+    const router = resolveRouter(parameters.router);
+    const frontend = artifact.build.frontend;
+    const hasViteFrontend = frontend?.source.kind === 'vite';
+    equal(worker.assets !== undefined, hasViteFrontend);
+    if (worker.assets !== undefined) {
+        equal(worker.assets.notFound, 'none');
+        equal(worker.assets.runWorkerFirst, true);
+    }
+    equal(release, generated({
+        workerName: name,
+        main: `./${worker.release.entrypoint}`,
+        ...(parameters.route === undefined ? {} : { route: parameters.route }),
+        vars: worker.bindings.vars,
+        secretBindings: worker.bindings.requiredSecrets,
+        modules: directModules(worker.release),
+        ...(hasViteFrontend
+            ? {
+                frontend: {
+                    directory: './frontend',
+                    routes: frontendRoutes(frontend),
+                    dev: false,
+                },
+            }
+            : {}),
+        ...(router === undefined
+            ? {}
+            : { router: { binding: router.binding, service: router.service } }),
+        ...(parameters.wrangler === undefined ? {} : { wrangler: parameters.wrangler }),
+        selfBinding: false,
+    }));
+    equal(release.compatibility_date, worker.runtime.compatibilityDate);
+    equalStringCollection(release.compatibility_flags, worker.runtime.compatibilityFlags);
+    equal(release.services ?? [], worker.bindings.services.map(serviceBinding));
+    equal(record(release.assets).html_handling, worker.assets?.htmlHandling);
+}
+function directModules(worker) {
+    try {
+        return workerModules(worker);
+    }
+    catch {
+        mismatch();
+    }
+}
+function generated(input) {
+    return JSON.parse(generateWranglerConfig(input));
+}
+function config(artifact, path) {
+    const file = artifact.files.find((candidate) => candidate.path === path);
+    if (file === undefined)
+        throw new TypeError(`Direct Cloudflare artifact is missing ${path}.`);
+    try {
+        const value = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(file.bytes()));
+        if (value === null || typeof value !== 'object' || Array.isArray(value))
+            throw new Error();
+        return value;
+    }
+    catch (cause) {
+        throw new TypeError(`Direct Cloudflare artifact ${path} is invalid.`, { cause });
+    }
+}
+function serviceBinding(binding) {
+    return { binding: binding.name, service: binding.service };
+}
+function record(input) {
+    return input !== null && typeof input === 'object' && !Array.isArray(input)
+        ? input
+        : {};
+}
+function equal(actual, expected) {
+    if (!isDeepStrictEqual(actual, expected)) {
+        throw new TypeError('Direct Cloudflare placement differs from its admitted Worker artifact.', {
+            cause: { actual, expected },
+        });
+    }
+}
+function equalStringCollection(actual, expected) {
+    if (!Array.isArray(actual) ||
+        actual.some((value) => typeof value !== 'string') ||
+        !isDeepStrictEqual([...actual].sort(), [...expected].sort())) {
+        mismatch();
+    }
+}
+function mismatch() {
+    throw new TypeError('Direct Cloudflare placement differs from its admitted Worker artifact.');
+}

package/dist/build/frontend/files.d.ts

@@ -0,0 +1,7 @@
+import type { Build } from '@astrale-os/sdk/deployment/build';
+import { frontend as frontendBuild } from '@astrale-os/sdk/deployment/build';
+export declare function frontendFiles(input: {
+    readonly frontend: Build['frontend'];
+    readonly projectDir: string;
+    readonly onLog?: (line: string) => void;
+}): Promise<readonly frontendBuild.FrontendFile[]>;

package/dist/build/frontend/files.js

@@ -0,0 +1,60 @@
+import { frontend as frontendBuild } from '@astrale-os/sdk/deployment/build';
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { readFile, readdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+export async function frontendFiles(input) {
+    const frontend = input.frontend;
+    if (frontend === undefined)
+        return [];
+    if (frontend.source.kind === 'external')
+        return frontendBuild.files(frontend, []);
+    const output = join(input.projectDir, '.astrale', 'frontend-build');
+    await rm(output, { recursive: true, force: true });
+    await run(viteCommand(input.projectDir), [
+        'build',
+        '--outDir',
+        output,
+        '--emptyOutDir',
+        ...(frontend.source.config === undefined ? [] : ['--config', frontend.source.config]),
+    ], input.projectDir, input.onLog);
+    return frontendBuild.files(frontend, await readFiles(output));
+}
+async function readFiles(root, current = '') {
+    const entries = await readdir(join(root, current), { withFileTypes: true });
+    const files = [];
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+        const path = current === '' ? entry.name : `${current}/${entry.name}`;
+        if (entry.isDirectory())
+            files.push(...(await readFiles(root, path)));
+        else if (entry.isFile()) {
+            files.push({ path, content: new Uint8Array(await readFile(join(root, path))) });
+        }
+    }
+    return files;
+}
+function viteCommand(projectDir) {
+    const command = join(projectDir, 'node_modules', '.bin', 'vite');
+    if (!existsSync(command))
+        throw new TypeError('Vite frontend requires a project-local vite binary.');
+    return command;
+}
+function run(command, args, cwd, onLog) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+        let output = '';
+        const collect = (buffer) => {
+            const value = buffer.toString();
+            output += value;
+            for (const line of value.split('\n'))
+                if (line.trim() !== '')
+                    onLog?.(line);
+        };
+        child.stdout?.on('data', collect);
+        child.stderr?.on('data', collect);
+        child.on('error', reject);
+        child.on('exit', (code) => code === 0
+            ? resolve()
+            : reject(new Error(`Vite failed (code ${code ?? 1}):\n${output.slice(-1500)}`)));
+    });
+}

package/dist/build/frontend/routes.d.ts

@@ -0,0 +1,2 @@
+import type { PrepareContext } from '@astrale-os/sdk/deployment/adapter';
+export declare function frontendRoutes(frontend: NonNullable<PrepareContext['build']['frontend']>): readonly string[];

package/dist/build/frontend/routes.js

@@ -0,0 +1,11 @@
+export 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());
+}

package/dist/build/index.d.ts

@@ -1,16 +1,8 @@
-/**
- * `@astrale-os/adapter-cloudflare/build` — the shared Cloudflare-Workers build
- * toolkit, exposed for sibling deploy adapters (e.g.
- * `@astrale-os/adapter-astrale`).
- *
- * This is the "compile a `defineDomain` into a Cloudflare Workers bundle + run
- * local dev" surface that every Cloudflare-Workers deploy strategy shares,
- * regardless of WHERE the bundle ultimately ships. It is NOT part of the public
- * adapter API (`@astrale-os/adapter-cloudflare`) — it's the seam two adapters
- * build on so the codegen/bundling/dev logic lives in exactly one place.
- */
-export { buildFrontend, FRONTEND_STAGE_DIR, watchFrontend, type FrontendWatchHandle, type FrontendWatchSubscribe, type FrontendWatchSubscription, } from './frontend.js';
-export { logTo, prepare } from './prepare.js';
-export { buildCloudflareWorker, type CloudflareWorkerBuild } from './worker.js';
-export { bulkPutSecrets, runWranglerBundle, runWranglerDeploy, runWranglerDev, runWranglerTypes, } from './wrangler-cli.js';
-//# sourceMappingURL=index.d.ts.map
+export { artifact, materialize, prepareWorkerArtifact } from './artifact.js';
+export { loadWorkerArtifact } from './worker/index.js';
+export type { WorkerArtifact } from './worker/index.js';
+export { resolveRouter, workerName } from './configuration.js';
+export { frontendFiles } from './frontend/files.js';
+export { qualifyWorkerBundle } from './qualification.js';
+export { assertSingletonRuntimeRoots } from './roots.js';
+export { runWranglerBundle, runWranglerDeploy, runWranglerDeploymentStatus, runWranglerTypes, } from '../wrangler/index.js';

package/dist/build/index.js

@@ -1,16 +1,7 @@
-/**
- * `@astrale-os/adapter-cloudflare/build` — the shared Cloudflare-Workers build
- * toolkit, exposed for sibling deploy adapters (e.g.
- * `@astrale-os/adapter-astrale`).
- *
- * This is the "compile a `defineDomain` into a Cloudflare Workers bundle + run
- * local dev" surface that every Cloudflare-Workers deploy strategy shares,
- * regardless of WHERE the bundle ultimately ships. It is NOT part of the public
- * adapter API (`@astrale-os/adapter-cloudflare`) — it's the seam two adapters
- * build on so the codegen/bundling/dev logic lives in exactly one place.
- */
-export { buildFrontend, FRONTEND_STAGE_DIR, watchFrontend, } from './frontend.js';
-export { logTo, prepare } from './prepare.js';
-export { buildCloudflareWorker } from './worker.js';
-export { bulkPutSecrets, runWranglerBundle, runWranglerDeploy, runWranglerDev, runWranglerTypes, } from './wrangler-cli.js';
-//# sourceMappingURL=index.js.map
+export { artifact, materialize, prepareWorkerArtifact } from './artifact.js';
+export { loadWorkerArtifact } from './worker/index.js';
+export { resolveRouter, workerName } from './configuration.js';
+export { frontendFiles } from './frontend/files.js';
+export { qualifyWorkerBundle } from './qualification.js';
+export { assertSingletonRuntimeRoots } from './roots.js';
+export { runWranglerBundle, runWranglerDeploy, runWranglerDeploymentStatus, runWranglerTypes, } from '../wrangler/index.js';

package/dist/build/materialize.d.ts

@@ -0,0 +1,4 @@
+export declare function materialize(root: string, files: readonly {
+    readonly path: string;
+    bytes(): Uint8Array;
+}[]): Promise<void>;

package/dist/build/materialize.js

@@ -0,0 +1,10 @@
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+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());
+    }
+}

package/dist/build/metafile.d.ts

@@ -0,0 +1,5 @@
+export interface WranglerMetafile {
+    readonly inputs: Readonly<Record<string, unknown>>;
+}
+/** Decode Wrangler's emitted esbuild graph at the provider-tooling boundary. */
+export declare function readWranglerMetafile(path: string): Promise<WranglerMetafile>;

package/dist/build/metafile.js

@@ -0,0 +1,14 @@
+import { readFile } from 'node:fs/promises';
+/** Decode Wrangler's emitted esbuild graph at the provider-tooling boundary. */
+export async function readWranglerMetafile(path) {
+    const source = await readFile(path, 'utf8');
+    const value = JSON.parse(source);
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        throw new TypeError('Wrangler metafile is not an object.');
+    }
+    const inputs = Reflect.get(value, 'inputs');
+    if (inputs === null || typeof inputs !== 'object' || Array.isArray(inputs)) {
+        throw new TypeError('Wrangler metafile has no input graph.');
+    }
+    return Object.freeze({ inputs: inputs });
+}

package/dist/build/qualification.d.ts

@@ -0,0 +1,5 @@
+/** Qualify Wrangler's emitted module, not generated source or an inferred graph. */
+export declare function qualifyWorkerBundle(evidence: {
+    readonly metafilePath: string;
+    readonly inputRoot: string;
+}): Promise<void>;

package/dist/build/qualification.js

@@ -0,0 +1,7 @@
+import { assertRuntimeClosure } from './closure.js';
+import { assertSingletonRuntimeRoots } from './roots.js';
+/** Qualify Wrangler's emitted module, not generated source or an inferred graph. */
+export async function qualifyWorkerBundle(evidence) {
+    await assertRuntimeClosure(evidence.metafilePath);
+    await assertSingletonRuntimeRoots(evidence.metafilePath, evidence.inputRoot);
+}

package/dist/build/roots.d.ts

@@ -0,0 +1,2 @@
+/** Prove that Wrangler emitted at most one physical root per runtime package. */
+export declare function assertSingletonRuntimeRoots(metafilePath: string, inputRoot: string): Promise<void>;

package/dist/build/roots.js

@@ -0,0 +1,34 @@
+import { realpath } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { readWranglerMetafile } from './metafile.js';
+const RUNTIME_PACKAGES = [
+    '@astrale-os/adapter-cloudflare',
+    '@astrale-os/sdk',
+    '@astrale-os/kernel-core',
+    '@astrale-os/kernel-dsl',
+    '@astrale-os/kernel-ports',
+    '@astrale-os/kernel-protocol',
+    '@astrale-os/kernel-server',
+    '@astrale-os/kernel-client',
+];
+/** Prove that Wrangler emitted at most one physical root per runtime package. */
+export async function assertSingletonRuntimeRoots(metafilePath, inputRoot) {
+    const metafile = await readWranglerMetafile(metafilePath);
+    for (const name of RUNTIME_PACKAGES) {
+        const roots = new Set();
+        for (const input of Object.keys(metafile.inputs)) {
+            const root = packageRoot(input, name);
+            if (root !== undefined)
+                roots.add(await realpath(resolve(inputRoot, root)));
+        }
+        if (roots.size > 1) {
+            throw new Error(`Cloudflare Worker contains duplicate physical ${name} roots: ${[...roots].join(', ')}.`);
+        }
+    }
+}
+function packageRoot(input, name) {
+    const normalized = input.replaceAll('\\', '/');
+    const marker = `node_modules/${name}/`;
+    const index = normalized.lastIndexOf(marker);
+    return index < 0 ? undefined : normalized.slice(0, index + marker.length - 1);
+}

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

@@ -0,0 +1,40 @@
+import type { WorkerDeploymentId } from '../../release/deployment.js';
+export type WorkerModuleKind = 'esm' | 'wasm' | 'text' | 'data';
+export interface WorkerArtifactModule {
+    readonly path: string;
+    readonly kind: WorkerModuleKind;
+    bytes(): Uint8Array;
+}
+export interface WorkerArtifactExecutable {
+    readonly entrypoint: string;
+    readonly modules: readonly WorkerArtifactModule[];
+}
+export interface WorkerArtifact {
+    readonly origin: string;
+    readonly revision: string;
+    readonly deployment: WorkerDeploymentId;
+    readonly release: WorkerArtifactExecutable;
+    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 contentType?: string;
+            bytes(): Uint8Array;
+        }[];
+        readonly notFound: 'none' | '404-page' | 'single-page-application';
+        readonly runWorkerFirst: boolean;
+        readonly htmlHandling?: 'none';
+    };
+}

package/dist/build/worker/artifact.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,3 @@
+import type { PreparedArtifact } from '@astrale-os/sdk/deployment/adapter';
+import type { WorkerArtifact } from './artifact.js';
+export declare function loadWorkerArtifact(artifact: PreparedArtifact): WorkerArtifact;