experimental-ash 0.25.2 → 0.27.0

package/dist/src/internal/logging.js

@@ -1,226 +1 @@
-/**
- * Framework-internal structured logger.
- *
- * Not public API; authors should use their own logger or Vercel
- * observability primitives.
- */
-import { SpanStatusCode, trace } from "#compiled/@opentelemetry/api/index.js";
-import { getErrorMessage } from "#compiled/@ai-sdk/provider/index.js";
-import { inspect } from "node:util";
-import { isNonEmptyString, isObject } from "#shared/guards.js";
-const MAX_INSPECT_STRING_LENGTH = 8 * 1024;
-const MAX_DETAIL_BYTES = 16 * 1024;
-const INSPECT_DEPTH = 10;
-/**
- * Builds a logger bound to a stable namespace (e.g. `"slack.route"` or
- * `"harness.tool-loop"`). The namespace appears in every rendered line
- * and is threaded through to OTel span events so a single grep can
- * correlate structured logs with traces.
- */
-export function createLogger(namespace) {
-    return {
-        debug(message, fields) {
-            write("debug", namespace, message, fields);
-        },
-        info(message, fields) {
-            write("info", namespace, message, fields);
-        },
-        warn(message, fields) {
-            write("warn", namespace, message, fields);
-        },
-        error(message, fields) {
-            write("error", namespace, message, fields);
-            recordOnActiveSpan(message, fields);
-        },
-    };
-}
-/**
- * Generates a stable, opaque identifier for one error instance.
- *
- * The same identifier should be included in every log line associated
- * with a given failure and in the user-visible error message so a
- * support ticket that quotes the id can be grepped back to a single
- * incident. Uses `crypto.randomUUID()` for uniqueness; callers should
- * not rely on the format beyond opacity.
- */
-export function createErrorId() {
-    return crypto.randomUUID();
-}
-/**
- * Normalizes an unknown throwable into a JSON-serializable summary.
- *
- * Pins `name` and `message` as first-class fields because OTel
- * conventions index them directly, and renders the full `util.inspect`
- * dump (cause chain included) into `detail` so upstream provider
- * `responseBody`, gateway `statusCode`, and any other enumerable
- * fields surface for log aggregators without per-subclass plumbing.
- *
- * Accepts either a raw throwable or an existing `{ errorId }` wrapper
- * so repeated logs can share one identifier.
- */
-export function formatError(error, errorId) {
-    const details = {
-        errorId: errorId ?? createErrorId(),
-        message: extractErrorMessage(error),
-    };
-    const name = extractErrorName(error);
-    if (name !== undefined) {
-        details.name = name;
-    }
-    details.detail = inspectError(error);
-    return details;
-}
-/**
- * Pulls a displayable `name` off a throwable. Real {@link Error}
- * instances contribute their `.name` (except the default `"Error"`
- * which adds no information beyond what `message` already carries);
- * plain-object shapes with a string `name` (e.g. errors that crossed
- * a workflow step boundary and lost their prototype) pass through too
- * so the downstream `code` derives from the original class name.
- */
-function extractErrorName(error) {
-    if (error instanceof Error) {
-        return error.name !== "Error" ? error.name : undefined;
-    }
-    if (isObject(error) && isNonEmptyString(error.name) && error.name !== "Error") {
-        return error.name;
-    }
-    return undefined;
-}
-/**
- * Like `@ai-sdk/provider`'s `getErrorMessage` but prefers an explicit
- * `.message` property on plain-object throwables over JSON-stringifying
- * the whole shape. This keeps the rendered message human-readable
- * when an Error has been stripped to a plain object by structured
- * clone (workflow step boundary, postMessage, etc.).
- */
-function extractErrorMessage(error) {
-    if (isObject(error) && !(error instanceof Error) && typeof error.message === "string") {
-        return error.message;
-    }
-    return getErrorMessage(error);
-}
-/**
- * Pulls the correlated `errorId` off a `step.failed` / `turn.failed`
- * / `session.failed` event's `details` payload (or any other shape
- * produced by {@link formatError}). Returns `undefined` when the
- * sender did not attach one (older cascades, non-model-call error
- * paths that predate the shared format).
- *
- * The inverse-reader of {@link formatError}. Channels that surface
- * user-visible error text use it to embed a correlation id so a
- * support ticket quoting the id can be grepped back to one incident.
- */
-export function extractErrorId(details) {
-    if (!isObject(details))
-        return undefined;
-    return isNonEmptyString(details.errorId) ? details.errorId : undefined;
-}
-/**
- * Formats an "in parentheses" hint summarizing a failed-event payload
- * for user-visible display. Returns an empty string when neither the
- * structured error name nor message is useful.
- */
-export function formatErrorHint(event) {
-    const rawName = isObject(event.details) ? event.details.name : undefined;
-    const name = isNonEmptyString(rawName) ? rawName : undefined;
-    const message = typeof event.message === "string" ? event.message.trim() : "";
-    if (name && message.length > 0) {
-        return ` (${name}: ${truncateForDisplay(message)})`;
-    }
-    if (name) {
-        return ` (${name})`;
-    }
-    if (message.length > 0) {
-        return ` (${truncateForDisplay(message)})`;
-    }
-    return "";
-}
-function truncateForDisplay(value, maxChars = 160) {
-    if (value.length <= maxChars) {
-        return value;
-    }
-    return `${value.slice(0, maxChars - 1).trimEnd()}…`;
-}
-/**
- * Records an error on an OTel span and sets the span status to ERROR.
- *
- * Exposed for call sites that already have a span in hand (the harness
- * turn span). The logger itself also records on the *active* span when
- * `.error()` is called, so direct use is only necessary when a specific
- * non-active span should be annotated.
- */
-export function recordErrorOnSpan(span, error) {
-    const message = error instanceof Error ? error.message : getErrorMessage(error);
-    const name = error instanceof Error ? error.name : "Error";
-    span.setStatus({ code: SpanStatusCode.ERROR, message });
-    span.recordException({ message, name, stack: inspectError(error) });
-}
-// ---------------------------------------------------------------------------
-// Internals
-// ---------------------------------------------------------------------------
-function write(level, namespace, message, fields) {
-    // `debug` routes through `console.log` because most runtimes
-    // default-silence `console.debug` and the aggregators we target
-    // treat the stderr path (info/warn/error) as canonical. Look up
-    // the sink per call so test spies installed on `console` take
-    // effect even if the logger was constructed earlier.
-    const sink = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
-    const line = `[ash:${namespace}] ${message}`;
-    if (fields === undefined) {
-        sink(line);
-        return;
-    }
-    sink(line, renderFields(fields));
-}
-/**
- * Normalizes {@link LogFields} for structured rendering.
- *
- * Errors are replaced with their {@link formatError} representation so
- * the same shape that flows into event stream `details` also appears
- * in the log. Other values pass through unchanged.
- */
-function renderFields(fields) {
-    const out = {};
-    for (const [key, value] of Object.entries(fields)) {
-        if (value === undefined) {
-            continue;
-        }
-        if (value instanceof Error) {
-            out[key] = formatError(value);
-            continue;
-        }
-        out[key] = value;
-    }
-    return out;
-}
-function recordOnActiveSpan(message, fields) {
-    const span = trace.getActiveSpan();
-    if (span === undefined) {
-        return;
-    }
-    const error = fields?.error;
-    if (error instanceof Error) {
-        recordErrorOnSpan(span, error);
-        return;
-    }
-    span.addEvent(message, fields ? renderFields(fields) : undefined);
-}
-function inspectError(error) {
-    return truncate(inspect(error, {
-        breakLength: Number.POSITIVE_INFINITY,
-        compact: false,
-        depth: INSPECT_DEPTH,
-        maxStringLength: MAX_INSPECT_STRING_LENGTH,
-    }), MAX_DETAIL_BYTES);
-}
-function truncate(value, maxBytes) {
-    if (Buffer.byteLength(value, "utf8") <= maxBytes) {
-        return value;
-    }
-    let sliced = value.slice(0, maxBytes);
-    while (Buffer.byteLength(sliced, "utf8") > maxBytes && sliced.length > 0) {
-        sliced = sliced.slice(0, -1);
-    }
-    return `${sliced}<…truncated>`;
-}
+import{inspect}from"node:util";import{isNonEmptyString,isObject}from"#shared/guards.js";import{SpanStatusCode,trace}from"#compiled/@opentelemetry/api/index.js";import{getErrorMessage}from"#compiled/@ai-sdk/provider/index.js";var MAX_INSPECT_STRING_LENGTH=8*1024,MAX_DETAIL_BYTES=16*1024,INSPECT_DEPTH=10;function createLogger(e){return{debug(t,n){write(`debug`,e,t,n)},info(t,n){write(`info`,e,t,n)},warn(t,n){write(`warn`,e,t,n)},error(t,n){write(`error`,e,t,n),recordOnActiveSpan(t,n)}}}function createErrorId(){return crypto.randomUUID()}function formatError(e,t){let n={errorId:t??createErrorId(),message:extractErrorMessage(e)},r=extractErrorName(e);return r!==void 0&&(n.name=r),n.detail=inspectError(e),n}function extractErrorName(e){if(e instanceof Error)return e.name===`Error`?void 0:e.name;if(isObject(e)&&isNonEmptyString(e.name)&&e.name!==`Error`)return e.name}function extractErrorMessage(e){return isObject(e)&&!(e instanceof Error)&&typeof e.message==`string`?e.message:getErrorMessage(e)}function extractErrorId(e){if(isObject(e))return isNonEmptyString(e.errorId)?e.errorId:void 0}function formatErrorHint(e){let r=isObject(e.details)?e.details.name:void 0,i=isNonEmptyString(r)?r:void 0,a=typeof e.message==`string`?e.message.trim():``;return i&&a.length>0?` (${i}: ${truncateForDisplay(a)})`:i?` (${i})`:a.length>0?` (${truncateForDisplay(a)})`:``}function truncateForDisplay(e,t=160){return e.length<=t?e:`${e.slice(0,t-1).trimEnd()}…`}function recordErrorOnSpan(e,t){let n=t instanceof Error?t.message:getErrorMessage(t),i=t instanceof Error?t.name:`Error`;e.setStatus({code:SpanStatusCode.ERROR,message:n}),e.recordException({message:n,name:i,stack:inspectError(t)})}function write(e,t,n,r){let i=e===`error`?console.error:e===`warn`?console.warn:console.log,a=`[ash:${t}] ${n}`;if(r===void 0){i(a);return}i(a,renderFields(r))}function renderFields(e){let t={};for(let[n,r]of Object.entries(e))if(r!==void 0){if(r instanceof Error){t[n]=formatError(r);continue}t[n]=r}return t}function recordOnActiveSpan(e,t){let n=trace.getActiveSpan();if(n===void 0)return;let r=t?.error;if(r instanceof Error){recordErrorOnSpan(n,r);return}n.addEvent(e,t?renderFields(t):void 0)}function inspectError(t){return truncate(inspect(t,{breakLength:1/0,compact:!1,depth:INSPECT_DEPTH,maxStringLength:MAX_INSPECT_STRING_LENGTH}),MAX_DETAIL_BYTES)}function truncate(e,t){if(Buffer.byteLength(e,`utf8`)<=t)return e;let n=e.slice(0,t);for(;Buffer.byteLength(n,`utf8`)>t&&n.length>0;)n=n.slice(0,-1);return`${n}<…truncated>`}export{createErrorId,createLogger,extractErrorId,formatError,formatErrorHint,recordErrorOnSpan};

package/dist/src/internal/nitro/host/artifacts-config.js

@@ -1,17 +1 @@
-import { resolvePackageSourceFilePath } from "#internal/application/package.js";
-/**
- * Creates the artifacts config baked into Nitro virtual handlers.
- */
-export function createNitroArtifactsConfig(input) {
-    if (!input.dev) {
-        return {
-            appRoot: input.appRoot,
-            dev: input.dev,
-        };
-    }
-    return {
-        appRoot: input.appRoot,
-        dev: input.dev,
-        moduleMapLoaderPath: resolvePackageSourceFilePath("src/internal/authored-module-map-loader.ts"),
-    };
-}
+import{resolvePackageSourceFilePath}from"#internal/application/package.js";function createNitroArtifactsConfig(e){return e.dev?{appRoot:e.appRoot,dev:e.dev,moduleMapLoaderPath:resolvePackageSourceFilePath(`src/internal/authored-module-map-loader.ts`)}:{appRoot:e.appRoot,dev:e.dev}}export{createNitroArtifactsConfig};

package/dist/src/internal/nitro/host/build-application.js

@@ -1,177 +1 @@
-import { readFile } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-import { build as buildNitro, copyPublicAssets, prepare, prerender } from "nitro/builder";
-import { resolvePackageRoot } from "#internal/application/package.js";
-import { prepareAshVersionedCacheDirectory, writeAshVersionedCacheMetadata, } from "#internal/application/cache-metadata.js";
-import { resolveNitroSurfaceOutputDirectory } from "#internal/application/paths.js";
-import { WorkflowBundleBuilder } from "#internal/workflow-bundle/builder.js";
-import { normalizeAshVercelFunctionOutput } from "#internal/workflow-bundle/vercel-workflow-output.js";
-import { createApplicationNitro } from "#internal/nitro/host/create-application-nitro.js";
-import { emitVercelAgentSummary } from "#internal/nitro/host/build-vercel-agent-summary.js";
-import { prepareApplicationHost } from "#internal/nitro/host/prepare-application-host.js";
-import { runVercelBuildPrewarm } from "#internal/nitro/host/vercel-build-prewarm.js";
-function trimTrailingSlash(path) {
-    return path.replace(/[\\/]+$/, "");
-}
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function normalizeEntrypoint(rootDir, entrypoint) {
-    if (typeof entrypoint !== "string" || entrypoint.trim().length === 0) {
-        return null;
-    }
-    return resolve(rootDir, entrypoint);
-}
-function resolveNextAshServicePrefix(input) {
-    if (!isRecord(input.config) || !isRecord(input.config.experimentalServices)) {
-        return undefined;
-    }
-    let hasNextService = false;
-    let servicePrefix;
-    for (const service of Object.values(input.config.experimentalServices)) {
-        if (!isRecord(service)) {
-            continue;
-        }
-        if (service.framework === "nextjs") {
-            hasNextService = true;
-            continue;
-        }
-        if (service.framework !== "ash") {
-            continue;
-        }
-        const ashEntrypoint = normalizeEntrypoint(input.configRoot, service.entrypoint);
-        const routePrefix = typeof service.routePrefix === "string" ? service.routePrefix.trim() : "";
-        if (ashEntrypoint === input.appRoot && routePrefix.length > 0 && routePrefix !== "/") {
-            servicePrefix = routePrefix;
-        }
-    }
-    return hasNextService ? servicePrefix : undefined;
-}
-async function resolveNextAshServicePrefixForVercelFunctionOutput(appRoot) {
-    let currentDir = appRoot;
-    while (true) {
-        try {
-            const configPath = join(currentDir, "vercel.json");
-            const config = JSON.parse(await readFile(configPath, "utf8"));
-            const servicePrefix = resolveNextAshServicePrefix({
-                appRoot,
-                configRoot: currentDir,
-                config,
-            });
-            if (servicePrefix !== undefined) {
-                return servicePrefix;
-            }
-        }
-        catch (error) {
-            if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {
-                throw error;
-            }
-        }
-        const parentDir = dirname(currentDir);
-        if (parentDir === currentDir) {
-            return undefined;
-        }
-        currentDir = parentDir;
-    }
-}
-async function readVercelServerRuntime(outputDir) {
-    try {
-        const config = JSON.parse(await readFile(join(outputDir, "functions", "__server.func", ".vc-config.json"), "utf8"));
-        return config.runtime;
-    }
-    catch {
-        return undefined;
-    }
-}
-async function emitVercelWorkflowFunctions(input) {
-    const builder = new WorkflowBundleBuilder({
-        appRoot: input.appRoot,
-        compiledArtifactsBootstrapPath: input.compiledArtifactsBootstrapPath,
-        outDir: input.workflowBuildDir,
-        rootDir: resolvePackageRoot(),
-        watch: false,
-    });
-    const runtime = await readVercelServerRuntime(input.outputDir);
-    await builder.buildVercelOutput({
-        flowNitroOutputDir: input.flowNitroOutputDir,
-        outputDir: input.outputDir,
-        runtime,
-    });
-}
-async function buildNitroOutput(nitro) {
-    const outputDirectory = trimTrailingSlash(nitro.options.output.dir);
-    await prepareAshVersionedCacheDirectory(outputDirectory);
-    await prepare(nitro);
-    await copyPublicAssets(nitro);
-    await prerender(nitro);
-    await buildNitro(nitro);
-    await writeAshVersionedCacheMetadata(outputDirectory);
-    return outputDirectory;
-}
-async function buildVercelNitroSurface(preparedHost, surface) {
-    const nitro = await createApplicationNitro(preparedHost, false, {
-        outputDir: resolveNitroSurfaceOutputDirectory(preparedHost.appRoot, surface),
-        surface,
-    });
-    try {
-        return await buildNitroOutput(nitro);
-    }
-    finally {
-        await nitro.close();
-    }
-}
-/**
- * Builds the production Nitro output for an Ash application.
- */
-export async function buildApplication(rootDir) {
-    const preparedHost = await prepareApplicationHost(rootDir);
-    if (!process.env.VERCEL) {
-        const nitro = await createApplicationNitro(preparedHost, false);
-        try {
-            const outputDirectory = await buildNitroOutput(nitro);
-            await emitVercelAgentSummary({
-                manifest: preparedHost.compileResult.manifest,
-                appRoot: preparedHost.appRoot,
-            });
-            return outputDirectory;
-        }
-        finally {
-            await nitro.close();
-        }
-    }
-    const nitro = await createApplicationNitro(preparedHost, false, {
-        surface: "app",
-    });
-    try {
-        const outputDirectory = await buildNitroOutput(nitro);
-        // Run sandbox prewarm before emitting the workflow functions so a
-        // prewarm failure aborts the build before we spend time bundling
-        // function output that we would never deploy.
-        await runVercelBuildPrewarm({
-            appRoot: preparedHost.appRoot,
-            log(message) {
-                console.log(message);
-            },
-        });
-        const flowNitroOutputDir = await buildVercelNitroSurface(preparedHost, "flow");
-        await emitVercelWorkflowFunctions({
-            appRoot: preparedHost.appRoot,
-            compiledArtifactsBootstrapPath: preparedHost.compiledArtifacts.bootstrapPath,
-            flowNitroOutputDir,
-            outputDir: outputDirectory,
-            workflowBuildDir: preparedHost.workflowBuildDir,
-        });
-        const servicePrefix = await resolveNextAshServicePrefixForVercelFunctionOutput(preparedHost.appRoot);
-        if (servicePrefix !== undefined) {
-            await normalizeAshVercelFunctionOutput(outputDirectory, { servicePrefix });
-        }
-        await emitVercelAgentSummary({
-            manifest: preparedHost.compileResult.manifest,
-            appRoot: preparedHost.appRoot,
-        });
-        return outputDirectory;
-    }
-    finally {
-        await nitro.close();
-    }
-}
+import{dirname,join,resolve}from"node:path";import{readFile}from"node:fs/promises";import{resolveNitroSurfaceOutputDirectory}from"#internal/application/paths.js";import{resolvePackageRoot}from"#internal/application/package.js";import{build,copyPublicAssets,prepare,prerender}from"nitro/builder";import{prepareAshVersionedCacheDirectory,writeAshVersionedCacheMetadata}from"#internal/application/cache-metadata.js";import{WorkflowBundleBuilder}from"#internal/workflow-bundle/builder.js";import{normalizeAshVercelFunctionOutput}from"#internal/workflow-bundle/vercel-workflow-output.js";import{createApplicationNitro}from"#internal/nitro/host/create-application-nitro.js";import{emitVercelAgentSummary}from"#internal/nitro/host/build-vercel-agent-summary.js";import{prepareApplicationHost}from"#internal/nitro/host/prepare-application-host.js";import{runVercelBuildPrewarm}from"#internal/nitro/host/vercel-build-prewarm.js";function trimTrailingSlash(e){return e.replace(/[\\/]+$/,``)}function isRecord(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function normalizeEntrypoint(e,t){return typeof t!=`string`||t.trim().length===0?null:resolve(e,t)}function resolveNextAshServicePrefix(e){if(!isRecord(e.config)||!isRecord(e.config.experimentalServices))return;let t=!1,n;for(let r of Object.values(e.config.experimentalServices)){if(!isRecord(r))continue;if(r.framework===`nextjs`){t=!0;continue}if(r.framework!==`ash`)continue;let i=normalizeEntrypoint(e.configRoot,r.entrypoint),a=typeof r.routePrefix==`string`?r.routePrefix.trim():``;i===e.appRoot&&a.length>0&&a!==`/`&&(n=a)}return t?n:void 0}async function resolveNextAshServicePrefixForVercelFunctionOutput(n){let i=n;for(;;){try{let e=join(i,`vercel.json`),a=JSON.parse(await readFile(e,`utf8`)),o=resolveNextAshServicePrefix({appRoot:n,configRoot:i,config:a});if(o!==void 0)return o}catch(e){if(!(e instanceof Error&&`code`in e&&e.code===`ENOENT`))throw e}let a=dirname(i);if(a===i)return;i=a}}async function readVercelServerRuntime(e){try{return JSON.parse(await readFile(join(e,`functions`,`__server.func`,`.vc-config.json`),`utf8`)).runtime}catch{return}}async function emitVercelWorkflowFunctions(e){let t=new WorkflowBundleBuilder({appRoot:e.appRoot,compiledArtifactsBootstrapPath:e.compiledArtifactsBootstrapPath,outDir:e.workflowBuildDir,rootDir:resolvePackageRoot(),watch:!1}),n=await readVercelServerRuntime(e.outputDir);await t.buildVercelOutput({flowNitroOutputDir:e.flowNitroOutputDir,outputDir:e.outputDir,runtime:n})}async function buildNitroOutput(e){let t=trimTrailingSlash(e.options.output.dir);return await prepareAshVersionedCacheDirectory(t),await prepare(e),await copyPublicAssets(e),await prerender(e),await build(e),await writeAshVersionedCacheMetadata(t),t}async function buildVercelNitroSurface(e,t){let n=await createApplicationNitro(e,!1,{outputDir:resolveNitroSurfaceOutputDirectory(e.appRoot,t),surface:t});try{return await buildNitroOutput(n)}finally{await n.close()}}async function buildApplication(e){let t=await prepareApplicationHost(e);if(!process.env.VERCEL){let e=await createApplicationNitro(t,!1);try{let n=await buildNitroOutput(e);return await emitVercelAgentSummary({manifest:t.compileResult.manifest,appRoot:t.appRoot}),n}finally{await e.close()}}let n=await createApplicationNitro(t,!1,{surface:`app`});try{let e=await buildNitroOutput(n);await runVercelBuildPrewarm({appRoot:t.appRoot,log(e){console.log(e)}});let r=await buildVercelNitroSurface(t,`flow`);await emitVercelWorkflowFunctions({appRoot:t.appRoot,compiledArtifactsBootstrapPath:t.compiledArtifacts.bootstrapPath,flowNitroOutputDir:r,outputDir:e,workflowBuildDir:t.workflowBuildDir});let i=await resolveNextAshServicePrefixForVercelFunctionOutput(t.appRoot);return i!==void 0&&await normalizeAshVercelFunctionOutput(e,{servicePrefix:i}),await emitVercelAgentSummary({manifest:t.compileResult.manifest,appRoot:t.appRoot}),e}finally{await n.close()}}export{buildApplication};

package/dist/src/internal/nitro/host/build-vercel-agent-summary.js

@@ -1,140 +1 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { resolveInstalledPackageInfo } from "#internal/application/package.js";
-import { VERCEL_ASH_AGENT_SUMMARY_KIND, VERCEL_ASH_AGENT_SUMMARY_OUTPUT_PATH, VERCEL_ASH_AGENT_SUMMARY_VERSION, normalizeChannelKindForDisplay, } from "#internal/vercel-agent-summary.js";
-/**
- * Builds the public {@link VercelAshAgentSummary} from a compiled agent
- * manifest. The result is the stable contract Vercel ingests from the
- * deployment build output — see {@link emitVercelAgentSummary} for the
- * write-out side.
- */
-export function buildVercelAgentSummary(input) {
-    const { manifest } = input;
-    return {
-        kind: VERCEL_ASH_AGENT_SUMMARY_KIND,
-        schemaVersion: VERCEL_ASH_AGENT_SUMMARY_VERSION,
-        generatorVersion: input.generatorVersion ?? resolveInstalledPackageInfo().version,
-        agent: {
-            name: manifest.config.name,
-            description: manifest.config.description,
-            modelId: manifest.config.model.id,
-        },
-        instructions: manifest.instructions ? toInstructionsEntry(manifest.instructions) : null,
-        schedules: manifest.schedules.map(toScheduleEntry),
-        tools: manifest.tools.map(toToolEntry),
-        skills: manifest.skills.map(toSkillEntry),
-        connections: manifest.connections.map(toConnectionEntry),
-        channels: manifest.channels.filter(isActiveChannel).map(toChannelEntry),
-        sandbox: manifest.sandbox === null
-            ? null
-            : {
-                logicalPath: manifest.sandbox.logicalPath,
-            },
-        subagents: manifest.subagents.map(toSubagentEntry),
-        diagnostics: {
-            errors: manifest.diagnosticsSummary.errors,
-            warnings: manifest.diagnosticsSummary.warnings,
-        },
-    };
-}
-/**
- * Writes the agent summary file. Returns the absolute path of the
- * written file.
- *
- * The file is written to {@link VERCEL_ASH_AGENT_SUMMARY_OUTPUT_PATH}
- * relative to {@link input.appRoot} — i.e.
- * `<appRoot>/.ash/agent-summary.json`. Lives outside `.vercel/output/`
- * by design, so it is not part of the Build Output API surface and is
- * never served on the deployment URL.
- *
- * On Vercel deployments, the build container's
- * `upload-ash-agent-summary.ts` helper picks up this file from
- * `rootPath` (which equals `appRoot` for the project being built) and
- * uploads it to `<projectId>/<deploymentId>/ash_agent_summary.json` as
- * a top-level deployment artifact — the same tier as
- * `deploy_metadata.json` and `turbo_summary.json`. The dashboard reads
- * it through the dedicated
- * `/v6/deployments/:id/files/ash-agent-summary` endpoint.
- *
- * For self-hosted setups (no Vercel build container in the loop), the
- * file simply sits on disk at the same path. Operators wire it up to
- * whatever surface they want.
- */
-export async function emitVercelAgentSummary(input) {
-    const summary = buildVercelAgentSummary({
-        generatorVersion: input.generatorVersion,
-        manifest: input.manifest,
-    });
-    const filePath = join(input.appRoot, VERCEL_ASH_AGENT_SUMMARY_OUTPUT_PATH);
-    await mkdir(dirname(filePath), { recursive: true });
-    await writeFile(filePath, `${JSON.stringify(summary, null, 2)}\n`);
-    return filePath;
-}
-function isActiveChannel(entry) {
-    return entry.kind === "channel";
-}
-function toInstructionsEntry(instructions) {
-    return {
-        logicalPath: instructions.logicalPath,
-        sourceKind: instructions.sourceKind,
-        markdown: instructions.markdown,
-    };
-}
-function toScheduleEntry(schedule) {
-    return {
-        name: schedule.name,
-        cron: schedule.cron,
-        logicalPath: schedule.logicalPath,
-    };
-}
-function toToolEntry(tool) {
-    return {
-        name: tool.name,
-        description: tool.description,
-        logicalPath: tool.logicalPath,
-    };
-}
-function toSkillEntry(skill) {
-    return {
-        name: skill.name,
-        description: skill.description,
-        logicalPath: skill.logicalPath,
-        sourceKind: skill.sourceKind,
-    };
-}
-function toConnectionEntry(connection) {
-    const entry = {
-        name: connection.connectionName,
-        description: connection.description,
-        url: connection.url,
-        logicalPath: connection.logicalPath,
-        type: "mcp",
-    };
-    if (connection.vercelConnect !== undefined) {
-        return {
-            ...entry,
-            vercelConnect: { connector: connection.vercelConnect.connector },
-        };
-    }
-    return entry;
-}
-function toChannelEntry(channel) {
-    const entry = {
-        name: channel.name,
-        method: channel.method,
-        urlPath: channel.urlPath,
-        type: normalizeChannelKindForDisplay(channel.adapterKind),
-        logicalPath: channel.logicalPath,
-    };
-    if (channel.adapterKind !== undefined) {
-        return { ...entry, adapterKind: channel.adapterKind };
-    }
-    return entry;
-}
-function toSubagentEntry(subagent) {
-    return {
-        name: subagent.name,
-        description: subagent.description,
-        logicalPath: subagent.logicalPath,
-    };
-}
+import{dirname,join}from"node:path";import{mkdir,writeFile}from"node:fs/promises";import{resolveInstalledPackageInfo}from"#internal/application/package.js";import{VERCEL_ASH_AGENT_SUMMARY_KIND,VERCEL_ASH_AGENT_SUMMARY_OUTPUT_PATH,VERCEL_ASH_AGENT_SUMMARY_VERSION,normalizeChannelKindForDisplay}from"#internal/vercel-agent-summary.js";function buildVercelAgentSummary(e){let{manifest:t}=e;return{kind:VERCEL_ASH_AGENT_SUMMARY_KIND,schemaVersion:VERCEL_ASH_AGENT_SUMMARY_VERSION,generatorVersion:e.generatorVersion??resolveInstalledPackageInfo().version,agent:{name:t.config.name,description:t.config.description,modelId:t.config.model.id},instructions:t.instructions?toInstructionsEntry(t.instructions):null,schedules:t.schedules.map(toScheduleEntry),tools:t.tools.map(toToolEntry),skills:t.skills.map(toSkillEntry),connections:t.connections.map(toConnectionEntry),channels:t.channels.filter(isActiveChannel).map(toChannelEntry),sandbox:t.sandbox===null?null:{logicalPath:t.sandbox.logicalPath},subagents:t.subagents.map(toSubagentEntry),diagnostics:{errors:t.diagnosticsSummary.errors,warnings:t.diagnosticsSummary.warnings}}}async function emitVercelAgentSummary(n){let r=buildVercelAgentSummary({generatorVersion:n.generatorVersion,manifest:n.manifest}),i=join(n.appRoot,VERCEL_ASH_AGENT_SUMMARY_OUTPUT_PATH);return await mkdir(dirname(i),{recursive:!0}),await writeFile(i,`${JSON.stringify(r,null,2)}\n`),i}function isActiveChannel(e){return e.kind===`channel`}function toInstructionsEntry(e){return{logicalPath:e.logicalPath,sourceKind:e.sourceKind,markdown:e.markdown}}function toScheduleEntry(e){return{name:e.name,cron:e.cron,logicalPath:e.logicalPath}}function toToolEntry(e){return{name:e.name,description:e.description,logicalPath:e.logicalPath}}function toSkillEntry(e){return{name:e.name,description:e.description,logicalPath:e.logicalPath,sourceKind:e.sourceKind}}function toConnectionEntry(e){let t={name:e.connectionName,description:e.description,url:e.url,logicalPath:e.logicalPath,type:`mcp`};return e.vercelConnect===void 0?t:{...t,vercelConnect:{connector:e.vercelConnect.connector}}}function toChannelEntry(e){let t={name:e.name,method:e.method,urlPath:e.urlPath,type:normalizeChannelKindForDisplay(e.adapterKind),logicalPath:e.logicalPath};return e.adapterKind===void 0?t:{...t,adapterKind:e.adapterKind}}function toSubagentEntry(e){return{name:e.name,description:e.description,logicalPath:e.logicalPath}}export{buildVercelAgentSummary,emitVercelAgentSummary};