@astrale-os/adapter-cloudflare 0.5.0-beta.17 → 0.5.0-beta.170

package/dist/build/codegen/wrangler.js

@@ -12,17 +12,27 @@
  * (extra bindings: KV, R2, D1, queues, …) — see `mergeUserConfig`.
  */
 import { deepMergeConfig } from './merge.js';
-// Wrangler 4.121.0's pinned workerd accepts dates through 2026-08-11.
-const COMPATIBILITY_DATE = '2026-08-11';
+/**
+ * The Workers runtime every generated Worker runs on, wherever it is deployed: its compatibility
+ * date, kept on the runtime baseline qualified with Wrangler 4.123.0, and its compatibility flags.
+ * Domain execution calls its Kernel through the invocation's public issuer, so Cloudflare must route
+ * same-zone callbacks through the public front door instead of bypassing Worker routes
+ * (`global_fetch_strictly_public`). An immutable deployment freezes it into its configuration.
+ */
+export const GENERATED_WORKER_RUNTIME = Object.freeze({
+    compatibilityDate: '2026-08-11',
+    compatibilityFlags: Object.freeze(['nodejs_compat', 'global_fetch_strictly_public']),
+});
 export function generateWranglerConfig(opts) {
     const config = {
         name: opts.workerName,
-        main: './worker.gen.ts',
-        compatibility_date: COMPATIBILITY_DATE,
-        compatibility_flags: ['nodejs_compat'],
-        workers_dev: true,
+        main: opts.main ?? './worker.gen.ts',
+        compatibility_date: GENERATED_WORKER_RUNTIME.compatibilityDate,
+        compatibility_flags: [...GENERATED_WORKER_RUNTIME.compatibilityFlags],
+        workers_dev: opts.route === undefined,
         version_metadata: { binding: 'ASTRALE_VERSION_METADATA' },
         observability: { enabled: true },
+        minify: true,
     };
     if (opts.route) {
         config.routes = [{ pattern: opts.route, custom_domain: true }];
@@ -31,19 +41,10 @@ export function generateWranglerConfig(opts) {
         config.assets = {
             directory: opts.frontend.directory,
             binding: 'ASSETS',
-            run_worker_first: opts.frontend.dev
-                ? true
-                : [
-                    '/invoke',
-                    '/invoke/*',
-                    '/install',
-                    '/install/*',
-                    '/health',
-                    '/health/*',
-                    '/.well-known',
-                    '/.well-known/*',
-                    ...opts.frontend.routes,
-                ],
+            html_handling: 'none',
+            // 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 = [];
@@ -57,6 +58,18 @@ export function generateWranglerConfig(opts) {
     if (opts.vars && Object.keys(opts.vars).length > 0) {
         config.vars = opts.vars;
     }
+    if (opts.secretBindings && opts.secretBindings.length > 0) {
+        config.secrets = { required: [...opts.secretBindings] };
+    }
+    if (opts.modules !== undefined) {
+        config.find_additional_modules = true;
+        config.base_dir = opts.modules.baseDir;
+        config.rules = opts.modules.rules.map((rule) => ({
+            type: rule.type,
+            globs: [...rule.globs],
+            fallthrough: true,
+        }));
+    }
     const merged = opts.wrangler ? mergeUserConfig(config, opts.wrangler) : config;
     return JSON.stringify(merged, null, 2) + '\n';
 }
@@ -67,11 +80,43 @@ const ADAPTER_OWNED_KEYS = [
     'assets',
     'routes',
     'compatibility_date',
+    'workers_dev',
     'version_metadata',
+    'secrets',
+    'find_additional_modules',
+    'base_dir',
 ];
+/**
+ * Keys Wrangler's bundler reads. Bundling sees the adapter base configuration only, so that every
+ * Environment of one source bundles the same bytes; an Environment's overlay never sets these.
+ */
+const BUNDLING_KEYS = [
+    'alias',
+    'build',
+    'define',
+    'jsx_factory',
+    'jsx_fragment',
+    'keep_names',
+    'minify',
+    'no_bundle',
+    'node_compat',
+    'preserve_file_names',
+    'rules',
+    'tsconfig',
+    'upload_source_maps',
+];
+/** Compatibility flags Wrangler's bundler reads: Node.js polyfills, `navigator`, fetch typing, Python. */
+const BUNDLING_FLAG = /nodejs|navigator|fetch_iterable_type_support|python_workers/u;
+/**
+ * Whether a compatibility flag shapes the bundle (Wrangler's bundler reads it), so that no
+ * Environment may add it: bundling takes no Environment.
+ */
+export function isBundlingCompatibilityFlag(flag) {
+    return BUNDLING_FLAG.test(flag);
+}
 /**
  * Deep-merge the dev's raw wrangler overlay over the generated config, after
- * refusing any attempt to override an adapter-owned key. Throwing (rather than
+ * refusing any attempt to override an adapter-owned key or a bundler input. Throwing (rather than
  * silently dropping) keeps a stray `main` from breaking the Worker unnoticed.
  */
 function mergeUserConfig(base, user) {
@@ -81,6 +126,17 @@ function mergeUserConfig(base, user) {
             'Use `workerName` for the worker name and `route` for routing; ' +
             '`main` and `assets` are generated by the adapter.');
     }
+    const baseFlags = Array.isArray(base.compatibility_flags) ? base.compatibility_flags : [];
+    const bundling = [
+        ...BUNDLING_KEYS.filter((k) => k in user),
+        ...(Array.isArray(user.compatibility_flags) ? user.compatibility_flags : [])
+            .filter((flag) => typeof flag === 'string' && BUNDLING_FLAG.test(flag))
+            .filter((flag) => !baseFlags.includes(flag))
+            .map((flag) => `compatibility_flags ${String(flag)}`),
+    ];
+    if (bundling.length > 0) {
+        throw new Error(`wrangler: ${bundling.join(', ')} shape(s) the bundle, which takes no Environment. ` +
+            'Bundling uses the adapter base configuration only.');
+    }
     return deepMergeConfig(base, user);
 }
-//# sourceMappingURL=wrangler.js.map

package/dist/build/configuration/invocation-timeout.d.ts

@@ -0,0 +1,2 @@
+import type { CloudflareParams } from '../../params.js';
+export declare function workerInvocationTimeout(value: CloudflareParams['invocationTimeoutMs']): number | undefined;

package/dist/build/configuration/invocation-timeout.js

@@ -0,0 +1,9 @@
+import { MAXIMUM_INVOCATION_TIMEOUT_MS } from '../../worker/settings.js';
+export function workerInvocationTimeout(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isSafeInteger(value) || value <= 0 || value > MAXIMUM_INVOCATION_TIMEOUT_MS) {
+        throw new TypeError('Cloudflare invocationTimeoutMs must be a positive integer within the platform timer range.');
+    }
+    return value;
+}

package/dist/build/configuration/request-limit.d.ts

@@ -0,0 +1,2 @@
+import type { CloudflareParams } from '../../params.js';
+export declare function workerRequestLimit(value: CloudflareParams['maximumRequestBytes']): number | undefined;

package/dist/build/configuration/request-limit.js

@@ -0,0 +1,9 @@
+import { MAXIMUM_REQUEST_BYTES } from '../../worker/settings.js';
+export function workerRequestLimit(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isSafeInteger(value) || value <= 0 || value > MAXIMUM_REQUEST_BYTES) {
+        throw new TypeError('Cloudflare maximumRequestBytes must be a positive integer at most 16 MiB.');
+    }
+    return value;
+}

package/dist/build/configuration/router.d.ts

@@ -0,0 +1,7 @@
+import type { CloudflareParams } from '../../params.js';
+export declare function resolveRouter(input: CloudflareParams['router']): {
+    readonly binding: string;
+    readonly service: string;
+    readonly hostSuffix: string;
+    readonly minLabels: number;
+} | undefined;

package/dist/build/configuration/router.js

@@ -0,0 +1,11 @@
+export function resolveRouter(input) {
+    if (input === false || input === undefined)
+        return undefined;
+    const value = input;
+    return Object.freeze({
+        binding: value.binding ?? 'ROUTER',
+        service: value.service ?? 'admin-router',
+        hostSuffix: value.hostSuffix ?? '.astrale.ai',
+        minLabels: value.minLabels ?? 4,
+    });
+}

package/dist/build/configuration/settings.d.ts

@@ -0,0 +1,6 @@
+import type { CloudflareParams } from '../../params.js';
+import type { WorkerSettings } from '../../worker/settings.js';
+/** Whether a binding name is one the adapter owns, so no author var or secret may take it. */
+export declare function isAdapterVar(name: string): boolean;
+/** Resolve one Environment's execution settings, defaults included, as its deployment binds them. */
+export declare function workerSettings(parameters: CloudflareParams): WorkerSettings;

package/dist/build/configuration/settings.js

@@ -0,0 +1,42 @@
+import { maximumExchangeTtl } from '@astrale-os/sdk/execution';
+import { BUILD_DIGEST_BINDING } from '../../worker/build-digest.js';
+import { captureDurableOptions, DEFAULT_INVOCATION_TIMEOUT_MS, DEFAULT_MAXIMUM_REQUEST_BYTES, SETTINGS_BINDING, } from '../../worker/settings.js';
+import { workerInvocationTimeout } from './invocation-timeout.js';
+import { workerRequestLimit } from './request-limit.js';
+import { resolveRouter } from './router.js';
+/**
+ * Plain bindings the adapter owns on a deployment, bound or not; no author var or secret takes
+ * these names. `IDENTITY_ISS` and `ASTRALE_PROVIDER_ASSIGNED_WORKER` belong to legacy direct mode.
+ */
+const ADAPTER_VARS = new Set([
+    'WORKER_URL',
+    BUILD_DIGEST_BINDING,
+    SETTINGS_BINDING,
+    'IDENTITY_ISS',
+    'ASTRALE_PROVIDER_ASSIGNED_WORKER',
+]);
+/** Whether a binding name is one the adapter owns, so no author var or secret may take it. */
+export function isAdapterVar(name) {
+    return ADAPTER_VARS.has(name);
+}
+/** Resolve one Environment's execution settings, defaults included, as its deployment binds them. */
+export function workerSettings(parameters) {
+    const router = resolveRouter(parameters.router);
+    return Object.freeze({
+        ...(parameters.durable === undefined
+            ? {}
+            : { durableOptions: captureDurableOptions(parameters.durable) }),
+        maximumRequestBytes: workerRequestLimit(parameters.maximumRequestBytes) ?? DEFAULT_MAXIMUM_REQUEST_BYTES,
+        invocationTimeoutMs: workerInvocationTimeout(parameters.invocationTimeoutMs) ?? DEFAULT_INVOCATION_TIMEOUT_MS,
+        tokenExchange: parameters.tokenExchange === false
+            ? false
+            : Object.freeze({ maximumLifetimeSeconds: maximumExchangeTtl(parameters.tokenExchange) }),
+        router: router === undefined
+            ? false
+            : Object.freeze({
+                binding: router.binding,
+                hostSuffix: router.hostSuffix,
+                minLabels: router.minLabels,
+            }),
+    });
+}

package/dist/build/configuration.d.ts

@@ -0,0 +1,4 @@
+export { workerInvocationTimeout } from './configuration/invocation-timeout.js';
+export { workerRequestLimit } from './configuration/request-limit.js';
+export { resolveRouter } from './configuration/router.js';
+export { isAdapterVar, workerSettings } from './configuration/settings.js';

package/dist/build/configuration.js

@@ -0,0 +1,4 @@
+export { workerInvocationTimeout } from './configuration/invocation-timeout.js';
+export { workerRequestLimit } from './configuration/request-limit.js';
+export { resolveRouter } from './configuration/router.js';
+export { isAdapterVar, workerSettings } from './configuration/settings.js';

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

@@ -0,0 +1,19 @@
+import type { Build } from '@astrale-os/sdk/deployment/build';
+import { frontend as frontendBuild } from '@astrale-os/sdk/deployment/build';
+/** The served frontend, and which of its files a browser may keep without revalidating. */
+export interface FrontendOutput {
+    readonly files: readonly frontendBuild.FrontendFile[];
+    /**
+     * Served paths the bundler content-addressed, so their bytes can never change under a given name.
+     * A frontend Astrale does not build leaves this empty, which is what keeps the absence of evidence
+     * indistinguishable from evidence of mutability.
+     */
+    readonly addressed: readonly string[];
+}
+export declare function frontendFiles(input: {
+    readonly frontend: Build['frontend'];
+    readonly projectDir: string;
+    readonly output: string;
+    readonly recordSource?: (path: string) => void;
+    readonly signal: AbortSignal;
+}): Promise<FrontendOutput>;

package/dist/build/frontend/files.js

@@ -0,0 +1,99 @@
+import { frontend as frontendBuild } from '@astrale-os/sdk/deployment/build';
+import { readFile, readdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { buildViteFrontend } from './vite.js';
+/**
+ * Root names that Cloudflare Workers Static Assets reads as configuration rather than serving.
+ *
+ * Wrangler withholds them from a direct upload and applies them, while the managed upload through
+ * Services serves them as ordinary public files, so the same output would behave differently per
+ * adapter. The Worker runs first on every request and owns frontend response headers and routing for
+ * both, which leaves these files nothing to configure.
+ */
+const RESERVED_ROOT_NAMES = new Set([
+    '_headers',
+    '_redirects',
+    '.assetsignore',
+]);
+/**
+ * Name of a Cloudflare Pages worker script, the server-side code of a Pages project.
+ *
+ * Wrangler refuses to upload a root asset under this name, since that would publish the code, unless
+ * an `.assetsignore` exists, and the reserved names above already exclude one. A direct deployment
+ * would therefore fail at upload, while the managed upload through Services would publish the code.
+ * Neither adapter runs a Pages worker: the Worker is the only server-side code for both.
+ */
+const PAGES_WORKER_NAME = '_worker.js';
+export async function frontendFiles(input) {
+    const frontend = input.frontend;
+    if (frontend === undefined)
+        return { files: [], addressed: [] };
+    if (frontend.source.kind === 'external') {
+        return { files: frontendBuild.files(frontend, []), addressed: [] };
+    }
+    await rm(input.output, { recursive: true, force: true });
+    const built = await buildViteFrontend({
+        projectDir: input.projectDir,
+        output: input.output,
+        ...(frontend.source.config === undefined ? {} : { config: frontend.source.config }),
+        recordSource: input.recordSource,
+        signal: input.signal,
+    });
+    const files = frontendBuild.files(frontend, await readFiles(input.output));
+    refuseReservedNames(files);
+    refusePagesWorker(files);
+    // A name the bundler reported but that never reached disk is not a served path; keeping only the
+    // intersection means the evidence describes exactly what this deployment will answer with.
+    const served = new Set(files.map((file) => file.path));
+    return { files, addressed: built.addressed.filter((path) => served.has(path)) };
+}
+/**
+ * Refuse output that Cloudflare would read as asset configuration instead of serving it.
+ *
+ * Only the root is reserved: a nested `docs/_headers` stays an ordinary file. The match ignores case
+ * and covers directories, because Wrangler's upload filter withholds any root entry under these names
+ * regardless of case, and a case-insensitive filesystem hands it `_Headers` when it reads `_headers`.
+ */
+function refuseReservedNames(files) {
+    const reserved = new Set(files
+        .map((file) => file.path.split('/')[0])
+        .filter((name) => RESERVED_ROOT_NAMES.has(name.toLowerCase())));
+    if (reserved.size === 0)
+        return;
+    const names = [...reserved].join(', ');
+    throw new TypeError(`Frontend output contains reserved Cloudflare asset configuration name(s) at its root: ${names}. ` +
+        'A direct cloudflare() deployment would apply them as Workers Static Assets configuration, while a managed astrale() deployment would serve them as public files. ' +
+        'The Worker owns frontend response headers and routing for both adapters: remove them from the Vite public directory, or stop the build from emitting them.');
+}
+/**
+ * Refuse output that Wrangler would decline to upload as a Cloudflare Pages worker script.
+ *
+ * Wrangler tests the relative path with a plain `startsWith`, not through its case-insensitive upload
+ * filter, so the match here is a case-sensitive prefix of the root name too. It covers a `_worker.js`
+ * file or directory and siblings such as `_worker.js.map`, which Wrangler refuses alike, while both
+ * adapters serve `_Worker.js` or a nested `docs/_worker.js` as an ordinary file.
+ */
+function refusePagesWorker(files) {
+    const workers = new Set(files
+        .map((file) => file.path.split('/')[0])
+        .filter((name) => name.startsWith(PAGES_WORKER_NAME)));
+    if (workers.size === 0)
+        return;
+    const names = [...workers].join(', ');
+    throw new TypeError(`Frontend output contains Cloudflare Pages worker name(s) at its root: ${names}. ` +
+        `A direct cloudflare() deployment would fail because Wrangler refuses to upload a root name starting with ${PAGES_WORKER_NAME} as possible server-side code, while a managed astrale() deployment would serve them as public files. ` +
+        'The Worker is the only server-side code for both adapters: remove or rename them in the Vite public directory, or stop the build from emitting them.');
+}
+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;
+}

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

@@ -0,0 +1,10 @@
+import type { legacy } 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: legacy.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.publicUrl).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,14 @@
+/**
+ * Build a Vite frontend in an isolated process and report its authored inputs, along with the
+ * outputs the bundler content-addressed. Those are the files a browser may keep forever, and only
+ * the build that named them can say which they are.
+ */
+export declare function buildViteFrontend(input: {
+    readonly projectDir: string;
+    readonly output: string;
+    readonly config?: string;
+    readonly recordSource?: (path: string) => void;
+    readonly signal: AbortSignal;
+}): Promise<{
+    readonly addressed: readonly string[];
+}>;

package/dist/build/frontend/vite.js

@@ -0,0 +1,42 @@
+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, along with the
+ * outputs the bundler content-addressed. Those are the files a browser may keep forever, and only
+ * the build that named them can say which they are.
+ */
+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');
+    const addressed = join(scratch, 'addressed.json');
+    try {
+        await runViteProcess({
+            cwd: input.projectDir,
+            arguments: [runnerPath(), input.output, evidence, input.config ?? '', addressed],
+            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);
+        const named = JSON.parse(await readFile(addressed, 'utf8'));
+        if (!Array.isArray(named) || named.some((path) => typeof path !== 'string')) {
+            throw new TypeError('Vite preparation output evidence is invalid.');
+        }
+        return { addressed: Object.freeze([...named]) };
+    }
+    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 {};