eve 0.24.6 → 0.25.1

package/docs/extensions.md

@@ -71,15 +71,21 @@ Config is bound once when the consumer mounts the extension and stays constant f
 
 ## Publishing
 
-Point `eve.extension` at the source directory and run `eve extension build` (wired to `build`/`prepare`):
+Declare separate authoring and distribution roots and run `eve extension build` (wired to `build`/`prepare`):
 
 ```jsonc title="package.json"
 {
   "name": "@acme/crm",
   "type": "module",
-  "eve": { "extension": "./extension" },
-  "files": ["extension", "dist"],
-  "peerDependencies": { "eve": "^x" },
+  "eve": {
+    "extension": {
+      "source": "./extension",
+      "dist": "./dist/extension",
+    },
+  },
+  "files": ["dist"],
+  "peerDependencies": { "eve": "*" },
+  "devDependencies": { "eve": "^x", "typescript": "^x" },
   "dependencies": { "zod": "^3" },
   "scripts": { "build": "eve extension build", "prepare": "eve extension build" },
 }
@@ -100,11 +106,21 @@ Author the source with `moduleResolution: "bundler"` — eve compiles it, so rel
 }
 ```
 
-`eve extension build` compiles the package's entry points to plain JavaScript with type declarations — the mount factory (`dist/index.mjs`) and the tool re-exports overrides use (`dist/tools`) — and fills the `exports` map so you never hand-list it. Compiling is what lets an installed extension load directly; local and workspace packages also work without publishing.
+`eve extension build` transforms every JavaScript or TypeScript module into an agent-shaped `dist/extension` tree, copies skill packages and their assets, emits type declarations, and writes `dist/extension/_manifest.json`. The generated package entrypoints (`dist/index.mjs` and `dist/tools/index.mjs`) re-export those same dist modules, and the build fills the `exports` map so you never hand-list it. The published package therefore needs `dist/`, not the author's original TypeScript. Consumers read only `eve.extension.dist`, so a published package may omit `eve.extension.source`; keep `source` declared wherever `eve extension build` runs.
+
+The build uses the package `tsconfig.json` when it emits declarations. Its `include` must cover every JavaScript or TypeScript module in the extension source (and JavaScript modules require `allowJs`); the build fails before publishing if any distributed module would be missing its declaration.
+
+The manifest contains only its format, the diagnostic eve build version, and the versions of extension capabilities this package actually uses. It does not contain compiled tools, schemas, names, or executable definitions; the consuming eve still discovers and normalizes the agent-shaped dist tree.
+
+### Workspace development
+
+During local development, `eve dev` automatically rebuilds mounted workspace extensions when their source changes.
 
 ### Dependencies
 
-`eve` is a **peer** dependency: one eve lives in the consuming app and the extension's `eve/*` imports resolve to it. Declare the eve versions your extension supports as the peer range (`"eve": "^1"`) — eve enforces it when the extension is mounted, failing the build with a clear error if the app's eve is out of range, rather than surfacing a confusing compile break. Everything else the extension imports (SDKs, `zod`, …) goes in `dependencies`; each extension resolves its own versions. The consumer recompiles the extension's contributions from source, so `files` must ship both `extension/` (that source) and `dist/` (the compiled entry points).
+`eve` is a required wildcard **peer** dependency: one eve lives in the consuming app and the extension's `eve/*` imports resolve to it. The extension's concrete eve version belongs in `devDependencies` for authoring types and build tooling. npm peer semver does not decide extension compatibility; eve validates the generated per-capability requirements. Do not mark the eve peer optional and do not add eve to regular `dependencies`.
+
+Everything else the extension imports at execution time (SDKs, `zod`, …) goes in `dependencies`; each extension resolves its own versions. Build-only and test-only packages go in `devDependencies`.
 
 Those deps resolve from `node_modules` under `eve dev`/`eve eval` and are bundled into the deployable by the consuming agent's `eve build`. A dependency that can't be bundled (a native addon) must be listed in the **consuming agent's** `build.externalDependencies` — an extension can't declare build config, so note it in your README.
 

package/docs/reference/cli.md

@@ -47,7 +47,7 @@ After scaffolding, a human terminal usually continues into `eve dev` (or a codin
 
 ## `eve extension`
 
-Commands for reusable [extension](/docs/extensions) packages. An extension is identified by `package.json#eve.extension` (for example `"eve": { "extension": "./extension" }`).
+Commands for reusable [extension](/docs/extensions) packages. An extension declares distinct authoring and distribution roots in `package.json#eve.extension` (for example `"eve": { "extension": { "source": "./extension", "dist": "./dist/extension" } }`).
 
 ### `eve extension init`
 
@@ -73,7 +73,7 @@ See [Extensions](/docs/extensions) for authoring and mount details.
 eve extension build
 ```
 
-Builds the current package as an extension: compiles the mount factory and tool re-exports into `dist/`, and fills the package `exports` map. Requires `package.json#eve.extension`.
+Builds the complete agent-shaped extension tree into its configured dist root, emits declarations and compatibility metadata, and fills the package `exports` map. The original TypeScript source is not required in the published package.
 
 ## `eve info`
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve",
-  "version": "0.24.6",
+  "version": "0.25.1",
   "private": false,
   "description": "Filesystem-first framework for durable backend AI agents that run anywhere.",
   "keywords": [

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

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

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

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

package/dist/src/setup/boxes/reconcile-host-framework-preset.d.ts

@@ -1,26 +0,0 @@
-import type { Prompter } from "../prompter.js";
-import { type SetupState } from "../state.js";
-import type { SetupBox } from "../step.js";
-import { syncHostFrameworkPreset } from "../vercel-project-framework.js";
-/** Injected for tests; defaults to the real framework-preset reconciliation. */
-export interface ReconcileHostFrameworkPresetDeps {
-    syncHostFrameworkPreset: typeof syncHostFrameworkPreset;
-}
-export interface ReconcileHostFrameworkPresetOptions {
-    /** Streams reconciliation progress and the applied-change note. */
-    prompter: Prompter;
-    deps?: ReconcileHostFrameworkPresetDeps;
-}
-/**
- * Aligns an already-linked Vercel project's Framework Preset with a newly-added
- * web (Next.js) channel before the deploy box runs. A project created as a
- * standalone agent keeps the `eve` preset, which would build the agent instead
- * of the host app; the command already deploys on the user's behalf, so this
- * corrects the preset directly (no confirmation) and notes the change.
- *
- * Runs only for an already-linked project — an unlinked directory links later
- * inside the deploy box, where a fresh `vercel link` detects the framework. All
- * effects live in {@link syncHostFrameworkPreset}, a no-op when the preset
- * already matches.
- */
-export declare function reconcileHostFrameworkPreset(options: ReconcileHostFrameworkPresetOptions): SetupBox<SetupState, null, null>;

package/dist/src/setup/boxes/reconcile-host-framework-preset.js

@@ -1 +0,0 @@
-import{isProjectResolved}from"../project-resolution.js";import{requireProjectPath}from"../state.js";import{syncHostFrameworkPreset}from"../vercel-project-framework.js";import{createPromptCommandOutput}from"#setup/cli/index.js";function reconcileHostFrameworkPreset(r){let i=r.deps??{syncHostFrameworkPreset};return{id:`reconcile-host-framework-preset`,shouldRun(t){return t.deploymentPending&&t.channelSelection.includes(`web`)&&isProjectResolved(t.project)},async gather(){return null},async perform({state:e,signal:n}){let a=requireProjectPath(e),o=createPromptCommandOutput(r.prompter.log);return await i.syncHostFrameworkPreset(r.prompter,a,o,{signal:n}),null},apply(e){return e}}}export{reconcileHostFrameworkPreset};

package/dist/src/shared/hook-definition.d.ts

@@ -1,36 +0,0 @@
-type BaseEvent = {
-    type: string;
-};
-/**
- * Side-effect-only handler for one accepted runtime stream event.
- *
- * `TEvent` is one variant of the runtime stream-event union.
- * {@link GenericStreamEventHooks} infers `TEvent` from the event key.
- */
-export type GenericStreamEventHook<TEvent extends BaseEvent, TContext> = (event: TEvent, ctx: TContext) => void | Promise<void>;
-/**
- * Map of stream-event subscribers an authored hook file may declare.
- *
- * `*` matches every accepted runtime stream event and runs after the
- * typed handler for that event (if any).
- */
-export type GenericStreamEventHooks<TEvent extends BaseEvent, TContext> = {
-    readonly "*"?: GenericStreamEventHook<TEvent, TContext>;
-} & {
-    readonly [K in TEvent["type"]]?: GenericStreamEventHook<Extract<TEvent, {
-        type: K;
-    }>, TContext>;
-};
-/**
- * Public hook definition authored in `agent/hooks/*.ts`.
- *
- * Hook files declare stream-event subscribers (under `events:`) that
- * fire after eve has accepted and durably recorded each event.
- * Handlers are observe-only: they cannot inject model context. To
- * contribute runtime model messages, use `defineDynamic` +
- * `defineInstructions` in `agent/instructions/`.
- */
-export interface GenericHookDefinition<TEvent extends BaseEvent, TContext> {
-    readonly events?: GenericStreamEventHooks<TEvent, TContext>;
-}
-export {};

package/dist/src/shared/hook-definition.js

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

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

@@ -1,9 +0,0 @@
-import type { StandardJSONSchemaV1 } from "#compiled/@standard-schema/spec/index.js";
-import { type JsonObject } from "#shared/json.js";
-type JsonSchemaDirection = "input" | "output";
-/**
- * Normalizes one Standard Schema or JSON Schema definition into plain JSON
- * Schema data that can cross eve runtime and client boundaries.
- */
-export declare function normalizeJsonSchemaDefinition(value: StandardJSONSchemaV1 | Record<string, unknown> | unknown, direction?: JsonSchemaDirection): JsonObject;
-export {};

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

@@ -1 +0,0 @@
-import{parseJsonObject}from"#shared/json.js";function normalizeJsonSchemaDefinition(t,n=`input`){return isStandardSchema(t)?parseJsonObject(t[`~standard`].jsonSchema[n]({target:`draft-07`})):parseJsonObject(t)}function isStandardSchema(e){return typeof e==`object`&&!!e&&`~standard`in e}export{normalizeJsonSchemaDefinition};