experimental-ash 0.24.0 → 0.24.2

package/dist/src/internal/authored-package-tsconfig-paths.js

@@ -0,0 +1,209 @@
+import { readFile, stat } from "node:fs/promises";
+import { dirname, join, resolve, sep } from "node:path";
+import { parse as parseJsonc } from "#compiled/jsonc-parser/index.js";
+const packageTsConfigPathsCache = new Map();
+const nearestPackageRootCache = new Map();
+/**
+ * Resolves tsconfig `paths` for authored source imported from linked
+ * workspace packages. Rolldown handles the root app tsconfig; this only
+ * fills the package-local config gap for sources outside the app root.
+ */
+export function createAuthoredPackageTsConfigPathsPlugin(input) {
+    return {
+        name: "ash-package-tsconfig-paths",
+        async resolveId(source, importer, options) {
+            if (importer === undefined || !isPackageImport(source)) {
+                return undefined;
+            }
+            const importerPath = resolve(importer);
+            if (isPathInsideOrEqual(importerPath, input.appPackageRoot)) {
+                return undefined;
+            }
+            const packageRoot = await resolveNearestPackageRoot(importerPath);
+            if (packageRoot === undefined || isPathInsideOrEqual(packageRoot, input.appPackageRoot)) {
+                return undefined;
+            }
+            const config = await loadPackageTsConfigPaths(packageRoot);
+            if (config === undefined) {
+                return undefined;
+            }
+            for (const candidate of createTsConfigPathCandidates(source, config)) {
+                const resolved = await this.resolve(candidate, importer, {
+                    kind: options.kind,
+                    skipSelf: true,
+                });
+                if (resolved !== null) {
+                    return resolved;
+                }
+                const existingPath = await resolveExistingPath(candidate, input.extensions);
+                if (existingPath !== undefined) {
+                    return { id: existingPath };
+                }
+            }
+            return undefined;
+        },
+    };
+}
+function loadPackageTsConfigPaths(packageRoot) {
+    const cached = packageTsConfigPathsCache.get(packageRoot);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const promise = readPackageTsConfigPaths(packageRoot);
+    packageTsConfigPathsCache.set(packageRoot, promise);
+    return promise;
+}
+async function readPackageTsConfigPaths(packageRoot) {
+    const configFile = await readPackageConfig(packageRoot);
+    if (configFile === undefined) {
+        return undefined;
+    }
+    const errors = [];
+    const parsed = parseJsonc(configFile.source, errors, {
+        allowTrailingComma: true,
+    });
+    if (errors.length > 0 || !isObjectRecord(parsed)) {
+        return undefined;
+    }
+    const compilerOptions = parsed.compilerOptions;
+    if (!isObjectRecord(compilerOptions) || !isObjectRecord(compilerOptions.paths)) {
+        return undefined;
+    }
+    const configDirectory = dirname(configFile.path);
+    const baseDirectory = typeof compilerOptions.baseUrl === "string"
+        ? resolve(configDirectory, compilerOptions.baseUrl)
+        : configDirectory;
+    const entries = Object.entries(compilerOptions.paths)
+        .flatMap(([pattern, targets]) => {
+        if (!Array.isArray(targets) || !targets.every((target) => typeof target === "string")) {
+            return [];
+        }
+        return [{ pattern, targets }];
+    })
+        .sort((left, right) => right.pattern.length - left.pattern.length);
+    if (entries.length === 0) {
+        return undefined;
+    }
+    return { baseDirectory, entries };
+}
+async function readPackageConfig(packageRoot) {
+    for (const fileName of ["tsconfig.json", "jsconfig.json"]) {
+        const configPath = join(packageRoot, fileName);
+        try {
+            return {
+                path: configPath,
+                source: await readFile(configPath, "utf8"),
+            };
+        }
+        catch (error) {
+            if (!isPathNotFoundError(error)) {
+                throw error;
+            }
+        }
+    }
+    return undefined;
+}
+function createTsConfigPathCandidates(source, config) {
+    const candidates = [];
+    for (const entry of config.entries) {
+        const match = matchTsConfigPathPattern(source, entry.pattern);
+        if (match === undefined) {
+            continue;
+        }
+        for (const target of entry.targets) {
+            const targetPath = target.includes("*") ? target.replaceAll("*", match) : target;
+            candidates.push(resolve(config.baseDirectory, targetPath));
+        }
+    }
+    return candidates;
+}
+function matchTsConfigPathPattern(source, pattern) {
+    const wildcardIndex = pattern.indexOf("*");
+    if (wildcardIndex === -1) {
+        return source === pattern ? "" : undefined;
+    }
+    const prefix = pattern.slice(0, wildcardIndex);
+    const suffix = pattern.slice(wildcardIndex + 1);
+    if (!source.startsWith(prefix) || !source.endsWith(suffix)) {
+        return undefined;
+    }
+    return source.slice(prefix.length, source.length - suffix.length);
+}
+async function resolveExistingPath(path, extensions) {
+    if (await existsAsFile(path)) {
+        return path;
+    }
+    for (const extension of extensions) {
+        const candidate = `${path}${extension}`;
+        if (await existsAsFile(candidate)) {
+            return candidate;
+        }
+    }
+    for (const extension of extensions) {
+        const candidate = join(path, `index${extension}`);
+        if (await existsAsFile(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+async function existsAsFile(path) {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function resolveNearestPackageRoot(path) {
+    const startDirectory = dirname(path);
+    const cached = nearestPackageRootCache.get(startDirectory);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const promise = findNearestPackageRoot(startDirectory);
+    nearestPackageRootCache.set(startDirectory, promise);
+    return promise;
+}
+async function findNearestPackageRoot(startDirectory) {
+    let currentDirectory = startDirectory;
+    while (true) {
+        if (await pathExists(join(currentDirectory, "package.json"))) {
+            return currentDirectory;
+        }
+        const parentDirectory = dirname(currentDirectory);
+        if (parentDirectory === currentDirectory) {
+            return undefined;
+        }
+        currentDirectory = parentDirectory;
+    }
+}
+async function pathExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isPathNotFoundError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        (error.code === "ENOENT" || error.code === "ENOTDIR"));
+}
+function isPackageImport(source) {
+    if (source.startsWith(".") || source.startsWith("/") || /^[A-Za-z]:[\\/]/.test(source)) {
+        return false;
+    }
+    return !/^(?:node|data|file):/.test(source);
+}
+function isObjectRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPathInsideOrEqual(path, directory) {
+    const resolvedPath = resolve(path);
+    const resolvedDirectory = resolve(directory);
+    return (resolvedPath === resolvedDirectory || resolvedPath.startsWith(`${resolvedDirectory}${sep}`));
+}

package/dist/src/internal/nitro/host/channel-routes.d.ts

@@ -2,6 +2,12 @@ import type { Nitro } from "nitro/types";
 import type { ChannelMethod } from "#public/definitions/channel.js";
 import type { NitroArtifactsConfigInput } from "#internal/nitro/host/artifacts-config.js";
 import type { PreparedApplicationHost } from "#internal/nitro/host/types.js";
+interface ChannelRouteNitro {
+    options: Pick<Nitro["options"], "handlers" | "virtual">;
+    routing: {
+        sync(): void;
+    };
+}
 /**
  * One Nitro route registration for an Ash channel.
  */
@@ -16,7 +22,7 @@ export declare function computeChannelRouteRegistrations(preparedHost: PreparedA
 /**
  * Registers virtual Nitro handlers for the provided Ash channel routes.
  */
-export declare function registerChannelVirtualHandlers(nitro: Nitro, input: {
+export declare function registerChannelVirtualHandlers(nitro: Pick<ChannelRouteNitro, "options">, input: {
     readonly artifactsConfig: NitroArtifactsConfigInput;
     readonly registrations: readonly NitroChannelRouteRegistration[];
 }): void;
@@ -24,8 +30,9 @@ export declare function registerChannelVirtualHandlers(nitro: Nitro, input: {
  * Replaces the currently-mounted Ash channel virtual handlers when the route
  * set changes.
  */
-export declare function syncChannelVirtualHandlers(nitro: Nitro, input: {
+export declare function syncChannelVirtualHandlers(nitro: ChannelRouteNitro, input: {
     readonly artifactsConfig: NitroArtifactsConfigInput;
     readonly next: readonly NitroChannelRouteRegistration[];
     readonly previous: readonly NitroChannelRouteRegistration[];
 }): boolean;
+export {};

package/dist/src/internal/nitro/host/dev-authored-source-watcher.d.ts

@@ -1,5 +1,15 @@
 import type { Nitro } from "nitro/types";
 import type { PreparedApplicationHost } from "#internal/nitro/host/types.js";
+type DevelopmentWatcherNitroOptions = Pick<Nitro["options"], "experimental" | "handlers" | "scheduledTasks" | "tasks" | "virtual"> & Partial<Pick<Nitro["options"], "dev" | "preset">>;
+interface DevelopmentWatcherNitro {
+    hooks: {
+        callHook: Nitro["hooks"]["callHook"];
+    };
+    options: DevelopmentWatcherNitroOptions;
+    routing: {
+        sync(): void;
+    };
+}
 /**
  * Handle for the authored-source development watcher.
  */
@@ -13,7 +23,8 @@ export interface AuthoredSourceWatcherHandle {
  * triggers Nitro rebuild reloads only when structural runtime wiring changes.
  */
 export declare function startAuthoredSourceWatcher(input: {
-    nitro: Nitro;
+    nitro: DevelopmentWatcherNitro;
     preparedHost: PreparedApplicationHost;
     schedulesEnabled?: boolean;
 }): Promise<AuthoredSourceWatcherHandle>;
+export {};

package/dist/src/internal/nitro/host/dev-authored-source-watcher.js

@@ -3,7 +3,7 @@ import { readdir, readFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { watch } from "chokidar";
-import { parse as parseJsonc } from "jsonc-parser";
+import { parse as parseJsonc } from "#compiled/jsonc-parser/index.js";
 import { clearCompiledRuntimeAgentBundleCache } from "#runtime/sessions/compiled-agent-cache.js";
 import { toErrorMessage } from "#shared/errors.js";
 import { resolvePackageSourceFilePath } from "#internal/application/package.js";
@@ -12,6 +12,7 @@ import { computeChannelRouteRegistrations, syncChannelVirtualHandlers, } from "#
 import { prepareApplicationHost } from "#internal/nitro/host/prepare-application-host.js";
 import { prewarmAppSandboxes } from "#execution/sandbox/prewarm.js";
 import { syncScheduleTaskHandlers } from "#internal/nitro/host/schedule-task-routes.js";
+import { getDevelopmentEnvironmentFilePaths, reloadDevelopmentEnvironmentFiles, } from "#cli/dev/environment.js";
 const DEBOUNCE_MS = 120;
 const WATCHED_LOCKFILE_NAMES = [
     "pnpm-lock.yaml",
@@ -44,6 +45,7 @@ export async function startAuthoredSourceWatcher(input) {
     let queue = Promise.resolve();
     let debounceTimer;
     const pendingEvents = new Set();
+    const pendingChangedPaths = new Set();
     const initialWatchPaths = await resolveAuthoredWatchPaths(currentHost);
     let currentWatchPathsByKey = createWatchPathMap(initialWatchPaths);
     const watcher = watch(initialWatchPaths, {
@@ -66,10 +68,16 @@ export async function startAuthoredSourceWatcher(input) {
                 return;
             }
             const eventSummary = pendingEvents.size;
+            const changedPaths = [...pendingChangedPaths];
             pendingEvents.clear();
+            pendingChangedPaths.clear();
             const previousHost = currentHost;
+            const hasEnvironmentChange = hasDevelopmentEnvironmentFileChange(previousHost.appRoot, changedPaths);
             console.log(`[ash:dev] change detected (${eventSummary} event${eventSummary === 1 ? "" : "s"}), rebuilding authored artifacts...`);
             try {
+                if (hasEnvironmentChange) {
+                    reloadDevelopmentEnvironmentFiles(previousHost.appRoot);
+                }
                 const nextHost = await prepareApplicationHost(previousHost.appRoot);
                 await prewarmAppSandboxes({
                     appRoot: nextHost.appRoot,
@@ -77,7 +85,7 @@ export async function startAuthoredSourceWatcher(input) {
                 });
                 const artifactsConfig = createNitroArtifactsConfig({
                     appRoot: nextHost.appRoot,
-                    dev: input.nitro.options.dev,
+                    dev: input.nitro.options.dev === true,
                 });
                 const hasChannelRouteChanged = syncChannelVirtualHandlers(input.nitro, {
                     artifactsConfig,
@@ -92,7 +100,7 @@ export async function startAuthoredSourceWatcher(input) {
                 });
                 clearCompiledRuntimeAgentBundleCache();
                 currentHost = nextHost;
-                const hasStructuralChange = hasChannelRouteChanged || hasScheduleRegistrationsChanged;
+                const hasStructuralChange = hasChannelRouteChanged || hasScheduleRegistrationsChanged || hasEnvironmentChange;
                 if (hasStructuralChange) {
                     console.log("[ash:dev] structural change detected, reloading Nitro worker...");
                     await input.nitro.hooks.callHook("rollup:reload");
@@ -120,6 +128,7 @@ export async function startAuthoredSourceWatcher(input) {
             return;
         }
         pendingEvents.add(`${event}:${changedPath}`);
+        pendingChangedPaths.add(changedPath);
         if (debounceTimer !== undefined) {
             clearTimeout(debounceTimer);
         }
@@ -160,6 +169,9 @@ async function resolveAuthoredWatchPaths(host) {
         join(host.appRoot, TS_CONFIG_GLOB_NAME),
     ]);
     const tsconfigPaths = await resolveTsConfigWatchPaths(host.appRoot);
+    for (const envFilePath of getDevelopmentEnvironmentFilePaths(host.appRoot)) {
+        watchPaths.add(envFilePath);
+    }
     for (const path of tsconfigPaths) {
         watchPaths.add(path);
     }
@@ -202,6 +214,10 @@ function syncWatcherPaths(input) {
 function toWatchPathKey(path) {
     return path.replaceAll("\\", "/");
 }
+function hasDevelopmentEnvironmentFileChange(appRoot, changedPaths) {
+    const environmentFilePathKeys = new Set(getDevelopmentEnvironmentFilePaths(appRoot).map((path) => toWatchPathKey(resolve(path))));
+    return changedPaths.some((path) => environmentFilePathKeys.has(toWatchPathKey(resolve(path))));
+}
 function resolveLockfileSearchDirectories(appRoot) {
     const directories = [];
     let currentDirectory = resolve(appRoot);

package/dist/src/internal/nitro/host/schedule-task-routes.d.ts

@@ -1,6 +1,9 @@
 import type { Nitro } from "nitro/types";
 import { type ScheduleRegistration } from "#runtime/schedules/register.js";
 import type { NitroArtifactsConfigInput } from "#internal/nitro/host/artifacts-config.js";
+interface ScheduleTaskNitro {
+    options: Pick<Nitro["options"], "experimental" | "scheduledTasks" | "tasks" | "virtual">;
+}
 /**
  * Inputs needed to wire one set of compiled authored schedules into Nitro's
  * task and cron surfaces.
@@ -39,7 +42,7 @@ export interface SyncScheduleTaskHandlersInput {
  * adapts it to Nitro's task contract while baking in the artifacts config so
  * the handler does not depend on a global runtime configuration store.
  */
-export declare function registerScheduleTaskHandlers(nitro: Nitro, input: RegisterScheduleTaskHandlersInput): void;
+export declare function registerScheduleTaskHandlers(nitro: ScheduleTaskNitro, input: RegisterScheduleTaskHandlersInput): void;
 /**
  * Replaces the currently-registered Ash schedule task handlers when the
  * compiled authored schedule set changes.
@@ -47,10 +50,11 @@ export declare function registerScheduleTaskHandlers(nitro: Nitro, input: Regist
  * Returns `true` when the registration set changed (and the caller should
  * trigger a Nitro rebuild reload), `false` when it was a structural no-op.
  */
-export declare function syncScheduleTaskHandlers(nitro: Nitro, input: SyncScheduleTaskHandlersInput): boolean;
+export declare function syncScheduleTaskHandlers(nitro: ScheduleTaskNitro, input: SyncScheduleTaskHandlersInput): boolean;
 /**
  * Removes every Ash-owned schedule task entry, virtual handler module, and
  * cron entry from the Nitro options. Used by the dev watcher before
  * re-registering the latest compiled set.
  */
-export declare function removeScheduleTaskHandlers(nitro: Nitro): void;
+export declare function removeScheduleTaskHandlers(nitro: ScheduleTaskNitro): void;
+export {};

package/dist/src/internal/nitro/host/start-development-server.js

@@ -2,6 +2,7 @@ import { build as buildNitro, createDevServer, prepare } from "nitro/builder";
 import { createApplicationNitro } from "#internal/nitro/host/create-application-nitro.js";
 import { prepareApplicationHost } from "#internal/nitro/host/prepare-application-host.js";
 import { prewarmAppSandboxes } from "#execution/sandbox/prewarm.js";
+import { loadDevelopmentEnvironmentFiles } from "#cli/dev/environment.js";
 const DEFAULT_DEVELOPMENT_SERVER_PORT = 3000;
 const MAX_ALLOWED_DEVELOPMENT_SERVER_PORT = 65_535;
 const MAX_DEVELOPMENT_SERVER_PORT_ATTEMPTS = 10;
@@ -160,6 +161,7 @@ async function listenForDevelopmentServer(input) {
  */
 export async function startDevelopmentServer(rootDir, options = {}) {
     const schedulesEnabled = options.schedules === true;
+    loadDevelopmentEnvironmentFiles(rootDir);
     const preparedHost = await prepareApplicationHost(rootDir);
     await prewarmAppSandboxes({
         appRoot: preparedHost.appRoot,

package/dist/src/internal/workflow-bundle/builder-support.js

@@ -372,37 +372,5 @@ function isJavaScriptLikePath(path) {
 export async function atomicWriteFile(targetPath, contents) {
     const tmpPath = `${targetPath}.tmp-${process.pid}-${Date.now().toString(36)}`;
     await writeFile(tmpPath, contents);
-    await renameWithWindowsRetry(tmpPath, targetPath);
-}
-/*
- * POSIX `rename` always succeeds when the target is open, but Windows
- * `MoveFileEx` rejects the call with EPERM/EACCES if any handle to the
- * target lacks FILE_SHARE_DELETE. Node's `fs.readFile` does not request
- * that share mode, so a concurrent reader (e.g. Nitro's Rolldown bundler
- * during `ash dev`) racing with this rename will trip the error even
- * though its open-read-close cycle releases the handle moments later.
- * Retrying with backoff lands the rename in one of those gaps and keeps
- * the atomic guarantee intact on Windows. POSIX skips the loop.
- */
-async function renameWithWindowsRetry(source, target) {
-    if (process.platform !== "win32") {
-        await rename(source, target);
-        return;
-    }
-    const maxAttempts = 10;
-    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-        try {
-            await rename(source, target);
-            return;
-        }
-        catch (error) {
-            const isContended = error instanceof Error &&
-                "code" in error &&
-                (error.code === "EPERM" || error.code === "EACCES" || error.code === "EBUSY");
-            if (!isContended || attempt === maxAttempts - 1) {
-                throw error;
-            }
-            await new Promise((resolve) => setTimeout(resolve, 10 * (attempt + 1)));
-        }
-    }
+    await rename(tmpPath, targetPath);
 }

package/dist/src/public/agents/auth.d.ts

@@ -0,0 +1,30 @@
+import type { TokenValue } from "#client/types.js";
+/**
+ * Outbound request auth hook used by remote agent dispatch.
+ */
+export type OutboundAuthFn = () => Promise<{
+    readonly headers: Readonly<Record<string, string>>;
+}>;
+/**
+ * Ash-owned subset of `@vercel/oidc` token lookup options.
+ */
+export interface VercelOidcOptions {
+    readonly expirationBufferMs?: number;
+    readonly project?: string;
+    readonly team?: string;
+}
+/**
+ * Returns a Vercel OIDC bearer token for an outbound remote-agent request.
+ */
+export declare function vercelOidc(options?: VercelOidcOptions): OutboundAuthFn;
+/**
+ * Returns a static or lazily resolved bearer token auth hook.
+ */
+export declare function bearer(token: TokenValue): OutboundAuthFn;
+/**
+ * Returns an HTTP Basic auth hook.
+ */
+export declare function basic(input: {
+    readonly password: TokenValue;
+    readonly username: string;
+}): OutboundAuthFn;

package/dist/src/public/agents/auth.js

@@ -0,0 +1,37 @@
+import { getVercelOidcToken } from "@vercel/oidc";
+/**
+ * Returns a Vercel OIDC bearer token for an outbound remote-agent request.
+ */
+export function vercelOidc(options = {}) {
+    return async () => ({
+        headers: {
+            authorization: `Bearer ${await getVercelOidcToken(options)}`,
+        },
+    });
+}
+/**
+ * Returns a static or lazily resolved bearer token auth hook.
+ */
+export function bearer(token) {
+    return async () => ({
+        headers: {
+            authorization: `Bearer ${await resolveTokenValue(token)}`,
+        },
+    });
+}
+/**
+ * Returns an HTTP Basic auth hook.
+ */
+export function basic(input) {
+    return async () => {
+        const encodedCredentials = btoa(`${input.username}:${await resolveTokenValue(input.password)}`);
+        return {
+            headers: {
+                authorization: `Basic ${encodedCredentials}`,
+            },
+        };
+    };
+}
+async function resolveTokenValue(value) {
+    return typeof value === "function" ? await value() : value;
+}

package/dist/src/public/definitions/remote-agent.d.ts

@@ -0,0 +1,25 @@
+import type { HeadersValue } from "#client/types.js";
+import type { OutboundAuthFn } from "#public/agents/auth.js";
+/**
+ * Public definition for a remote Ash agent lowered as a subagent tool.
+ */
+export interface RemoteAgentDefinition {
+    readonly auth?: OutboundAuthFn;
+    readonly description: string;
+    readonly headers?: HeadersValue;
+    readonly kind: "remote";
+    readonly path: string;
+    readonly url: string;
+}
+/**
+ * Authored input accepted by {@link defineRemoteAgent}. Identity is derived
+ * from the file path under `agent/subagents/`; authored definitions do not
+ * carry a `name` field.
+ */
+export type RemoteAgentDefinitionInput = Omit<RemoteAgentDefinition, "kind" | "path"> & {
+    readonly path?: string;
+};
+/**
+ * Defines a remote Ash agent that the parent can call as a subagent tool.
+ */
+export declare function defineRemoteAgent(input: RemoteAgentDefinitionInput): RemoteAgentDefinition;

package/dist/src/public/definitions/remote-agent.js

@@ -0,0 +1,11 @@
+import { ASH_CREATE_SESSION_ROUTE_PATH } from "#protocol/routes.js";
+/**
+ * Defines a remote Ash agent that the parent can call as a subagent tool.
+ */
+export function defineRemoteAgent(input) {
+    return {
+        ...input,
+        kind: "remote",
+        path: input.path ?? ASH_CREATE_SESSION_ROUTE_PATH,
+    };
+}

package/dist/src/public/index.d.ts

@@ -2,3 +2,4 @@
  * Core agent authoring helpers for `agent/agent.ts`.
  */
 export { type AgentCompactionDefinition, type AgentDefinition, type AgentModelDefinition, type AgentModelOptionsDefinition, defineAgent, } from "#public/definitions/agent.js";
+export { type RemoteAgentDefinition, type RemoteAgentDefinitionInput, defineRemoteAgent, } from "#public/definitions/remote-agent.js";

package/dist/src/public/index.js

@@ -2,3 +2,4 @@
  * Core agent authoring helpers for `agent/agent.ts`.
  */
 export { defineAgent, } from "#public/definitions/agent.js";
+export { defineRemoteAgent, } from "#public/definitions/remote-agent.js";

package/dist/src/public/next/index.d.ts

@@ -72,10 +72,10 @@ export interface WithAshOptions {
  * 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` using the deployment origin from `VERCEL_URL`. 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.
+ * `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 declare function withAsh<TConfig extends AshNextConfig>(configOrFunction: AshNextConfigInput<TConfig>, options?: WithAshOptions): AshNextConfigFunction<TConfig>;
 export {};

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

@@ -32,16 +32,6 @@ function joinRoutePrefix(prefix, path) {
 function normalizeOrigin(origin) {
     return new URL(origin.trim()).origin;
 }
-function hasUrlScheme(value) {
-    return /^[a-z][a-z\d+.-]*:/i.test(value);
-}
-function resolveVercelDeploymentOrigin() {
-    const deploymentUrl = process.env.VERCEL_URL;
-    if (deploymentUrl === undefined || deploymentUrl.trim().length === 0) {
-        return undefined;
-    }
-    return normalizeOrigin(hasUrlScheme(deploymentUrl) ? deploymentUrl : `https://${deploymentUrl}`);
-}
 function readLocalProductionPort() {
     const configuredPort = process.env[ASH_NEXT_PRODUCTION_PORT_ENV];
     if (configuredPort === undefined || configuredPort.trim().length === 0) {
@@ -54,16 +44,15 @@ function readLocalProductionPort() {
     return port;
 }
 function resolveProductionDestination(servicePrefix) {
-    const configuredOrigin = process.env[ASH_NEXT_PRODUCTION_ORIGIN_ENV];
-    if (configuredOrigin !== undefined && configuredOrigin.trim().length > 0) {
+    if (process.env.VERCEL) {
         return {
-            destinationPrefix: joinRoutePrefix(normalizeOrigin(configuredOrigin), servicePrefix),
+            destinationPrefix: servicePrefix,
         };
     }
-    const vercelOrigin = resolveVercelDeploymentOrigin();
-    if (vercelOrigin !== undefined) {
+    const configuredOrigin = process.env[ASH_NEXT_PRODUCTION_ORIGIN_ENV];
+    if (configuredOrigin !== undefined && configuredOrigin.trim().length > 0) {
         return {
-            destinationPrefix: joinRoutePrefix(vercelOrigin, servicePrefix),
+            destinationPrefix: joinRoutePrefix(normalizeOrigin(configuredOrigin), servicePrefix),
         };
     }
     const localServerOrigin = `http://127.0.0.1:${String(readLocalProductionPort())}`;
@@ -73,11 +62,13 @@ function resolveProductionDestination(servicePrefix) {
     };
 }
 function createAshRewriteRules(destinationPrefix) {
-    return ASH_PROXY_REWRITE_SOURCES.map((source) => ({
-        basePath: false,
-        destination: joinRoutePrefix(destinationPrefix, source),
-        source,
-    }));
+    return ASH_PROXY_REWRITE_SOURCES.map((source) => {
+        const rule = {
+            destination: joinRoutePrefix(destinationPrefix, source),
+            source,
+        };
+        return rule;
+    });
 }
 async function resolveExistingRewrites(rewrites) {
     return await rewrites?.();
@@ -114,10 +105,10 @@ async function resolveNextConfig(configOrFunction, phase, context) {
  * 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` using the deployment origin from `VERCEL_URL`. 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.
+ * `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();