eve 0.5.4 → 0.6.0-beta.3

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

@@ -0,0 +1 @@
+import{dirname,join,resolve,sep}from"node:path";import{readFile,stat}from"node:fs/promises";import{parse}from"#compiled/jsonc-parser/index.js";const packageTsConfigPathsCache=new Map,nearestPackageRootCache=new Map;function createAuthoredPackageTsConfigPathsPlugin(e){return{name:`eve-package-tsconfig-paths`,async resolveId(t,r,i){if(r===void 0||!isPackageImport(t))return;let a=resolve(r);if(isPathInsideOrEqual(a,e.appPackageRoot))return;let o=await resolveNearestPackageRoot(a);if(o===void 0||isPathInsideOrEqual(o,e.appPackageRoot))return;let s=await loadPackageTsConfigPaths(o);if(s!==void 0)for(let n of createTsConfigPathCandidates(t,s)){let t=await this.resolve(n,r,{kind:i.kind,skipSelf:!0});if(t!==null)return t;let a=await resolveExistingPath(n,e.extensions);if(a!==void 0)return{id:a}}}}}function loadPackageTsConfigPaths(e){let t=packageTsConfigPathsCache.get(e);if(t!==void 0)return t;let n=readPackageTsConfigPaths(e);return packageTsConfigPathsCache.set(e,n),n}async function readPackageTsConfigPaths(t){let r=await readPackageConfig(t);if(r===void 0)return;let i=[],a=parse(r.source,i,{allowTrailingComma:!0});if(i.length>0||!isObjectRecord(a))return;let s=a.compilerOptions;if(!isObjectRecord(s)||!isObjectRecord(s.paths))return;let c=dirname(r.path),l=typeof s.baseUrl==`string`?resolve(c,s.baseUrl):c,u=Object.entries(s.paths).flatMap(([e,t])=>!Array.isArray(t)||!t.every(e=>typeof e==`string`)?[]:[{pattern:e,targets:t}]).sort((e,t)=>t.pattern.length-e.pattern.length);if(u.length!==0)return{baseDirectory:l,entries:u}}async function readPackageConfig(e){for(let n of[`tsconfig.json`,`jsconfig.json`]){let r=join(e,n);try{return{path:r,source:await readFile(r,`utf8`)}}catch(e){if(!isPathNotFoundError(e))throw e}}}function createTsConfigPathCandidates(e,t){let r=[];for(let i of t.entries){let a=matchTsConfigPathPattern(e,i.pattern);if(a!==void 0)for(let e of i.targets){let i=e.includes(`*`)?e.replaceAll(`*`,a):e;r.push(resolve(t.baseDirectory,i))}}return r}function matchTsConfigPathPattern(e,t){let n=t.indexOf(`*`);if(n===-1)return e===t?``:void 0;let r=t.slice(0,n),i=t.slice(n+1);if(!(!e.startsWith(r)||!e.endsWith(i)))return e.slice(r.length,e.length-i.length)}async function resolveExistingPath(e,n){if(await existsAsFile(e))return e;for(let t of n){let n=`${e}${t}`;if(await existsAsFile(n))return n}for(let r of n){let n=join(e,`index${r}`);if(await existsAsFile(n))return n}}async function existsAsFile(e){try{return(await stat(e)).isFile()}catch{return!1}}function resolveNearestPackageRoot(t){let n=dirname(t),r=nearestPackageRootCache.get(n);if(r!==void 0)return r;let i=findNearestPackageRoot(n);return nearestPackageRootCache.set(n,i),i}async function findNearestPackageRoot(n){let r=n;for(;;){if(await pathExists(join(r,`package.json`)))return r;let n=dirname(r);if(n===r)return;r=n}}async function pathExists(e){try{return await stat(e),!0}catch{return!1}}function isPathNotFoundError(e){return typeof e==`object`&&!!e&&`code`in e&&(e.code===`ENOENT`||e.code===`ENOTDIR`)}function isPackageImport(e){return e.startsWith(`.`)||e.startsWith(`/`)||/^[A-Za-z]:[\\/]/.test(e)?!1:!/^(?:node|data|file):/.test(e)}function isObjectRecord(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function isPathInsideOrEqual(e,t){let i=resolve(e),a=resolve(t);return i===a||i.startsWith(`${a}${sep}`)}export{createAuthoredPackageTsConfigPathsPlugin};

package/dist/src/internal/bundler/nitro-rolldown.d.ts

@@ -0,0 +1,26 @@
+type RolldownOutputChunk = {
+    readonly type: "chunk";
+    readonly code: string;
+    readonly fileName: string;
+};
+type RolldownOutputAsset = {
+    readonly type: "asset";
+    readonly fileName: string;
+    readonly source: string | Uint8Array;
+};
+type RolldownOutput = {
+    readonly output: readonly [RolldownOutputChunk, ...(RolldownOutputChunk | RolldownOutputAsset)[]];
+};
+export type RolldownBuild = (options: Record<string, unknown>) => Promise<RolldownOutput>;
+type RolldownParseAst = (sourceText: string, options?: Record<string, unknown> | null, filename?: string) => unknown;
+type RolldownParseAstModule = {
+    readonly parseAst: RolldownParseAst;
+};
+/**
+ * Loads Rolldown's parser from Nitro's dependency tree so workflow directive
+ * transforms can use the same bundler dependency without exposing it publicly.
+ */
+export declare function loadNitroRolldownParseAst(): Promise<RolldownParseAstModule>;
+export declare function buildWithNitroRolldown(options: Record<string, unknown>): Promise<RolldownOutput>;
+export declare function getSingleRolldownChunk(output: RolldownOutput, description: string): RolldownOutputChunk;
+export {};

package/dist/src/internal/bundler/nitro-rolldown.js

@@ -0,0 +1 @@
+import{createRequire}from"node:module";import{pathToFileURL}from"node:url";let rolldownPromise,rolldownParseAstPromise;function loadNitroRolldown(){return rolldownPromise??=(async()=>await import(pathToFileURL(createRequire(createRequire(import.meta.url).resolve(`nitro/package.json`)).resolve(`rolldown`)).href))(),rolldownPromise}function loadNitroRolldownParseAst(){return rolldownParseAstPromise??=(async()=>await import(pathToFileURL(createRequire(createRequire(import.meta.url).resolve(`nitro/package.json`)).resolve(`rolldown/parseAst`)).href))(),rolldownParseAstPromise}async function buildWithNitroRolldown(e){let{build:t}=await loadNitroRolldown();return await t(e)}function getSingleRolldownChunk(e,t){let n=e.output.filter(e=>e.type===`chunk`),r=n[0];if(r===void 0||n.length!==1)throw Error(`Expected one bundled ${t}.`);return r}export{buildWithNitroRolldown,getSingleRolldownChunk,loadNitroRolldownParseAst};

package/dist/src/internal/helpers/markdown.d.ts

@@ -0,0 +1,45 @@
+import { type ScheduleDefinition } from "#public/definitions/schedule.js";
+import { type SkillDefinition } from "#public/definitions/skill.js";
+import type { InstructionsDefinition } from "#public/definitions/instructions.js";
+/**
+ * Lowers authored instructions prompt markdown into the shared public
+ * definition shape. Instructions identity is path-derived, so the lowered
+ * definition never carries a `name`.
+ */
+export declare function lowerInstructionsMarkdown(markdown: string): InstructionsDefinition;
+/**
+ * Optional input for {@link lowerSkillMarkdown}.
+ *
+ * `slug` is the path-derived skill identifier (the directory name for a
+ * skill package, or the filename for a flat skill); it is used only to
+ * derive a sensible default description when the markdown body has none.
+ * Skill identity itself comes from the file path — the lowered definition
+ * never carries a `name`.
+ */
+interface LowerSkillMarkdownInput {
+    readonly description?: string;
+    readonly slug?: string;
+}
+/**
+ * Lowers authored skill markdown into the shared public definition shape.
+ *
+ * Supports both packaged skill files (`SKILL.md` inside a skill
+ * directory; description comes from frontmatter) and flat skill files
+ * (`<name>.md` next to other skills; description may be derived from
+ * the markdown body). Identity is path-derived, so an authored `name`
+ * frontmatter field is silently ignored — `SKILL.md` files commonly
+ * carry one for compatibility with the broader Agent Skills ecosystem,
+ * and we accept it without using it rather than rejecting the file.
+ */
+/**
+ * Lowers an authored schedule markdown file into the shared public
+ * definition shape. The frontmatter must contain `cron`. The body
+ * becomes the schedule's `markdown` (the fire-and-forget prompt the
+ * agent runs when the cron fires). Markdown-form schedules cannot
+ * declare a `run` handler — use the `.ts` form for handler-based
+ * schedules. Schedule identity is path-derived, so the lowered
+ * definition never carries a `name`.
+ */
+export declare function lowerScheduleMarkdown(source: string): ScheduleDefinition;
+export declare function lowerSkillMarkdown(source: string, input?: LowerSkillMarkdownInput): SkillDefinition;
+export {};

package/dist/src/internal/helpers/markdown.js

@@ -0,0 +1,3 @@
+import{isObject}from"#shared/guards.js";import{normalizeInstructionsDefinition,normalizeScheduleDefinition,normalizeSkillDefinition}from"#internal/authored-definition/core.js";import matter from"#compiled/gray-matter/index.js";import{defineSchedule}from"#public/definitions/schedule.js";import{defineSkill}from"#public/definitions/skill.js";const CLOSED_FRONTMATTER_PATTERN=/^---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$)/;function rejectJavaScriptFrontmatter(){throw Error(`JavaScript frontmatter is not supported.`)}const SAFE_GRAY_MATTER_OPTIONS={language:`yaml`,engines:{javascript:rejectJavaScriptFrontmatter,js:rejectJavaScriptFrontmatter}};function parseMarkdownDocument(t){if(!matter.test(t))return{hasFrontmatter:!1,frontmatter:{},markdown:t};let n;try{n=matter(t,SAFE_GRAY_MATTER_OPTIONS)}catch(e){throw startsWithFrontmatterFence(t)&&!hasClosedFrontmatterFence(t)?Error(`Markdown frontmatter is missing a closing delimiter.`):e}if(!isObject(n.data))throw Error(`Markdown frontmatter must parse to an object.`);return{hasFrontmatter:!0,frontmatter:n.data,markdown:normalizeFrontmatterMarkdownBody(n.content)}}function lowerInstructionsMarkdown(e){return normalizeInstructionsDefinition({markdown:e},`Expected authored instructions markdown to match the public Eve shape.`)}function lowerScheduleMarkdown(e){let t=parseMarkdownDocument(e);if(!t.hasFrontmatter)throw Error(`Schedule markdown must start with YAML frontmatter declaring "cron".`);if(`run`in t.frontmatter)throw Error('Markdown-form schedules do not support the "run" frontmatter key. Use a TypeScript schedule (`<name>.ts`) to author a handler.');return defineSchedule(normalizeScheduleDefinition({...t.frontmatter,markdown:t.markdown},`Expected authored schedule markdown to match the public Eve shape.`))}function lowerSkillMarkdown(e,t={}){let n=parseMarkdownDocument(e),i=t.slug;if(i===void 0&&!n.hasFrontmatter)throw Error(`Skill markdown must start with YAML frontmatter.`);let a=stripIgnoredSkillFrontmatterKeys(n.frontmatter),o=toOptionalString(a.description,`description`),s=i===void 0?requireStringFrontmatter(a.description,`description`):o??t.description??deriveFlatSkillDescription(n.markdown,i),c={...a,description:s,markdown:n.markdown};return applyOptionalSkillFrontmatter(c,a),defineSkill(normalizeSkillDefinition(c,`Expected authored skill markdown to match the public Eve shape.`))}function startsWithFrontmatterFence(e){return e.startsWith(`---
+`)||e.startsWith(`---\r
+`)}function hasClosedFrontmatterFence(e){return CLOSED_FRONTMATTER_PATTERN.test(e)}function normalizeFrontmatterMarkdownBody(e){return e.replace(/^\r?\n/u,``)}function applyOptionalSkillFrontmatter(e,t){let n=toOptionalString(t.license,`license`);n!==void 0&&(e.license=n);let r=toOptionalStringRecord(t.metadata,`metadata`);r!==void 0&&(e.metadata=r)}const IGNORED_SKILL_FRONTMATTER_KEYS=[`name`];function stripIgnoredSkillFrontmatterKeys(e){let t={...e};for(let e of IGNORED_SKILL_FRONTMATTER_KEYS)delete t[e];return t}function toOptionalString(e,t){if(e!=null){if(typeof e!=`string`)throw Error(`Expected "${t}" frontmatter to be a string.`);return e}}function requireStringFrontmatter(e,t){let n=toOptionalString(e,t);if(n===void 0)throw Error(`Missing required "${t}" frontmatter.`);return n}function toOptionalStringRecord(t,n){if(t==null)return;if(!isObject(t))throw Error(`Expected "${n}" frontmatter to be an object.`);let r=Object.entries(t).map(([e,t])=>{if(typeof t!=`string`)throw Error(`Expected "${n}.${e}" frontmatter to be a string.`);return[e,t]});return Object.fromEntries(r)}function deriveFlatSkillDescription(e,t){let n=e.split(/\r?\n/u).map(e=>e.trim()).find(e=>e!==``&&!e.startsWith("```"));return n===void 0?`Instructions for the ${t} skill.`:n.replace(/^[#>*\-\s]+/u,``).trim()||`Instructions for the ${t} skill.`}export{lowerInstructionsMarkdown,lowerScheduleMarkdown,lowerSkillMarkdown};

package/dist/src/internal/instrumentation.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Shared instrumentation primitives used by both the channel projection
+ * builder (`#channel/instrumentation.ts`) and the harness telemetry
+ * builder (`#harness/instrumentation-runtime-context.ts`).
+ *
+ * Both layers resolve a user-authored projector callback into a plain
+ * record and reason about the same channel-kind vocabulary. Keeping that
+ * vocabulary and the defensive resolution shell in one place stops the
+ * two sites from drifting (e.g. the framework-kind set growing in one
+ * file but not the other).
+ */
+import { type Logger } from "#internal/logging.js";
+import type { InstrumentationChannelKind } from "#public/channels/index.js";
+/**
+ * Returns `true` when `kind` is a valid instrumentation channel kind: a
+ * framework kind (`"http"`, `"schedule"`, `"subagent"`) or a
+ * path-derived `channel:<name>` kind.
+ */
+export declare function isInstrumentationChannelKind(kind: string): kind is InstrumentationChannelKind;
+/**
+ * Narrows a raw kind string to the public {@link InstrumentationChannelKind}
+ * union, falling back to `"unknown"` for anything unrecognized or absent.
+ */
+export declare function normalizeInstrumentationChannelKind(rawKind: string | undefined): InstrumentationChannelKind;
+/**
+ * Invokes a user-authored instrumentation projector defensively.
+ *
+ * Returns the JSON object the projector produced. Returns `undefined`
+ * without warning for a no-op `undefined`, or with a warning when it threw,
+ * returned a `Promise`, returned an incorrect shape, or included values
+ * outside Eve's JSON contract. Every rejection path is warning-only so
+ * instrumentation can never break the turn. Per-value shaping (for example
+ * reserved-key filtering) is left to the caller, since the channel and
+ * harness expose different value shapes.
+ */
+export declare function resolveInstrumentationProjection(input: {
+    readonly invoke: () => unknown;
+    readonly log: Logger;
+    readonly source: string;
+}): Record<string, unknown> | undefined;

package/dist/src/internal/instrumentation.js

@@ -0,0 +1 @@
+import{formatError}from"#internal/logging.js";import{isPlainRecord,isThenable}from"#shared/guards.js";import{parseJsonObject}from"#shared/json.js";const FRAMEWORK_CHANNEL_KINDS=new Set([`http`,`schedule`,`subagent`]);function isInstrumentationChannelKind(e){return e.startsWith(`channel:`)||FRAMEWORK_CHANNEL_KINDS.has(e)}function normalizeInstrumentationChannelKind(e){return e!==void 0&&isInstrumentationChannelKind(e)?e:`unknown`}function resolveInstrumentationProjection(n){let{invoke:r,log:i,source:a}=n,o;try{o=r()}catch(t){i.warn(`ignoring instrumentation projection after projector failure`,{error:formatError(t),source:a});return}if(isThenable(o)){i.warn(`ignoring instrumentation projection because it returned a Promise`,{source:a}),Promise.resolve(o).catch(t=>{i.warn(`ignored instrumentation projection Promise rejected`,{error:formatError(t),source:a})});return}if(o!==void 0){if(!isPlainRecord(o)){i.warn(`ignoring instrumentation projection because it is not a record`,{source:a});return}try{return parseJsonObject(o)}catch(t){i.warn(`ignoring instrumentation projection because it is outside the JSON contract`,{error:formatError(t),source:a});return}}}export{isInstrumentationChannelKind,normalizeInstrumentationChannelKind,resolveInstrumentationProjection};

package/dist/src/internal/json-schema.d.ts

@@ -0,0 +1 @@
+export { normalizeJsonSchemaDefinition } from "#shared/json-schema.js";

package/dist/src/internal/json-schema.js

@@ -0,0 +1 @@
+import{normalizeJsonSchemaDefinition}from"#shared/json-schema.js";export{normalizeJsonSchemaDefinition};

package/dist/src/internal/logging.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Framework-internal structured logger.
+ *
+ * Not public API; authors should use their own logger or Vercel
+ * observability primitives.
+ */
+import { type Span } from "#compiled/@opentelemetry/api/index.js";
+import type { JsonObject } from "#shared/json.js";
+/**
+ * Extra structured context attached to a log record.
+ *
+ * Values that are Errors are normalized through {@link formatError}
+ * before rendering, so a caller can pass `{ error }` and the full
+ * cause chain will flow through to the sink.
+ */
+type LogFields = Readonly<Record<string, unknown>>;
+/**
+ * One namespaced logger handle. Returned by {@link createLogger}.
+ *
+ * Every method accepts an optional {@link LogFields} record of extra
+ * key/value pairs to attach to the rendered line. Callers that want to
+ * associate related lines should pass the same `errorId` on each call.
+ */
+export interface Logger {
+    debug(message: string, fields?: LogFields): void;
+    info(message: string, fields?: LogFields): void;
+    warn(message: string, fields?: LogFields): void;
+    error(message: string, fields?: LogFields): void;
+}
+/**
+ * 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 declare function createLogger(namespace: string): Logger;
+/**
+ * Logs any throwable at `error` severity with its full {@link formatError}
+ * representation, and returns the correlated `errorId`.
+ *
+ * Prefer over `logger.error(message, { error })` at `catch` sites where the
+ * caught value is `unknown`: it also normalizes non-`Error` throwables (e.g.
+ * plain objects that crossed a workflow step boundary) that the bare logger
+ * would otherwise emit without a `detail` dump.
+ */
+export declare function logError(logger: Logger, message: string, error: unknown, fields?: LogFields): string;
+/**
+ * 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 declare function createErrorId(): string;
+/**
+ * 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 declare function formatError(error: unknown, errorId?: string): JsonObject;
+/**
+ * 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 declare function extractErrorId(details: unknown): string | 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 declare function formatErrorHint(event: {
+    readonly message?: string;
+    readonly details?: unknown;
+}): string;
+/**
+ * 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 declare function recordErrorOnSpan(span: Span, error: unknown): void;
+export {};

package/dist/src/internal/logging.js

@@ -0,0 +1 @@
+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";const LEVEL_SEVERITY={debug:10,info:20,warn:30,error:40};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 logError(e,t,n,r){let i=formatError(n);return e.error(t,{...r,error:i}),typeof i.errorId==`string`?i.errorId:createErrorId()}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 resolveThreshold(){let e=process.env.EVE_LOG_LEVEL?.toLowerCase();return e===`debug`||e===`info`||e===`warn`||e===`error`?LEVEL_SEVERITY[e]:LEVEL_SEVERITY.info}function write(e,t,n,r){if(LEVEL_SEVERITY[e]<resolveThreshold())return;let i=e===`error`?console.error:e===`warn`?console.warn:console.log,a=`[eve:${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 a=t?.error;if(a instanceof Error){recordErrorOnSpan(n,a);return}if(isFormattedError(a)){n.setStatus({code:SpanStatusCode.ERROR,message:a.message}),n.recordException({message:a.message,name:typeof a.name==`string`?a.name:`Error`,stack:typeof a.detail==`string`?a.detail:void 0});return}n.addEvent(e,t?renderFields(t):void 0)}function isFormattedError(e){return isObject(e)&&typeof e.errorId==`string`&&typeof e.message==`string`}function inspectError(t){return truncate(inspect(t,{breakLength:1/0,compact:!1,depth:10,maxStringLength:8192}),16384)}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,logError,recordErrorOnSpan};

package/dist/src/internal/nitro/dev-runtime-artifacts.d.ts

@@ -0,0 +1,32 @@
+import type { CompileAgentResult } from "#compiler/compile-agent.js";
+export interface DevelopmentRuntimeArtifactsRevision {
+    readonly revision: string;
+}
+/**
+ * Resolves the dev-server pointer that records the latest runtime artifact
+ * snapshot for new sessions.
+ */
+export declare function resolveDevelopmentRuntimeArtifactsPointerPath(appRoot: string): string;
+/**
+ * Publishes one immutable dev runtime snapshot and points future sessions at it.
+ */
+export declare function publishDevelopmentRuntimeArtifactsSnapshot(compileResult: CompileAgentResult): Promise<string>;
+/**
+ * Stages one immutable dev runtime snapshot without moving the latest pointer.
+ */
+export declare function stageDevelopmentRuntimeArtifactsSnapshot(compileResult: CompileAgentResult): Promise<string>;
+/**
+ * Moves the dev runtime pointer so future sessions use a staged snapshot.
+ */
+export declare function activateDevelopmentRuntimeArtifactsSnapshot(input: {
+    readonly appRoot: string;
+    readonly snapshotRoot: string;
+}): Promise<void>;
+/**
+ * Reads the latest dev runtime snapshot root when the dev server has one.
+ */
+export declare function readDevelopmentRuntimeArtifactsSnapshotRoot(pointerPath: string | undefined): string | undefined;
+/**
+ * Reads a revision token for the latest dev runtime artifact snapshot.
+ */
+export declare function readDevelopmentRuntimeArtifactsRevision(appRoot: string): DevelopmentRuntimeArtifactsRevision;

package/dist/src/internal/nitro/dev-runtime-artifacts.js

@@ -0,0 +1 @@
+import{basename,dirname,join,relative}from"node:path";import{cp,mkdir,readFile,readdir,rename,rm,writeFile}from"node:fs/promises";import{existsSync,readFileSync}from"node:fs";import{randomUUID}from"node:crypto";const DEV_RUNTIME_ARTIFACTS_DIRECTORY=`dev-runtime`,DEV_RUNTIME_ARTIFACTS_SNAPSHOT_SKIP_NAMES=new Set([`.eve`,`.git`,`.output`,`.turbo`,`.vercel`,`.workflow-data`,`node_modules`]);function resolveDevelopmentRuntimeArtifactsPointerPath(e){return join(e,`.eve`,DEV_RUNTIME_ARTIFACTS_DIRECTORY,`current.json`)}async function publishDevelopmentRuntimeArtifactsSnapshot(e){let t=await stageDevelopmentRuntimeArtifactsSnapshot(e);return await activateDevelopmentRuntimeArtifactsSnapshot({appRoot:e.project.appRoot,snapshotRoot:t}),t}async function stageDevelopmentRuntimeArtifactsSnapshot(e){let t=join(e.project.appRoot,`.eve`,DEV_RUNTIME_ARTIFACTS_DIRECTORY,`snapshots`,`${Date.now().toString(36)}-${randomUUID()}`);return await copyAuthoredAppSourceSnapshot({appRoot:e.project.appRoot,snapshotRoot:t}),await cp(e.paths.compileDirectoryPath,join(t,`.eve`,`compile`),{recursive:!0}),await rewriteSnapshotCompiledManifest({appRoot:e.project.appRoot,manifestPath:join(t,`.eve`,`compile`,`compiled-agent-manifest.json`),snapshotRoot:t}),t}async function activateDevelopmentRuntimeArtifactsSnapshot(e){await writeDevelopmentRuntimeArtifactsPointer(e)}function readDevelopmentRuntimeArtifactsSnapshotRoot(e){if(!(e===void 0||!existsSync(e)))try{let t=JSON.parse(readFileSync(e,`utf8`));return t.kind!==`eve-dev-runtime-artifacts-pointer`||t.version!==1||typeof t.appRoot!=`string`||t.appRoot.length===0?void 0:t.appRoot}catch{return}}function readDevelopmentRuntimeArtifactsRevision(e){return{revision:readDevelopmentRuntimeArtifactsSnapshotRoot(resolveDevelopmentRuntimeArtifactsPointerPath(e))??e}}async function copyAuthoredAppSourceSnapshot(e){await mkdir(e.snapshotRoot,{recursive:!0});for(let t of await readdir(e.appRoot,{withFileTypes:!0}))DEV_RUNTIME_ARTIFACTS_SNAPSHOT_SKIP_NAMES.has(t.name)||await cp(join(e.appRoot,t.name),join(e.snapshotRoot,t.name),{filter:t=>!shouldSkipSnapshotSource(e.appRoot,t),recursive:!0})}function shouldSkipSnapshotSource(e,t){let n=relative(e,t);return n.length===0?!1:n.split(/[\\/]/).some(e=>DEV_RUNTIME_ARTIFACTS_SNAPSHOT_SKIP_NAMES.has(e))}async function rewriteSnapshotCompiledManifest(e){let t=JSON.parse(await readFile(e.manifestPath,`utf8`)),n=rewriteManifestRoots({appRoot:e.appRoot,snapshotRoot:e.snapshotRoot,value:t});await writeFile(e.manifestPath,`${JSON.stringify(n,null,2)}\n`)}function rewriteManifestRoots(e){if(Array.isArray(e.value))return e.value.map(t=>rewriteManifestRoots({...e,value:t}));if(e.value===null||typeof e.value!=`object`)return e.value;let t={};for(let[n,r]of Object.entries(e.value)){if(typeof r==`string`&&(n===`appRoot`||n===`agentRoot`)){t[n]=rewritePathWithinAppRoot({appRoot:e.appRoot,path:r,snapshotRoot:e.snapshotRoot});continue}t[n]=rewriteManifestRoots({appRoot:e.appRoot,snapshotRoot:e.snapshotRoot,value:r})}return t}function rewritePathWithinAppRoot(t){let i=relative(t.appRoot,t.path);return i.startsWith(`..`)||i.length===0||basename(i)===``?t.path===t.appRoot?t.snapshotRoot:t.path:join(t.snapshotRoot,i)}async function writeDevelopmentRuntimeArtifactsPointer(e){let n=resolveDevelopmentRuntimeArtifactsPointerPath(e.appRoot),r=`${n}.${randomUUID()}.tmp`,i={appRoot:e.snapshotRoot,kind:`eve-dev-runtime-artifacts-pointer`,version:1};await mkdir(dirname(n),{recursive:!0}),await writeFile(r,`${JSON.stringify(i,null,2)}\n`);try{await rename(r,n)}catch(e){throw await rm(r,{force:!0}).catch(()=>{}),e}}export{activateDevelopmentRuntimeArtifactsSnapshot,publishDevelopmentRuntimeArtifactsSnapshot,readDevelopmentRuntimeArtifactsRevision,readDevelopmentRuntimeArtifactsSnapshotRoot,resolveDevelopmentRuntimeArtifactsPointerPath,stageDevelopmentRuntimeArtifactsSnapshot};

package/dist/src/internal/nitro/host/artifacts-config.d.ts

@@ -0,0 +1,16 @@
+import type { NitroArtifactsConfig } from "#internal/nitro/routes/runtime-artifacts.js";
+/**
+ * Artifacts config serialized into virtual Nitro handlers so route handlers
+ * can resolve compiled artifacts without a global runtime configuration store.
+ */
+export interface NitroArtifactsConfigInput extends NitroArtifactsConfig {
+    readonly appRoot: string;
+    readonly dev: boolean;
+}
+/**
+ * Creates the artifacts config baked into Nitro virtual handlers.
+ */
+export declare function createNitroArtifactsConfig(input: {
+    readonly appRoot: string;
+    readonly dev: boolean;
+}): NitroArtifactsConfigInput;

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

@@ -0,0 +1 @@
+import{resolvePackageSourceFilePath}from"#internal/application/package.js";import{resolveDevelopmentRuntimeArtifactsPointerPath}from"#internal/nitro/dev-runtime-artifacts.js";function createNitroArtifactsConfig(e){return e.dev?{appRoot:e.appRoot,devRuntimeArtifactsPointerPath:resolveDevelopmentRuntimeArtifactsPointerPath(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.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Builds the production Nitro output for an Eve application.
+ */
+export declare function buildApplication(rootDir: string): Promise<string>;

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

@@ -0,0 +1 @@
+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{prepareEveVersionedCacheDirectory,writeEveVersionedCacheMetadata}from"#internal/application/cache-metadata.js";import{WorkflowBundleBuilder}from"#internal/workflow-bundle/builder.js";import{normalizeEveVercelFunctionOutput}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";import{findClosestVercelOutputDirectory}from"#shared/vercel-output-directory.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 normalizeServicePrefix(e){return typeof e.routePrefix==`string`?e.routePrefix.trim():typeof e.mount==`string`?e.mount.trim():isRecord(e.mount)&&typeof e.mount.path==`string`&&e.mount.path.trim().length>0?e.mount.path.trim():``}function resolveCoDeployedEveServicePrefix(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!==`eve`){t=!0;continue}let i=normalizeEntrypoint(e.configRoot,r.entrypoint),a=normalizeServicePrefix(r);i===e.appRoot&&a.length>0&&a!==`/`&&(n=a)}return t?n:void 0}async function resolveCoDeployedEveServicePrefixForVercelFunctionOutput(n){let i=await findClosestVercelOutputDirectory(n);if(i!==void 0)try{let e=resolveCoDeployedEveServicePrefix({appRoot:n,configRoot:n,config:JSON.parse(await readFile(join(i,`config.json`),`utf8`))});if(e!==void 0)return e}catch(e){if(!(e instanceof Error&&`code`in e&&e.code===`ENOENT`))throw e}let a=n;for(;;){for(let e of[join(a,`vercel.json`),join(a,`.vercel`,`output`,`config.json`)])try{let t=JSON.parse(await readFile(e,`utf8`)),i=resolveCoDeployedEveServicePrefix({appRoot:n,configRoot:e.endsWith(`vercel.json`)?a:n,config:t});if(i!==void 0)return i}catch(e){if(!(e instanceof Error&&`code`in e&&e.code===`ENOENT`))throw e}let i=dirname(a);if(i===a)return;a=i}}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 prepareEveVersionedCacheDirectory(t),await prepare(e),await copyPublicAssets(e),await prerender(e),await build(e),await writeEveVersionedCacheMetadata(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 resolveCoDeployedEveServicePrefixForVercelFunctionOutput(t.appRoot),r=await createApplicationNitro(t,!1,{surface:`app`});try{let e=await buildNitroOutput(r);await runVercelBuildPrewarm({appRoot:t.appRoot,log(e){console.log(e)}});let i=await buildVercelNitroSurface(t,`flow`);return await emitVercelWorkflowFunctions({appRoot:t.appRoot,compiledArtifactsBootstrapPath:t.compiledArtifacts.bootstrapPath,flowNitroOutputDir:i,outputDir:e,workflowBuildDir:t.workflowBuildDir}),n!==void 0&&await normalizeEveVercelFunctionOutput(e,{servicePrefix:n}),await emitVercelAgentSummary({manifest:t.compileResult.manifest,appRoot:t.appRoot}),e}finally{await r.close()}}export{buildApplication};

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

@@ -0,0 +1,40 @@
+import type { CompiledAgentManifest } from "#compiler/manifest.js";
+import { type VercelEveAgentSummary } from "#internal/vercel-agent-summary.js";
+/**
+ * Builds the public {@link VercelEveAgentSummary} 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 declare function buildVercelAgentSummary(input: {
+    manifest: CompiledAgentManifest;
+    generatorVersion?: string;
+}): VercelEveAgentSummary;
+/**
+ * Writes the agent summary file. Returns the absolute path of the
+ * written file.
+ *
+ * The file is written to {@link VERCEL_EVE_AGENT_SUMMARY_OUTPUT_PATH}
+ * relative to {@link input.appRoot} — i.e.
+ * `<appRoot>/.eve/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-eve-agent-summary.ts` helper picks up this file from
+ * `rootPath` (which equals `appRoot` for the project being built) and
+ * uploads it to `<projectId>/<deploymentId>/eve_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/eve-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 declare function emitVercelAgentSummary(input: {
+    manifest: CompiledAgentManifest;
+    appRoot: string;
+    generatorVersion?: string;
+}): Promise<string>;

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

@@ -0,0 +1 @@
+import{dirname,join}from"node:path";import{mkdir,writeFile}from"node:fs/promises";import{resolveInstalledPackageInfo}from"#internal/application/package.js";import{VERCEL_EVE_AGENT_SUMMARY_KIND,VERCEL_EVE_AGENT_SUMMARY_OUTPUT_PATH,VERCEL_EVE_AGENT_SUMMARY_VERSION,normalizeChannelKindForDisplay}from"#internal/vercel-agent-summary.js";function buildVercelAgentSummary(e){let{manifest:t}=e;return{kind:VERCEL_EVE_AGENT_SUMMARY_KIND,schemaVersion:VERCEL_EVE_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_EVE_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:e.protocol};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};

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

@@ -0,0 +1,38 @@
+import type { Nitro } from "nitro/types";
+import type { ChannelRouteMethod } 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 Eve channel.
+ */
+export interface NitroChannelRouteRegistration {
+    readonly method: ChannelRouteMethod;
+    readonly route: string;
+}
+/**
+ * Computes the merged set of channel routes the Nitro host should mount.
+ */
+export declare function computeChannelRouteRegistrations(preparedHost: PreparedApplicationHost): readonly NitroChannelRouteRegistration[];
+/**
+ * Registers virtual Nitro handlers for the provided Eve channel routes.
+ */
+export declare function registerChannelVirtualHandlers(nitro: Pick<ChannelRouteNitro, "options">, input: {
+    readonly artifactsConfig: NitroArtifactsConfigInput;
+    readonly registrations: readonly NitroChannelRouteRegistration[];
+}): void;
+/**
+ * Replaces the currently-mounted Eve channel virtual handlers when the route
+ * set changes.
+ */
+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/channel-routes.js

@@ -0,0 +1,3 @@
+import{resolvePackageDependencyPath,resolvePackageSourceFilePath}from"#internal/application/package.js";import{stringifyEsmImportSpecifier}from"#internal/application/import-specifier.js";import{getAllFrameworkChannelNames,getFrameworkChannelDefinitions}from"#runtime/framework-channels/index.js";const EVE_CHANNEL_VIRTUAL_ID_PREFIX=`#eve-channel/`;function computeChannelRouteRegistrations(e){let t=e.compileResult.manifest.channels,n=new Set,a=[],o=new Set,s=getAllFrameworkChannelNames();for(let e of t){if(e.kind===`disabled`){if(!s.has(e.name))throw Error(`agent/channels/${e.name}.ts exports disableRoute() but "${e.name}" is not a framework channel. Rename the file to one of: ${[...s].sort().join(`, `)}.`);o.add(e.name);continue}n.add(e.name),a.push({method:e.method,route:e.urlPath})}let c=getFrameworkChannelDefinitions().filter(e=>!n.has(e.name)&&!o.has(e.name)).map(e=>({method:e.method,route:e.urlPath})),l=new Set,u=[];for(let e of[...c,...a]){let t=createChannelRouteKey(e);l.has(t)||(l.add(t),u.push(e))}return u}function registerChannelVirtualHandlers(e,t){for(let n of t.registrations)addChannelVirtualHandler(e,{artifactsConfig:t.artifactsConfig,method:n.method,route:n.route})}function syncChannelVirtualHandlers(e,t){return areChannelRouteRegistrationsEqual(t.previous,t.next)?!1:(removeChannelVirtualHandlers(e),registerChannelVirtualHandlers(e,{artifactsConfig:t.artifactsConfig,registrations:t.next}),e.routing.sync(),!0)}function createChannelRouteKey(e){return`${e.method.toUpperCase()} ${e.route}`}function addChannelVirtualHandler(r,i){let o=createChannelRouteKey(i),s=`${EVE_CHANNEL_VIRTUAL_ID_PREFIX}${o}`,c=stringifyEsmImportSpecifier(resolvePackageSourceFilePath(`src/internal/nitro/routes/channel-dispatch.ts`)),l=stringifyEsmImportSpecifier(resolvePackageDependencyPath(`nitro`));if(i.method===`WEBSOCKET`){r.options.handlers.push({handler:s,route:i.route}),r.options.virtual[s]=[`import { defineWebSocketHandler } from ${l};`,`import { dispatchChannelWebSocketRequest } from ${c};`,`const config = ${JSON.stringify(i.artifactsConfig)};`,`export default defineWebSocketHandler((event) => dispatchChannelWebSocketRequest(event, ${JSON.stringify(o)}, config));`].join(`
+`);return}r.options.handlers.push({handler:s,method:i.method,route:i.route}),r.options.virtual[s]=[`import { dispatchChannelRequest } from ${c};`,`const config = ${JSON.stringify(i.artifactsConfig)};`,`export default (event) => dispatchChannelRequest(event, ${JSON.stringify(o)}, config);`].join(`
+`)}function removeChannelVirtualHandlers(e){for(let t=e.options.handlers.length-1;t>=0;--t){let n=e.options.handlers[t];n!==void 0&&isChannelVirtualHandler(n)&&e.options.handlers.splice(t,1)}for(let t of Object.keys(e.options.virtual))t.startsWith(EVE_CHANNEL_VIRTUAL_ID_PREFIX)&&delete e.options.virtual[t]}function isChannelVirtualHandler(e){return e.handler.startsWith(EVE_CHANNEL_VIRTUAL_ID_PREFIX)}function areChannelRouteRegistrationsEqual(e,t){if(e.length!==t.length)return!1;for(let n=0;n<e.length;n+=1){let r=e[n],i=t[n];if(r===void 0||i===void 0||r.method!==i.method||r.route!==i.route)return!1}return!0}export{computeChannelRouteRegistrations,registerChannelVirtualHandlers,syncChannelVirtualHandlers};

package/dist/src/internal/nitro/host/code-mode-runtime-dependency-plugin.d.ts

@@ -0,0 +1 @@
+export default function installCodeModeRuntimeDependencyPlugin(): void;

package/dist/src/internal/nitro/host/code-mode-runtime-dependency-plugin.js

@@ -0,0 +1 @@
+import{installCodeModeModule}from"#shared/code-mode.js";import*as codeMode from"#compiled/experimental-ai-sdk-code-mode/index.js";installCodeModeModule(codeMode);function installCodeModeRuntimeDependencyPlugin(){}export{installCodeModeRuntimeDependencyPlugin as default};

package/dist/src/internal/nitro/host/compiled-sandbox-backend-prune-plugin.d.ts

@@ -0,0 +1,13 @@
+interface BundlerPluginShape {
+    readonly name: string;
+    load?(id: string): string | null | undefined;
+    resolveId?(source: string, importer: string | undefined): string | {
+        id: string;
+    } | null | undefined;
+}
+/**
+ * Creates the bundler plugin that prunes the local sandbox backend module
+ * from hosted Nitro server bundles.
+ */
+export declare function createCompiledSandboxBackendPrunePlugin(): BundlerPluginShape;
+export {};

package/dist/src/internal/nitro/host/compiled-sandbox-backend-prune-plugin.js

@@ -0,0 +1,2 @@
+const PRUNED_LOCAL_SANDBOX_MODULE_ID=`\0eve-pruned-local-sandbox-backend`,LOCAL_BINDING_SOURCE_RE=/[/\\]bindings[/\\]local\.js$/;function createCompiledSandboxBackendPrunePlugin(){return{name:`eve-hosted-sandbox-backend-prune`,load(e){return e===PRUNED_LOCAL_SANDBOX_MODULE_ID?[`export function createLocalSandboxBackend() {`,`  throw new Error("The local sandbox backend is pruned from hosted server bundles.");`,`}`,``].join(`
+`):null},resolveId(t){return LOCAL_BINDING_SOURCE_RE.test(t)?PRUNED_LOCAL_SANDBOX_MODULE_ID:null}}}export{createCompiledSandboxBackendPrunePlugin};

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

@@ -0,0 +1,9 @@
+import type { Nitro } from "nitro/types";
+import type { NitroBuildSurface, PreparedApplicationHost } from "#internal/nitro/host/types.js";
+/**
+ * Wires Eve's package-owned app, channel, workflow inspection, and Workflow
+ * SDK endpoints into one Nitro host instance.
+ */
+export declare function configureNitroRoutes(nitro: Nitro, preparedHost: PreparedApplicationHost, input: {
+    surface: NitroBuildSurface;
+}): Promise<void>;

package/dist/src/internal/nitro/host/configure-nitro-routes.js

@@ -0,0 +1,4 @@
+import{EVE_DEV_DISPATCH_SCHEDULE_ROUTE_PATTERN,EVE_DEV_RUNTIME_ARTIFACTS_ROUTE_PATH,EVE_HEALTH_ROUTE_PATH,EVE_INFO_ROUTE_PATH}from"#protocol/routes.js";import{dirname,join,relative}from"node:path";import{mkdir,writeFile}from"node:fs/promises";import{resolvePackageRoot,resolvePackageSourceFilePath,resolveWorkflowModulePath}from"#internal/application/package.js";import{normalizeEsmImportSpecifier,stringifyEsmImportSpecifier}from"#internal/application/import-specifier.js";import{WorkflowBundleBuilder}from"#internal/workflow-bundle/builder.js";import{createNitroArtifactsConfig}from"#internal/nitro/host/artifacts-config.js";import{computeChannelRouteRegistrations,registerChannelVirtualHandlers}from"#internal/nitro/host/channel-routes.js";function includesApplicationRoutes(e){return e===`all`||e===`app`}function includesWorkflowBundles(e){return includesWorkflowRoute(e)}function includesWorkflowRoute(e){return e===`all`||e===`flow`}function registerHandler(e,t){let n=`#eve-route-handler/${t.method??`ALL`} ${t.route}`,r=stringifyEsmImportSpecifier(t.handlerPath);e.options.handlers.push({handler:n,method:t.method,route:t.route}),e.options.virtual[n]=[`import handler from ${r};`,`export default handler;`].join(`
+`)}function resolveNitroWorkflowBuildDirectory(e){return join(e.options.buildDir,`workflow`)}function createRelativeImportSpecifier(e,t){let n=relative(e,t).replaceAll(`\\`,`/`);return n.startsWith(`.`)?n:`./${n}`}async function addWorkflowFileHandler(e,t){let n=join(resolveNitroWorkflowBuildDirectory(e),`${t.bundleName}-handler.mjs`),r=dirname(n),a=createRelativeImportSpecifier(r,t.bundlePath),c=(t.directHandlers??[]).map(e=>{let t=createRelativeImportSpecifier(r,e.bundlePath);return{importSpecifier:t,isOwnBundle:t===a,queuePrefix:e.queuePrefix}});await mkdir(r,{recursive:!0}),await writeFile(n,buildWorkflowFileHandlerSource({bundlePath:a,directHandlers:c,runtimeImportSpecifier:t.runtimeImportSpecifier})),e.options.handlers.push({handler:n,route:t.route})}function buildWorkflowFileHandlerSource(e){let t=[`// Generated by Eve. Do not edit by hand.`,`import { POST } from ${JSON.stringify(e.bundlePath)};`];if(e.directHandlers.length>0&&e.runtimeImportSpecifier!==void 0){let n=0,r=e.directHandlers.map(e=>{if(e.isOwnBundle)return{...e,binding:`POST`};let t=`__eveWorkflowDirectHandler${n}`;return n+=1,{...e,binding:t}});for(let e of r)e.isOwnBundle||t.push(`import { POST as ${e.binding} } from ${JSON.stringify(e.importSpecifier)};`);t.push(`import { getWorld as __eveGetWorkflowWorld } from ${JSON.stringify(e.runtimeImportSpecifier)};`,``,`try {`,`  const __eveWorkflowWorld = await __eveGetWorkflowWorld();`,`  if (typeof __eveWorkflowWorld?.registerHandler === "function") {`);for(let e of r)t.push(`    __eveWorkflowWorld.registerHandler(${JSON.stringify(e.queuePrefix)}, ${e.binding});`);t.push(`  }`,`} catch (err) {`,`  console.warn("[eve] Failed to register direct workflow queue handlers:", err);`,`}`)}return t.push(``,`export default async ({ req }) => {`,`  return await POST(req);`,`};`,``),t.join(`
+`)}function addFrameworkVirtualHandler(e,t){let n=`#eve-route${t.route}`,r=stringifyEsmImportSpecifier(t.modulePath);e.options.handlers.push({handler:n,method:t.method,route:t.route}),e.options.virtual[n]=[`import { ${t.handlerExport} } from ${r};`,`export default async (event) => ${t.handlerExport}(${t.args}, event.req);`].join(`
+`)}async function configureNitroRoutes(i,a,o){if(includesWorkflowBundles(o.surface)){let e=resolvePackageRoot(),t=new WorkflowBundleBuilder({appRoot:a.appRoot,compiledArtifactsBootstrapPath:a.compiledArtifacts.bootstrapPath,outDir:a.workflowBuildDir,rootDir:e,watch:i.options.dev}),n=Promise.resolve(),buildWorkflowArtifacts=async()=>{await t.build({nitroStepOutfile:includesWorkflowRoute(o.surface)?join(resolveNitroWorkflowBuildDirectory(i),`steps.mjs`):void 0,nitroWorkflowOutfile:i.options.dev&&includesWorkflowRoute(o.surface)?join(resolveNitroWorkflowBuildDirectory(i),`workflows.mjs`):void 0})},syncWorkflowArtifacts=async()=>{let e=n.then(buildWorkflowArtifacts);n=e.catch(()=>{}),await e},r=!0;await syncWorkflowArtifacts(),i.hooks.hook(`build:before`,async()=>{if(r){r=!1;return}await syncWorkflowArtifacts()}),i.options.dev&&i.hooks.hook(`dev:reload`,async()=>{await syncWorkflowArtifacts()})}let s=createNitroArtifactsConfig({appRoot:a.appRoot,dev:i.options.dev});includesApplicationRoutes(o.surface)&&(registerHandler(i,{handlerPath:resolvePackageSourceFilePath(`src/internal/nitro/routes/index.ts`),method:`GET`,route:`/`}),registerHandler(i,{handlerPath:resolvePackageSourceFilePath(`src/internal/nitro/routes/health.ts`),method:`GET`,route:EVE_HEALTH_ROUTE_PATH}),addFrameworkVirtualHandler(i,{args:JSON.stringify({appRoot:s.appRoot}),handlerExport:`handleAgentInfoRequest`,method:`GET`,modulePath:resolvePackageSourceFilePath(`src/internal/nitro/routes/info.ts`),route:EVE_INFO_ROUTE_PATH}),registerChannelVirtualHandlers(i,{artifactsConfig:s,registrations:computeChannelRouteRegistrations(a)}),i.options.dev&&(addFrameworkVirtualHandler(i,{args:JSON.stringify({appRoot:s.appRoot}),handlerExport:`handleDevRuntimeArtifactsRequest`,method:`GET`,modulePath:resolvePackageSourceFilePath(`src/internal/nitro/routes/dev-runtime-artifacts.ts`),route:EVE_DEV_RUNTIME_ARTIFACTS_ROUTE_PATH}),addFrameworkVirtualHandler(i,{args:JSON.stringify({appRoot:s.appRoot}),handlerExport:`handleDevScheduleDispatchRequest`,method:`POST`,modulePath:resolvePackageSourceFilePath(`src/internal/nitro/routes/dev-schedule-dispatch.ts`),route:EVE_DEV_DISPATCH_SCHEDULE_ROUTE_PATTERN})));let l=resolveNitroWorkflowBuildDirectory(i),u=includesWorkflowRoute(o.surface)?i.options.dev?join(l,`workflows.mjs`):join(a.workflowBuildDir,`workflows.mjs`):void 0,d=i.options.dev&&u!==void 0?[{bundlePath:u,queuePrefix:`__wkf_workflow_`}]:[],f=d.length>0?normalizeEsmImportSpecifier(resolveWorkflowModulePath(`workflow/runtime`)):void 0;u&&await addWorkflowFileHandler(i,{bundleName:`workflows`,bundlePath:u,directHandlers:d,route:`/.well-known/workflow/v1/flow`,runtimeImportSpecifier:f}),i.routing.sync()}export{configureNitroRoutes};

package/dist/src/internal/nitro/host/create-application-nitro.d.ts

@@ -0,0 +1,14 @@
+import type { Nitro } from "nitro/types";
+import type { NitroBuildSurface, PreparedApplicationHost } from "#internal/nitro/host/types.js";
+/**
+ * Creates one configured Nitro instance for either production build or dev
+ * hosting of an Eve application.
+ *
+ * `surface` narrows the mounted routes for isolated production builds.
+ * `outputDir` lets callers stage those isolated builds into separate Nitro
+ * output roots before assembling the final hosted deployment.
+ */
+export declare function createApplicationNitro(preparedHost: PreparedApplicationHost, dev: boolean, options?: {
+    outputDir?: string;
+    surface?: NitroBuildSurface;
+}): Promise<Nitro>;

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

@@ -0,0 +1 @@
+import{dirname,isAbsolute,join,relative,resolve}from"node:path";import{readFile}from"node:fs/promises";import{resolveNitroBuildDirectory}from"#internal/application/paths.js";import{resolvePackageSourceDirectoryPath,resolvePackageSourceFilePath,resolveWorkflowModulePath}from"#internal/application/package.js";import{resolveCodeModeEnabled}from"#shared/code-mode.js";import{EVE_PACKAGE_NAME}from"#internal/package-name.js";import{fileURLToPath}from"node:url";import{createNitro}from"nitro/builder";import{prepareEveVersionedCacheDirectory,writeEveVersionedCacheMetadata}from"#internal/application/cache-metadata.js";import{createNitroArtifactsConfig}from"#internal/nitro/host/artifacts-config.js";import{createCompiledSandboxBackendPrunePlugin}from"#internal/nitro/host/compiled-sandbox-backend-prune-plugin.js";import{configureNitroRoutes}from"#internal/nitro/host/configure-nitro-routes.js";import{applyEveCronHandlerRoute}from"#internal/nitro/host/cron-handler-route.js";import{createNitroBundlerConfig}from"#internal/nitro/host/nitro-bundler-config.js";import{addNitroRoutingImportSpecifierPlugin}from"#internal/nitro/host/nitro-routing-import-specifier-plugin.js";import{registerScheduleTaskHandlers}from"#internal/nitro/host/schedule-task-routes.js";import{SERVER_EXTERNAL_PACKAGES}from"#internal/nitro/host/server-external-packages.js";import{createEveVercelOptions}from"#internal/nitro/host/vercel-build-output-config.js";import{applyWorkflowTransform}from"#internal/workflow-bundle/workflow-builders.js";import{transformDynamicToolExecute}from"#internal/workflow-bundle/dynamic-tool-transform.js";const WORKFLOW_ALIAS_SPECIFIERS=[`workflow`,`workflow/api`,`workflow/errors`,`workflow/internal/builtins`,`workflow/internal/private`,`workflow/runtime`],WORKFLOW_TRANSFORM_PATCHED=Symbol(`eve.workflow-transform-patched`),FRAMEWORK_HOSTED_EXTERNAL_PACKAGES=[`@napi-rs/keyring`];function resolveWorkflowAliases(){let e={};for(let t of WORKFLOW_ALIAS_SPECIFIERS)e[t]=resolveWorkflowModulePath(t);return e}function resolveNitroPreset(e){if(!e&&process.env.VERCEL)return`vercel`}function includesApplicationSurface(e){return e===`all`||e===`app`}function includesWorkflowSurface(e){return e===`all`||e===`flow`}function includesWorkflowStepRegistrations(e){return includesWorkflowSurface(e)}function manifestEnablesCodeMode(e){return[e,...e.subagents.map(e=>e.agent)].some(e=>resolveCodeModeEnabled(e.config.experimental?.codeMode)||e.workflowEnabled===!0)}function manifestHasWebSocketChannel(e){return e.channels.some(e=>e.kind===`channel`&&e.method===`WEBSOCKET`)}function resolveWorkflowStepEntrypointPath(e,t){return e.options.dev?join(e.options.buildDir,`workflow`,`steps.mjs`):join(t.workflowBuildDir,`steps.mjs`)}function collectHostedTraceDependencies(e){let t=e.compileResult.manifest.config.build;return[...new Set([...FRAMEWORK_HOSTED_EXTERNAL_PACKAGES,...SERVER_EXTERNAL_PACKAGES,...t?.externalDependencies??[]])].filter(e=>e!==EVE_PACKAGE_NAME)}function createDevelopmentWatchOptions(e){if(e.length!==0)return{ignored:[e,join(e,`**`)]}}function normalizePath(e){return e.replaceAll(`\\`,`/`)}function stripPathQueryAndHash(e){let t=e.indexOf(`?`),n=e.indexOf(`#`),r=t===-1?n:n===-1?t:Math.min(t,n);return r===-1?e:e.slice(0,r)}function stripFileSystemPrefix(e){return e.startsWith(`/@fs/`)?e.slice(4):e}function resolveNitroModuleComparisonPath(e,n){return n.startsWith(`file://`)?normalizePath(stripFileSystemPrefix(stripPathQueryAndHash(fileURLToPath(n)))):isAbsolute(n)?normalizePath(stripFileSystemPrefix(stripPathQueryAndHash(n))):normalizePath(stripFileSystemPrefix(stripPathQueryAndHash(resolve(e,n))))}function isWorkflowBundlePath(e,t){let n=normalizePath(e);return n.startsWith(t)||n.includes(`/.eve/workflow-cache/`)}function normalizeStepTransformComparisonPath(e){let t=normalizePath(e);return process.platform===`win32`?t.toLowerCase():t}function parseImportedModuleSpecifiers(e){let t=/^\s*import\s+(?:.+?\s+from\s+)?["']([^"']+)["'];?\s*$/gm,n=[];for(let r of e.matchAll(t)){let e=r[1];e!==void 0&&n.push(e)}return n}function resolveNitroImportPath(t,n,r){return n.startsWith(`workflow`)?resolveWorkflowModulePath(n):n.startsWith(`.`)||n.startsWith(`/`)||n.startsWith(`file://`)?resolveNitroModuleComparisonPath(r===void 0?t:dirname(resolveNitroModuleComparisonPath(t,r)),n):null}async function collectNitroStepTransformTargets(e,t){let n=await readFile(e,`utf8`),r=new Set;for(let i of parseImportedModuleSpecifiers(n)){let n=resolveNitroImportPath(t,i,e);n!==null&&r.add(normalizeStepTransformComparisonPath(n))}return r}async function addNitroStepNoExternals(e,t){if(e.options.noExternals===!0)return;let n;try{n=await collectNitroStepTransformTargets(t,e.options.rootDir)}catch(e){if(e instanceof Error&&`code`in e&&e.code===`ENOENT`)return;throw e}let r=Array.isArray(e.options.noExternals)?[...e.options.noExternals]:[];e.options.noExternals=[...new Set([...r,...n])]}function createRelativeTransformFilename(e,t){let n=normalizePath(e).replace(/\/$/,``),i=normalizePath(t),a=n.toLowerCase(),o=i.toLowerCase();if(o.startsWith(`${a}/`))return i.slice(n.length+1);if(o===a)return`.`;let s=relative(n,i).replaceAll(`\\`,`/`);if(s.startsWith(`../`)&&(s=s.split(`/`).filter(e=>e!==`..`).join(`/`)),s.includes(`:`)||s.startsWith(`/`)){let e=i.split(`/`).pop();return e===void 0||e.length===0?`unknown.ts`:e}return s}function addWorkflowModuleSideEffectsPlugin(e,t){let r=[t,join(e.options.buildDir,`workflow`)].map(t=>resolveNitroModuleComparisonPath(e.options.rootDir,t));e.hooks.hook(`rollup:before`,(t,n)=>{Array.isArray(n.plugins)&&n.plugins.unshift({name:`eve:workflow-module-side-effects`,resolveId(t,n){let i=resolveNitroImportPath(e.options.rootDir,t,n)??resolveNitroModuleComparisonPath(e.options.rootDir,t);return r.some(e=>isWorkflowBundlePath(i,e))?{id:i,moduleSideEffects:`no-treeshake`}:null}})})}function addNitroStepModuleSideEffectsPlugin(e,t){let n=null,getStepTransformTargets=async()=>(n===null&&(n=await collectNitroStepTransformTargets(t.stepEntrypointPath,e.options.rootDir)),n);e.hooks.hook(`build:before`,()=>{n=null}),e.options.dev&&e.hooks.hook(`dev:reload`,()=>{n=null}),e.hooks.hook(`rollup:before`,(t,n)=>{Array.isArray(n.plugins)&&n.plugins.unshift({name:`eve:workflow-step-module-side-effects`,async resolveId(t,n){let r=resolveNitroImportPath(e.options.rootDir,t,n);return r===null||!(await getStepTransformTargets()).has(normalizeStepTransformComparisonPath(r))?null:{id:r,moduleSideEffects:`no-treeshake`}}})})}function addNitroStepTransformPlugin(e,t){let n=null,getStepTransformTargets=async()=>(n===null&&(n=await collectNitroStepTransformTargets(t.stepEntrypointPath,e.options.rootDir)),n);e.hooks.hook(`build:before`,()=>{n=null}),e.options.dev&&e.hooks.hook(`dev:reload`,()=>{n=null}),e.hooks.hook(`rollup:before`,(t,n)=>{Array.isArray(n.plugins)&&n.plugins.unshift({async transform(t,n){let r=await getStepTransformTargets(),i=resolveNitroModuleComparisonPath(e.options.rootDir,n);return r.has(normalizeStepTransformComparisonPath(i))?{code:(await applyWorkflowTransform(createRelativeTransformFilename(e.options.rootDir,i),t,`step`,i,e.options.rootDir)).code,map:null}:null},name:`eve:workflow-step-transform`})})}function addDynamicToolTransformPlugin(e){e.hooks.hook(`rollup:before`,(e,t)=>{Array.isArray(t.plugins)&&t.plugins.unshift({async transform(e,t){if(!t.includes(`/tools/`))return null;let n=await transformDynamicToolExecute(t,e);return n===null?null:{code:n.code,map:null}},name:`eve:dynamic-tool-transform`})})}function addInstrumentationModuleSideEffectsPlugin(e,t){let n=normalizePath(t);e.hooks.hook(`rollup:before`,(e,t)=>{Array.isArray(t.plugins)&&t.plugins.unshift({name:`eve:instrumentation-module-side-effects`,resolveId(e){return normalizePath(e)===n?{id:e,moduleSideEffects:`no-treeshake`}:null}})})}function patchWorkflowTransformExcludePath(e,t){let n=normalizePath(t);e.hooks.hook(`rollup:before`,(e,t)=>{if(Array.isArray(t.plugins))for(let e of t.plugins){if(typeof e!=`object`||!e)continue;let t=e;if(t.name!==`workflow:transform`||t[WORKFLOW_TRANSFORM_PATCHED]===!0||typeof t.transform!=`function`)continue;let r=t.transform;t.transform=function(e,t,...i){return isWorkflowBundlePath(t,n)?null:r.call(this,e,t,...i)},t[WORKFLOW_TRANSFORM_PATCHED]=!0}})}async function createApplicationNitro(e,t,r={}){let i=r.surface??`all`,a=!t&&includesApplicationSurface(i)&&e.scheduleRegistrations.length>0,c=resolveNitroPreset(t),l=c===`vercel`?createCompiledSandboxBackendPrunePlugin():null,u=l===null?[]:[l],d=createNitroBundlerConfig(u),f=createNitroBundlerConfig(u),p=collectHostedTraceDependencies(e),m=resolveNitroBuildDirectory(e.appRoot,i),h=includesApplicationSurface(i)&&(t||manifestHasWebSocketChannel(e.compileResult.manifest)),g=[];manifestEnablesCodeMode(e.compileResult.manifest)&&g.push(resolvePackageSourceFilePath(`src/internal/nitro/host/code-mode-runtime-dependency-plugin.ts`)),e.compiledArtifacts.instrumentationPluginPath!==void 0&&g.push(e.compiledArtifacts.instrumentationPluginPath),g.push(e.compiledArtifacts.bootstrapPath),await prepareEveVersionedCacheDirectory(m);let _=await createNitro({_cli:{command:t?`dev`:`build`},buildDir:m,dev:t,features:{websocket:h},logLevel:t?1:void 0,output:r.outputDir===void 0?void 0:{dir:r.outputDir},preset:c,plugins:g,publicAssets:[],scanDirs:includesWorkflowStepRegistrations(i)?[resolvePackageSourceDirectoryPath(`src/execution`)]:void 0,rolldownConfig:d,rollupConfig:f,rootDir:e.appRoot,serverDir:!1,traceDeps:p,vercel:createEveVercelOptions(c===`vercel`&&includesApplicationSurface(i)),watchOptions:t?createDevelopmentWatchOptions(e.appRoot):void 0},t?{watch:!0}:void 0);if(await writeEveVersionedCacheMetadata(m),addNitroRoutingImportSpecifierPlugin(_),includesWorkflowSurface(i)){let t=resolveWorkflowAliases();for(let[e,n]of Object.entries(t))_.options.alias[e]=n;addWorkflowModuleSideEffectsPlugin(_,e.workflowBuildDir),patchWorkflowTransformExcludePath(_,e.workflowBuildDir)}if(includesWorkflowStepRegistrations(i)){let t=resolveWorkflowStepEntrypointPath(_,e);addNitroStepModuleSideEffectsPlugin(_,{stepEntrypointPath:t}),addNitroStepTransformPlugin(_,{stepEntrypointPath:t})}if(addDynamicToolTransformPlugin(_),e.compiledArtifacts.instrumentationSourcePath!==void 0&&addInstrumentationModuleSideEffectsPlugin(_,e.compiledArtifacts.instrumentationSourcePath),t&&includesWorkflowSurface(i)){let t=e.workflowBuildDir,r=new Set([normalizePath(join(t,`workflows.mjs`))]);_.hooks.hook(`rollup:before`,(e,t)=>{let n=t.external;t.external=(e,...t)=>{if(r.has(normalizePath(e)))return!0;if(typeof n==`function`)return n(e,...t)}})}return a&&(applyEveCronHandlerRoute(_),registerScheduleTaskHandlers(_,{artifactsConfig:createNitroArtifactsConfig({appRoot:e.appRoot,dev:_.options.dev}),dispatchModulePath:resolvePackageSourceFilePath(`src/internal/nitro/routes/schedule-task.ts`),registrations:e.scheduleRegistrations})),await configureNitroRoutes(_,e,{surface:i}),includesWorkflowStepRegistrations(i)&&await addNitroStepNoExternals(_,resolveWorkflowStepEntrypointPath(_,e)),_}export{createApplicationNitro};

package/dist/src/internal/nitro/host/cron-handler-route.d.ts

@@ -0,0 +1,41 @@
+import type { Nitro } from "nitro/types";
+/**
+ * Builds an unguessable route path for Eve's Vercel cron handler.
+ *
+ * Vercel cron jobs hit a single configurable path (default `/_vercel/cron`)
+ * for every scheduled tick, identifying the schedule via the
+ * `x-vercel-cron-schedule` header. The default path is publicly known and
+ * relies on the user setting a `CRON_SECRET` env var to authenticate
+ * incoming requests.
+ *
+ * Eve sidesteps the manual env var by giving each build a unique random
+ * handler path under the framework's protocol prefix — the path itself is
+ * the secret. Vercel's cron infra reads the path from the deploy's
+ * `config.crons[]` so the platform always knows where to POST, and the same
+ * path is registered as a Nitro route handler in the function. The path is
+ * never logged, exposed in HTTP responses, or persisted, so it is
+ * unguessable to anyone without access to the deploy's build artifacts.
+ *
+ * If `CRON_SECRET` is also set, Nitro's preset will additionally validate
+ * the `Authorization` header — the unguessable path replaces a required
+ * `CRON_SECRET` and acts as defense in depth when both are configured.
+ */
+export declare function createEveCronHandlerRoute(): string;
+/**
+ * Applies Eve's unguessable cron handler route to a Nitro instance built
+ * with the Vercel preset.
+ *
+ * The Vercel preset reads `nitro.options.vercel.cronHandlerRoute` at two
+ * later moments in the build:
+ *   - the `build:before` hook registers the Nitro handler at that path,
+ *   - the build output writer emits `config.crons[].path` from the same
+ *     value.
+ *
+ * Both reads happen after `createNitro()` returns, so a one-time mutation
+ * before the first build hook fires keeps the handler and the published
+ * cron path in sync.
+ *
+ * No-op for non-Vercel presets, which never populate
+ * `nitro.options.vercel`.
+ */
+export declare function applyEveCronHandlerRoute(nitro: Nitro): void;

package/dist/src/internal/nitro/host/cron-handler-route.js

@@ -0,0 +1 @@
+import{EVE_ROUTE_PREFIX}from"#protocol/routes.js";import{randomBytes}from"node:crypto";function createEveCronHandlerRoute(){return`${EVE_ROUTE_PREFIX}/cron/${randomBytes(32).toString(`base64url`)}`}function applyEveCronHandlerRoute(e){e.options.vercel!==void 0&&(e.options.vercel.cronHandlerRoute=createEveCronHandlerRoute())}export{applyEveCronHandlerRoute,createEveCronHandlerRoute};

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

@@ -0,0 +1,29 @@
+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.
+ */
+export interface AuthoredSourceWatcherHandle {
+    close(): Promise<void>;
+}
+/**
+ * Starts the authored-source watcher used by `eve dev`.
+ *
+ * The watcher recompiles authored artifacts, refreshes runtime caches, and
+ * triggers Nitro rebuild reloads only when structural runtime wiring changes.
+ */
+export declare function startAuthoredSourceWatcher(input: {
+    nitro: DevelopmentWatcherNitro;
+    preparedHost: PreparedApplicationHost;
+}): Promise<AuthoredSourceWatcherHandle>;
+export {};