experimental-ash 0.26.0 → 0.28.0

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{};

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

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

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

@@ -1,4 +1 @@
-/**
- * Schedule authoring helpers for `agent/schedules/*` files.
- */
-export { defineSchedule, } from "#public/definitions/schedule.js";
+import{defineSchedule}from"#public/definitions/schedule.js";export{defineSchedule};

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

@@ -1,5 +1 @@
-/**
- * Skill authoring helpers and runtime accessors.
- */
-export { getSkill } from "#context/accessors.js";
-export { defineSkill, } from "#public/definitions/skill.js";
+import{defineSkill}from"#public/definitions/skill.js";import{getSkill}from"#context/accessors.js";export{defineSkill,getSkill};

package/dist/src/public/tool-result-narrowing.js

@@ -1,87 +1 @@
-/**
- * Cross-instance symbol for reading the stable definition key stamped
- * by `defineTool` / `defineMcpClientConnection`. `Symbol.for` ensures
- * both the resolution pipeline's module copy and the user's import
- * share the same property key.
- */
-const DEFINITION_KEY = Symbol.for("experimental-ash.definition-source-key");
-/**
- * Global registry mapping definition keys to their resolved runtime
- * names. Rooted on `globalThis` via `Symbol.for` so every module
- * copy shares one registry — same pattern as `context/key.ts`
- * (`KEY_REGISTRY_GLOBAL_KEY`).
- */
-const REGISTRY_SYMBOL = Symbol.for("experimental-ash.definition-source-registry");
-const registryContainer = globalThis;
-if (registryContainer[REGISTRY_SYMBOL] === undefined) {
-    registryContainer[REGISTRY_SYMBOL] = new Map();
-}
-const definitionSourceRegistry = registryContainer[REGISTRY_SYMBOL];
-/**
- * Stamps a stable content-derived key on the definition so it can be
- * identified across module instances. Called by `defineTool` and
- * `defineMcpClientConnection` at definition time.
- */
-export function stampDefinitionKey(definition, key) {
-    Object.defineProperty(definition, DEFINITION_KEY, { value: key });
-}
-/**
- * Reads the stable key from a definition, or `undefined` if unstamped.
- */
-function readDefinitionKey(definition) {
-    if (DEFINITION_KEY in definition) {
-        return definition[DEFINITION_KEY];
-    }
-    return undefined;
-}
-/**
- * Registers a definition key → source entry mapping in the global
- * registry. Called by the resolution pipeline after loading the
- * authored module.
- */
-export function registerDefinitionSource(key, entry) {
-    definitionSourceRegistry.set(key, entry);
-}
-const CONNECTION_TOOL_SEPARATOR = "__";
-/**
- * Narrows a {@link RuntimeActionResult} to a typed tool or connection
- * result by matching against an authored definition object.
- *
- * Pass a `ToolDefinition` to get a typed `output`; pass a
- * `McpClientConnectionDefinition` to match any tool from that
- * connection (`output` stays `unknown`).
- *
- * Returns `undefined` when the result doesn't match, or when
- * `isError` is `true`.
- */
-export const toolResultFrom = toolResultFromImpl;
-function toolResultFromImpl(result, source) {
-    if (result.kind !== "tool-result")
-        return undefined;
-    if (result.isError === true)
-        return undefined;
-    const key = readDefinitionKey(source);
-    if (key === undefined)
-        return undefined;
-    const entry = definitionSourceRegistry.get(key);
-    if (entry === undefined)
-        return undefined;
-    if (entry.kind === "tool") {
-        if (result.toolName !== entry.name)
-            return undefined;
-        return {
-            callId: result.callId,
-            output: result.output,
-            toolName: result.toolName,
-        };
-    }
-    const prefix = entry.name + CONNECTION_TOOL_SEPARATOR;
-    if (!result.toolName.startsWith(prefix))
-        return undefined;
-    return {
-        callId: result.callId,
-        connectionToolName: result.toolName.slice(prefix.length),
-        output: result.output,
-        toolName: result.toolName,
-    };
-}
+var DEFINITION_KEY=Symbol.for(`experimental-ash.definition-source-key`),REGISTRY_SYMBOL=Symbol.for(`experimental-ash.definition-source-registry`),registryContainer=globalThis;registryContainer[REGISTRY_SYMBOL]===void 0&&(registryContainer[REGISTRY_SYMBOL]=new Map);var definitionSourceRegistry=registryContainer[REGISTRY_SYMBOL];function stampDefinitionKey(t,n){Object.defineProperty(t,DEFINITION_KEY,{value:n})}function readDefinitionKey(t){if(DEFINITION_KEY in t)return t[DEFINITION_KEY]}function registerDefinitionSource(e,t){definitionSourceRegistry.set(e,t)}var CONNECTION_TOOL_SEPARATOR=`__`,toolResultFrom=toolResultFromImpl;function toolResultFromImpl(e,t){if(e.kind!==`tool-result`||e.isError===!0)return;let n=readDefinitionKey(t);if(n===void 0)return;let r=definitionSourceRegistry.get(n);if(r===void 0)return;if(r.kind===`tool`)return e.toolName===r.name?{callId:e.callId,output:e.output,toolName:e.toolName}:void 0;let i=r.name+CONNECTION_TOOL_SEPARATOR;if(e.toolName.startsWith(i))return{callId:e.callId,connectionToolName:e.toolName.slice(i.length),output:e.output,toolName:e.toolName}}export{registerDefinitionSource,stampDefinitionKey,toolResultFrom};

package/dist/src/public/tools/approval/approval-helpers.js

@@ -1,22 +1 @@
-/**
- * Returns a `needsApproval` callback that always requires user approval before
- * the tool executes.
- */
-export function always() {
-    return () => true;
-}
-/**
- * Returns a `needsApproval` callback that never requires user approval before
- * the tool executes.
- */
-export function never() {
-    return () => false;
-}
-/**
- * Returns a `needsApproval` callback that requires approval only the first
- * time the tool is used in a session. Subsequent calls within the same session
- * are allowed automatically.
- */
-export function once() {
-    return ({ approvedTools, toolName }) => !approvedTools.has(toolName);
-}
+function always(){return()=>!0}function never(){return()=>!1}function once(){return({approvedTools:e,toolName:t})=>!e.has(t)}export{always,never,once};

package/dist/src/public/tools/approval/index.js

@@ -1,4 +1 @@
-/**
- * Per-tool approval helpers used inside `agent/tools/*.ts` files.
- */
-export { always, never, once } from "#public/tools/approval/approval-helpers.js";
+import{always,never,once}from"#public/tools/approval/approval-helpers.js";export{always,never,once};