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

package/dist/build/direct.js

@@ -0,0 +1,52 @@
+import { isDeepStrictEqual } from 'node:util';
+import { releaseNamespace, releaseWorkerName } from '../release/index.js';
+import { workerName } from './configuration.js';
+export function admitDirectPlacement(artifact, worker, parameters) {
+    const name = workerName(parameters, worker.origin);
+    const release = config(artifact, 'wrangler.release.jsonc');
+    const gateway = config(artifact, 'wrangler.gateway.jsonc');
+    equal(release.name, releaseWorkerName(worker.revision));
+    equal(release.main, `./${worker.release.entrypoint}`);
+    equal(release.compatibility_date, worker.runtime.compatibilityDate);
+    equal(release.compatibility_flags, worker.runtime.compatibilityFlags);
+    equal(release.vars ?? {}, worker.bindings.vars);
+    equal(release.services ?? [], worker.bindings.services.map((binding) => ({
+        binding: binding.name,
+        service: binding.service,
+    })));
+    equal(record(release.secrets).required ?? [], worker.bindings.requiredSecrets);
+    const rules = Array.isArray(release.rules) ? release.rules : [];
+    equal(rules.flatMap((rule) => {
+        const globs = record(rule).globs;
+        return Array.isArray(globs) ? globs : [];
+    }), worker.release.modules
+        .filter((module) => module.path !== worker.release.entrypoint)
+        .map((module) => module.path));
+    equal(gateway.name, name);
+    equal(gateway.main, `./${worker.gateway.entrypoint}`);
+    equal(gateway.dispatch_namespaces, [{ binding: 'RELEASES', namespace: releaseNamespace(name) }]);
+}
+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 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.');
+    }
+}

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

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

package/dist/build/frontend-v1.js

@@ -0,0 +1,133 @@
+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 { createServer } from 'node:net';
+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));
+}
+export async function startFrontend(input) {
+    const frontend = input.frontend;
+    if (frontend === undefined || frontend.source.kind !== 'vite')
+        return undefined;
+    const port = await ephemeralPort();
+    const child = spawn(viteCommand(input.projectDir), [
+        '--host',
+        '127.0.0.1',
+        '--port',
+        String(port),
+        '--strictPort',
+        ...(frontend.source.config === undefined ? [] : ['--config', frontend.source.config]),
+    ], { cwd: input.projectDir, stdio: ['ignore', 'pipe', 'pipe'] });
+    const output = [];
+    const collect = (buffer) => {
+        for (const line of buffer.toString().split('\n')) {
+            if (line.trim() === '')
+                continue;
+            output.push(line);
+            if (output.length > 40)
+                output.shift();
+            input.onLog?.(line);
+        }
+    };
+    child.stdout?.on('data', collect);
+    child.stderr?.on('data', collect);
+    const url = `http://127.0.0.1:${port}`;
+    try {
+        await ready(url, child, output);
+    }
+    catch (cause) {
+        await stop(child);
+        throw cause;
+    }
+    return Object.freeze({ url, stop: () => stop(child) });
+}
+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)}`)));
+    });
+}
+function ephemeralPort() {
+    return new Promise((resolve, reject) => {
+        const server = createServer();
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address !== null ? address.port : 0;
+            server.close((cause) => (cause === undefined ? resolve(port) : reject(cause)));
+        });
+    });
+}
+async function ready(url, child, output) {
+    const deadline = Date.now() + 15_000;
+    while (Date.now() < deadline) {
+        if (child.exitCode !== null) {
+            throw new Error(`Vite exited before readiness (code ${child.exitCode}).\n${output.join('\n')}`);
+        }
+        try {
+            const response = await fetch(url, { signal: AbortSignal.timeout(500) });
+            await response.body?.cancel();
+            return;
+        }
+        catch {
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+    }
+    throw new Error(`Vite did not become ready at ${url}.`);
+}
+function stop(child) {
+    if (child.exitCode !== null || child.killed)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        child.once('exit', () => resolve());
+        child.kill('SIGTERM');
+    });
+}

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

@@ -0,0 +1,8 @@
+export declare function prepareGateway(input: {
+    readonly projectDir: string;
+    readonly directory: string;
+    readonly name: string;
+    readonly route?: string;
+    readonly namespace: string;
+    readonly revision: string;
+}): Promise<Uint8Array>;

package/dist/build/gateway/prepare.js

@@ -0,0 +1,32 @@
+import { readFile, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { admitWorkerBundle } from '../bundle/admit.js';
+import { generateWranglerConfig } from '../codegen/wrangler.js';
+import { qualifyWorkerBundle } from '../qualification.js';
+import { runWranglerBundle } from '../wrangler-cli.js';
+import { generateGatewayEntry } from './source.js';
+export async function prepareGateway(input) {
+    const gatewaySource = join(input.directory, 'gateway.gen.ts');
+    await writeFile(gatewaySource, generateGatewayEntry(input.revision));
+    const configPath = join(input.directory, 'wrangler.gateway.prepare.jsonc');
+    await writeFile(configPath, generateWranglerConfig({
+        workerName: input.name,
+        main: './gateway.gen.ts',
+        ...(input.route === undefined ? {} : { route: input.route }),
+        releases: { binding: 'RELEASES', namespace: input.namespace },
+        selfBinding: false,
+    }));
+    const output = join(input.directory, 'dist-gateway');
+    await rm(output, { recursive: true, force: true });
+    const emitted = await runWranglerBundle({
+        projectDir: input.projectDir,
+        configPath,
+        outDir: output,
+    });
+    await qualifyWorkerBundle({
+        metafilePath: emitted.metafilePath,
+        inputRoot: dirname(configPath),
+    });
+    await admitWorkerBundle(emitted.bundlePath);
+    return new Uint8Array(await readFile(emitted.bundlePath));
+}

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

@@ -0,0 +1 @@
+export declare function generateGatewayEntry(revision: string): string;

package/dist/build/gateway/source.js

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

package/dist/build/index.d.ts

@@ -1,16 +1,10 @@
-/**
- * `@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, startFrontend, type FrontendDevHandle } from './frontend-v1.js';
+export { qualifyWorkerBundle } from './qualification.js';
+export { assertSingletonRuntimeRoots } from './roots.js';
+export { signingIdentity } from '../identity/source.js';
+export { signingIdentitySecrets } from '../identity/secret.js';
+export { runWranglerBundle, runWranglerDeploy, runWranglerDeploymentStatus, runWranglerDev, runWranglerTypes, } from './wrangler-cli.js';

package/dist/build/index.js

@@ -1,16 +1,9 @@
-/**
- * `@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, startFrontend } from './frontend-v1.js';
+export { qualifyWorkerBundle } from './qualification.js';
+export { assertSingletonRuntimeRoots } from './roots.js';
+export { signingIdentity } from '../identity/source.js';
+export { signingIdentitySecrets } from '../identity/secret.js';
+export { runWranglerBundle, runWranglerDeploy, runWranglerDeploymentStatus, runWranglerDev, runWranglerTypes, } from './wrangler-cli.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/parse-output.d.ts

@@ -24,4 +24,3 @@ export declare function parseDeployUrl(text: string, route?: string): string | u
 export declare function parseDeployVersionId(text: string): string | undefined;
 /** Normalize a local dev URL to an origin: `0.0.0.0` → `localhost`, fill the port. */
 export declare function normalizeLocal(url: string, port: number): string;
-//# sourceMappingURL=parse-output.d.ts.map

package/dist/build/parse-output.js

@@ -55,4 +55,3 @@ export function normalizeLocal(url, port) {
         return `http://localhost:${port}`;
     }
 }
-//# sourceMappingURL=parse-output.js.map

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,38 @@
+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 release: WorkerArtifactExecutable;
+    readonly gateway: 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;
+    };
+}

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;