@astrale-os/adapter-cloudflare 0.5.0-beta.115 → 0.5.0-beta.116

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.5.0-beta.116](https://github.com/astrale-os/sdk/compare/adapter-cloudflare-v0.5.0-beta.115...adapter-cloudflare-v0.5.0-beta.116) (2026-09-05)
+
+
+### Features
+
+* add explicit Project environments and remote development ([#415](https://github.com/astrale-os/sdk/issues/415)) ([7357a05](https://github.com/astrale-os/sdk/commit/7357a055a39749238dd9116da0c171bb9a15882d))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @astrale-os/sdk bumped to 0.5.0-beta.113
+
 ## [0.5.0-beta.115](https://github.com/astrale-os/sdk/compare/adapter-cloudflare-v0.5.0-beta.114...adapter-cloudflare-v0.5.0-beta.115) (2026-09-05)
 
 

package/README.md

@@ -10,9 +10,35 @@ npm install @astrale-os/sdk@beta @astrale-os/adapter-cloudflare@beta
 
 Bare installs return to stable releases when the package set is promoted and npm `latest` advances.
 
-`pnpm dev` starts the Worker and optional Vite frontend with hot reload on collision-free allocated
-ports. It does not own Kernel installation or public ingress; the managed Astrale adapter composes
-those lifecycle responsibilities around this provider-local session.
+One `cloudflare()` value configures one Project Environment. `astrale-domain dev <environment>`
+builds locally and deploys each admitted Worker and frontend update remotely through the same path
+as `deploy`; it starts no local Worker, Vite server, or tunnel. Omitting `route` uses the observed
+stable `*.workers.dev` issuer. Add `installation: { instance: '...' }` to the Project Environment
+when generic tooling should reconcile the ready Release onto an Astrale Kernel.
+
+One watcher serializes its own updates. For an existing Worker, it uploads a candidate, reconciles
+configured triggers, and stages the candidate at 0% while the previous version retains 100% of normal
+HTTP traffic. Exact-version probes verify Publication, Bundle, and serving identity before promotion;
+serving the Publication also initializes the Application Runtime. After promotion, normal requests
+must prove that exact version again. A failed candidate remains at 0% and can be replaced on retry.
+Bundled View routes must also serve the prepared browser-file generation before readiness passes.
+This covers frontend-only changes without changing the Schema or reinstalling the Domain. HTML
+and transient asset misses are not cached; ordinary successful asset responses keep their cache policy.
+The first deployment uses ordinary Worker provisioning because no previous version exists to retain.
+An existing traffic-split rollout must be resolved before this single-version workflow can continue.
+
+A direct Cloudflare target shared across machines must still have one external writer, normally a
+CI/CD concurrency group. Live deployment checks detect competing changes but are not an atomic
+compare-and-swap or distributed lock. Use separate Worker targets for uncoordinated development.
+Routes, custom domains, schedules, and other non-versioned provider settings are reconciled through
+Wrangler before candidate probing; they can remain changed after a failed attempt. Candidate readiness
+protects the HTTP implementation, not an atomic rollback of external resources or trigger settings.
+
+When an Environment also declares `installation`, the SDK excludes another local checkout that
+targets the same resolved `Kernel issuer + Domain origin` (including bookmark aliases), reconciles
+exact installed Release evidence, and opens
+the default View when the Application has a frontend. These are Project-tooling behaviors rather
+than Cloudflare adapter responsibilities.
 
 ## Provider-local staging
 

package/dist/adapter.d.ts

@@ -1,15 +1,14 @@
+import type { Deployment } from '@astrale-os/sdk/deployment';
 import type { Release } from '@astrale-os/sdk/deployment/release';
 import { verifyReadiness } from '@astrale-os/sdk/deployment/verify';
 import type { CloudflareParams } from './params.js';
 import { artifact } from './build/artifact.js';
 import { type CloudflareDeployDependencies } from './deploy/index.js';
-import { developCloudflare } from './development/develop.js';
 import { signingIdentity } from './identity/source.js';
 export interface CloudflareDependencies extends CloudflareDeployDependencies {
     readonly artifact: typeof artifact;
-    readonly develop: typeof developCloudflare;
     readonly signingIdentity: typeof signingIdentity;
 }
-export declare function cloudflare(environments: Readonly<Record<string, CloudflareParams>>): import("@astrale-os/sdk/deployment/adapter").Adapter<CloudflareParams>;
-export declare function cloudflareWithDependencies(environments: Readonly<Record<string, CloudflareParams>>, dependencies: CloudflareDependencies): import("@astrale-os/sdk/deployment/adapter").Adapter<CloudflareParams>;
+export declare function cloudflare(parameters?: CloudflareParams): Deployment<CloudflareParams>;
+export declare function cloudflareWithDependencies(parameters: CloudflareParams, dependencies: CloudflareDependencies): Deployment<CloudflareParams>;
 export declare function waitForReadiness(verify: typeof verifyReadiness, release: Release, signal?: AbortSignal): Promise<void>;

package/dist/adapter.js

@@ -1,35 +1,41 @@
-import { defineAdapter } from '@astrale-os/sdk/deployment/adapter';
+import { defineAdapter, defineDeployment } from '@astrale-os/sdk/deployment/adapter';
 import { verifyReadiness } from '@astrale-os/sdk/deployment/verify';
 import { createRequire } from 'node:module';
 import { artifact, materialize } from './build/artifact.js';
+import { verifyWorkerFrontend } from './build/frontend/readiness.js';
 import { deployCloudflare } from './deploy/index.js';
-import { developCloudflare } from './development/develop.js';
+import { versionReadinessFetch } from './deploy/readiness.js';
 import { signingIdentity } from './identity/source.js';
-import { runWranglerDeploy } from './wrangler/deploy.js';
+import { runWranglerRollout } from './wrangler/rollout.js';
 import { runWranglerDeploymentStatus } from './wrangler/status.js';
 const packageVersion = createRequire(import.meta.url)('../package.json')
     .version;
-export function cloudflare(environments) {
-    return cloudflareWithDependencies(environments, {
+export function cloudflare(parameters = {}) {
+    return cloudflareWithDependencies(parameters, {
         artifact,
         materialize,
-        runWranglerDeploy,
+        runWranglerRollout,
         runWranglerDeploymentStatus,
-        develop: developCloudflare,
         signingIdentity,
-        waitForReadiness: (release, signal) => waitForReadiness(verifyReadiness, release, signal),
+        waitForReadiness: (release, signal, version, worker, workerName) => waitForReadiness(async (release, options) => {
+            const checks = {
+                ...options,
+                fetch: versionReadinessFetch(release.addressing.issuer, version, globalThis.fetch, workerName),
+            };
+            await verifyReadiness(release, checks);
+            await verifyWorkerFrontend(release, worker, checks);
+        }, release, signal),
     });
 }
-export function cloudflareWithDependencies(environments, dependencies) {
-    return defineAdapter({
+export function cloudflareWithDependencies(parameters, dependencies) {
+    const adapter = defineAdapter({
         name: 'cloudflare',
         version: packageVersion,
-        environments,
         prepare: dependencies.artifact,
-        develop: (parameters, context) => dependencies.develop(parameters, context),
         deploy: (parameters, context) => deployCloudflare(parameters, context, dependencies),
         secretsFile: (parameters) => parameters.secrets,
     });
+    return defineDeployment(adapter, parameters);
 }
 export async function waitForReadiness(verify, release, signal) {
     const deadline = Date.now() + 90_000;

package/dist/build/artifact.js

@@ -6,7 +6,7 @@ import { workerDeployment } from '../release/index.js';
 import { generateWranglerConfig } from './codegen/wrangler.js';
 import { deploymentAddressing, resolveRouter, workerName } from './configuration.js';
 import { frontendFiles } from './frontend/files.js';
-import { frontendRoutes } from './frontend/routes.js';
+import { frontendRevision } from './frontend/revision.js';
 import { encodeWorkerArtifactManifest, inferMediaType, workerContentDigest, WORKER_MANIFEST_PATH, } from './worker/artifact.manifest.js';
 import { prepareExecution, RELEASE_ENTRY, RELEASE_SERVICE, runtimeVars, } from './worker/execution.prepare.js';
 import { admitWorkerRuntimeConfiguration } from './worker/runtime.js';
@@ -26,9 +26,16 @@ async function prepare(params, context, direct) {
     const directory = await mkdtemp(join(stateDirectory, 'prepare-'));
     try {
         const router = resolveRouter(params.router);
-        const name = workerName(params, context.build.schema.compiled.root.origin);
+        const name = workerName(params, context.build.schema.compiled.root.origin, context.environment);
         const revision = context.build.schema.compiled.root.revision;
         const configuredIssuer = deploymentAddressing(params);
+        const frontend = await frontendFiles({
+            frontend: context.build.frontend,
+            projectDir: context.projectDir,
+            output: join(directory, 'frontend'),
+            recordSource: context.recordSource,
+            signal: context.signal,
+        });
         const modules = await prepareExecution({
             params,
             context,
@@ -37,13 +44,8 @@ async function prepare(params, context, direct) {
             direct,
             configuredIssuer,
             router,
+            ...(frontend.length === 0 ? {} : { frontendRevision: frontendRevision(frontend) }),
         });
-        const frontend = context.mode === 'development'
-            ? []
-            : await frontendFiles({
-                frontend: context.build.frontend,
-                projectDir: context.projectDir,
-            });
         const releaseConfig = generateWranglerConfig({
             workerName: name,
             main: `./${RELEASE_ENTRY}`,
@@ -55,8 +57,6 @@ async function prepare(params, context, direct) {
                 ? {
                     frontend: {
                         directory: './frontend',
-                        routes: frontendRoutes(context.build.frontend),
-                        dev: false,
                     },
                 }
                 : {}),

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

@@ -20,8 +20,6 @@ export interface WranglerCodegenOptions {
     /** Exact materialized local frontend; absence means no ASSETS binding. */
     frontend?: {
         readonly directory: string;
-        readonly routes: readonly string[];
-        readonly dev: boolean;
     };
     /** Plain (non-secret) vars to bake in. */
     vars?: Record<string, string>;

package/dist/build/codegen/wrangler.js

@@ -34,18 +34,9 @@ export function generateWranglerConfig(opts) {
             directory: opts.frontend.directory,
             binding: 'ASSETS',
             html_handling: 'none',
-            run_worker_first: opts.frontend.dev
-                ? true
-                : [
-                    '/invoke',
-                    '/install',
-                    '/install/*',
-                    '/health',
-                    '/health/*',
-                    '/.well-known',
-                    '/.well-known/*',
-                    ...opts.frontend.routes,
-                ],
+            // Match the portable Worker artifact: frontend routing and sandbox-safe asset
+            // response headers are owned by the Worker for both deployment adapters.
+            run_worker_first: true,
         };
     }
     const services = [];

package/dist/build/configuration/worker-name.d.ts

@@ -1,2 +1,2 @@
 import type { CloudflareParams } from '../../params.js';
-export declare function workerName(parameters: CloudflareParams, origin: string): string;
+export declare function workerName(parameters: CloudflareParams, origin: string, environment?: string): string;

package/dist/build/configuration/worker-name.js

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 const WORKER_NAME = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/u;
-export function workerName(parameters, origin) {
+export function workerName(parameters, origin, environment = '') {
     if (parameters.workerName !== undefined) {
         if (!WORKER_NAME.test(parameters.workerName) || parameters.workerName.length > 63) {
             throw new TypeError('Cloudflare workerName is invalid.');
@@ -12,7 +12,7 @@ export function workerName(parameters, origin) {
         .replace(/[^a-z0-9]+/gu, '-')
         .slice(0, 12)
         .replace(/^-+|-+$/gu, '') || 'domain';
-    const hexadecimal = createHash('sha256').update(origin).digest('hex');
+    const hexadecimal = createHash('sha256').update(`${origin}\0${environment}`).digest('hex');
     const identity = BigInt(`0x${hexadecimal}`).toString(36).padStart(50, '0');
     return `${readable}-${identity}`;
 }

package/dist/build/direct.d.ts

@@ -1,4 +1,4 @@
 import type { PreparedArtifact } from '@astrale-os/sdk/deployment/adapter';
 import type { CloudflareParams } from '../params.js';
 import type { WorkerArtifact } from './worker/index.js';
-export declare function admitDirectPlacement(artifact: PreparedArtifact, worker: WorkerArtifact, parameters: CloudflareParams): void;
+export declare function admitDirectPlacement(artifact: PreparedArtifact, worker: WorkerArtifact, parameters: CloudflareParams, environment?: string): void;

package/dist/build/direct.js

@@ -1,10 +1,9 @@
 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);
+export function admitDirectPlacement(artifact, worker, parameters, environment = '') {
+    const name = workerName(parameters, worker.origin, environment);
     const release = config(artifact, 'wrangler.jsonc');
     const router = resolveRouter(parameters.router);
     const frontend = artifact.build.frontend;
@@ -25,8 +24,6 @@ export function admitDirectPlacement(artifact, worker, parameters) {
             ? {
                 frontend: {
                     directory: './frontend',
-                    routes: frontendRoutes(frontend),
-                    dev: false,
                 },
             }
             : {}),

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

@@ -3,5 +3,7 @@ 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;
+    readonly output: string;
+    readonly recordSource?: (path: string) => void;
+    readonly signal: AbortSignal;
 }): Promise<readonly frontendBuild.FrontendFile[]>;

package/dist/build/frontend/files.js

@@ -1,24 +1,22 @@
 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';
+import { buildViteFrontend } from './vite.js';
 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));
+    await rm(input.output, { recursive: true, force: true });
+    await buildViteFrontend({
+        projectDir: input.projectDir,
+        output: input.output,
+        ...(frontend.source.config === undefined ? {} : { config: frontend.source.config }),
+        recordSource: input.recordSource,
+        signal: input.signal,
+    });
+    return frontendBuild.files(frontend, await readFiles(input.output));
 }
 async function readFiles(root, current = '') {
     const entries = await readdir(join(root, current), { withFileTypes: true });
@@ -33,28 +31,3 @@ async function readFiles(root, current = '') {
     }
     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/readiness.d.ts

@@ -0,0 +1,10 @@
+import type { Release } from '@astrale-os/sdk/deployment/release';
+import type { verifyReadiness } from '@astrale-os/sdk/deployment/verify';
+import type { WorkerArtifact } from '../worker/artifact.js';
+type ReadinessFetch = NonNullable<NonNullable<Parameters<typeof verifyReadiness>[1]>['fetch']>;
+/** Publication equality alone cannot prove a frontend-only deployment has propagated. */
+export declare function verifyWorkerFrontend(release: Release, worker: Pick<WorkerArtifact, 'assets'>, options?: {
+    readonly fetch?: ReadinessFetch;
+    readonly signal?: AbortSignal;
+}): Promise<void>;
+export {};

package/dist/build/frontend/readiness.js

@@ -0,0 +1,21 @@
+import { frontendRevision } from './revision.js';
+/** Publication equality alone cannot prove a frontend-only deployment has propagated. */
+export async function verifyWorkerFrontend(release, worker, options = {}) {
+    const frontend = release.build.frontend;
+    if (frontend === undefined || frontend.source.kind === 'external')
+        return;
+    if (worker.assets === undefined)
+        throw new Error('Prepared Worker frontend assets are missing.');
+    const expected = frontendRevision(worker.assets.files);
+    const fetcher = options.fetch ?? globalThis.fetch;
+    for (const route of frontend.routes) {
+        const response = await fetcher(new URL(route.path, release.addressing.issuer).href, {
+            redirect: 'error',
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
+        });
+        const matches = response.status === 200 && response.headers.get('X-Astrale-Frontend') === expected;
+        await response.body?.cancel();
+        if (!matches)
+            throw new Error(`Frontend ${route.path} is not serving the prepared browser build yet.`);
+    }
+}

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

@@ -0,0 +1,5 @@
+/** Bind the generated Worker to its exact browser files, independently of Schema revision. */
+export declare function frontendRevision(files: readonly {
+    readonly path: string;
+    bytes(): Uint8Array;
+}[]): string;

package/dist/build/frontend/revision.js

@@ -0,0 +1,14 @@
+import { createHash } from 'node:crypto';
+/** Bind the generated Worker to its exact browser files, independently of Schema revision. */
+export function frontendRevision(files) {
+    const hash = createHash('sha256');
+    const ordered = files
+        .map((file) => ({ path: file.path.replace(/^\//u, ''), bytes: file.bytes }))
+        .sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+    for (const file of ordered) {
+        const bytes = file.bytes();
+        hash.update(JSON.stringify([file.path, bytes.byteLength]));
+        hash.update(bytes);
+    }
+    return `sha256:${hash.digest('hex')}`;
+}

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

@@ -0,0 +1,8 @@
+/** Build a Vite frontend in an isolated process and report its authored inputs. */
+export declare function buildViteFrontend(input: {
+    readonly projectDir: string;
+    readonly output: string;
+    readonly config?: string;
+    readonly recordSource?: (path: string) => void;
+    readonly signal: AbortSignal;
+}): Promise<void>;

package/dist/build/frontend/vite.js

@@ -0,0 +1,32 @@
+import { existsSync } from 'node:fs';
+import { mkdir, mkdtemp, readFile, rm } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runViteProcess } from './vite.process.js';
+/** Build a Vite frontend in an isolated process and report its authored inputs. */
+export async function buildViteFrontend(input) {
+    const parent = dirname(input.output);
+    await mkdir(parent, { recursive: true });
+    const scratch = await mkdtemp(join(parent, 'vite-run-'));
+    const evidence = join(scratch, 'sources.json');
+    try {
+        await runViteProcess({
+            cwd: input.projectDir,
+            arguments: [runnerPath(), input.output, evidence, input.config ?? ''],
+            signal: input.signal,
+        });
+        const sources = JSON.parse(await readFile(evidence, 'utf8'));
+        if (!Array.isArray(sources) || sources.some((path) => typeof path !== 'string')) {
+            throw new TypeError('Vite preparation source evidence is invalid.');
+        }
+        for (const path of sources)
+            input.recordSource?.(path);
+    }
+    finally {
+        await rm(scratch, { recursive: true, force: true });
+    }
+}
+function runnerPath() {
+    const built = fileURLToPath(new URL('./vite.runner.js', import.meta.url));
+    return existsSync(built) ? built : fileURLToPath(new URL('./vite.runner.ts', import.meta.url));
+}

package/dist/build/frontend/vite.process.d.ts

@@ -0,0 +1,7 @@
+/** Run one bounded, cancellable Vite subprocess. */
+export declare function runViteProcess(input: {
+    readonly cwd: string;
+    readonly arguments: readonly string[];
+    readonly signal: AbortSignal;
+    readonly timeoutMs?: number;
+}): Promise<void>;

package/dist/build/frontend/vite.process.js

@@ -0,0 +1,65 @@
+import { spawn } from 'node:child_process';
+const MAXIMUM_OUTPUT_BYTES = 1024 * 1024;
+const TERMINATION_GRACE_MS = 1_000;
+const VITE_TIMEOUT_MS = 300_000;
+/** Run one bounded, cancellable Vite subprocess. */
+export function runViteProcess(input) {
+    if (input.signal.aborted)
+        return Promise.reject(abortReason(input.signal));
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, input.arguments, {
+            cwd: input.cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        let output = '';
+        let outputBytes = 0;
+        let terminating;
+        let escalation;
+        const timeout = setTimeout(() => terminate(new Error('Vite process timed out.')), input.timeoutMs ?? VITE_TIMEOUT_MS);
+        const abort = () => terminate(abortReason(input.signal));
+        input.signal.addEventListener('abort', abort, { once: true });
+        const cleanup = () => {
+            clearTimeout(timeout);
+            if (escalation !== undefined)
+                clearTimeout(escalation);
+            input.signal.removeEventListener('abort', abort);
+        };
+        function terminate(cause) {
+            if (terminating !== undefined)
+                return;
+            terminating = cause;
+            child.kill('SIGTERM');
+            escalation = setTimeout(() => {
+                if (child.exitCode === null && child.signalCode === null)
+                    child.kill('SIGKILL');
+            }, TERMINATION_GRACE_MS);
+        }
+        const collect = (buffer) => {
+            outputBytes += buffer.byteLength;
+            if (outputBytes > MAXIMUM_OUTPUT_BYTES) {
+                terminate(new Error('Vite process exceeded its output limit.'));
+                return;
+            }
+            output += buffer.toString();
+        };
+        child.stdout.on('data', collect);
+        child.stderr.on('data', collect);
+        child.once('error', (cause) => {
+            cleanup();
+            reject(terminating ?? cause);
+        });
+        child.once('close', (code) => {
+            cleanup();
+            if (terminating !== undefined)
+                reject(terminating);
+            else if (code === 0)
+                resolve();
+            else
+                reject(new Error(`Vite failed (code ${code ?? 1}):\n${output.slice(-1500)}`));
+        });
+    });
+}
+function abortReason(signal) {
+    return signal.reason instanceof Error ? signal.reason : new Error('Vite process cancelled.');
+}

package/dist/build/frontend/vite.runner.d.ts

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

package/dist/build/frontend/vite.runner.js

@@ -0,0 +1,120 @@
+import { readdir, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { isAbsolute, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+const CONFIG_FILES = Object.freeze([
+    'vite.config.js',
+    'vite.config.mjs',
+    'vite.config.ts',
+    'vite.config.cjs',
+    'vite.config.mts',
+    'vite.config.cts',
+]);
+await main();
+async function main() {
+    const [output, evidence, configured] = process.argv.slice(2);
+    if (output === undefined || evidence === undefined) {
+        throw new TypeError('Vite preparation runner arguments are invalid.');
+    }
+    const projectDir = process.cwd();
+    const vite = await projectVite(projectDir);
+    const sources = new Set();
+    let publicDir = false;
+    let environment = {
+        directory: false,
+        mode: 'production',
+    };
+    const config = configured === '' || configured === undefined ? undefined : configured;
+    await vite.build({
+        logLevel: 'silent',
+        ...(config === undefined
+            ? {}
+            : { configFile: isAbsolute(config) ? config : resolve(projectDir, config) }),
+        build: { outDir: output, emptyOutDir: true },
+        plugins: [
+            {
+                name: 'astrale:preparation-sources',
+                configResolved(value) {
+                    publicDir = value.publicDir;
+                    environment = { directory: value.envDir, mode: value.mode };
+                    for (const path of value.configFileDependencies)
+                        sources.add(path);
+                },
+                transform(_source, id) {
+                    const path = physicalModulePath(id);
+                    if (path !== undefined)
+                        sources.add(path);
+                },
+            },
+        ],
+    });
+    for (const path of configCandidates(projectDir, config))
+        sources.add(path);
+    for (const path of environmentCandidates(environment))
+        sources.add(path);
+    if (publicDir !== false)
+        await collectTree(publicDir, sources);
+    await writeFile(evidence, JSON.stringify([...sources]));
+}
+function environmentCandidates(input) {
+    const directory = input.directory;
+    if (directory === false)
+        return [];
+    return ['.env', '.env.local', `.env.${input.mode}`, `.env.${input.mode}.local`].map((name) => join(directory, name));
+}
+function physicalModulePath(id) {
+    if (id.startsWith('\0'))
+        return undefined;
+    const path = id.replace(/[?#].*$/u, '');
+    if (path.length === 0)
+        return undefined;
+    if (path.startsWith('file:')) {
+        try {
+            return fileURLToPath(path);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return isAbsolute(path) ? path : undefined;
+}
+async function projectVite(projectDir) {
+    try {
+        const manifest = createRequire(join(projectDir, 'package.json')).resolve('vite/package.json');
+        const entry = createRequire(manifest).resolve('vite');
+        return (await import(pathToFileURL(entry).href));
+    }
+    catch (cause) {
+        throw new TypeError('Vite frontend requires a project-local Vite package.', { cause });
+    }
+}
+function configCandidates(projectDir, configured) {
+    if (configured !== undefined) {
+        return [isAbsolute(configured) ? configured : resolve(projectDir, configured)];
+    }
+    return CONFIG_FILES.map((name) => join(projectDir, name));
+}
+async function collectTree(path, output) {
+    output.add(path);
+    let entries;
+    try {
+        entries = await readdir(path, { withFileTypes: true });
+    }
+    catch (cause) {
+        if (errorCode(cause) === 'ENOENT')
+            return;
+        throw cause;
+    }
+    for (const entry of entries) {
+        const child = join(path, entry.name);
+        if (entry.isDirectory())
+            await collectTree(child, output);
+        else if (entry.isFile())
+            output.add(child);
+    }
+}
+function errorCode(input) {
+    return input !== null && typeof input === 'object' && 'code' in input
+        ? String(Reflect.get(input, 'code'))
+        : undefined;
+}