experimental-ash 0.25.2 → 0.27.0

package/dist/src/public/next/index.js

@@ -1,148 +1 @@
-import { isAbsolute, resolve } from "node:path";
-import { ASH_ROUTE_PREFIX } from "#protocol/routes.js";
-import { resolveAshDestinationPrefix } from "./server.js";
-import { ensureAshVercelJson } from "./vercel-json.js";
-/**
- * Private route namespace used when a Vercel deployment hosts Ash as a
- * separate experimental service behind the Next.js app.
- */
-export const ASH_NEXT_SERVICE_PREFIX = "/_ash_internal/ash";
-const ASH_NEXT_PRODUCTION_ORIGIN_ENV = "ASH_NEXT_PRODUCTION_ORIGIN";
-const ASH_NEXT_PRODUCTION_PORT_ENV = "ASH_NEXT_PRODUCTION_PORT";
-const DEFAULT_ASH_BUILD_COMMAND = "ash build";
-const DEFAULT_ASH_NEXT_PRODUCTION_PORT = 4274;
-const ASH_PROXY_REWRITE_SOURCES = [`${ASH_ROUTE_PREFIX}/:path+`];
-function resolveApplicationRoot(appPath) {
-    if (appPath === undefined || appPath.length === 0) {
-        return process.cwd();
-    }
-    return isAbsolute(appPath) ? appPath : resolve(process.cwd(), appPath);
-}
-function normalizeRoutePrefix(prefix) {
-    const prefixed = prefix.startsWith("/") ? prefix : `/${prefix}`;
-    const normalized = prefixed.replace(/\/+$/, "");
-    if (normalized.length === 0) {
-        throw new Error("Ash Next.js service prefix cannot resolve to the root route.");
-    }
-    return normalized;
-}
-function joinRoutePrefix(prefix, path) {
-    return `${prefix.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
-}
-function normalizeOrigin(origin) {
-    return new URL(origin.trim()).origin;
-}
-function readLocalProductionPort() {
-    const configuredPort = process.env[ASH_NEXT_PRODUCTION_PORT_ENV];
-    if (configuredPort === undefined || configuredPort.trim().length === 0) {
-        return DEFAULT_ASH_NEXT_PRODUCTION_PORT;
-    }
-    const port = Number.parseInt(configuredPort, 10);
-    if (String(port) !== configuredPort.trim() || port < 1 || port > 65_535) {
-        throw new Error(`${ASH_NEXT_PRODUCTION_PORT_ENV} must be an integer between 1 and 65535.`);
-    }
-    return port;
-}
-function resolveProductionDestination(servicePrefix) {
-    if (process.env.VERCEL) {
-        return {
-            destinationPrefix: servicePrefix,
-        };
-    }
-    const configuredOrigin = process.env[ASH_NEXT_PRODUCTION_ORIGIN_ENV];
-    if (configuredOrigin !== undefined && configuredOrigin.trim().length > 0) {
-        return {
-            destinationPrefix: joinRoutePrefix(normalizeOrigin(configuredOrigin), servicePrefix),
-        };
-    }
-    const localServerOrigin = `http://127.0.0.1:${String(readLocalProductionPort())}`;
-    return {
-        destinationPrefix: localServerOrigin,
-        localServerOrigin,
-    };
-}
-function createAshRewriteRules(destinationPrefix) {
-    return ASH_PROXY_REWRITE_SOURCES.map((source) => {
-        const rule = {
-            destination: joinRoutePrefix(destinationPrefix, source),
-            source,
-        };
-        return rule;
-    });
-}
-async function resolveExistingRewrites(rewrites) {
-    return await rewrites?.();
-}
-function mergeRewriteRules(existing, ashRules) {
-    if (existing === undefined) {
-        return {
-            beforeFiles: ashRules,
-        };
-    }
-    if (!isRewriteSections(existing)) {
-        return {
-            afterFiles: existing,
-            beforeFiles: ashRules,
-        };
-    }
-    return {
-        ...existing,
-        beforeFiles: [...ashRules, ...(existing.beforeFiles ?? [])],
-    };
-}
-function isRewriteSections(rewrites) {
-    return !Array.isArray(rewrites);
-}
-async function resolveNextConfig(configOrFunction, phase, context) {
-    return typeof configOrFunction === "function"
-        ? await configOrFunction(phase, context)
-        : configOrFunction;
-}
-/**
- * Wraps a Next.js config so same-origin Ash endpoints proxy to a separate Ash
- * service.
- *
- * In development, `withAsh` starts `ash dev --no-repl --port 0` for the Ash
- * app and rewrites Ash protocol endpoints to that local URL. In production on
- * Vercel, it rewrites to the private Ash service prefix configured in
- * `vercel.json`. Outside Vercel production, it serves an existing
- * `.output/server/index.mjs` Ash build on a stable local port when present;
- * otherwise set `ASH_NEXT_PRODUCTION_ORIGIN` to the origin that serves the Ash
- * service namespace.
- */
-export function withAsh(configOrFunction, options = {}) {
-    const nextRoot = process.cwd();
-    const appRoot = resolveApplicationRoot(options.ashRoot);
-    const servicePrefixInput = normalizeRoutePrefix(options.servicePrefix ?? ASH_NEXT_SERVICE_PREFIX);
-    const shouldConfigureVercelJson = options.configureVercelJson !== false;
-    return async function ashNextConfig(phase, context) {
-        const nextConfig = await resolveNextConfig(configOrFunction, phase, context);
-        const existingRewrites = nextConfig.rewrites;
-        const configuredVercel = shouldConfigureVercelJson
-            ? await ensureAshVercelJson({
-                appRoot,
-                ashBuildCommand: options.ashBuildCommand ?? DEFAULT_ASH_BUILD_COMMAND,
-                nextRoot,
-                servicePrefix: servicePrefixInput,
-            })
-            : {
-                servicePrefix: servicePrefixInput,
-            };
-        const productionDestination = resolveProductionDestination(configuredVercel.servicePrefix);
-        return {
-            ...nextConfig,
-            async rewrites() {
-                const [existing, destinationPrefix] = await Promise.all([
-                    resolveExistingRewrites(existingRewrites),
-                    resolveAshDestinationPrefix({
-                        appRoot,
-                        phase,
-                        productionDestinationPrefix: productionDestination.destinationPrefix,
-                        productionServerOrigin: productionDestination.localServerOrigin,
-                    }),
-                ]);
-                return mergeRewriteRules(existing, createAshRewriteRules(destinationPrefix));
-            },
-        };
-    };
-}
+import{resolveAshDestinationPrefix}from"./server.js";import{ensureAshVercelJson}from"./vercel-json.js";import{ASH_ROUTE_PREFIX}from"#protocol/routes.js";import{isAbsolute,resolve}from"node:path";var ASH_NEXT_SERVICE_PREFIX=`/_ash_internal/ash`,ASH_NEXT_PRODUCTION_ORIGIN_ENV=`ASH_NEXT_PRODUCTION_ORIGIN`,ASH_NEXT_PRODUCTION_PORT_ENV=`ASH_NEXT_PRODUCTION_PORT`,DEFAULT_ASH_BUILD_COMMAND=`ash build`,DEFAULT_ASH_NEXT_PRODUCTION_PORT=4274,ASH_PROXY_REWRITE_SOURCES=[`${ASH_ROUTE_PREFIX}/:path+`];function resolveApplicationRoot(e){return e===void 0||e.length===0?process.cwd():isAbsolute(e)?e:resolve(process.cwd(),e)}function normalizeRoutePrefix(e){let t=(e.startsWith(`/`)?e:`/${e}`).replace(/\/+$/,``);if(t.length===0)throw Error(`Ash Next.js service prefix cannot resolve to the root route.`);return t}function joinRoutePrefix(e,t){return`${e.replace(/\/+$/,``)}/${t.replace(/^\/+/,``)}`}function normalizeOrigin(e){return new URL(e.trim()).origin}function readLocalProductionPort(){let e=process.env[ASH_NEXT_PRODUCTION_PORT_ENV];if(e===void 0||e.trim().length===0)return DEFAULT_ASH_NEXT_PRODUCTION_PORT;let t=Number.parseInt(e,10);if(String(t)!==e.trim()||t<1||t>65535)throw Error(`${ASH_NEXT_PRODUCTION_PORT_ENV} must be an integer between 1 and 65535.`);return t}function resolveProductionDestination(e){if(process.env.VERCEL)return{destinationPrefix:e};let t=process.env[ASH_NEXT_PRODUCTION_ORIGIN_ENV];if(t!==void 0&&t.trim().length>0)return{destinationPrefix:joinRoutePrefix(normalizeOrigin(t),e)};let n=`http://127.0.0.1:${String(readLocalProductionPort())}`;return{destinationPrefix:n,localServerOrigin:n}}function createAshRewriteRules(e){return ASH_PROXY_REWRITE_SOURCES.map(t=>({destination:joinRoutePrefix(e,t),source:t}))}async function resolveExistingRewrites(e){return await e?.()}function mergeRewriteRules(e,t){return e===void 0?{beforeFiles:t}:isRewriteSections(e)?{...e,beforeFiles:[...t,...e.beforeFiles??[]]}:{afterFiles:e,beforeFiles:t}}function isRewriteSections(e){return!Array.isArray(e)}async function resolveNextConfig(e,t,n){return typeof e==`function`?await e(t,n):e}function withAsh(n,r={}){let i=process.cwd(),a=resolveApplicationRoot(r.ashRoot),o=normalizeRoutePrefix(r.servicePrefix??`/_ash_internal/ash`),s=r.configureVercelJson!==!1;return async function(c,l){let u=await resolveNextConfig(n,c,l),d=u.rewrites,f=resolveProductionDestination((s?await ensureAshVercelJson({appRoot:a,ashBuildCommand:r.ashBuildCommand??DEFAULT_ASH_BUILD_COMMAND,nextRoot:i,servicePrefix:o}):{servicePrefix:o}).servicePrefix);return{...u,async rewrites(){let[t,n]=await Promise.all([resolveExistingRewrites(d),resolveAshDestinationPrefix({appRoot:a,phase:c,productionDestinationPrefix:f.destinationPrefix,productionServerOrigin:f.localServerOrigin})]);return mergeRewriteRules(t,createAshRewriteRules(n))}}}}export{ASH_NEXT_SERVICE_PREFIX,withAsh};

package/dist/src/public/next/server.js

@@ -1,348 +1 @@
-import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
-import { mkdir, open, readFile, rm, stat, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { resolvePackageRoot } from "#internal/application/package.js";
-import { ASH_ROUTE_PREFIX } from "#protocol/routes.js";
-const ASH_BASE_URL_ENV = "ASH_BASE_URL";
-const DEFAULT_SERVER_READY_TIMEOUT_MS = 30_000;
-const DEV_SERVER_REGISTRY_TIMEOUT_MS = 30_000;
-const DEV_SERVER_REGISTRY_POLL_MS = 100;
-const DEV_SERVER_STALE_LOCK_MS = 30_000;
-const ASH_CACHE_DIRECTORY_NAME = ".ash";
-const ASH_NEXT_DEV_SERVER_FILE_NAME = "next-dev-server.json";
-const ASH_NEXT_DEV_SERVER_LOCK_FILE_NAME = "next-dev-server.lock";
-const LOCAL_SERVER_URL_PATTERN = /https?:\/\/(?:\[[^\]\s]+\]|[^\s/:[\]]+)(?::\d+)?/;
-const NEXT_PHASE_PRODUCTION_BUILD = "phase-production-build";
-const globalStateSymbol = Symbol.for("experimental-ash.next.state");
-function getGlobalState() {
-    const globalWithState = globalThis;
-    globalWithState[globalStateSymbol] ??= {
-        servers: new Map(),
-    };
-    return globalWithState[globalStateSymbol];
-}
-function joinRoutePrefix(prefix, path) {
-    return `${prefix.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
-}
-function normalizeOrigin(origin) {
-    return new URL(origin).origin;
-}
-function readAshBaseUrlEnvironment() {
-    const configuredUrl = process.env[ASH_BASE_URL_ENV];
-    if (configuredUrl === undefined || configuredUrl.trim().length === 0) {
-        return undefined;
-    }
-    return normalizeOrigin(configuredUrl);
-}
-function isNodeErrorWithCode(error, code) {
-    return error instanceof Error && "code" in error && error.code === code;
-}
-function delay(ms) {
-    return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
-}
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function resolveAshCacheDirectory(appRoot) {
-    return join(appRoot, ASH_CACHE_DIRECTORY_NAME);
-}
-function resolveAshDevServerRegistryPath(appRoot) {
-    return join(resolveAshCacheDirectory(appRoot), ASH_NEXT_DEV_SERVER_FILE_NAME);
-}
-function resolveAshDevServerLockPath(appRoot) {
-    return join(resolveAshCacheDirectory(appRoot), ASH_NEXT_DEV_SERVER_LOCK_FILE_NAME);
-}
-function normalizeDevServerRegistry(value) {
-    if (!isRecord(value)) {
-        return undefined;
-    }
-    if (typeof value.appRoot !== "string" ||
-        typeof value.origin !== "string" ||
-        typeof value.updatedAt !== "string") {
-        return undefined;
-    }
-    if (value.pid !== null && typeof value.pid !== "number") {
-        return undefined;
-    }
-    try {
-        return {
-            appRoot: value.appRoot,
-            origin: normalizeOrigin(value.origin),
-            pid: value.pid,
-            updatedAt: value.updatedAt,
-        };
-    }
-    catch {
-        return undefined;
-    }
-}
-async function isAshServerHealthy(origin) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => {
-        controller.abort();
-    }, 1_000);
-    try {
-        const response = await fetch(joinRoutePrefix(origin, `${ASH_ROUTE_PREFIX}/health`), {
-            signal: controller.signal,
-        });
-        return response.ok;
-    }
-    catch {
-        return false;
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-}
-async function readUsableAshDevServerRegistry(appRoot) {
-    try {
-        const registry = normalizeDevServerRegistry(JSON.parse(await readFile(resolveAshDevServerRegistryPath(appRoot), "utf8")));
-        if (registry === undefined || registry.appRoot !== appRoot) {
-            return undefined;
-        }
-        if (!(await isAshServerHealthy(registry.origin))) {
-            return undefined;
-        }
-        process.env[ASH_BASE_URL_ENV] = registry.origin;
-        return registry.origin;
-    }
-    catch (error) {
-        if (isNodeErrorWithCode(error, "ENOENT")) {
-            return undefined;
-        }
-        throw error;
-    }
-}
-async function writeAshDevServerRegistry(appRoot, handle) {
-    await mkdir(resolveAshCacheDirectory(appRoot), {
-        recursive: true,
-    });
-    await writeFile(resolveAshDevServerRegistryPath(appRoot), `${JSON.stringify({
-        appRoot,
-        origin: handle.origin,
-        pid: handle.process?.pid ?? null,
-        updatedAt: new Date().toISOString(),
-    }, null, 2)}\n`);
-}
-async function removeStaleAshDevServerLock(lockPath) {
-    try {
-        const lockStat = await stat(lockPath);
-        if (Date.now() - lockStat.mtimeMs > DEV_SERVER_STALE_LOCK_MS) {
-            await rm(lockPath, {
-                force: true,
-            });
-        }
-    }
-    catch (error) {
-        if (!isNodeErrorWithCode(error, "ENOENT")) {
-            throw error;
-        }
-    }
-}
-async function acquireAshDevServerLock(appRoot) {
-    const cacheDirectory = resolveAshCacheDirectory(appRoot);
-    const lockPath = resolveAshDevServerLockPath(appRoot);
-    const deadline = Date.now() + DEV_SERVER_REGISTRY_TIMEOUT_MS;
-    await mkdir(cacheDirectory, {
-        recursive: true,
-    });
-    while (true) {
-        try {
-            const lockFile = await open(lockPath, "wx");
-            await lockFile.writeFile(`${String(process.pid)}\n`);
-            await lockFile.close();
-            return async () => {
-                await rm(lockPath, {
-                    force: true,
-                });
-            };
-        }
-        catch (error) {
-            if (!isNodeErrorWithCode(error, "EEXIST")) {
-                throw error;
-            }
-            const registeredOrigin = await readUsableAshDevServerRegistry(appRoot);
-            if (registeredOrigin !== undefined) {
-                return async () => { };
-            }
-            await removeStaleAshDevServerLock(lockPath);
-            if (Date.now() > deadline) {
-                throw new Error(`Timed out after ${DEV_SERVER_REGISTRY_TIMEOUT_MS}ms waiting for another Next.js process to start Ash.`);
-            }
-            await delay(DEV_SERVER_REGISTRY_POLL_MS);
-        }
-    }
-}
-function createAshBinaryPath() {
-    return join(resolvePackageRoot(), "bin", "ash.js");
-}
-function normalizeParsedOrigin(urlText) {
-    const url = new URL(urlText);
-    return url.origin;
-}
-function startServerProcess(input) {
-    return new Promise((resolvePromise, reject) => {
-        const child = spawn(input.command, input.args, {
-            cwd: input.cwd,
-            env: {
-                ...process.env,
-                ...input.env,
-            },
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        const timeout = setTimeout(() => {
-            child.kill();
-            reject(new Error(`Timed out after ${input.timeoutMs ?? DEFAULT_SERVER_READY_TIMEOUT_MS}ms waiting for Ash to print its server URL.`));
-        }, input.timeoutMs ?? DEFAULT_SERVER_READY_TIMEOUT_MS);
-        const cleanup = () => {
-            clearTimeout(timeout);
-            child.off("error", handleError);
-            child.off("exit", handleEarlyExit);
-        };
-        const handleError = (error) => {
-            cleanup();
-            reject(error);
-        };
-        const handleEarlyExit = (code, signal) => {
-            cleanup();
-            reject(new Error(`Ash server process exited before printing its server URL (code ${String(code)}, signal ${String(signal)}).`));
-        };
-        const handleOutput = (chunk) => {
-            const match = LOCAL_SERVER_URL_PATTERN.exec(chunk.toString("utf8"));
-            if (match === null) {
-                return;
-            }
-            cleanup();
-            resolvePromise({
-                origin: normalizeParsedOrigin(match[0]),
-                process: child,
-            });
-        };
-        const handleStdout = (chunk) => {
-            process.stdout.write(chunk);
-            handleOutput(chunk);
-        };
-        const handleStderr = (chunk) => {
-            process.stderr.write(chunk);
-            handleOutput(chunk);
-        };
-        child.once("error", handleError);
-        child.once("exit", handleEarlyExit);
-        child.stdout.on("data", handleStdout);
-        child.stderr.on("data", handleStderr);
-    });
-}
-function installProcessShutdown(handle) {
-    const childProcess = handle.process;
-    if (childProcess === undefined) {
-        return handle;
-    }
-    const close = () => {
-        if (!childProcess.killed) {
-            childProcess.kill();
-        }
-    };
-    process.once("beforeExit", close);
-    process.once("exit", close);
-    return handle;
-}
-function startAshDevServer(appRoot) {
-    return startServerProcess({
-        args: [createAshBinaryPath(), "dev", "--no-repl", "--port", "0"],
-        command: process.execPath,
-        cwd: appRoot,
-    }).then((handle) => {
-        process.env[ASH_BASE_URL_ENV] = handle.origin;
-        return installProcessShutdown(handle);
-    });
-}
-function startAshProductionServer(input) {
-    const parsedOrigin = new URL(input.origin);
-    const port = parsedOrigin.port;
-    const serverEntry = join(input.appRoot, ".output", "server", "index.mjs");
-    if (!existsSync(serverEntry)) {
-        return undefined;
-    }
-    return startServerProcess({
-        args: [serverEntry],
-        command: process.execPath,
-        cwd: input.appRoot,
-        env: {
-            HOST: parsedOrigin.hostname,
-            NITRO_HOST: parsedOrigin.hostname,
-            NITRO_PORT: port,
-            PORT: port,
-        },
-    }).then(installProcessShutdown);
-}
-async function resolveSharedAshDevServer(appRoot) {
-    const registeredOrigin = await readUsableAshDevServerRegistry(appRoot);
-    if (registeredOrigin !== undefined) {
-        return {
-            origin: registeredOrigin,
-        };
-    }
-    const releaseLock = await acquireAshDevServerLock(appRoot);
-    try {
-        const lockedRegisteredOrigin = await readUsableAshDevServerRegistry(appRoot);
-        if (lockedRegisteredOrigin !== undefined) {
-            return {
-                origin: lockedRegisteredOrigin,
-            };
-        }
-        const handle = await startAshDevServer(appRoot);
-        await writeAshDevServerRegistry(appRoot, handle);
-        return handle;
-    }
-    finally {
-        await releaseLock();
-    }
-}
-export async function resolveAshDestinationPrefix(input) {
-    const state = getGlobalState();
-    if (process.env.NODE_ENV === "production") {
-        if (input.phase === NEXT_PHASE_PRODUCTION_BUILD) {
-            return input.productionDestinationPrefix;
-        }
-        const key = `production:${input.appRoot}`;
-        let productionServer = state.servers.get(key);
-        if (productionServer === undefined) {
-            productionServer =
-                process.env.VERCEL || input.productionServerOrigin === undefined
-                    ? undefined
-                    : startAshProductionServer({
-                        appRoot: input.appRoot,
-                        origin: input.productionServerOrigin,
-                    });
-            if (productionServer !== undefined) {
-                productionServer = productionServer.catch((error) => {
-                    state.servers.delete(key);
-                    throw error;
-                });
-                state.servers.set(key, productionServer);
-            }
-        }
-        if (productionServer !== undefined) {
-            return (await productionServer).origin;
-        }
-        return input.productionDestinationPrefix;
-    }
-    const configuredAshBaseUrl = readAshBaseUrlEnvironment();
-    if (configuredAshBaseUrl !== undefined) {
-        return configuredAshBaseUrl;
-    }
-    if (process.env.NODE_ENV !== "development") {
-        return input.productionDestinationPrefix;
-    }
-    const key = `dev:${input.appRoot}`;
-    let server = state.servers.get(key);
-    if (server === undefined) {
-        server = resolveSharedAshDevServer(input.appRoot).catch((error) => {
-            state.servers.delete(key);
-            throw error;
-        });
-        state.servers.set(key, server);
-    }
-    return (await server).origin;
-}
+import{ASH_ROUTE_PREFIX}from"#protocol/routes.js";import{join}from"node:path";import{mkdir,open,readFile,rm,stat,writeFile}from"node:fs/promises";import{existsSync}from"node:fs";import{resolvePackageRoot}from"#internal/application/package.js";import{spawn}from"node:child_process";var ASH_BASE_URL_ENV=`ASH_BASE_URL`,DEFAULT_SERVER_READY_TIMEOUT_MS=3e4,DEV_SERVER_REGISTRY_TIMEOUT_MS=3e4,DEV_SERVER_REGISTRY_POLL_MS=100,DEV_SERVER_STALE_LOCK_MS=3e4,ASH_CACHE_DIRECTORY_NAME=`.ash`,ASH_NEXT_DEV_SERVER_FILE_NAME=`next-dev-server.json`,ASH_NEXT_DEV_SERVER_LOCK_FILE_NAME=`next-dev-server.lock`,LOCAL_SERVER_URL_PATTERN=/https?:\/\/(?:\[[^\]\s]+\]|[^\s/:[\]]+)(?::\d+)?/,NEXT_PHASE_PRODUCTION_BUILD=`phase-production-build`,globalStateSymbol=Symbol.for(`experimental-ash.next.state`);function getGlobalState(){let e=globalThis;return e[globalStateSymbol]??={servers:new Map},e[globalStateSymbol]}function joinRoutePrefix(e,t){return`${e.replace(/\/+$/,``)}/${t.replace(/^\/+/,``)}`}function normalizeOrigin(e){return new URL(e).origin}function readAshBaseUrlEnvironment(){let e=process.env[ASH_BASE_URL_ENV];if(!(e===void 0||e.trim().length===0))return normalizeOrigin(e)}function isNodeErrorWithCode(e,t){return e instanceof Error&&`code`in e&&e.code===t}function delay(e){return new Promise(t=>setTimeout(t,e))}function isRecord(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function resolveAshCacheDirectory(e){return join(e,ASH_CACHE_DIRECTORY_NAME)}function resolveAshDevServerRegistryPath(e){return join(resolveAshCacheDirectory(e),ASH_NEXT_DEV_SERVER_FILE_NAME)}function resolveAshDevServerLockPath(e){return join(resolveAshCacheDirectory(e),ASH_NEXT_DEV_SERVER_LOCK_FILE_NAME)}function normalizeDevServerRegistry(e){if(isRecord(e)&&!(typeof e.appRoot!=`string`||typeof e.origin!=`string`||typeof e.updatedAt!=`string`)&&!(e.pid!==null&&typeof e.pid!=`number`))try{return{appRoot:e.appRoot,origin:normalizeOrigin(e.origin),pid:e.pid,updatedAt:e.updatedAt}}catch{return}}async function isAshServerHealthy(t){let n=new AbortController,r=setTimeout(()=>{n.abort()},1e3);try{return(await fetch(joinRoutePrefix(t,`${ASH_ROUTE_PREFIX}/health`),{signal:n.signal})).ok}catch{return!1}finally{clearTimeout(r)}}async function readUsableAshDevServerRegistry(e){try{let t=normalizeDevServerRegistry(JSON.parse(await readFile(resolveAshDevServerRegistryPath(e),`utf8`)));return t===void 0||t.appRoot!==e||!await isAshServerHealthy(t.origin)?void 0:(process.env[ASH_BASE_URL_ENV]=t.origin,t.origin)}catch(e){if(isNodeErrorWithCode(e,`ENOENT`))return;throw e}}async function writeAshDevServerRegistry(e,t){await mkdir(resolveAshCacheDirectory(e),{recursive:!0}),await writeFile(resolveAshDevServerRegistryPath(e),`${JSON.stringify({appRoot:e,origin:t.origin,pid:t.process?.pid??null,updatedAt:new Date().toISOString()},null,2)}\n`)}async function removeStaleAshDevServerLock(e){try{let t=await stat(e);Date.now()-t.mtimeMs>DEV_SERVER_STALE_LOCK_MS&&await rm(e,{force:!0})}catch(e){if(!isNodeErrorWithCode(e,`ENOENT`))throw e}}async function acquireAshDevServerLock(e){let t=resolveAshCacheDirectory(e),i=resolveAshDevServerLockPath(e),a=Date.now()+DEV_SERVER_REGISTRY_TIMEOUT_MS;for(await mkdir(t,{recursive:!0});;)try{let e=await open(i,`wx`);return await e.writeFile(`${String(process.pid)}\n`),await e.close(),async()=>{await rm(i,{force:!0})}}catch(t){if(!isNodeErrorWithCode(t,`EEXIST`))throw t;if(await readUsableAshDevServerRegistry(e)!==void 0)return async()=>{};if(await removeStaleAshDevServerLock(i),Date.now()>a)throw Error(`Timed out after ${DEV_SERVER_REGISTRY_TIMEOUT_MS}ms waiting for another Next.js process to start Ash.`);await delay(DEV_SERVER_REGISTRY_POLL_MS)}}function createAshBinaryPath(){return join(resolvePackageRoot(),`bin`,`ash.js`)}function normalizeParsedOrigin(e){return new URL(e).origin}function startServerProcess(e){return new Promise((t,n)=>{let r=spawn(e.command,e.args,{cwd:e.cwd,env:{...process.env,...e.env},stdio:[`ignore`,`pipe`,`pipe`]}),i=setTimeout(()=>{r.kill(),n(Error(`Timed out after ${e.timeoutMs??DEFAULT_SERVER_READY_TIMEOUT_MS}ms waiting for Ash to print its server URL.`))},e.timeoutMs??DEFAULT_SERVER_READY_TIMEOUT_MS),cleanup=()=>{clearTimeout(i),r.off(`error`,handleError),r.off(`exit`,handleEarlyExit)},handleError=e=>{cleanup(),n(e)},handleEarlyExit=(e,t)=>{cleanup(),n(Error(`Ash server process exited before printing its server URL (code ${String(e)}, signal ${String(t)}).`))},handleOutput=e=>{let n=LOCAL_SERVER_URL_PATTERN.exec(e.toString(`utf8`));n!==null&&(cleanup(),t({origin:normalizeParsedOrigin(n[0]),process:r}))};r.once(`error`,handleError),r.once(`exit`,handleEarlyExit),r.stdout.on(`data`,e=>{process.stdout.write(e),handleOutput(e)}),r.stderr.on(`data`,e=>{process.stderr.write(e),handleOutput(e)})})}function installProcessShutdown(e){let t=e.process;if(t===void 0)return e;let close=()=>{t.killed||t.kill()};return process.once(`beforeExit`,close),process.once(`exit`,close),e}function startAshDevServer(e){return startServerProcess({args:[createAshBinaryPath(),`dev`,`--no-repl`,`--port`,`0`],command:process.execPath,cwd:e}).then(e=>(process.env[ASH_BASE_URL_ENV]=e.origin,installProcessShutdown(e)))}function startAshProductionServer(e){let n=new URL(e.origin),r=n.port,i=join(e.appRoot,`.output`,`server`,`index.mjs`);if(existsSync(i))return startServerProcess({args:[i],command:process.execPath,cwd:e.appRoot,env:{HOST:n.hostname,NITRO_HOST:n.hostname,NITRO_PORT:r,PORT:r}}).then(installProcessShutdown)}async function resolveSharedAshDevServer(e){let t=await readUsableAshDevServerRegistry(e);if(t!==void 0)return{origin:t};let n=await acquireAshDevServerLock(e);try{let t=await readUsableAshDevServerRegistry(e);if(t!==void 0)return{origin:t};let n=await startAshDevServer(e);return await writeAshDevServerRegistry(e,n),n}finally{await n()}}async function resolveAshDestinationPrefix(e){let t=getGlobalState();if(process.env.NODE_ENV===`production`){if(e.phase===NEXT_PHASE_PRODUCTION_BUILD)return e.productionDestinationPrefix;let n=`production:${e.appRoot}`,r=t.servers.get(n);return r===void 0&&(r=process.env.VERCEL||e.productionServerOrigin===void 0?void 0:startAshProductionServer({appRoot:e.appRoot,origin:e.productionServerOrigin}),r!==void 0&&(r=r.catch(e=>{throw t.servers.delete(n),e}),t.servers.set(n,r))),r===void 0?e.productionDestinationPrefix:(await r).origin}let n=readAshBaseUrlEnvironment();if(n!==void 0)return n;if(process.env.NODE_ENV!==`development`)return e.productionDestinationPrefix;let r=`dev:${e.appRoot}`,i=t.servers.get(r);return i===void 0&&(i=resolveSharedAshDevServer(e.appRoot).catch(e=>{throw t.servers.delete(r),e}),t.servers.set(r,i)),(await i).origin}export{resolveAshDestinationPrefix};

package/dist/src/public/next/vercel-json.js

@@ -1,77 +1 @@
-import { readFile, writeFile } from "node:fs/promises";
-import { join, relative } from "node:path";
-const VERCEL_JSON_FILE_NAME = "vercel.json";
-const VERCEL_JSON_SCHEMA = "https://openapi.vercel.sh/vercel.json";
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function resolveRelativeEntrypoint(fromRoot, toRoot) {
-    const relativePath = relative(fromRoot, toRoot);
-    if (relativePath.length === 0) {
-        return ".";
-    }
-    return relativePath.replaceAll("\\", "/");
-}
-function normalizeVercelJsonConfig(value) {
-    if (!isRecord(value)) {
-        throw new Error(`${VERCEL_JSON_FILE_NAME} must contain a JSON object.`);
-    }
-    const experimentalServices = value.experimentalServices;
-    if (experimentalServices !== undefined && !isRecord(experimentalServices)) {
-        throw new Error(`${VERCEL_JSON_FILE_NAME} experimentalServices must be a JSON object.`);
-    }
-    return value;
-}
-async function readVercelJsonConfig(path) {
-    try {
-        return normalizeVercelJsonConfig(JSON.parse(await readFile(path, "utf8")));
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-            return {};
-        }
-        throw error;
-    }
-}
-function findServiceByFramework(services, framework) {
-    return Object.values(services).find((service) => service.framework === framework);
-}
-export async function ensureAshVercelJson(input) {
-    const vercelJsonPath = join(input.nextRoot, VERCEL_JSON_FILE_NAME);
-    const existingConfig = await readVercelJsonConfig(vercelJsonPath);
-    const nextEntrypoint = ".";
-    const ashEntrypoint = resolveRelativeEntrypoint(input.nextRoot, input.appRoot);
-    const existingServices = existingConfig.experimentalServices ?? {};
-    const configuredAshService = findServiceByFramework(existingServices, "ash");
-    const configuredNextService = findServiceByFramework(existingServices, "nextjs");
-    const servicePrefix = configuredAshService?.routePrefix ?? input.servicePrefix;
-    const experimentalServices = {
-        ...existingServices,
-    };
-    if (configuredNextService === undefined) {
-        experimentalServices.web = {
-            entrypoint: nextEntrypoint,
-            framework: "nextjs",
-            routePrefix: "/",
-        };
-    }
-    if (configuredAshService === undefined) {
-        experimentalServices.ash = {
-            buildCommand: input.ashBuildCommand,
-            entrypoint: ashEntrypoint,
-            framework: "ash",
-            routePrefix: servicePrefix,
-        };
-    }
-    const vercelConfig = {
-        ...existingConfig,
-        $schema: existingConfig.$schema ?? VERCEL_JSON_SCHEMA,
-        experimentalServices,
-    };
-    if (JSON.stringify(existingConfig) !== JSON.stringify(vercelConfig)) {
-        await writeFile(vercelJsonPath, `${JSON.stringify(vercelConfig, null, 2)}\n`);
-    }
-    return {
-        servicePrefix,
-    };
-}
+import{join,relative}from"node:path";import{readFile,writeFile}from"node:fs/promises";var VERCEL_JSON_FILE_NAME=`vercel.json`,VERCEL_JSON_SCHEMA=`https://openapi.vercel.sh/vercel.json`;function isRecord(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function resolveRelativeEntrypoint(e,n){let r=relative(e,n);return r.length===0?`.`:r.replaceAll(`\\`,`/`)}function normalizeVercelJsonConfig(e){if(!isRecord(e))throw Error(`${VERCEL_JSON_FILE_NAME} must contain a JSON object.`);let t=e.experimentalServices;if(t!==void 0&&!isRecord(t))throw Error(`${VERCEL_JSON_FILE_NAME} experimentalServices must be a JSON object.`);return e}async function readVercelJsonConfig(e){try{return normalizeVercelJsonConfig(JSON.parse(await readFile(e,`utf8`)))}catch(e){if(e instanceof Error&&`code`in e&&e.code===`ENOENT`)return{};throw e}}function findServiceByFramework(e,t){return Object.values(e).find(e=>e.framework===t)}async function ensureAshVercelJson(t){let n=join(t.nextRoot,VERCEL_JSON_FILE_NAME),i=await readVercelJsonConfig(n),a=resolveRelativeEntrypoint(t.nextRoot,t.appRoot),o=i.experimentalServices??{},s=findServiceByFramework(o,`ash`),c=findServiceByFramework(o,`nextjs`),l=s?.routePrefix??t.servicePrefix,u={...o};c===void 0&&(u.web={entrypoint:`.`,framework:`nextjs`,routePrefix:`/`}),s===void 0&&(u.ash={buildCommand:t.ashBuildCommand,entrypoint:a,framework:`ash`,routePrefix:l});let d={...i,$schema:i.$schema??VERCEL_JSON_SCHEMA,experimentalServices:u};return JSON.stringify(i)!==JSON.stringify(d)&&await writeFile(n,`${JSON.stringify(d,null,2)}\n`),{servicePrefix:l}}export{ensureAshVercelJson};

package/dist/src/public/sandbox/backends/default.js

@@ -1,15 +1 @@
-import { lazyBackend } from "#execution/sandbox/lazy-backend.js";
-import { localBackend } from "#public/sandbox/backends/local.js";
-import { vercelBackend } from "#public/sandbox/backends/vercel.js";
-/**
- * Constructs an env-aware sandbox backend that delegates to
- * {@link vercelBackend} on hosted Vercel (where `process.env.VERCEL`
- * is truthy) and to {@link localBackend} everywhere else.
- *
- * Optionally accepts a keyed options bag (`{ local, vercel }`) so each
- * inner backend receives its own typed create options without forcing
- * authors to pin to one backend up front.
- */
-export function defaultBackend(opts) {
-    return lazyBackend(() => process.env.VERCEL ? vercelBackend(opts?.vercel) : localBackend(opts?.local));
-}
+import{lazyBackend}from"#execution/sandbox/lazy-backend.js";import{localBackend}from"#public/sandbox/backends/local.js";import{vercelBackend}from"#public/sandbox/backends/vercel.js";function defaultBackend(e){return lazyBackend(()=>process.env.VERCEL?vercelBackend(e?.vercel):localBackend(e?.local))}export{defaultBackend};

package/dist/src/public/sandbox/backends/local.js

@@ -1,18 +1 @@
-import { createLocalSandboxBackend } from "#execution/sandbox/bindings/local.js";
-/**
- * Constructs the built-in local sandbox backend.
- *
- * The local backend runs the workspace under `just-bash` against an
- * in-memory filesystem and persists snapshots into `.ash/sandbox-cache/`
- * under the application root. It is the default backend on developer
- * machines (`pnpm ash dev`).
- *
- * Accepts an `opts` parameter for parity with other backends, but
- * `LocalSandboxCreateOptions` is empty today — `just-bash` does not
- * currently expose any configuration worth surfacing. New options would
- * be added by widening `LocalSandboxCreateOptions` and routing them
- * into the binding without changing this signature.
- */
-export function localBackend(opts) {
-    return createLocalSandboxBackend({ createOptions: opts });
-}
+import{createLocalSandboxBackend}from"#execution/sandbox/bindings/local.js";function localBackend(e){return createLocalSandboxBackend({createOptions:e})}export{localBackend};

package/dist/src/public/sandbox/backends/vercel.js

@@ -1,25 +1 @@
-import { createVercelSandboxBackend } from "#execution/sandbox/bindings/vercel.js";
-/**
- * Constructs the built-in Vercel sandbox backend.
- *
- * The optional `opts` parameter is forwarded to the Vercel SDK's
- * `Sandbox.create(...)` for every fresh sandbox the framework creates
- * (template at prewarm, session at first-time create). On resume
- * (`Sandbox.get`), no create happens, so opts are not re-applied.
- *
- * `opts.source`, if supplied, is used only on the template create —
- * the author's snapshot, git revision, or tarball becomes the base
- * layer of the template. Bootstrap, seed files, and framework setup
- * still run on top, and every session derives from the resulting
- * Ash-owned snapshot. `source` is stripped from session creates so the
- * framework's snapshot always wins.
- *
- * `bootstrap({ use })` applies its options to the template via
- * `sandbox.update(...)`; those settings persist into the snapshot.
- * `onSession({ use })` applies its options to the live session via the
- * SDK's `update` under the hood — overriding any overlapping field
- * from `opts`.
- */
-export function vercelBackend(opts) {
-    return createVercelSandboxBackend({ createOptions: opts });
-}
+import{createVercelSandboxBackend}from"#execution/sandbox/bindings/vercel.js";function vercelBackend(e){return createVercelSandboxBackend({createOptions:e})}export{vercelBackend};

package/dist/src/public/sandbox/index.js

@@ -1,10 +1 @@
-/**
- * Sandbox authoring helpers for `agent/sandbox.ts` (or
- * `agent/sandbox/sandbox.ts` when paired with a `workspace/` folder).
- */
-export { getSandbox } from "#context/accessors.js";
-export { defineSandbox, } from "#public/definitions/sandbox.js";
-export { SandboxTemplateNotProvisionedError } from "#public/definitions/sandbox-backend.js";
-export { defaultBackend } from "#public/sandbox/backends/default.js";
-export { localBackend } from "#public/sandbox/backends/local.js";
-export { vercelBackend } from "#public/sandbox/backends/vercel.js";
+import{SandboxTemplateNotProvisionedError}from"#public/definitions/sandbox-backend.js";import{getSandbox}from"#context/accessors.js";import{localBackend}from"#public/sandbox/backends/local.js";import{vercelBackend}from"#public/sandbox/backends/vercel.js";import{defineSandbox}from"#public/definitions/sandbox.js";import{defaultBackend}from"#public/sandbox/backends/default.js";export{SandboxTemplateNotProvisionedError,defaultBackend,defineSandbox,getSandbox,localBackend,vercelBackend};

package/dist/src/public/sandbox/local-sandbox.js

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