eve 0.5.4 → 0.6.0-beta.1

package/dist/src/internal/attachments/sandbox-refs.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Sandbox-resident attachment references.
+ *
+ * Refs are the compact wire format used after inbound attachment bytes
+ * have been written into the sandbox:
+ *
+ * ```
+ * eve-sandbox:?path=<urlencoded-resolved-path>&size=<bytes>&type=<mediaType>
+ * ```
+ */
+/**
+ * Custom URL scheme used by every sandbox-resident attachment ref. The
+ * trailing colon is part of the scheme per WHATWG URL semantics.
+ */
+export declare const SANDBOX_URL_SCHEME = "eve-sandbox:";
+/**
+ * Serializable description of one sandbox-resident file attachment.
+ *
+ * `path` is the backend-native absolute path returned by
+ * {@link SandboxSession.resolvePath}; `size` and `mediaType` are
+ * snapshotted so hydration can decide whether to inline without
+ * re-reading the file.
+ */
+export interface SandboxRef {
+    readonly path: string;
+    readonly size: number;
+    readonly mediaType: string;
+}
+/**
+ * Encodes a {@link SandboxRef} as a URL suitable for use as
+ * `FilePart.data`.
+ */
+export declare function encodeSandboxRef(ref: SandboxRef): URL;
+/**
+ * Parses a {@link SandboxRef} from its URL form.
+ */
+export declare function decodeSandboxRef(value: URL | string): SandboxRef;
+/**
+ * Cheap runtime check: does this value look like a sandbox-ref URL?
+ *
+ * Accepts `URL` instances with the `eve-sandbox:` scheme. Strings are
+ * NOT accepted — the staging and hydration layers only inspect
+ * URL-instance `FilePart.data` values, matching the existing
+ * `data instanceof URL` branch in `fileDataToBytes`.
+ */
+export declare function isSandboxRefUrl(value: unknown): value is URL;

package/dist/src/internal/attachments/sandbox-refs.js

@@ -0,0 +1 @@
+const SANDBOX_URL_SCHEME=`eve-sandbox:`,PATH_QUERY_KEY=`path`,SIZE_QUERY_KEY=`size`,TYPE_QUERY_KEY=`type`;function isValidSize(e){return Number.isFinite(e)&&Number.isInteger(e)&&e>=0}function encodeSandboxRef(t){if(typeof t.path!=`string`||t.path.length===0)throw RangeError(`SandboxRef.path must be a non-empty string.`);if(!isValidSize(t.size))throw RangeError(`SandboxRef.size must be a non-negative integer. Received: ${String(t.size)}.`);if(typeof t.mediaType!=`string`||t.mediaType.length===0)throw RangeError(`SandboxRef.mediaType must be a non-empty string.`);let n=new URL(SANDBOX_URL_SCHEME);return n.searchParams.set(PATH_QUERY_KEY,t.path),n.searchParams.set(SIZE_QUERY_KEY,String(t.size)),n.searchParams.set(TYPE_QUERY_KEY,t.mediaType),n}function decodeSandboxRef(t){let n=t instanceof URL?t:new URL(t);if(n.protocol!==`eve-sandbox:`)throw Error(`SandboxRef URL must use scheme "${SANDBOX_URL_SCHEME}". Got: "${n.protocol}".`);let r=n.searchParams.get(PATH_QUERY_KEY);if(r===null||r===``)throw Error(`SandboxRef URL is missing the required "path" query param.`);let i=n.searchParams.get(SIZE_QUERY_KEY);if(i===null||i===``)throw Error(`SandboxRef URL is missing the required "size" query param.`);let a=Number(i);if(!isValidSize(a))throw Error(`SandboxRef URL "size" must be a non-negative integer. Got: ${JSON.stringify(i)}.`);let o=n.searchParams.get(TYPE_QUERY_KEY);if(o===null||o===``)throw Error(`SandboxRef URL is missing the required "type" query param.`);return{mediaType:o,path:r,size:a}}function isSandboxRefUrl(e){return e instanceof URL&&e.protocol===`eve-sandbox:`}export{SANDBOX_URL_SCHEME,decodeSandboxRef,encodeSandboxRef,isSandboxRefUrl};

package/dist/src/internal/attachments/url-refs.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Custom URL scheme for serializing `URL` objects in `FilePart.data`
+ * across the queue boundary.
+ *
+ * Route handlers place `new URL("https://...")` on `FilePart.data`.
+ * Before the message crosses the queue, `send()` rewrites these as
+ * `eve-url:https://...` strings. After the queue, the staging pipeline
+ * reconstitutes them back to `URL` objects so `instanceof URL` checks
+ * work reliably.
+ */
+export declare function serializeUrlFilePart(url: URL): string;
+export declare function isSerializedUrlFilePart(data: unknown): data is string;
+export declare function deserializeUrlFilePart(data: string): URL;
+/**
+ * Whether a `FilePart.data` string carries a framework-internal ref scheme.
+ */
+export declare function hasInternalRefScheme(data: string): boolean;

package/dist/src/internal/attachments/url-refs.js

@@ -0,0 +1 @@
+import{SANDBOX_URL_SCHEME}from"#internal/attachments/sandbox-refs.js";import{ATTACHMENT_REF_SCHEME}from"#internal/attachments/refs.js";const EVE_URL_SCHEME=`eve-url:`;function serializeUrlFilePart(e){return`${EVE_URL_SCHEME}${e.href}`}function isSerializedUrlFilePart(e){return typeof e==`string`&&e.startsWith(EVE_URL_SCHEME)}function deserializeUrlFilePart(e){return new URL(e.slice(8))}const INTERNAL_REF_SCHEMES=[EVE_URL_SCHEME,SANDBOX_URL_SCHEME,ATTACHMENT_REF_SCHEME];function hasInternalRefScheme(e){return INTERNAL_REF_SCHEMES.some(t=>e.startsWith(t))}export{deserializeUrlFilePart,hasInternalRefScheme,isSerializedUrlFilePart,serializeUrlFilePart};

package/dist/src/internal/authored-asset-import-plugin.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Creates the Rollup-compatible plugin that gives authored modules a small
+ * asset-module surface for non-code relative imports.
+ */
+export declare function createAuthoredAssetImportPlugin(): Record<string, unknown>;

package/dist/src/internal/authored-asset-import-plugin.js

@@ -0,0 +1 @@
+import{dirname,extname,isAbsolute,resolve}from"node:path";import{readFile}from"node:fs/promises";const AUTHORED_ASSET_CODE_EXTENSIONS=[`.ts`,`.tsx`,`.mts`,`.cts`,`.js`,`.jsx`,`.mjs`,`.cjs`,`.json`];function createAuthoredAssetImportPlugin(){return{name:`eve-authored-asset-import`,resolveId(t,i){if(!isPotentialAuthoredAssetImport(t)||i===void 0)return;let{path:a,suffix:o}=splitImportSuffix(t);return`${isAbsolute(a)?a:resolve(dirname(i),a)}${o}`},async load(e){let{path:t,suffix:n}=splitImportSuffix(e);if(!isPotentialAuthoredAssetImport(t))return;if(n===`?raw`){let e=await readAssetText(t);return e===void 0?void 0:{code:`export default ${JSON.stringify(e)};`,moduleType:`js`}}let r=await readAssetDataUrl(t);if(r!==void 0)return{code:`export default ${JSON.stringify(r)};`,moduleType:`js`}}}}async function readAssetText(e){try{return await readFile(e,`utf8`)}catch(e){if(isPathNotFoundError(e))return;throw e}}function isPotentialAuthoredAssetImport(e){if(e.startsWith(`\0`)||e.startsWith(`node:`)||e.startsWith(`data:`)||e.startsWith(`file:`))return!1;let{path:n}=splitImportSuffix(e);if(!n.startsWith(`.`)&&!n.startsWith(`/`)&&!/^[A-Za-z]:[\\/]/.test(n))return!1;let r=extname(n);return r.length>0&&r!==`.node`&&!AUTHORED_ASSET_CODE_EXTENSIONS.includes(r)}function splitImportSuffix(e){let t=e.indexOf(`?`),n=e.indexOf(`#`),r=t===-1?n:n===-1?t:Math.min(t,n);return r===-1?{path:e,suffix:``}:{path:e.slice(0,r),suffix:e.slice(r)}}async function readAssetDataUrl(e){try{let t=await readFile(e);return`data:${getAssetMimeType(e)};base64,${t.toString(`base64`)}`}catch(e){if(isPathNotFoundError(e))return;throw e}}function isPathNotFoundError(e){return typeof e==`object`&&!!e&&`code`in e&&(e.code===`ENOENT`||e.code===`ENOTDIR`)}function getAssetMimeType(e){switch(extname(e).toLowerCase()){case`.css`:return`text/css`;case`.csv`:return`text/csv`;case`.gif`:return`image/gif`;case`.html`:return`text/html`;case`.jpg`:case`.jpeg`:return`image/jpeg`;case`.png`:return`image/png`;case`.svg`:return`image/svg+xml`;case`.txt`:return`text/plain`;case`.wasm`:return`application/wasm`;case`.webp`:return`image/webp`;default:return`application/octet-stream`}}export{createAuthoredAssetImportPlugin};

package/dist/src/internal/authored-definition/channel.d.ts

@@ -0,0 +1,16 @@
+import { type CompiledChannel } from "#channel/compiled-channel.js";
+/**
+ * Normalizes one authored channel definition into the canonical internal
+ * shape consumed by the compiler.
+ *
+ * Authored channels must go through {@link defineChannel} (or a wrapper
+ * like `slackChannel` / `eveChannel`) and therefore must be
+ * {@link CompiledChannel} values. The legacy plain-`{ fetch, receive? }`
+ * Route shape is no longer supported — drop a clear error for it so
+ * users on old patterns get a useful migration hint instead of a silent
+ * runtime crash deeper in dispatch.
+ *
+ * Disable sentinels are handled by the compiler before this function is
+ * called.
+ */
+export declare function normalizeChannelDefinition(value: unknown, message: string): CompiledChannel;

package/dist/src/internal/authored-definition/channel.js

@@ -0,0 +1 @@
+import{isCompiledChannel}from"#channel/compiled-channel.js";function normalizeChannelDefinition(e,t){if(!isCompiledChannel(e))throw Error(`${t} Use \`defineChannel({ routes, ... })\` (or a wrapper like \`slackChannel\` / \`eveChannel\`) — bare \`{ fetch, receive? }\` channel objects are no longer supported.`);return e}export{normalizeChannelDefinition};

package/dist/src/internal/authored-definition/connection.d.ts

@@ -0,0 +1,18 @@
+import type { McpClientConnectionDefinition } from "#public/definitions/connections/mcp.js";
+import type { OpenAPIConnectionDefinition } from "#public/definitions/connections/openapi.js";
+/**
+ * Validates one authored MCP client connection module export at build time
+ * and returns the public definition type. The module export is `unknown`
+ * because it comes from a dynamically-loaded authored file; this function
+ * bridges the gap with runtime checks so authoring errors surface during
+ * `eve build`.
+ */
+export declare function normalizeMcpClientConnectionDefinition(value: unknown, message: string): McpClientConnectionDefinition;
+/**
+ * Validates one authored OpenAPI connection module export at build time
+ * and returns the public definition type. Mirrors
+ * {@link normalizeMcpClientConnectionDefinition} but validates the
+ * OpenAPI-specific `spec`/`baseUrl`/`operations` fields and reuses the
+ * shared auth and headers validation.
+ */
+export declare function normalizeOpenApiConnectionDefinition(value: unknown, message: string): OpenAPIConnectionDefinition;

package/dist/src/internal/authored-definition/connection.js

@@ -0,0 +1 @@
+import{expectObjectRecord,expectOnlyKnownKeys}from"#internal/authored-module.js";import{normalizeAuthorizationSpec}from"#runtime/connections/validate-authorization.js";const KNOWN_TOP_LEVEL_KEYS=[`approval`,`auth`,`description`,`headers`,`tools`,`url`],KNOWN_OPENAPI_TOP_LEVEL_KEYS=[`approval`,`auth`,`baseUrl`,`description`,`headers`,`operations`,`spec`],KNOWN_AUTHORIZATION_KEYS=[`completeAuthorization`,`getToken`,`principalType`,`startAuthorization`,`vercelConnect`];function normalizeMcpClientConnectionDefinition(n,i){let a=expectObjectRecord(n,i);expectOnlyKnownKeys(a,KNOWN_TOP_LEVEL_KEYS,i),validateUrl(a,i),validateDescription(a,i);let o=normalizeAuthorization(a,i),s=normalizeHeaders(a,i),c=normalizeToolFilter(a,i);if(o!==void 0&&s!==void 0&&typeof s!=`function`&&Object.keys(s).some(e=>e.toLowerCase()===`authorization`))throw Error(`${i} "headers" must not include an "Authorization" key when "auth" is also provided.`);let l={description:a.description,url:a.url};if(o!==void 0&&(l.auth=o),s!==void 0&&(l.headers=s),c!==void 0&&(l.tools=c),a.approval!==void 0){if(typeof a.approval!=`function`)throw Error(`${i} The "approval" field must be a function when provided.`);l.approval=a.approval}return l}function normalizeOpenApiConnectionDefinition(n,r){let a=expectObjectRecord(n,r);expectOnlyKnownKeys(a,KNOWN_OPENAPI_TOP_LEVEL_KEYS,r),validateSpec(a,r),validateBaseUrl(a,r),validateDescription(a,r);let o=normalizeAuthorization(a,r),s=normalizeHeaders(a,r),c=normalizeFilterField(a,`operations`,r);if(o!==void 0&&s!==void 0&&typeof s!=`function`&&Object.keys(s).some(e=>e.toLowerCase()===`authorization`))throw Error(`${r} "headers" must not include an "Authorization" key when "auth" is also provided.`);let l={description:a.description,spec:a.spec};if(a.baseUrl!==void 0&&(l.baseUrl=a.baseUrl),o!==void 0&&(l.auth=o),s!==void 0&&(l.headers=s),c!==void 0&&(l.operations=c),a.approval!==void 0){if(typeof a.approval!=`function`)throw Error(`${r} The "approval" field must be a function when provided.`);l.approval=a.approval}return l}function validateSpec(e,t){let n=e.spec;if(typeof n==`string`){if(!URL.canParse(n))throw Error(`${t} The "spec" field must be a valid URL when provided as a string.`);let e=new URL(n);if(e.protocol!==`https:`&&e.protocol!==`http:`)throw Error(`${t} The "spec" URL must use the http or https protocol, got "${e.protocol}".`);return}if(typeof n!=`object`||!n||Array.isArray(n))throw Error(`${t} The "spec" field must be a URL string or an inline OpenAPI document object.`)}function validateBaseUrl(e,t){if(e.baseUrl===void 0)return;if(typeof e.baseUrl!=`string`||!URL.canParse(e.baseUrl))throw Error(`${t} The "baseUrl" field must be a valid URL when provided.`);let n=new URL(e.baseUrl);if(n.protocol!==`https:`&&n.protocol!==`http:`)throw Error(`${t} The "baseUrl" field must use the http or https protocol, got "${n.protocol}".`)}function validateUrl(e,t){if(typeof e.url!=`string`||!URL.canParse(e.url))throw Error(`${t} The "url" field must be a valid URL.`);let n=new URL(e.url);if(n.protocol!==`https:`&&n.protocol!==`http:`)throw Error(`${t} The "url" field must use the http or https protocol, got "${n.protocol}".`)}function validateDescription(e,t){if(typeof e.description!=`string`||e.description.length===0)throw Error(`${t} The "description" field must be a non-empty string.`)}function normalizeAuthorization(r,i){if(r.auth===void 0)return;let o=expectObjectRecord(r.auth,`${i} The "auth" field must be an object with a "getToken" method.`);return expectOnlyKnownKeys(o,KNOWN_AUTHORIZATION_KEYS,`${i} The "auth" field`),normalizeAuthorizationSpec(o,i)}function normalizeHeaders(e,t){if(e.headers===void 0)return;if(typeof e.headers==`function`)return e.headers;if(typeof e.headers!=`object`||e.headers===null||Array.isArray(e.headers))throw Error(`${t} The "headers" field must be a plain object or a function.`);let n=e.headers;for(let[e,r]of Object.entries(n)){let n=typeof r;if(n!==`string`&&n!==`function`&&n!==`object`||n===`object`&&(r===null||typeof r.then!=`function`))throw Error(`${t} The "headers.${e}" value must be a string, Promise, or function.`)}return n}function normalizeToolFilter(e,t){return normalizeFilterField(e,`tools`,t)}function normalizeFilterField(e,t,n){let r=e[t];if(r===void 0)return;if(typeof r!=`object`||!r||Array.isArray(r))throw Error(`${n} The "${t}" field must specify either "allow" or "block".`);let i=r,a=`allow`in i,o=`block`in i;if(a&&o)throw Error(`${n} The "${t}" field must specify either "allow" or "block", not both.`);if(!a&&!o)throw Error(`${n} The "${t}" field must specify either "allow" or "block".`);return a?(validateStringArray(i.allow,`${n} The "${t}.allow"`),{allow:i.allow}):(validateStringArray(i.block,`${n} The "${t}.block"`),{block:i.block})}function validateStringArray(e,t){if(!Array.isArray(e))throw Error(`${t} field must be an array of strings.`);for(let n=0;n<e.length;n++)if(typeof e[n]!=`string`)throw Error(`${t}[${n}] must be a string.`)}export{normalizeMcpClientConnectionDefinition,normalizeOpenApiConnectionDefinition};

package/dist/src/internal/authored-definition/core.d.ts

@@ -0,0 +1,46 @@
+import type { AgentDefinition, AgentBuildDefinition } from "#public/definitions/agent.js";
+import type { ScheduleDefinition } from "#public/definitions/schedule.js";
+import type { SkillDefinition } from "#public/definitions/skill.js";
+import type { InstructionsDefinition } from "#public/definitions/instructions.js";
+type NormalizedAgentDefinition = Omit<AgentDefinition, "build"> & {
+    build?: {
+        externalDependencies?: Readonly<AgentBuildDefinition["externalDependencies"]>;
+    };
+};
+/**
+ * Normalizes one authored agent definition into the canonical internal shape.
+ *
+ * Authored `name` fields are rejected — agent identity is derived at compile
+ * time from `manifest.agentId` (package name or app-root basename).
+ */
+export declare function normalizeAgentDefinition(value: unknown, message: string): Readonly<NormalizedAgentDefinition>;
+/**
+ * Normalizes one authored instructions definition into the canonical
+ * internal shape.
+ *
+ * Authored `name` fields are rejected — instructions prompt identity is
+ * derived from the file path (`instructions.md` or
+ * `instructions.{ts,...}`).
+ */
+export declare function normalizeInstructionsDefinition(value: unknown, message: string): InstructionsDefinition & {
+    readonly markdown: string;
+};
+/**
+ * Normalizes one authored skill definition into the canonical internal
+ * shape.
+ *
+ * Authored `name` fields are rejected — skill identity is derived from
+ * the file path under `agent/skills/`.
+ */
+export declare function normalizeSkillDefinition(value: unknown, message: string): SkillDefinition;
+/**
+ * Normalizes one authored schedule definition into the canonical internal
+ * shape.
+ *
+ * Authored `name` fields are rejected — schedule identity is derived from
+ * the file path under `agent/schedules/`. Exactly one of `markdown` (the
+ * fire-and-forget agent prompt) or `run` (the cron handler function)
+ * must be provided.
+ */
+export declare function normalizeScheduleDefinition(value: unknown, message: string): ScheduleDefinition;
+export {};

package/dist/src/internal/authored-definition/core.js

@@ -0,0 +1 @@
+import{expectBoolean,expectFunction,expectObjectRecord,expectOnlyKnownKeys,expectProviderOptions,expectString,getOptionalStringRecordProperty}from"#internal/authored-module.js";function normalizeAgentDefinition(e,t){let i=expectObjectRecord(e,t);if(expectOnlyKnownKeys(i,[`build`,`compaction`,`description`,`experimental`,`model`,`modelContextWindowTokens`,`modelOptions`,`outputSchema`],t),i.model===void 0)throw Error(`${t} The "model" field is required.`);let o={model:i.model};return i.description!==void 0&&(o.description=expectString(i.description,t)),i.compaction!==void 0&&(o.compaction=normalizeAgentCompactionDefinition(i.compaction,t)),i.build!==void 0&&(o.build=normalizeAgentBuildDefinition(i.build,t)),i.experimental!==void 0&&(o.experimental=normalizeAgentExperimentalDefinition(i.experimental,t)),i.modelOptions!==void 0&&(o.modelOptions=normalizeAgentModelOptions(i.modelOptions,t)),i.modelContextWindowTokens!==void 0&&(o.modelContextWindowTokens=expectPositiveInteger(i.modelContextWindowTokens,t)),i.outputSchema!==void 0&&(o.outputSchema=i.outputSchema),o}function expectPositiveInteger(e,t){if(typeof e!=`number`||!Number.isInteger(e)||e<=0)throw Error(t);return e}function normalizeAgentBuildDefinition(e,t){let i=expectObjectRecord(e,t);expectOnlyKnownKeys(i,[`externalDependencies`],t);let o={};if(i.externalDependencies!==void 0){if(!Array.isArray(i.externalDependencies))throw Error(t);o.externalDependencies=Object.freeze(i.externalDependencies.map(e=>expectString(e,t)))}return o}function normalizeAgentExperimentalDefinition(t,i){let a=expectObjectRecord(t,i);expectOnlyKnownKeys(a,[`codeMode`],i);let o={};return a.codeMode!==void 0&&(o.codeMode=expectBoolean(a.codeMode,i)),o}function normalizeAgentModelOptions(e,t){let a=expectObjectRecord(e,t);expectOnlyKnownKeys(a,[`providerOptions`],t);let o=a.providerOptions;return o===void 0?{}:{providerOptions:expectProviderOptions(o,t)}}function normalizeAgentCompactionDefinition(e,t){let i=expectObjectRecord(e,t);expectOnlyKnownKeys(i,[`model`,`modelContextWindowTokens`,`thresholdPercent`],t);let a={};if(i.model!==void 0&&(a.model=i.model),i.modelContextWindowTokens!==void 0&&(a.modelContextWindowTokens=expectPositiveInteger(i.modelContextWindowTokens,t)),i.thresholdPercent!==void 0){let e=i.thresholdPercent;if(typeof e!=`number`||!Number.isFinite(e)||e<0||e>1)throw Error(t);a.thresholdPercent=e}return a}function normalizeInstructionsDefinition(e,t){let i=expectObjectRecord(e,t);return expectOnlyKnownKeys(i,[`markdown`],t),{markdown:expectString(i.markdown,t)}}function normalizeSkillDefinition(e,t){let i=expectObjectRecord(e,t);expectOnlyKnownKeys(i,[`description`,`files`,`license`,`markdown`,`metadata`],t);let s={description:expectString(i.description,t),markdown:expectString(i.markdown,t)},c=i.license,l=getOptionalStringRecordProperty(i,`metadata`,t);return c!==void 0&&(s.license=expectString(c,t)),l!==void 0&&(s.metadata=l),i.files!==void 0&&(s.files=normalizeSkillFiles(i.files,t)),s}function normalizeSkillFiles(e,t){let r=expectObjectRecord(e,t),i={};for(let[e,n]of Object.entries(r)){if(typeof n==`string`||n instanceof Uint8Array){i[e]=n;continue}throw Error(`${t} Expected skill file "${e}" to be a string or Uint8Array.`)}return i}function normalizeScheduleDefinition(e,i){let o=expectObjectRecord(e,i);expectOnlyKnownKeys(o,[`cron`,`markdown`,`run`],i);let s=expectString(o.cron,i),c=o.markdown!==void 0,l=o.run!==void 0;if(c&&l)throw Error(`${i} Pass either "markdown" (fire-and-forget) or "run" (handler) — not both.`);if(!c&&!l)throw Error(`${i} Must provide either "markdown" (fire-and-forget) or "run" (handler).`);let u={cron:s};return c?u.markdown=expectString(o.markdown,i):u.run=expectFunction(o.run,i),u}export{normalizeAgentDefinition,normalizeInstructionsDefinition,normalizeScheduleDefinition,normalizeSkillDefinition};

package/dist/src/internal/authored-definition/sandbox.d.ts

@@ -0,0 +1,17 @@
+import type { SandboxBackend } from "#public/definitions/sandbox-backend.js";
+import type { SandboxDefinition, SandboxRevalidationKeyFn } from "#public/definitions/sandbox.js";
+type NormalizedSandboxDefinition = Readonly<Omit<SandboxDefinition, "backend">> & {
+    readonly backend?: SandboxBackend;
+    readonly description?: string;
+    readonly revalidationKey?: SandboxRevalidationKeyFn;
+};
+/**
+ * Normalizes one authored sandbox definition into the canonical internal
+ * shape. If the author supplied a `backend` callback (e.g.
+ * `backend: () => vercelBackend({...})`), it is wrapped via
+ * {@link lazyBackend} so downstream consumers always see a plain
+ * `SandboxBackend` value — the callback fires exactly once on first
+ * access and the resulting backend is memoized.
+ */
+export declare function normalizeSandboxDefinition(value: unknown, message: string): NormalizedSandboxDefinition;
+export {};

package/dist/src/internal/authored-definition/sandbox.js

@@ -0,0 +1 @@
+import{expectFunction,expectObjectRecord,expectOnlyKnownKeys}from"#internal/authored-module.js";import{lazyBackend}from"#execution/sandbox/lazy-backend.js";function normalizeSandboxDefinition(n,r){let i=expectObjectRecord(n,r);expectOnlyKnownKeys(i,[`backend`,`bootstrap`,`description`,`onSession`,`revalidationKey`],r);let a={};if(i.backend!==void 0&&(a.backend=expectSandboxBackend(i.backend,r)),i.description!==void 0){if(typeof i.description!=`string`)throw Error(`${r} The "description" field must be a string when set.`);a.description=i.description}if(i.bootstrap!==void 0&&(a.bootstrap=expectFunction(i.bootstrap,r)),i.revalidationKey!==void 0&&(a.revalidationKey=expectFunction(i.revalidationKey,r)),a.bootstrap===void 0&&a.revalidationKey!==void 0)throw Error(`${r} The "revalidationKey" field can only be set when "bootstrap" is set.`);return i.onSession!==void 0&&(a.onSession=expectFunction(i.onSession,r)),a}function expectSandboxBackend(e,t){if(typeof e==`function`)return lazyBackend(e);let r=expectObjectRecord(e,`${t} The "backend" field must be a SandboxBackend value (use vercelBackend(), localBackend(), or your own factory) or a zero-arg function returning one.`);if(typeof r.name!=`string`||r.name.length===0)throw Error(`${t} The "backend" value must expose a non-empty string "name" identifier.`);if(typeof r.create!=`function`)throw Error(`${t} The "backend" value must expose a "create" function.`);if(r.prewarm!==void 0&&typeof r.prewarm!=`function`)throw Error(`${t} The "backend.prewarm" property must be a function when set.`);return r}export{normalizeSandboxDefinition};

package/dist/src/internal/authored-definition/schema-backed.d.ts

@@ -0,0 +1,36 @@
+import type { InternalToolDefinitionWithExecuteFn } from "#shared/tool-definition.js";
+import { type DynamicToolEventName } from "#shared/dynamic-tool-definition.js";
+/**
+ * Canonical normalized shape of one authored tool default export.
+ *
+ * Identity is path-derived — the compiler stamps the filename slug onto
+ * the compiled entry. This shape never carries an authored `name`.
+ */
+type NormalizedAuthoredTool = Readonly<Omit<InternalToolDefinitionWithExecuteFn, "name">>;
+/**
+ * Result of normalizing one authored tool default export. Either a real tool
+ * definition, a sentinel that disables a framework default, or a dynamic
+ * tool resolver. In all cases the disable target / runtime name is the
+ * authored file's slug, supplied by the compiler — this layer never sees
+ * a name.
+ */
+type NormalizedToolEntry = {
+    readonly kind: "tool";
+    readonly definition: NormalizedAuthoredTool;
+} | {
+    readonly kind: "disabled";
+} | {
+    readonly kind: "enable-workflow";
+} | {
+    readonly kind: "dynamic-tool";
+    readonly eventNames: readonly DynamicToolEventName[];
+};
+/**
+ * Normalizes one authored tool default export. Recognizes real tool
+ * definitions (`defineTool(...)`), disable sentinels (`disableTool()`), and the
+ * `Workflow` opt-in sentinel.
+ *
+ * Authored `name` fields are rejected — tool identity is path-derived.
+ */
+export declare function normalizeToolDefinition(value: unknown, message: string): NormalizedToolEntry;
+export {};

package/dist/src/internal/authored-definition/schema-backed.js

@@ -0,0 +1 @@
+import{expectFunction,expectObjectRecord,expectOnlyKnownKeys,expectString}from"#internal/authored-module.js";import{isDynamicSentinel}from"#shared/dynamic-tool-definition.js";import{normalizeJsonSchemaDefinition}from"#internal/json-schema.js";import{isDisabledToolSentinel,isEnableWorkflowToolSentinel}from"#public/definitions/tool.js";function normalizeToolDefinition(e,t){if(isDynamicSentinel(e))return{kind:`dynamic-tool`,eventNames:Object.keys(e.events)};if(isDisabledToolSentinel(e))return{kind:`disabled`};if(isEnableWorkflowToolSentinel(e))return{kind:`enable-workflow`};let n=expectObjectRecord(e,t);expectOnlyKnownKeys(n,[`auth`,`description`,`execute`,`inputSchema`,`needsApproval`,`onCompact`,`outputSchema`,`toModelOutput`],t);let r=n.inputSchema===void 0?null:normalizeJsonSchemaDefinition(n.inputSchema),i=n.outputSchema===void 0?void 0:normalizeJsonSchemaDefinition(n.outputSchema,`output`),a={description:expectString(n.description,t),execute:expectFunction(n.execute,t),inputSchema:r};return i!==void 0&&(a.outputSchema=i),n.onCompact!==void 0&&expectFunction(n.onCompact,t),n.needsApproval!==void 0&&expectFunction(n.needsApproval,t),n.toModelOutput!==void 0&&expectFunction(n.toModelOutput,t),n.auth!==void 0&&expectFunction(expectObjectRecord(n.auth,t).getToken,t),{kind:`tool`,definition:a}}export{normalizeToolDefinition};

package/dist/src/internal/authored-module-bundle.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Adds actionable context to lower-level authored module bundling failures.
+ */
+export declare function createAuthoredModuleBundleError(modulePath: string, error: unknown): Error;

package/dist/src/internal/authored-module-bundle.js

@@ -0,0 +1,2 @@
+function createAuthoredModuleBundleError(e,t){let n=t instanceof Error?t.message:String(t),r=[];return(/\.node(?:\b|["'?])/i.test(n)||/native addon|native module|invalid utf-?8|Could not load .*\.node/i.test(n))&&r.push(`If this comes from a native Node package, keep that package external with agent build.externalDependencies so Vercel/Nitro traces it instead of bundling it.`),/Unexpected character|No loader is configured|Could not load|Unknown file extension/i.test(n)&&r.push(`If this comes from an asset import, Eve only supports assets that Rolldown can emit for a Node ESM bundle; otherwise load the file through fs/import.meta.url or externalize the package.`),Error([`Failed to bundle authored module "${e}".`,n,...r.map(e=>`Hint: ${e}`)].join(`
+`))}export{createAuthoredModuleBundleError};

package/dist/src/internal/authored-module-loader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Loads one authored module namespace from disk during compile-time
+ * discovery. Concurrent loads of the same `modulePath` share a single
+ * Promise so the underlying bundle/import pipeline runs once.
+ */
+export declare function loadAuthoredModuleNamespace(modulePath: string): Promise<Record<string, unknown>>;

package/dist/src/internal/authored-module-loader.js

@@ -0,0 +1,2 @@
+import{expectObjectRecord}from"#internal/authored-module.js";import{dirname,join,resolve,sep}from"node:path";import{existsSync,mkdirSync,writeFileSync}from"node:fs";import{createHash}from"node:crypto";import{createAuthoredAssetImportPlugin}from"#internal/authored-asset-import-plugin.js";import{createAuthoredModuleBundleError}from"#internal/authored-module-bundle.js";import{createAuthoredPackageTsConfigPathsPlugin}from"#internal/authored-package-tsconfig-paths.js";import{buildWithNitroRolldown,getSingleRolldownChunk}from"#internal/bundler/nitro-rolldown.js";import{createNodeEsmCompatBannerPlugin}from"#internal/node-esm-compat-banner.js";const AUTHORED_BUNDLED_MODULE_EXTENSION=/\.[cm]?[jt]sx?$/,AUTHORED_MODULE_BUNDLE_DIRECTORY_PATH=join(`node_modules`,`.cache`,`eve`,`authored-modules`),RESOLVE_EXTENSIONS=[`.ts`,`.tsx`,`.mts`,`.cts`,`.js`,`.jsx`,`.mjs`,`.cjs`,`.json`],CHANNEL_MODULE_CACHE_KEY=`__eveChannelModuleCache__`,CACHED_CHANNEL_PREFIX=`eve-cached-channel:`;function getChannelModuleCache(){return globalThis[CHANNEL_MODULE_CACHE_KEY]}const inFlightModuleLoads=new Map;function loadAuthoredModuleNamespace(e){let t=resolve(e),n=inFlightModuleLoads.get(t);if(n!==void 0)return n;let i=(async()=>{try{return await doLoadAuthoredModuleNamespace(e)}finally{inFlightModuleLoads.delete(t)}})();return inFlightModuleLoads.set(t,i),i}async function doLoadAuthoredModuleNamespace(t){return expectObjectRecord(AUTHORED_BUNDLED_MODULE_EXTENSION.test(t)?await loadBundledAuthoredModule(t):await import(createFileImportSpecifier(t)),`Expected "${t}" to export a module namespace object.`)}function createFileImportSpecifier(e){let t=e.replaceAll(`\\`,`/`);return/^[A-Za-z]:\//.test(t)?`file:///${encodeURI(t)}`:t.startsWith(`/`)?`file://${encodeURI(t)}`:t}async function loadBundledAuthoredModule(e){let t=getChannelModuleCache(),i=resolveAuthoredPackageRoot(e),s=resolveAuthoredTsConfigPath(i),c=t&&t.size>0?{name:`eve-channel-identity`,async resolveId(e,n,i){if(!/channels[/\\]/.test(e)||i.kind!==`import-statement`)return;let a=await this.resolve(e,n,{kind:i.kind,skipSelf:!0});if(a===null||typeof a.id!=`string`)return;let o=resolve(a.id);if(t.has(o))return{id:`${CACHED_CHANNEL_PREFIX}${o}`}},load(e){if(!e.startsWith(CACHED_CHANNEL_PREFIX))return;let t=e.slice(19);return{code:[`const cache = globalThis["${CHANNEL_MODULE_CACHE_KEY}"];`,`export default cache.get(${JSON.stringify(t)});`].join(`
+`),moduleType:`js`}}}:null,l=[createAuthoredAssetImportPlugin(),createAuthoredPackageTsConfigPathsPlugin({appPackageRoot:i,extensions:RESOLVE_EXTENSIONS}),createNodeEsmCompatBannerPlugin({includeRequire:!0}),createPackageBoundaryPlugin(i),c].filter(e=>e!==null),u;try{u=getSingleRolldownChunk(await buildWithNitroRolldown({cwd:i,input:e,platform:`node`,plugins:l,resolve:{extensions:[...RESOLVE_EXTENSIONS]},tsconfig:s,write:!1,output:{comments:!1,format:`esm`,sourcemap:`inline`}}),`authored module for "${e}"`)}catch(t){throw createAuthoredModuleBundleError(e,t)}let d=createHash(`sha1`).update(e).update(`\0`).update(u.code).digest(`hex`),f=join(i,AUTHORED_MODULE_BUNDLE_DIRECTORY_PATH),p=join(f,`${d}.mjs`);return existsSync(p)||(mkdirSync(f,{recursive:!0}),writeFileSync(p,u.code)),await import(`${createFileImportSpecifier(p)}?v=${d}`)}function createPackageBoundaryPlugin(e){return{name:`eve-package-boundary`,async resolveId(t,n,i){if(!isPackageImport(t))return;if(isEveFrameworkImport(t))return{external:!0,id:t};let a=n===void 0||n.startsWith(`\0`)||n.startsWith(CACHED_CHANNEL_PREFIX)?void 0:resolve(n);if(a!==void 0&&isPathInsideOrEqual(a,e)){let e=await this.resolve(t,n,{kind:i.kind,skipSelf:!0});if(e===null||typeof e.id!=`string`||isNodeModulesPath(e.id))return{external:!0,id:t}}}}}function isPackageImport(e){return e.startsWith(`.`)||e.startsWith(`/`)||/^[A-Za-z]:[\\/]/.test(e)||/^(?:node|data|file):/.test(e)||e.startsWith(`@/`)?!1:!e.startsWith(CACHED_CHANNEL_PREFIX)}function isEveFrameworkImport(e){return e===`eve`||e.startsWith(`eve/`)}function isNodeModulesPath(e){return e.replaceAll(`\\`,`/`).includes(`/node_modules/`)}function isPathInsideOrEqual(e,t){let n=resolve(e),a=resolve(t);return n===a||n.startsWith(`${a}${sep}`)}function resolveAuthoredTsConfigPath(e){for(let t of[`tsconfig.json`,`jsconfig.json`]){let r=join(e,t);if(existsSync(r))return r}return!1}function resolveAuthoredPackageRoot(e){let r=dirname(e);for(;;){if(existsSync(join(r,`package.json`)))return r;let i=dirname(r);if(i===r)throw Error(`Failed to resolve the authored package root for "${e}".`);r=i}}export{loadAuthoredModuleNamespace};

package/dist/src/internal/authored-module-map-loader.d.ts

@@ -0,0 +1,10 @@
+import { type CompiledModuleMap } from "#compiler/module-map.js";
+import type { RuntimeDiskCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
+/**
+ * Loads a disk-backed module map by hydrating authored modules directly from
+ * source. This is for dev/build flows that need tsconfig alias support and
+ * source reloads without relying on Node's module cache for module-map.mjs.
+ */
+export declare function loadCompiledModuleMapFromAuthoredSource(input: {
+    readonly compiledArtifactsSource: RuntimeDiskCompiledArtifactsSource;
+}): Promise<CompiledModuleMap>;

package/dist/src/internal/authored-module-map-loader.js

@@ -0,0 +1 @@
+import{join}from"node:path";import{collectModuleRefsForManifest}from"#compiler/module-map.js";import{ROOT_COMPILED_AGENT_NODE_ID}from"#compiler/manifest.js";import{loadAuthoredModuleNamespace}from"#internal/authored-module-loader.js";import{loadCompiledManifest}from"#runtime/loaders/manifest.js";async function loadCompiledModuleMapFromAuthoredSource(e){return await hydrateCompiledModuleMapFromManifest(await loadCompiledManifest({compiledArtifactsSource:e.compiledArtifactsSource}))}async function hydrateCompiledModuleMapFromManifest(e){let t={},r=[{agentRoot:e.agentRoot,manifest:e,nodeId:ROOT_COMPILED_AGENT_NODE_ID},...[...e.subagents].sort((e,t)=>e.nodeId.localeCompare(t.nodeId)).map(e=>({agentRoot:e.agent.agentRoot,manifest:e.agent,nodeId:e.nodeId}))];for(let e of r)t[e.nodeId]={modules:await hydrateCompiledNodeScope({agentRoot:e.agentRoot,manifest:e.manifest})};return{nodes:t}}async function hydrateCompiledNodeScope(n){let i=collectModuleRefsForManifest(n.manifest).sort((e,t)=>e.sourceId.localeCompare(t.sourceId)),a={};for(let t of i){let i=join(n.agentRoot,t.logicalPath);a[t.sourceId]=await loadAuthoredModuleNamespace(i)}return a}export{loadCompiledModuleMapFromAuthoredSource};

package/dist/src/internal/authored-module.d.ts

@@ -0,0 +1,42 @@
+import type { ModuleDefinitionExport } from "#public/definitions/source.js";
+import type { ModuleSourceRef } from "#shared/source-ref.js";
+import type { AgentModelOptionsDefinition } from "#shared/agent-definition.js";
+/**
+ * Returns the selected authored module export from one namespace.
+ */
+export declare function getAuthoredModuleExport(moduleNamespace: Record<string, unknown>, source: ModuleSourceRef | {
+    readonly exportName?: string;
+    readonly logicalPath: string;
+}): unknown;
+/**
+ * Materializes one authored module export that may be a definition factory.
+ */
+export declare function materializeAuthoredModuleExport<TDefinition>(exportValue: ModuleDefinitionExport<TDefinition>): Promise<TDefinition>;
+/**
+ * Returns the value as a plain object or throws.
+ */
+export declare function expectObjectRecord(value: unknown, message: string): Record<string, unknown>;
+/**
+ * Returns the value as a string or throws.
+ */
+export declare function expectString(value: unknown, message: string): string;
+/**
+ * Returns the value as a boolean or throws.
+ */
+export declare function expectBoolean(value: unknown, message: string): boolean;
+/**
+ * Returns the value as a function or throws.
+ */
+export declare function expectFunction<TFunction extends (...args: never[]) => unknown>(value: unknown, message: string): TFunction;
+/**
+ * Returns the value as a provider options object or throws.
+ */
+export declare function expectProviderOptions(value: unknown, message: string): Required<AgentModelOptionsDefinition>["providerOptions"];
+/**
+ * Rejects unexpected keys on one plain object.
+ */
+export declare function expectOnlyKnownKeys(record: Record<string, unknown>, knownKeys: readonly string[], message: string): void;
+/**
+ * Returns one optional string-record property when present.
+ */
+export declare function getOptionalStringRecordProperty(record: Record<string, unknown>, key: string, message: string): Record<string, string> | undefined;

package/dist/src/internal/authored-module.js

@@ -0,0 +1 @@
+function getAuthoredModuleExport(e,t){return e[t.exportName??`default`]}async function materializeAuthoredModuleExport(e){return typeof e==`function`?await e():e}function expectObjectRecord(e,t){if(typeof e!=`object`||!e||Array.isArray(e))throw Error(t);return e}function expectString(e,t){if(typeof e!=`string`)throw Error(t);return e}function expectBoolean(e,t){if(typeof e!=`boolean`)throw Error(t);return e}function expectFunction(e,t){if(typeof e!=`function`)throw Error(t);return e}function expectProviderOptions(e,t){let n=expectObjectRecord(e,t),r={};for(let[e,i]of Object.entries(n))r[e]=expectObjectRecord(i,t);return r}function expectOnlyKnownKeys(e,t,n){let r=new Set(t);for(let t of Object.keys(e))if(!r.has(t))throw Error(`${n} Unknown key "${t}".`)}function getOptionalStringRecordProperty(e,t,n){let r=e[t];if(r===void 0)return;let i=expectObjectRecord(r,n),a={};for(let[e,t]of Object.entries(i))a[e]=expectString(t,n);return a}export{expectBoolean,expectFunction,expectObjectRecord,expectOnlyKnownKeys,expectProviderOptions,expectString,getAuthoredModuleExport,getOptionalStringRecordProperty,materializeAuthoredModuleExport};

package/dist/src/internal/authored-package-tsconfig-paths.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Resolves tsconfig `paths` for authored source imported from linked
+ * workspace packages. Rolldown handles the root app tsconfig; this only
+ * fills the package-local config gap for sources outside the app root.
+ */
+export declare function createAuthoredPackageTsConfigPathsPlugin(input: {
+    appPackageRoot: string;
+    extensions: readonly string[];
+}): Record<string, unknown>;

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