The Open Framework for Building Agents
feat(dev): materialize immutable generations (#759)
Casey Gowriee0b64a5cbefd
diff --git a/.changeset/calm-trees-build.md b/.changeset/calm-trees-build.mdnew file mode 100644index 000000000..c4564b37a--- /dev/null+++ b/.changeset/calm-trees-build.md@@ -0,0 +1,5 @@+---+"eve": patch+---++Keep development runtime generations executable after authored source or dependencies change by bundling ordinary dependencies and materializing configured external dependency closures.diff --git a/packages/eve/src/execution/sandbox/prewarm.scenario.test.ts b/packages/eve/src/execution/sandbox/prewarm.scenario.test.tsindex d1667deca..a739fafe4 100644--- a/packages/eve/src/execution/sandbox/prewarm.scenario.test.ts+++ b/packages/eve/src/execution/sandbox/prewarm.scenario.test.ts@@ -6,7 +6,7 @@ import { afterEach, describe, expect, it, vi } from "vitest";import { compileAgent, compileAgentInBuildWorkspace } from "#compiler/compile-agent.js";import { resolvePackageSourceFilePath } from "#internal/application/package.js";import { createDevelopmentNitroArtifactsConfig } from "#internal/nitro/host/artifacts-config.js";-import { publishDevelopmentRuntimeArtifactsSnapshot } from "#internal/nitro/dev-runtime-artifacts.js";+import { publishDevelopmentGeneration } from "#internal/nitro/development-generation.js";import { resolveNitroCompiledArtifactsSource } from "#internal/nitro/routes/runtime-artifacts.js";import { useTemporaryDirectories } from "#internal/testing/use-temporary-app-roots.js";import type {@@ -99,7 +99,7 @@ describe("prewarmAppSandboxes", () => {const compileResult = await compileAgent({startPath: appRoot,});- await publishDevelopmentRuntimeArtifactsSnapshot(compileResult);+ await publishDevelopmentGeneration(compileResult);await prewarmAppSandboxes({appRoot,diff --git a/packages/eve/src/internal/application/compiled-artifacts.ts b/packages/eve/src/internal/application/compiled-artifacts.tsindex 843405f66..9554ea909 100644--- a/packages/eve/src/internal/application/compiled-artifacts.ts+++ b/packages/eve/src/internal/application/compiled-artifacts.ts@@ -1,5 +1,5 @@import { existsSync } from "node:fs";-import { mkdir, writeFile } from "node:fs/promises";+import { copyFile, mkdir, writeFile } from "node:fs/promises";import { join } from "node:path";import type { CompileMetadata } from "#compiler/artifacts.js";@@ -12,6 +12,7 @@ import {resolvePackageSourceFilePath,} from "#internal/application/package.js";import type { AgentWorkflowWorldDefinition } from "#shared/agent-definition.js";+import { readMaterializedAuthoredModuleIndex } from "#internal/materialized-authored-modules.js";export type BuiltInWorkflowWorldTarget = "local" | "vercel";@@ -99,6 +100,79 @@ export async function writeCompiledArtifactsFiles(input: {return generatedArtifacts;}+// The dev host's Nitro inputs outlive any single generation, so nothing+// written here may point into authored source or a prunable snapshot: the+// bootstrap references no authored module, and the instrumentation bundle is+// copied out of the generation into the stable host directory.+export async function writeDevelopmentCompiledArtifactsFiles(input: {+ readonly compileResult: CompileAgentResult;+ readonly outDir: string;+ readonly runtimeAppRoot: string;+}): Promise<GeneratedCompiledArtifactsFiles> {+ const bootstrapPath = join(input.outDir, "compiled-artifacts-bootstrap.mjs");+ const instrumentationPluginPath = join(input.outDir, "compiled-artifacts-instrumentation.mjs");+ const instrumentationSourcePath = join(+ input.outDir,+ "compiled-artifacts-instrumentation-source.mjs",+ );+ const workflowWorldPluginPath = join(input.outDir, "compiled-artifacts-workflow-world.mjs");+ const materializedIndex = await readMaterializedAuthoredModuleIndex(input.runtimeAppRoot);++ if (materializedIndex === undefined) {+ throw new Error(`Development generation at "${input.runtimeAppRoot}" is not materialized.`);+ }++ await mkdir(input.outDir, { recursive: true });+ await writeFile(+ bootstrapPath,+ createDevelopmentCompiledArtifactsBootstrapSource(input.compileResult.manifest.config.name),+ );+ await writeFile(+ workflowWorldPluginPath,+ createWorkflowWorldPluginSource({+ compiledArtifactsBootstrapPath: bootstrapPath,+ configuredWorld: input.compileResult.manifest.config.experimental?.workflow?.world,+ defaultWorld: "local",+ }),+ );++ const generatedArtifacts: GeneratedCompiledArtifactsFiles = {+ bootstrapPath,+ workflowWorldPluginPath,+ };++ if (materializedIndex.instrumentation !== undefined) {+ await copyFile(+ join(input.runtimeAppRoot, ".eve", "compile", materializedIndex.instrumentation),+ instrumentationSourcePath,+ );+ await writeFile(+ instrumentationPluginPath,+ createInstrumentationPluginSource({+ agentName: input.compileResult.manifest.config.name,+ instrumentationPath: instrumentationSourcePath,+ registerConfigPath: resolvePackageSourceFilePath("src/harness/instrumentation-config.ts"),+ }),+ );+ generatedArtifacts.instrumentationPluginPath = instrumentationPluginPath;+ generatedArtifacts.instrumentationSourcePath = instrumentationSourcePath;+ }++ return generatedArtifacts;+}++function createDevelopmentCompiledArtifactsBootstrapSource(agentName: string): string {+ return [+ "// Generated by eve. Do not edit by hand.",+ `import { installEveWorkflowQueueNamespace } from ${stringifyEsmImportSpecifier(resolvePackageSourceFilePath("src/internal/workflow/queue-namespace.ts"))};`,+ "",+ `installEveWorkflowQueueNamespace(${JSON.stringify(agentName)});`,+ "",+ "export default function installDevelopmentCompiledArtifactsPlugin() {}",+ "",+ ].join("\n");+}+const INSTRUMENTATION_EXTENSIONS = [".ts", ".mts", ".js", ".mjs"];/**diff --git a/packages/eve/src/internal/authored-directive-prologue.test.ts b/packages/eve/src/internal/authored-directive-prologue.test.tsnew file mode 100644index 000000000..b6e579b0f--- /dev/null+++ b/packages/eve/src/internal/authored-directive-prologue.test.ts@@ -0,0 +1,29 @@+import { describe, expect, it } from "vitest";++import { assertNoWorkflowDirectivePrologue } from "#internal/authored-directive-prologue.js";++describe("assertNoWorkflowDirectivePrologue", () => {+ it.each(["use step", "use workflow"])("rejects an authored %s directive", async (directive) => {+ await expect(+ assertNoWorkflowDirectivePrologue({+ filePath: "/app/agent/tools/example.ts",+ source: `'use strict';\n${JSON.stringify(directive)};\nexport const value = 1;\n`,+ }),+ ).rejects.toThrow(new RegExp(`actual .*${directive}.* directive`, "u"));+ });++ it("accepts comments and ordinary strings containing directive text", async () => {+ await expect(+ assertNoWorkflowDirectivePrologue({+ filePath: "/app/agent/tools/example.ts",+ source: [+ '// "use step" is documentation, not a directive.',+ 'const message = "use workflow";',+ '"use step";',+ "export { message };",+ "",+ ].join("\n"),+ }),+ ).resolves.toBeUndefined();+ });+});diff --git a/packages/eve/src/internal/authored-directive-prologue.ts b/packages/eve/src/internal/authored-directive-prologue.tsnew file mode 100644index 000000000..331f7118c--- /dev/null+++ b/packages/eve/src/internal/authored-directive-prologue.ts@@ -0,0 +1,35 @@+import { parseWithNitroRolldownAst } from "#internal/bundler/nitro-rolldown.js";++const UNSUPPORTED_WORKFLOW_DIRECTIVES = new Set(["use step", "use workflow"]);++interface DirectiveStatement {+ readonly directive?: unknown;+}++interface Program {+ readonly body?: unknown;+}++export async function assertNoWorkflowDirectivePrologue(input: {+ readonly filePath: string;+ readonly source: string;+}): Promise<void> {+ const program = (await parseWithNitroRolldownAst(input.filePath, input.source)) as Program;++ if (!Array.isArray(program.body)) {+ throw new Error(`Failed to parse authored module "${input.filePath}".`);+ }++ for (const statement of program.body as DirectiveStatement[]) {+ if (typeof statement.directive !== "string") {+ break;+ }++ if (UNSUPPORTED_WORKFLOW_DIRECTIVES.has(statement.directive)) {+ throw new Error(+ `Authored module "${input.filePath}" contains an actual "${statement.directive}" directive. ` ++ "Workflow directives are reserved for eve-generated workflow entrypoints.",+ );+ }+ }+}diff --git a/packages/eve/src/internal/authored-module-loader.ts b/packages/eve/src/internal/authored-module-loader.tsindex a7698b7ac..d7b873c2c 100644--- a/packages/eve/src/internal/authored-module-loader.ts+++ b/packages/eve/src/internal/authored-module-loader.ts@@ -1,18 +1,28 @@import { createHash } from "node:crypto";-import { existsSync, mkdirSync, realpathSync, statSync, writeFileSync } from "node:fs";-import { createRequire } from "node:module";-import { dirname, isAbsolute, join, resolve, sep } from "node:path";+import { existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";+import { dirname, isAbsolute, join, resolve } from "node:path";import { createAuthoredAssetImportPlugin } from "#internal/authored-asset-import-plugin.js";+import { assertNoWorkflowDirectivePrologue } from "#internal/authored-directive-prologue.js";import { createAuthoredModuleBundleError } from "#internal/authored-module-bundle.js";import { createAuthoredPackageTsConfigPathsPlugin } from "#internal/authored-package-tsconfig-paths.js";import { createFixedNamespaceScopePlugin } from "#internal/bundler/extension-scope-plugin.js";+import {+ CACHED_CHANNEL_PREFIX,+ RESOLVE_EXTENSIONS,+ createGenerationPackageBoundaryPlugin,+ createRuntimeLoaderPackageBoundaryPlugin,+ isNodeModulesPath,+ isPathImport,+ normalizeExternalDependencies,+ type RolldownResolveContext,+} from "#internal/authored-package-boundary.js";import { expectObjectRecord } from "#internal/authored-module.js";import {buildWithNitroRolldown,getSingleRolldownChunk,} from "#internal/bundler/nitro-rolldown.js";-import { SERVER_EXTERNAL_PACKAGES } from "#internal/nitro/host/server-external-packages.js";+import type { ResolvedAuthoredExternalModule } from "#internal/materialize-authored-external-dependencies.js";import { createNodeEsmCompatBannerPlugin } from "#internal/node-esm-compat-banner.js";const AUTHORED_BUNDLED_MODULE_EXTENSION = /\.[cm]?[jt]sx?$/;@@ -22,32 +32,7 @@ const AUTHORED_MODULE_BUNDLE_DIRECTORY_PATH = join("eve","authored-modules",);-const RESOLVE_EXTENSIONS = [- ".ts",- ".tsx",- ".mts",- ".cts",- ".js",- ".jsx",- ".mjs",- ".cjs",- ".json",-] as const;-const CHANNEL_MODULE_CACHE_KEY = "__eveChannelModuleCache__";-const CACHED_CHANNEL_PREFIX = "eve-cached-channel:";--type RolldownResolveResult = {- readonly id: string;-};--type RolldownResolveContext = {- resolve(- source: string,- importer: string | undefined,- options: { kind: string; skipSelf: boolean },- ): Promise<RolldownResolveResult | null>;-};export interface AuthoredModuleLoadOptions {readonly externalDependencies?: readonly string[];@@ -59,6 +44,11 @@ export interface AuthoredModuleLoadOptions {readonly extensionScopeNamespace?: string;}+export interface AuthoredGenerationModuleBundle {+ readonly code: string;+ readonly externalModules: readonly ResolvedAuthoredExternalModule[];+}+function getChannelModuleCache(): Map<string, unknown> | undefined {return (globalThis as Record<string, unknown>)[CHANNEL_MODULE_CACHE_KEY] as| Map<string, unknown>@@ -147,20 +137,78 @@ function createFileImportSpecifier(modulePath: string): string {}/**- * Bundles one authored entry module to a self-contained ESM string using the- * same plugin stack the dev/eval loader uses: `eve/*` and node_modules deps stay- * external, relative source is inlined, and (when `extensionScopeNamespace` is- * set) `defineState`/`defineExtension` are scoped to that namespace. Shared with- * `eve extension build`'s entrypoint compilation so both paths bundle identically.+ * Bundles one authored entry for immediate dev/eval loading. Package dependencies+ * remain external while relative authored source is inlined.*/export async function bundleAuthoredModuleCode(modulePath: string,options: AuthoredModuleLoadOptions = {},): Promise<string> {- const channelCache = getChannelModuleCache();+ return await buildAuthoredModuleBundle(modulePath, options, {+ channelIdentity: true,+ packageBoundaryPlugin: createRuntimeLoaderPackageBoundaryPlugin({+ externalDependencies: normalizeExternalDependencies(options.externalDependencies),+ packageRoot: resolveAuthoredPackageRoot(modulePath),+ }),+ plugins: [],+ sourcemap: "inline",+ });+}++/**+ * Bundles one authored entry for an immutable development generation. Ordinary+ * package dependencies are inlined so the emitted code stays executable after+ * the original workspace changes; framework runtime imports and configured+ * external dependencies stay external, and every configured external the+ * bundle references is reported for closure materialization.+ */+export async function bundleAuthoredModuleForGeneration(+ modulePath: string,+ options: AuthoredModuleLoadOptions = {},+): Promise<AuthoredGenerationModuleBundle> {+ const externalModules = new Map<string, ResolvedAuthoredExternalModule>();+ const code = await buildAuthoredModuleBundle(modulePath, options, {+ // Generation bundles must not reference process state: the channel+ // identity plugin emits reads of a process-global cache keyed by live+ // source paths, which an immutable retained artifact cannot depend on.+ channelIdentity: false,+ packageBoundaryPlugin: createGenerationPackageBoundaryPlugin({+ externalDependencies: normalizeExternalDependencies(options.externalDependencies),+ packageRoot: resolveAuthoredPackageRoot(modulePath),+ recordExternalModule(externalModule) {+ externalModules.set(+ `${externalModule.packageName}\0${externalModule.resolvedId}`,+ externalModule,+ );+ },+ }),+ plugins: [createAuthoredDirectiveGuardPlugin()],+ sourcemap: false,+ });++ return {+ code: removeRolldownModuleRegionComments(code),+ externalModules: [...externalModules.values()].sort((left, right) =>+ `${left.packageName}\0${left.resolvedId}`.localeCompare(+ `${right.packageName}\0${right.resolvedId}`,+ ),+ ),+ };+}++async function buildAuthoredModuleBundle(+ modulePath: string,+ options: AuthoredModuleLoadOptions,+ configuration: {+ readonly channelIdentity: boolean;+ readonly packageBoundaryPlugin: Record<string, unknown>;+ readonly plugins: readonly Record<string, unknown>[];+ readonly sourcemap: false | "inline";+ },+): Promise<string> {+ const channelCache = configuration.channelIdentity ? getChannelModuleCache() : undefined;const packageRoot = resolveAuthoredPackageRoot(modulePath);const tsconfigPath = resolveAuthoredTsConfigPath(packageRoot);- const externalDependencies = normalizeExternalDependencies(options.externalDependencies);const channelIdentityPlugin =channelCache && channelCache.size > 0? {@@ -210,6 +258,7 @@ export async function bundleAuthoredModuleCode(: null;const plugins = [channelIdentityPlugin,+ ...configuration.plugins,options.extensionScopeNamespace === undefined? null: createFixedNamespaceScopePlugin(options.extensionScopeNamespace),@@ -220,7 +269,7 @@ export async function bundleAuthoredModuleCode(extensions: RESOLVE_EXTENSIONS,}),createNodeEsmCompatBannerPlugin({ includeRequire: true }),- createPackageBoundaryPlugin(packageRoot, externalDependencies),+ configuration.packageBoundaryPlugin,].filter((plugin) => plugin !== null);try {@@ -237,7 +286,7 @@ export async function bundleAuthoredModuleCode(output: {comments: false,format: "esm",- sourcemap: "inline",+ sourcemap: configuration.sourcemap,},});return getSingleRolldownChunk(result, `authored module for "${modulePath}"`).code;@@ -246,6 +295,27 @@ export async function bundleAuthoredModuleCode(}}+function createAuthoredDirectiveGuardPlugin(): Record<string, unknown> {+ return {+ name: "eve-authored-directive-guard",+ async transform(source: string, id: string) {+ if (!AUTHORED_BUNDLED_MODULE_EXTENSION.test(id) || isNodeModulesPath(id)) {+ return undefined;+ }++ await assertNoWorkflowDirectivePrologue({ filePath: id, source });+ return undefined;+ },+ };+}++function removeRolldownModuleRegionComments(code: string): string {+ return code+ .split("\n")+ .filter((line) => !line.startsWith("//#region ") && line !== "//#endregion")+ .join("\n");+}+async function loadBundledAuthoredModule(modulePath: string,options: AuthoredModuleLoadOptions,@@ -303,126 +373,6 @@ function createAuthoredRelativeExtensionResolverPlugin(input: {};}-function createPackageBoundaryPlugin(- packageRoot: string,- externalDependencies: readonly string[],-): Record<string, unknown> {- // The bundler reports importers by realpath while `packageRoot` keeps the- // caller's spelling (e.g. macOS `/var` vs `/private/var`); compare- // canonical paths or the app-authored branch is skipped silently.- const canonicalPackageRoot = toCanonicalPath(packageRoot);-- return {- name: "eve-package-boundary",- async resolveId(- this: RolldownResolveContext,- source: string,- importer: string | undefined,- options: { kind: string },- ) {- if (!isPackageImport(source)) {- return undefined;- }-- if (isEveFrameworkImport(source)) {- return {- external: true,- id: source,- };- }-- const configuredExternalDependency = resolveConfiguredExternalDependency(- source,- externalDependencies,- );-- if (configuredExternalDependency !== undefined) {- if (source !== configuredExternalDependency) {- const resolved = await this.resolve(source, importer, {- kind: options.kind,- skipSelf: true,- });-- if (resolved !== null && typeof resolved.id === "string") {- return {- external: true,- id: resolveExternalFilePath({- importer,- packageRoot,- resolvedId: resolved.id,- source,- }),- };- }-- const resolvedSubpath = resolveExternalFilePath({- importer,- packageRoot,- source,- });-- if (resolvedSubpath !== undefined) {- return {- external: true,- id: resolvedSubpath,- };- }- }-- return {- external: true,- id: source,- };- }-- const importerPath =- importer === undefined ||- importer.startsWith("\0") ||- importer.startsWith(CACHED_CHANNEL_PREFIX)- ? undefined- : resolve(importer);-- // Keep package imports authored directly by the app external by- // default, but let symlinked/file workspace packages compile as- // source. Those packages often export `.ts` files and rely on the- // bundler's extension resolution for their own relative imports.- if (- importerPath !== undefined &&- isPathInsideOrEqual(toCanonicalPath(importerPath), canonicalPackageRoot)- ) {- const resolved = await this.resolve(source, importer, {- kind: options.kind,- skipSelf: true,- });-- if (resolved === null || typeof resolved.id !== "string") {- // Failing here (instead of emitting the bare specifier as an- // external) is load-bearing: importing a bundle whose package is- // missing poisons Node's process-wide package-config cache with a- // negative entry, and once the package is installed the same- // long-running process keeps failing resolution until restart.- // The bundler's resolver is fresh on every rebuild, so failing at- // bundle time keeps the dev server able to recover after install.- throw new Error(- `Cannot resolve package "${source}" imported from "${importerPath}". ` +- `Install it with your package manager (e.g. \`pnpm install\`); ` +- `a running \`eve dev\` retries on the next rebuild.`,- );- }-- if (isNodeModulesPath(resolved.id)) {- return {- external: true,- id: source,- };- }- }-- return undefined;- },- };-}-function createInFlightModuleLoadKey(modulePath: string,options: AuthoredModuleLoadOptions,@@ -432,66 +382,6 @@ function createInFlightModuleLoadKey(return `${modulePath}\0${externalDependencies.join("\0")}\0${options.extensionScopeNamespace ?? ""}`;}-function normalizeExternalDependencies(externalDependencies: readonly string[] = []): string[] {- return [...new Set([...SERVER_EXTERNAL_PACKAGES, ...externalDependencies])].sort();-}--function resolveConfiguredExternalDependency(- source: string,- externalDependencies: readonly string[],-): string | undefined {- return externalDependencies.find(- (dependencyName) => source === dependencyName || source.startsWith(`${dependencyName}/`),- );-}--function resolveExternalFilePath(input: {- importer: string | undefined;- packageRoot: string;- resolvedId?: string;- source: string;-}): string | undefined {- if (input.resolvedId !== undefined) {- const resolvedPath = resolveExistingExternalFilePath(input.resolvedId);-- if (resolvedPath !== undefined) {- return resolvedPath;- }- }-- const importerPath = normalizeImporterPath(input.importer);-- if (importerPath !== undefined) {- try {- return createRequire(importerPath).resolve(input.source);- } catch {- // Fall back to the app package root below.- }- }-- try {- return createRequire(join(input.packageRoot, "package.json")).resolve(input.source);- } catch {- return input.resolvedId;- }-}--function resolveExistingExternalFilePath(id: string): string | undefined {- if (existsSync(id)) {- return id;- }-- for (const extension of RESOLVE_EXTENSIONS) {- const candidate = `${id}${extension}`;-- if (existsSync(candidate)) {- return candidate;- }- }-- return undefined;-}-function resolveExistingImportPath(path: string,extensions: readonly string[],@@ -527,63 +417,6 @@ function isFile(path: string): boolean {}}-function normalizeImporterPath(importer: string | undefined): string | undefined {- if (- importer === undefined ||- importer.startsWith("\0") ||- importer.startsWith(CACHED_CHANNEL_PREFIX)- ) {- return undefined;- }-- return resolve(importer);-}--function isPackageImport(source: string): boolean {- if (isPathImport(source)) {- return false;- }-- if (/^(?:node|data|file):/.test(source)) {- return false;- }-- if (source.startsWith("@/")) {- return false;- }-- return !source.startsWith(CACHED_CHANNEL_PREFIX);-}--function isPathImport(source: string): boolean {- return source.startsWith(".") || source.startsWith("/") || /^[A-Za-z]:[\\/]/.test(source);-}--function isEveFrameworkImport(source: string): boolean {- return source === "eve" || source.startsWith("eve/");-}--function isNodeModulesPath(path: string): boolean {- return path.replaceAll("\\", "/").includes("/node_modules/");-}--function toCanonicalPath(path: string): string {- try {- return realpathSync(path);- } catch {- return resolve(path);- }-}--function isPathInsideOrEqual(path: string, directory: string): boolean {- const resolvedPath = resolve(path);- const resolvedDirectory = resolve(directory);-- return (- resolvedPath === resolvedDirectory || resolvedPath.startsWith(`${resolvedDirectory}${sep}`)- );-}-function resolveAuthoredTsConfigPath(packageRoot: string): string | false {for (const fileName of ["tsconfig.json", "jsconfig.json"]) {const path = join(packageRoot, fileName);diff --git a/packages/eve/src/internal/authored-module-map-loader.ts b/packages/eve/src/internal/authored-module-map-loader.tsindex 2ec5d3ec8..787b58ca6 100644--- a/packages/eve/src/internal/authored-module-map-loader.ts+++ b/packages/eve/src/internal/authored-module-map-loader.ts@@ -1,4 +1,5 @@import { join } from "node:path";+import { pathToFileURL } from "node:url";import type { CompiledAgentManifest, CompiledAgentNodeManifest } from "#compiler/manifest.js";import { ROOT_COMPILED_AGENT_NODE_ID } from "#compiler/manifest.js";@@ -6,6 +7,8 @@ import { collectModuleRefsForManifest, type CompiledModuleMap } from "#compiler/import type { RuntimeDiskCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";import { loadCompiledManifest } from "#runtime/loaders/manifest.js";import { loadAuthoredModuleNamespace } from "#internal/authored-module-loader.js";+import { expectObjectRecord } from "#internal/authored-module.js";+import { readMaterializedAuthoredModuleIndex } from "#internal/materialized-authored-modules.js";/*** Ambient namespace read by `defineExtension` when it is evaluated from a module@@ -28,7 +31,10 @@ export async function loadCompiledModuleMapFromAuthoredSource(input: {compiledArtifactsSource: input.compiledArtifactsSource,});- return await hydrateCompiledModuleMapFromManifest(manifest);+ return await hydrateCompiledModuleMapFromManifest(+ manifest,+ input.compiledArtifactsSource.appRoot,+ );}interface ExtensionScopeIndex {@@ -40,6 +46,7 @@ interface ExtensionScopeIndex {async function hydrateCompiledModuleMapFromManifest(manifest: CompiledAgentManifest,+ runtimeAppRoot: string,): Promise<CompiledModuleMap> {const nodes: CompiledModuleMap["nodes"] = {};const nodeManifests: Array<{@@ -69,12 +76,22 @@ async function hydrateCompiledModuleMapFromManifest(manifest.extensionMounts.map((mount) => [mount.mountSourceId, mount.packageNamespace]),),};+ const materializedIndex = await readMaterializedAuthoredModuleIndex(runtimeAppRoot);for (const nodeManifest of nodeManifests) {+ const materializedModules = materializedIndex?.nodes[nodeManifest.nodeId]?.modules;+ if (materializedIndex !== undefined && materializedModules === undefined) {+ throw new Error(+ `Materialized authored module index is missing node "${nodeManifest.nodeId}".`,+ );+ }+nodes[nodeManifest.nodeId] = {modules: await hydrateCompiledNodeScope({agentRoot: nodeManifest.agentRoot,manifest: nodeManifest.manifest,+ materializedModules,+ runtimeAppRoot,scopeIndex,}),};@@ -100,6 +117,8 @@ function extensionNamespaceForSourceId(async function hydrateCompiledNodeScope(input: {agentRoot: string;manifest: CompiledAgentNodeManifest;+ materializedModules?: Readonly<Record<string, string>>;+ runtimeAppRoot: string;scopeIndex: ExtensionScopeIndex;}): Promise<CompiledModuleMap["nodes"][string]["modules"]> {const refs = collectModuleRefsForManifest(input.manifest).sort((left, right) =>@@ -123,6 +142,21 @@ async function hydrateCompiledNodeScope(input: {container[EXT_CONFIG_SCOPE] = mountConfigScope;}try {+ const materializedPath = input.materializedModules?.[ref.sourceId];+ if (input.materializedModules !== undefined && materializedPath === undefined) {+ throw new Error(`Materialized authored module index is missing source "${ref.sourceId}".`);+ }++ if (materializedPath !== undefined) {+ modules[ref.sourceId] = expectObjectRecord(+ await import(+ `${pathToFileURL(join(input.runtimeAppRoot, ".eve", "compile", materializedPath)).href}?generation=${encodeURIComponent(materializedPath)}`+ ),+ `Expected materialized authored module "${ref.sourceId}" to export a namespace object.`,+ );+ continue;+ }+modules[ref.sourceId] = await loadAuthoredModuleNamespace(modulePath, {externalDependencies,extensionScopeNamespace,diff --git a/packages/eve/src/internal/authored-package-boundary.ts b/packages/eve/src/internal/authored-package-boundary.tsnew file mode 100644index 000000000..28c96d3bb--- /dev/null+++ b/packages/eve/src/internal/authored-package-boundary.ts@@ -0,0 +1,278 @@+import { existsSync, realpathSync } from "node:fs";+import { join, resolve, sep } from "node:path";++import type { ResolvedAuthoredExternalModule } from "#internal/materialize-authored-external-dependencies.js";+import { SERVER_EXTERNAL_PACKAGES } from "#internal/nitro/host/server-external-packages.js";++export const CACHED_CHANNEL_PREFIX = "eve-cached-channel:";++export const RESOLVE_EXTENSIONS = [+ ".ts",+ ".tsx",+ ".mts",+ ".cts",+ ".js",+ ".jsx",+ ".mjs",+ ".cjs",+ ".json",+] as const;++type RolldownResolveResult = {+ readonly id: string;+};++export type RolldownResolveContext = {+ resolve(+ source: string,+ importer: string | undefined,+ options: { kind: string; skipSelf: boolean },+ ): Promise<RolldownResolveResult | null>;+};++export function createGenerationPackageBoundaryPlugin(input: {+ readonly externalDependencies: readonly string[];+ readonly packageRoot: string;+ readonly recordExternalModule: (externalModule: ResolvedAuthoredExternalModule) => void;+}): Record<string, unknown> {+ return {+ name: "eve-generation-package-boundary",+ async resolveId(+ this: RolldownResolveContext,+ source: string,+ importer: string | undefined,+ options: { kind: string },+ ) {+ if (!isPackageImport(source)) {+ return undefined;+ }++ if (isFrameworkRuntimeImport(source, importer)) {+ return {+ external: true,+ id: source,+ };+ }++ const externalModule = await resolveConfiguredExternalModule.call(this, {+ externalDependencies: input.externalDependencies,+ importer,+ kind: options.kind,+ packageRoot: input.packageRoot,+ source,+ });+ if (externalModule === undefined) {+ return undefined;+ }++ input.recordExternalModule(externalModule);+ return { external: true, id: source };+ },+ };+}++export function createRuntimeLoaderPackageBoundaryPlugin(input: {+ readonly externalDependencies: readonly string[];+ readonly packageRoot: string;+}): Record<string, unknown> {+ const canonicalPackageRoot = toCanonicalPath(input.packageRoot);++ return {+ name: "eve-runtime-loader-package-boundary",+ async resolveId(+ this: RolldownResolveContext,+ source: string,+ importer: string | undefined,+ options: { kind: string },+ ) {+ if (!isPackageImport(source)) {+ return undefined;+ }++ if (isFrameworkRuntimeImport(source, importer)) {+ return { external: true, id: source };+ }++ const externalModule = await resolveConfiguredExternalModule.call(this, {+ externalDependencies: input.externalDependencies,+ importer,+ kind: options.kind,+ packageRoot: input.packageRoot,+ source,+ });+ if (externalModule !== undefined) {+ return {+ external: true,+ id:+ resolveExistingExternalFilePath(externalModule.resolvedId) ?? externalModule.resolvedId,+ };+ }++ const importerPath =+ importer === undefined ||+ importer.startsWith("\0") ||+ importer.startsWith(CACHED_CHANNEL_PREFIX)+ ? undefined+ : resolve(importer);++ // Keep package imports authored directly by the app external by+ // default, but let symlinked/file workspace packages compile as+ // source. Those packages often export `.ts` files and rely on the+ // bundler's extension resolution for their own relative imports.+ if (+ importerPath !== undefined &&+ isPathInsideOrEqual(toCanonicalPath(importerPath), canonicalPackageRoot)+ ) {+ const resolved = await this.resolve(source, importer, {+ kind: options.kind,+ skipSelf: true,+ });++ if (resolved === null || typeof resolved.id !== "string") {+ // Failing here (instead of emitting the bare specifier as an+ // external) is load-bearing: importing a bundle whose package is+ // missing poisons Node's process-wide package-config cache with a+ // negative entry, and once the package is installed the same+ // long-running process keeps failing resolution until restart.+ // The bundler's resolver is fresh on every rebuild, so failing at+ // bundle time keeps the dev server able to recover after install.+ throw new Error(+ `Cannot resolve package "${source}" imported from "${importerPath}". ` ++ `Install it with your package manager (e.g. \`pnpm install\`); ` ++ `a running \`eve dev\` retries on the next rebuild.`,+ );+ }++ if (isNodeModulesPath(resolved.id)) {+ return {+ external: true,+ id: source,+ };+ }+ }++ return undefined;+ },+ };+}++async function resolveConfiguredExternalModule(+ this: RolldownResolveContext,+ input: {+ readonly externalDependencies: readonly string[];+ readonly importer: string | undefined;+ readonly kind: string;+ readonly packageRoot: string;+ readonly source: string;+ },+): Promise<ResolvedAuthoredExternalModule | undefined> {+ const packageName = resolveConfiguredExternalDependency(input.source, input.externalDependencies);+ if (packageName === undefined) {+ return undefined;+ }++ let resolved = await this.resolve(input.source, input.importer, {+ kind: input.kind,+ skipSelf: true,+ });+ if (resolved === null) {+ resolved = await this.resolve(input.source, join(input.packageRoot, "package.json"), {+ kind: input.kind,+ skipSelf: true,+ });+ }+ if (resolved === null || typeof resolved.id !== "string") {+ throw new Error(`Cannot resolve external package "${input.source}".`);+ }++ return { packageName, resolvedId: resolved.id };+}++export function normalizeExternalDependencies(+ externalDependencies: readonly string[] = [],+): string[] {+ return [...new Set([...SERVER_EXTERNAL_PACKAGES, ...externalDependencies])].sort();+}++function resolveConfiguredExternalDependency(+ source: string,+ externalDependencies: readonly string[],+): string | undefined {+ return externalDependencies.find(+ (dependencyName) => source === dependencyName || source.startsWith(`${dependencyName}/`),+ );+}++function resolveExistingExternalFilePath(id: string): string | undefined {+ if (existsSync(id)) {+ return id;+ }++ for (const extension of RESOLVE_EXTENSIONS) {+ const candidate = `${id}${extension}`;++ if (existsSync(candidate)) {+ return candidate;+ }+ }++ return undefined;+}++function isPackageImport(source: string): boolean {+ if (isPathImport(source)) {+ return false;+ }++ if (/^(?:node|data|file):/.test(source)) {+ return false;+ }++ if (source.startsWith("@/")) {+ return false;+ }++ return !source.startsWith(CACHED_CHANNEL_PREFIX);+}++export function isPathImport(source: string): boolean {+ return source.startsWith(".") || source.startsWith("/") || /^[A-Za-z]:[\\/]/.test(source);+}++function isFrameworkRuntimeImport(source: string, importer: string | undefined): boolean {+ if (source === "eve" || source.startsWith("eve/")) {+ return true;+ }++ // Workflow runtime imports in authored source must bind to the+ // process-shared workflow runtime. Third-party packages inlined into a+ // bundle keep their own copies instead: eve vendors `@workflow/*`, so a+ // bare transitive import (e.g. `@ai-sdk/provider-utils` → `@workflow/serde`)+ // is not resolvable from a materialized generation.+ if (source === "workflow" || source.startsWith("workflow/") || source.startsWith("@workflow/")) {+ return importer === undefined || !isNodeModulesPath(importer);+ }++ return false;+}++export function isNodeModulesPath(path: string): boolean {+ return path.replaceAll("\\", "/").includes("/node_modules/");+}++function toCanonicalPath(path: string): string {+ try {+ return realpathSync(path);+ } catch {+ return resolve(path);+ }+}++function isPathInsideOrEqual(path: string, directory: string): boolean {+ const resolvedPath = resolve(path);+ const resolvedDirectory = resolve(directory);++ return (+ resolvedPath === resolvedDirectory || resolvedPath.startsWith(`${resolvedDirectory}${sep}`)+ );+}diff --git a/packages/eve/src/internal/bundler/nitro-node-file-trace.ts b/packages/eve/src/internal/bundler/nitro-node-file-trace.tsnew file mode 100644index 000000000..a419206a8--- /dev/null+++ b/packages/eve/src/internal/bundler/nitro-node-file-trace.ts@@ -0,0 +1,49 @@+import { createRequire } from "node:module";+import { pathToFileURL } from "node:url";++interface NodeFileTraceResult {+ readonly fileList: ReadonlySet<string>;+ readonly warnings: ReadonlySet<Error>;+}++type NodeFileTrace = (+ files: string[],+ options: {+ readonly base: string;+ readonly conditions: string[];+ readonly processCwd: string;+ },+) => Promise<NodeFileTraceResult>;++interface NodeFileTraceModule {+ readonly nodeFileTrace: NodeFileTrace;+}++let nodeFileTraceModulePromise: Promise<NodeFileTraceModule> | undefined;++async function loadNitroNodeFileTrace(): Promise<NodeFileTraceModule> {+ nodeFileTraceModulePromise ??= (async () => {+ const require = createRequire(import.meta.url);+ const nitroRequire = createRequire(require.resolve("nitro/package.json"));+ const modulePath = nitroRequire.resolve("@vercel/nft");+ return (await import(pathToFileURL(modulePath).href)) as NodeFileTraceModule;+ })();++ return await nodeFileTraceModulePromise;+}++// Traces under `node` + `import` conditions: the runtime loads materialized+// externals with ESM `import()`, so tracing through `require` conditions+// would materialize files the runtime never resolves.+export async function traceNodeEsmFiles(input: {+ readonly base: string;+ readonly entries: readonly string[];+ readonly processCwd: string;+}): Promise<NodeFileTraceResult> {+ const { nodeFileTrace } = await loadNitroNodeFileTrace();+ return await nodeFileTrace([...input.entries], {+ base: input.base,+ conditions: ["node", "import"],+ processCwd: input.processCwd,+ });+}diff --git a/packages/eve/src/internal/materialize-authored-external-dependencies.ts b/packages/eve/src/internal/materialize-authored-external-dependencies.tsnew file mode 100644index 000000000..821b245e3--- /dev/null+++ b/packages/eve/src/internal/materialize-authored-external-dependencies.ts@@ -0,0 +1,397 @@+import { createHash } from "node:crypto";+import { constants as fsConstants } from "node:fs";+import {+ copyFile,+ lstat,+ mkdir,+ readFile,+ readdir,+ readlink,+ realpath,+ rm,+ stat,+ symlink,+} from "node:fs/promises";+import { dirname, isAbsolute, join, parse, relative, resolve, sep } from "node:path";++import { traceNodeEsmFiles } from "#internal/bundler/nitro-node-file-trace.js";++const COPY_MODE = fsConstants.COPYFILE_FICLONE;++export interface ResolvedAuthoredExternalModule {+ readonly packageName: string;+ readonly resolvedId: string;+}++export async function materializeAuthoredExternalDependencies(input: {+ readonly appRoot: string;+ readonly externalModules: readonly ResolvedAuthoredExternalModule[];+ readonly snapshotSourceRoot: string;+ readonly sourceRoot: string;+}): Promise<string> {+ if (input.externalModules.length === 0) {+ return createHash("sha256").digest("hex");+ }++ const sourceRoot = await realpath(input.sourceRoot);+ const appRoot = await realpath(input.appRoot);+ const packages = await resolveExternalPackages(input.externalModules);++ const fingerprint = createHash("sha256");+ const tracedPaths = await traceExternalDependencyPaths(packages, appRoot);+ const materializedPaths = new Set<string>();+ const materializedDirectories = new Set<string>();++ for (const externalPackage of packages) {+ await materializeDependencyDirectory({+ fingerprint,+ materializedDirectories,+ materializedPaths,+ snapshotSourceRoot: input.snapshotSourceRoot,+ sourcePath: externalPackage.packageRoot,+ sourceRoot,+ });+ }++ for (const tracedPath of tracedPaths) {+ const packageRoot = await findNearestPackageRoot(tracedPath);+ if (packageRoot !== undefined) {+ await materializeDependencyDirectory({+ fingerprint,+ materializedDirectories,+ materializedPaths,+ snapshotSourceRoot: input.snapshotSourceRoot,+ sourcePath: packageRoot,+ sourceRoot,+ });+ }+ }++ for (const tracedPath of tracedPaths) {+ await materializeTracedPath({+ fingerprint,+ materializedPaths,+ snapshotSourceRoot: input.snapshotSourceRoot,+ sourcePath: tracedPath,+ sourceRoot,+ });+ }++ for (const externalPackage of packages) {+ const materializedPackageRoot = toMaterializedPath({+ snapshotSourceRoot: input.snapshotSourceRoot,+ sourcePath: externalPackage.packageRoot,+ sourceRoot,+ });+ const runtimePackageRoot = join(+ toMaterializedPath({+ snapshotSourceRoot: input.snapshotSourceRoot,+ sourcePath: appRoot,+ sourceRoot,+ }),+ "node_modules",+ ...externalPackage.packageName.split("/"),+ );++ if (resolve(runtimePackageRoot) !== resolve(materializedPackageRoot)) {+ await rm(runtimePackageRoot, { force: true, recursive: true });+ await mkdir(dirname(runtimePackageRoot), { recursive: true });+ await symlink(+ relative(dirname(runtimePackageRoot), materializedPackageRoot) || ".",+ runtimePackageRoot,+ "junction",+ );+ }++ fingerprint+ .update("package\0")+ .update(externalPackage.packageName)+ .update("\0")+ .update(toSemanticPath(externalPackage.packageRoot, sourceRoot))+ .update("\0");+ }++ return fingerprint.digest("hex");+}++async function traceExternalDependencyPaths(+ packages: readonly ExternalPackage[],+ processCwd: string,+): Promise<string[]> {+ const groups = new Map<string, { base: string; entries: string[] }>();++ for (const externalPackage of packages) {+ const base = parse(externalPackage.resolvedId).root;+ const key = normalizePathRoot(base);+ const group = groups.get(key) ?? { base, entries: [] };+ group.entries.push(externalPackage.resolvedId);+ groups.set(key, group);+ }++ const tracedPaths = new Set<string>();+ const warnings: Error[] = [];++ for (const group of [...groups.values()].sort((left, right) =>+ normalizePathRoot(left.base).localeCompare(normalizePathRoot(right.base)),+ )) {+ const trace = await traceNodeEsmFiles({+ base: group.base,+ entries: group.entries.sort(),+ processCwd,+ });+ warnings.push(...trace.warnings);++ for (const tracedPath of trace.fileList) {+ tracedPaths.add(isAbsolute(tracedPath) ? tracedPath : resolve(group.base, tracedPath));+ }+ }++ if (warnings.length > 0) {+ const messages = warnings.map((warning) => warning.message).sort();+ throw new Error(+ `Failed to trace the complete authored external dependency closure:\n${messages.join("\n")}`,+ );+ }++ return [...tracedPaths].sort((left, right) => left.localeCompare(right));+}++async function materializeDependencyDirectory(input: {+ readonly fingerprint: ReturnType<typeof createHash>;+ readonly materializedDirectories: Set<string>;+ readonly materializedPaths: Set<string>;+ readonly snapshotSourceRoot: string;+ readonly sourcePath: string;+ readonly sourceRoot: string;+}): Promise<void> {+ const canonicalDirectory = await realpath(input.sourcePath);+ if (input.materializedDirectories.has(canonicalDirectory)) {+ return;+ }+ input.materializedDirectories.add(canonicalDirectory);++ for (const entry of (await readdir(canonicalDirectory, { withFileTypes: true })).sort(+ (left, right) => left.name.localeCompare(right.name),+ )) {+ const sourcePath = join(canonicalDirectory, entry.name);+ const sourceStats = await lstat(sourcePath);++ if (sourceStats.isDirectory()) {+ await materializeDependencyDirectory({ ...input, sourcePath });+ continue;+ }++ if (sourceStats.isSymbolicLink()) {+ await materializeTracedPath({+ fingerprint: input.fingerprint,+ materializedPaths: input.materializedPaths,+ snapshotSourceRoot: input.snapshotSourceRoot,+ sourcePath,+ sourceRoot: input.sourceRoot,+ });+ continue;+ }++ await materializeTracedPath({+ fingerprint: input.fingerprint,+ materializedPaths: input.materializedPaths,+ snapshotSourceRoot: input.snapshotSourceRoot,+ sourcePath,+ sourceRoot: input.sourceRoot,+ });+ }+}++interface ExternalPackage {+ readonly packageName: string;+ readonly packageRoot: string;+ readonly resolvedId: string;+}++async function resolveExternalPackages(+ modules: readonly ResolvedAuthoredExternalModule[],+): Promise<ExternalPackage[]> {+ const packagesByName = new Map<string, ExternalPackage>();++ for (const module of modules) {+ const packageRoot = await findPackageRoot(module.resolvedId, module.packageName);+ const existing = packagesByName.get(module.packageName);++ if (existing !== undefined && resolve(existing.packageRoot) !== resolve(packageRoot)) {+ throw new Error(+ `Authored external dependency "${module.packageName}" resolves to multiple package instances.`,+ );+ }++ packagesByName.set(module.packageName, {+ packageName: module.packageName,+ packageRoot,+ resolvedId: module.resolvedId,+ });+ }++ return [...packagesByName.values()].sort((left, right) =>+ left.packageName.localeCompare(right.packageName),+ );+}++async function findPackageRoot(resolvedId: string, packageName: string): Promise<string> {+ let current = dirname(await realpath(resolvedId));++ while (true) {+ const packageJsonPath = join(current, "package.json");++ try {+ const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8")) as {+ readonly name?: unknown;+ };++ if (packageJson.name === packageName) {+ return current;+ }+ } catch (error) {+ if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {+ throw error;+ }+ }++ const parent = dirname(current);+ if (parent === current) {+ throw new Error(+ `Cannot find package root for authored external dependency "${packageName}" from "${resolvedId}".`,+ );+ }+ current = parent;+ }+}++async function findNearestPackageRoot(path: string): Promise<string | undefined> {+ const canonicalPath = await realpath(path);+ let current = (await stat(canonicalPath)).isDirectory() ? canonicalPath : dirname(canonicalPath);++ while (true) {+ try {+ const packageJson = JSON.parse(await readFile(join(current, "package.json"), "utf8")) as {+ readonly name?: unknown;+ };+ if (typeof packageJson.name === "string" && packageJson.name.length > 0) {+ return current;+ }+ } catch (error) {+ if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {+ throw error;+ }+ }++ const parent = dirname(current);+ if (parent === current) {+ return undefined;+ }+ current = parent;+ }+}++async function materializeTracedPath(input: {+ readonly fingerprint: ReturnType<typeof createHash>;+ readonly materializedPaths: Set<string>;+ readonly snapshotSourceRoot: string;+ readonly sourcePath: string;+ readonly sourceRoot: string;+}): Promise<void> {+ const materializedPathKey = toSemanticPath(input.sourcePath, input.sourceRoot);+ if (input.materializedPaths.has(materializedPathKey)) {+ return;+ }+ input.materializedPaths.add(materializedPathKey);++ const targetPath = toMaterializedPath(input);+ const sourceStats = await lstat(input.sourcePath);+ const portablePath = toSemanticPath(input.sourcePath, input.sourceRoot);++ if (sourceStats.isSymbolicLink()) {+ const declaredTarget = await readlink(input.sourcePath);+ const resolvedTarget = await realpath(resolve(dirname(input.sourcePath), declaredTarget));+ const targetLinkTarget = toMaterializedPath({+ snapshotSourceRoot: input.snapshotSourceRoot,+ sourcePath: resolvedTarget,+ sourceRoot: input.sourceRoot,+ });+ const targetStats = await stat(input.sourcePath);++ await rm(targetPath, { force: true, recursive: true });+ await mkdir(dirname(targetPath), { recursive: true });+ await symlink(+ relative(dirname(targetPath), targetLinkTarget) || ".",+ targetPath,+ targetStats.isDirectory() ? "junction" : "file",+ );+ input.fingerprint+ .update(portablePath)+ .update("\0link\0")+ .update(toSemanticPath(resolvedTarget, input.sourceRoot))+ .update("\0");+ return;+ }++ if (!sourceStats.isFile()) {+ throw new Error(`Unsupported traced authored dependency path "${input.sourcePath}".`);+ }++ await mkdir(dirname(targetPath), { recursive: true });+ await copyFile(input.sourcePath, targetPath, COPY_MODE);+ input.fingerprint+ .update(portablePath)+ .update("\0file\0")+ .update(await readFile(input.sourcePath))+ .update("\0");+}++function toMaterializedPath(input: {+ readonly snapshotSourceRoot: string;+ readonly sourcePath: string;+ readonly sourceRoot: string;+}): string {+ if (isPathInsideOrEqual(input.sourcePath, input.sourceRoot)) {+ return join(input.snapshotSourceRoot, relative(input.sourceRoot, input.sourcePath));+ }++ const pathRoot = parse(resolve(input.sourcePath)).root;+ return join(+ input.snapshotSourceRoot,+ ".eve",+ "external-dependencies",+ createPathRootKey(pathRoot),+ relative(pathRoot, input.sourcePath),+ );+}++function toSemanticPath(path: string, sourceRoot: string): string {+ if (isPathInsideOrEqual(path, sourceRoot)) {+ return `source/${toPortablePath(relative(sourceRoot, path))}`;+ }++ const pathRoot = parse(resolve(path)).root;+ return `external/${createPathRootKey(pathRoot)}/${toPortablePath(relative(pathRoot, path))}`;+}++function createPathRootKey(pathRoot: string): string {+ return createHash("sha256").update(normalizePathRoot(pathRoot)).digest("hex").slice(0, 12);+}++function isPathInsideOrEqual(path: string, directory: string): boolean {+ const relativePath = relative(resolve(directory), resolve(path));+ return !(+ isAbsolute(relativePath) ||+ relativePath === ".." ||+ relativePath.startsWith(`..${sep}`) ||+ relativePath.startsWith(sep)+ );+}++function normalizePathRoot(pathRoot: string): string {+ return toPortablePath(pathRoot).toLowerCase();+}++function toPortablePath(path: string): string {+ return path.split(sep).join("/");+}diff --git a/packages/eve/src/internal/materialized-authored-modules.ts b/packages/eve/src/internal/materialized-authored-modules.tsnew file mode 100644index 000000000..b65d14dd5--- /dev/null+++ b/packages/eve/src/internal/materialized-authored-modules.ts@@ -0,0 +1,260 @@+import { createHash } from "node:crypto";+import { existsSync } from "node:fs";+import { lstat, mkdir, readFile, readdir, readlink, writeFile } from "node:fs/promises";+import { join, relative, sep } from "node:path";++import type { CompiledAgentManifest, CompiledAgentNodeManifest } from "#compiler/manifest.js";+import { COMPILED_AGENT_MANIFEST_KIND, ROOT_COMPILED_AGENT_NODE_ID } from "#compiler/manifest.js";+import { collectModuleRefsForManifest } from "#compiler/module-map.js";+import { bundleAuthoredModuleForGeneration } from "#internal/authored-module-loader.js";+import {+ materializeAuthoredExternalDependencies,+ type ResolvedAuthoredExternalModule,+} from "#internal/materialize-authored-external-dependencies.js";++const MATERIALIZED_MODULES_DIRECTORY = "authored-modules";+const MATERIALIZED_MODULES_INDEX = "authored-modules.json";+const INSTRUMENTATION_EXTENSIONS = [".ts", ".mts", ".js", ".mjs"] as const;++export interface MaterializedAuthoredModuleIndex {+ readonly fingerprint: string;+ readonly instrumentation?: string;+ readonly nodes: Readonly<Record<string, { readonly modules: Readonly<Record<string, string>> }>>;+ readonly version: 1;+}++export async function materializeAuthoredModules(input: {+ readonly appRoot: string;+ readonly runtimeAppRoot: string;+ readonly snapshotSourceRoot: string;+ readonly sourceRoot: string;+}): Promise<MaterializedAuthoredModuleIndex> {+ const compileRoot = join(input.runtimeAppRoot, ".eve", "compile");+ const manifest = await readCompiledManifest(join(compileRoot, "compiled-agent-manifest.json"));+ const modulesRoot = join(compileRoot, MATERIALIZED_MODULES_DIRECTORY);+ const scopeIndex = createExtensionScopeIndex(manifest);+ const nodes: Record<string, { modules: Record<string, string> }> = {};+ const externalModules: ResolvedAuthoredExternalModule[] = [];+ const fingerprint = createHash("sha256");++ await mkdir(modulesRoot, { recursive: true });+ for (const node of collectNodeManifests(manifest)) {+ const modules: Record<string, string> = {};++ for (const ref of collectModuleRefsForManifest(node.manifest).sort((left, right) =>+ left.sourceId.localeCompare(right.sourceId),+ )) {+ const bundle = await bundleAuthoredModuleForGeneration(+ join(node.agentRoot, ref.logicalPath),+ {+ externalDependencies: node.manifest.config.build?.externalDependencies ?? [],+ extensionScopeNamespace: extensionNamespaceForSourceId(ref.sourceId, scopeIndex),+ },+ );+ const fileName = createMaterializedModuleFileName(node.nodeId, ref.sourceId, bundle.code);++ await writeFile(join(modulesRoot, fileName), bundle.code);+ externalModules.push(...bundle.externalModules);+ fingerprint+ .update("module\0")+ .update(node.nodeId)+ .update("\0")+ .update(ref.sourceId)+ .update("\0")+ .update(bundle.code)+ .update("\0");+ modules[ref.sourceId] = join(MATERIALIZED_MODULES_DIRECTORY, fileName);+ }++ nodes[node.nodeId] = { modules };+ }++ const instrumentation = resolveInstrumentationModule(manifest.agentRoot);+ let instrumentationPath: string | undefined;++ if (instrumentation !== undefined) {+ const bundle = await bundleAuthoredModuleForGeneration(instrumentation, {+ externalDependencies: manifest.config.build?.externalDependencies ?? [],+ });+ const fileName = createMaterializedModuleFileName(+ ROOT_COMPILED_AGENT_NODE_ID,+ "instrumentation",+ bundle.code,+ );++ await writeFile(join(modulesRoot, fileName), bundle.code);+ externalModules.push(...bundle.externalModules);+ instrumentationPath = join(MATERIALIZED_MODULES_DIRECTORY, fileName);+ fingerprint.update("instrumentation\0").update(bundle.code).update("\0");+ }++ await hashDirectoryIfPresent({+ fingerprint,+ path: join(compileRoot, "workspace-resources"),+ root: join(compileRoot, "workspace-resources"),+ });+ fingerprint+ .update("external-dependencies\0")+ .update(+ await materializeAuthoredExternalDependencies({+ appRoot: input.appRoot,+ externalModules,+ snapshotSourceRoot: input.snapshotSourceRoot,+ sourceRoot: input.sourceRoot,+ }),+ )+ .update("\0");++ const index: {+ fingerprint: string;+ instrumentation?: string;+ nodes: MaterializedAuthoredModuleIndex["nodes"];+ version: 1;+ } = {+ fingerprint: fingerprint.digest("hex"),+ nodes,+ version: 1,+ };+ if (instrumentationPath !== undefined) {+ index.instrumentation = instrumentationPath;+ }+ await writeFile(join(compileRoot, MATERIALIZED_MODULES_INDEX), `${JSON.stringify(index)}\n`);+ return index;+}++export async function readMaterializedAuthoredModuleIndex(+ runtimeAppRoot: string,+): Promise<MaterializedAuthoredModuleIndex | undefined> {+ const indexPath = join(runtimeAppRoot, ".eve", "compile", MATERIALIZED_MODULES_INDEX);+ if (!existsSync(indexPath)) {+ return undefined;+ }++ const parsed = JSON.parse(+ await readFile(indexPath, "utf8"),+ ) as Partial<MaterializedAuthoredModuleIndex>;+ if (+ parsed.version !== 1 ||+ typeof parsed.fingerprint !== "string" ||+ parsed.fingerprint.length === 0 ||+ typeof parsed.nodes !== "object" ||+ parsed.nodes === null ||+ (parsed.instrumentation !== undefined && typeof parsed.instrumentation !== "string")+ ) {+ throw new Error(`Invalid materialized authored module index at "${indexPath}".`);+ }++ return parsed as MaterializedAuthoredModuleIndex;+}++interface ExtensionScopeIndex {+ readonly byMountNamespace: ReadonlyMap<string, string>;+}++function collectNodeManifests(manifest: CompiledAgentManifest): Array<{+ readonly agentRoot: string;+ readonly manifest: CompiledAgentNodeManifest;+ readonly nodeId: string;+}> {+ return [+ { agentRoot: manifest.agentRoot, manifest, nodeId: ROOT_COMPILED_AGENT_NODE_ID },+ ...[...manifest.subagents]+ .sort((left, right) => left.nodeId.localeCompare(right.nodeId))+ .map((subagent) => ({+ agentRoot: subagent.agent.agentRoot,+ manifest: subagent.agent,+ nodeId: subagent.nodeId,+ })),+ ];+}++function createExtensionScopeIndex(manifest: CompiledAgentManifest): ExtensionScopeIndex {+ return {+ byMountNamespace: new Map(+ manifest.extensionMounts.map((mount) => [mount.namespace, mount.packageNamespace]),+ ),+ };+}++function extensionNamespaceForSourceId(+ sourceId: string,+ index: ExtensionScopeIndex,+): string | undefined {+ const match = sourceId.match(/^ext:([^:]+):/u);+ return match === null ? undefined : index.byMountNamespace.get(match[1]!);+}++async function readCompiledManifest(path: string): Promise<CompiledAgentManifest> {+ const manifest = JSON.parse(await readFile(path, "utf8")) as CompiledAgentManifest;++ if (manifest.kind !== COMPILED_AGENT_MANIFEST_KIND) {+ throw new Error(`Invalid compiled agent manifest at "${path}".`);+ }++ return manifest;+}++function resolveInstrumentationModule(agentRoot: string): string | undefined {+ for (const extension of INSTRUMENTATION_EXTENSIONS) {+ const candidate = join(agentRoot, `instrumentation${extension}`);+ if (existsSync(candidate)) {+ return candidate;+ }+ }++ return undefined;+}++function createMaterializedModuleFileName(nodeId: string, sourceId: string, code: string): string {+ return `${createHash("sha256")+ .update(nodeId)+ .update("\0")+ .update(sourceId)+ .update("\0")+ .update(code)+ .digest("hex")}.mjs`;+}++async function hashDirectoryIfPresent(input: {+ readonly fingerprint: ReturnType<typeof createHash>;+ readonly path: string;+ readonly root: string;+}): Promise<void> {+ if (!existsSync(input.path)) {+ return;+ }++ const stats = await lstat(input.path);+ const relativePath = toPortablePath(relative(input.root, input.path));++ if (stats.isSymbolicLink()) {+ input.fingerprint+ .update(relativePath)+ .update("\0link\0")+ .update(await readlink(input.path))+ .update("\0");+ return;+ }++ if (stats.isDirectory()) {+ for (const entry of (await readdir(input.path)).sort()) {+ await hashDirectoryIfPresent({+ ...input,+ path: join(input.path, entry),+ });+ }+ return;+ }++ if (stats.isFile()) {+ input.fingerprint+ .update(relativePath)+ .update("\0file\0")+ .update(await readFile(input.path))+ .update("\0");+ }+}++function toPortablePath(path: string): string {+ return path.split(sep).join("/");+}diff --git a/packages/eve/src/internal/nitro/dev-generation-artifacts.scenario.test.ts b/packages/eve/src/internal/nitro/dev-generation-artifacts.scenario.test.tsnew file mode 100644index 000000000..02894800e--- /dev/null+++ b/packages/eve/src/internal/nitro/dev-generation-artifacts.scenario.test.ts@@ -0,0 +1,293 @@+import { existsSync } from "node:fs";+import { mkdir, readFile, readdir, realpath, rm, symlink, writeFile } from "node:fs/promises";+import { basename, dirname, join, relative } from "node:path";++import { describe, expect, it } from "vitest";++import { compileAgent } from "#compiler/compile-agent.js";+import { ROOT_COMPILED_AGENT_NODE_ID } from "#compiler/manifest.js";+import { loadCompiledModuleMapFromAuthoredSource } from "#internal/authored-module-map-loader.js";+import {+ discardDevelopmentGeneration,+ stageDevelopmentGeneration,+} from "#internal/nitro/development-generation.js";+import { createAuthoredSourceRuntimeCompiledArtifactsSource } from "#internal/application/runtime-compiled-artifacts-source.js";+import { useScenarioApp } from "#internal/testing/scenario-app.js";++describe("development generation artifacts", () => {+ const scenarioApp = useScenarioApp();++ it("executes its ESM external closure after the original source and dependencies are removed", async () => {+ const app = await scenarioApp({+ dependencies: {+ "fixture-bundled": "1.0.0",+ "fixture-external": "1.0.0",+ },+ files: {+ "agent/agent.mjs": [+ "export default {",+ ' model: "openai/gpt-5.4",',+ ' build: { externalDependencies: ["fixture-external"] },',+ "};",+ "",+ ].join("\n"),+ "agent/instructions.md": "Use the available tools.",+ "agent/tools/read_value.mjs": [+ 'import { bundledValue } from "fixture-bundled";',+ 'import { externalValue } from "fixture-external/feature";',+ "",+ "export default {",+ ' description: "Read dependency values.",',+ " execute() {",+ " return `${bundledValue}:${externalValue}`;",+ " },",+ "};",+ "",+ ].join("\n"),+ },+ name: "immutable-generation-closure",+ });+ const externalFixtureRoot = await writeDependencyFixture(app.appRoot);++ const compileResult = await compileAgent({ startPath: app.appRoot });+ const snapshot = await stageDevelopmentGeneration(compileResult);+ const externalPackagePath = join(snapshot.runtimeAppRoot, "node_modules", "fixture-external");+ const materializedExternalPath = await realpath(externalPackagePath);+ const canonicalSnapshotRoot = await realpath(snapshot.snapshotRoot);++ expect(relative(canonicalSnapshotRoot, materializedExternalPath)).not.toMatch(+ /^\.\.(?:[\\/]|$)/u,+ );+ expect(existsSync(join(materializedExternalPath, "binding.node"))).toBe(true);++ await writeFile(+ join(externalFixtureRoot, "fixture-transitive", "index.mjs"),+ 'export const transitiveValue = "external-changed";\n',+ );+ const changedDependencies = await stageDevelopmentGeneration(+ await compileAgent({ startPath: app.appRoot }),+ );+ expect(changedDependencies.fingerprint).not.toBe(snapshot.fingerprint);++ await rm(join(app.appRoot, "node_modules"), { force: true, recursive: true });+ await rm(externalFixtureRoot, { force: true, recursive: true });+ await writeFile(+ join(app.appRoot, "agent", "tools", "read_value.mjs"),+ 'throw new Error("mutated source loaded");\n',+ );++ const moduleMap = await loadCompiledModuleMapFromAuthoredSource({+ compiledArtifactsSource: createAuthoredSourceRuntimeCompiledArtifactsSource(+ snapshot.runtimeAppRoot,+ ),+ });+ const toolSourceId = compileResult.manifest.tools[0]?.sourceId;+ expect(toolSourceId).toBeDefined();+ const tool = moduleMap.nodes[ROOT_COMPILED_AGENT_NODE_ID]?.modules[toolSourceId!] as {+ default: { execute(): string };+ };++ expect(tool.default.execute()).toBe(+ "bundled-original:serde-original:external-original:payload-original",+ );+ });++ it("uses a path-independent fingerprint that includes instrumentation", async () => {+ const app = await scenarioApp({+ files: {+ "agent/agent.mjs": 'export default { model: "openai/gpt-5.4" };\n',+ "agent/instrumentation.mjs": 'export default { marker: "one" };\n',+ "agent/instructions.md": "Use the configured model.",+ "agent/skills/guide.md": [+ "---",+ "description: Follow the guide.",+ "---",+ "",+ "Use the original guidance.",+ "",+ ].join("\n"),+ },+ name: "generation-fingerprint",+ });+ const firstCompile = await compileAgent({ startPath: app.appRoot });+ const first = await stageDevelopmentGeneration(firstCompile);+ const identical = await stageDevelopmentGeneration(firstCompile);+ const firstIndex = JSON.parse(+ await readFile(+ join(first.runtimeAppRoot, ".eve", "compile", "authored-modules.json"),+ "utf8",+ ),+ ) as { readonly instrumentation?: string };+ const materializedInstrumentation = await readFile(+ join(first.runtimeAppRoot, ".eve", "compile", firstIndex.instrumentation!),+ "utf8",+ );++ expect(first.fingerprint).toBe(identical.fingerprint);+ expect(materializedInstrumentation).not.toContain("/.eve/dev-runtime/snapshots/");++ await writeFile(+ join(app.appRoot, "agent", "instrumentation.mjs"),+ 'export default { marker: "two" };\n',+ );+ const changedCompile = await compileAgent({ startPath: app.appRoot });+ const changed = await stageDevelopmentGeneration(changedCompile);++ expect(changed.fingerprint).not.toBe(first.fingerprint);+ await expect(+ readFile(join(changed.runtimeAppRoot, ".eve", "compile", "authored-modules.json"), "utf8"),+ ).resolves.toContain('"instrumentation"');++ await writeFile(+ join(app.appRoot, "agent", "skills", "guide.md"),+ ["---", "description: Follow the guide.", "---", "", "Use the changed guidance.", ""].join(+ "\n",+ ),+ );+ const changedResources = await stageDevelopmentGeneration(+ await compileAgent({ startPath: app.appRoot }),+ );+ expect(changedResources.fingerprint).not.toBe(changed.fingerprint);+ });++ it("rejects only authored workflow directives", async () => {+ const app = await scenarioApp({+ files: {+ "agent/agent.mjs": 'export default { model: "openai/gpt-5.4" };\n',+ "agent/instructions.md": "Use the available tools.",+ "agent/tools/directive_text.mjs": [+ '// "use workflow" is documentation.',+ 'const message = "use step";',+ '"use workflow";',+ 'export default { description: "Return text.", execute: () => message };',+ "",+ ].join("\n"),+ },+ name: "authored-directive-guard",+ });+ const validCompile = await compileAgent({ startPath: app.appRoot });++ await expect(stageDevelopmentGeneration(validCompile)).resolves.toBeDefined();+ const snapshotsRoot = join(app.appRoot, ".eve", "dev-runtime", "snapshots");+ const stagedGenerations = await readdir(snapshotsRoot);++ await writeFile(+ join(app.appRoot, "agent", "tools", "directive_text.mjs"),+ [+ '"use step";',+ 'export default { description: "Return text.", execute: () => "invalid" };',+ "",+ ].join("\n"),+ );+ const invalidCompile = await compileAgent({ startPath: app.appRoot });++ await expect(stageDevelopmentGeneration(invalidCompile)).rejects.toThrow(+ /actual "use step" directive/u,+ );+ await expect(readdir(snapshotsRoot)).resolves.toEqual(stagedGenerations);+ });++ it("discards a staged generation that was never activated", async () => {+ const app = await scenarioApp({+ files: {+ "agent/agent.mjs": 'export default { model: "openai/gpt-5.4" };\n',+ "agent/instructions.md": "Use the configured model.",+ },+ name: "discard-generation",+ });+ const compileResult = await compileAgent({ startPath: app.appRoot });+ const snapshot = await stageDevelopmentGeneration(compileResult);++ await discardDevelopmentGeneration(snapshot);++ expect(existsSync(snapshot.snapshotRoot)).toBe(false);+ });+});++async function writeDependencyFixture(appRoot: string): Promise<string> {+ const nodeModulesRoot = join(appRoot, "node_modules");+ const bundledRoot = join(nodeModulesRoot, "fixture-bundled");+ const externalFixtureRoot = join(dirname(appRoot), `${basename(appRoot)}-linked-dependencies`);+ const externalRoot = join(externalFixtureRoot, "fixture-external");+ const transitiveRoot = join(externalFixtureRoot, "fixture-transitive");++ await mkdir(bundledRoot, { recursive: true });+ await writeFile(+ join(bundledRoot, "package.json"),+ `${JSON.stringify({ exports: "./index.mjs", name: "fixture-bundled", type: "module" })}\n`,+ );+ // eve vendors `@workflow/*`, so a transitive workflow import reachable only+ // through an inlined dependency must be inlined with it — a bare specifier+ // would be unresolvable once the generation outlives `node_modules`.+ await writeFile(+ join(bundledRoot, "index.mjs"),+ [+ '"use workflow";',+ 'import { serdeMarker } from "@workflow/serde";',+ "export const bundledValue = `bundled-original:${serdeMarker}`;",+ "",+ ].join("\n"),+ );++ const vendoredWorkflowRoot = join(nodeModulesRoot, "@workflow", "serde");+ await mkdir(vendoredWorkflowRoot, { recursive: true });+ await writeFile(+ join(vendoredWorkflowRoot, "package.json"),+ `${JSON.stringify({ exports: "./index.mjs", name: "@workflow/serde", type: "module" })}\n`,+ );+ await writeFile(+ join(vendoredWorkflowRoot, "index.mjs"),+ 'export const serdeMarker = "serde-original";\n',+ );++ await mkdir(externalRoot, { recursive: true });+ await writeFile(+ join(externalRoot, "package.json"),+ `${JSON.stringify({+ dependencies: { "fixture-transitive": "1.0.0" },+ exports: {+ "./feature": {+ import: "./feature.mjs",+ require: "./wrong.cjs",+ },+ },+ name: "fixture-external",+ type: "module",+ })}\n`,+ );+ await writeFile(+ join(externalRoot, "feature.mjs"),+ [+ 'import { readFileSync } from "node:fs";',+ 'import { transitiveValue } from "fixture-transitive";',+ 'export const externalValue = `${transitiveValue}:${readFileSync(new URL("./payload.txt", import.meta.url), "utf8").trim()}`;',+ "",+ ].join("\n"),+ );+ await writeFile(join(externalRoot, "wrong.cjs"), 'throw new Error("require export used");\n');+ await writeFile(join(externalRoot, "binding.node"), "native-addon-placeholder\n");+ await writeFile(join(externalRoot, "payload.txt"), "payload-original\n");+ await mkdir(join(externalRoot, "node_modules"), { recursive: true });++ await mkdir(transitiveRoot, { recursive: true });+ await writeFile(+ join(transitiveRoot, "package.json"),+ `${JSON.stringify({+ exports: "./index.mjs",+ name: "fixture-transitive",+ type: "module",+ })}\n`,+ );+ await writeFile(+ join(transitiveRoot, "index.mjs"),+ 'export const transitiveValue = "external-original";\n',+ );++ await symlink(+ transitiveRoot,+ join(externalRoot, "node_modules", "fixture-transitive"),+ "junction",+ );+ await symlink(externalRoot, join(nodeModulesRoot, "fixture-external"), "junction");+ return externalFixtureRoot;+}diff --git a/packages/eve/src/internal/nitro/dev-runtime-artifacts.integration.test.ts b/packages/eve/src/internal/nitro/dev-runtime-artifacts.integration.test.tsindex 10e48e56d..2c3aa9bd9 100644--- a/packages/eve/src/internal/nitro/dev-runtime-artifacts.integration.test.ts+++ b/packages/eve/src/internal/nitro/dev-runtime-artifacts.integration.test.ts@@ -13,10 +13,10 @@ import { createDiskRuntimeCompiledArtifactsSource } from "#runtime/compiled-artiimport { getCompiledRuntimeAgentBundle } from "#runtime/sessions/compiled-agent-cache.js";import { createRuntimeSession, withRuntimeSession } from "#runtime/sessions/runtime-session.js";import { createDevelopmentNitroArtifactsConfig } from "#internal/nitro/host/artifacts-config.js";+import { publishDevelopmentGeneration } from "#internal/nitro/development-generation.js";import {activateDevelopmentRuntimeArtifactsSnapshot,pruneDevelopmentRuntimeArtifactsSnapshots,- publishDevelopmentRuntimeArtifactsSnapshot,readDevelopmentRuntimeArtifactsSnapshotRoot,readDevelopmentRuntimeArtifactsRevision,resolveDevelopmentRuntimeArtifactsPointerPath,@@ -112,7 +112,7 @@ async function createNextStyleImportSnapshotFixture(): Promise<{ readonly appRoo}),);- await publishDevelopmentRuntimeArtifactsSnapshot({+ await publishDevelopmentGeneration({paths: { compileDirectoryPath },project: { appRoot },} as CompileAgentResult);@@ -294,8 +294,10 @@ describe("development runtime artifact snapshots", () => {runtimeAppRoot: join(activeSnapshotRoot, "source", "app"),snapshotRoot: activeSnapshotRoot,snapshotSourceRoot: join(activeSnapshotRoot, "source"),+ sourceRoot: appRoot,},});+ await utimes(activeSnapshotRoot, oldActiveTime, oldActiveTime);await pruneDevelopmentRuntimeArtifactsSnapshots({appRoot,@@ -310,6 +312,37 @@ describe("development runtime artifact snapshots", () => {expect(existsSync(staleSnapshotRoot)).toBe(false);});+ it("retains every activated generation until lease-aware pruning exists", async () => {+ const appRoot = await createScratchDirectory("eve-dev-runtime-activated-retention-");+ const snapshotsRoot = join(appRoot, ".eve", "dev-runtime", "snapshots");+ const firstSnapshotRoot = join(snapshotsRoot, "first");+ const nextSnapshotRoot = join(snapshotsRoot, "next");++ for (const snapshotRoot of [firstSnapshotRoot, nextSnapshotRoot]) {+ await mkdir(snapshotRoot, { recursive: true });+ await utimes(snapshotRoot, new Date(1_000), new Date(1_000));+ await activateDevelopmentRuntimeArtifactsSnapshot({+ appRoot,+ snapshot: {+ runtimeAppRoot: join(snapshotRoot, "source"),+ snapshotRoot,+ snapshotSourceRoot: join(snapshotRoot, "source"),+ sourceRoot: appRoot,+ },+ });+ }++ await pruneDevelopmentRuntimeArtifactsSnapshots({+ appRoot,+ now: 1_000_000,+ recentWindowMs: 0,+ retainCount: 0,+ });++ expect(existsSync(firstSnapshotRoot)).toBe(true);+ expect(existsSync(nextSnapshotRoot)).toBe(true);+ });+it("preserves snapshots referenced by active durable workflow data", async () => {const appRoot = await createScratchDirectory("eve-dev-runtime-artifacts-prune-durable-");const snapshotsRoot = join(appRoot, ".eve", "dev-runtime", "snapshots");@@ -339,6 +372,7 @@ describe("development runtime artifact snapshots", () => {runtimeAppRoot: join(activeSnapshotRoot, "source", "app"),snapshotRoot: activeSnapshotRoot,snapshotSourceRoot: join(activeSnapshotRoot, "source"),+ sourceRoot: appRoot,},});await mkdir(join(appRoot, ".workflow-data", "default", "runs"), { recursive: true });@@ -478,10 +512,11 @@ describe("development runtime artifact snapshots", () => {)}\n`,);- const snapshot = await publishDevelopmentRuntimeArtifactsSnapshot({+ const snapshot = await stageDevelopmentRuntimeArtifactsSnapshot({paths: { compileDirectoryPath },project: { appRoot },} as CompileAgentResult);+ await activateDevelopmentRuntimeArtifactsSnapshot({ appRoot, snapshot });await writeFile(toolPath, "export const temperature = 73;\n");diff --git a/packages/eve/src/internal/nitro/dev-runtime-artifacts.ts b/packages/eve/src/internal/nitro/dev-runtime-artifacts.tsindex 88c896d65..decaa00f6 100644--- a/packages/eve/src/internal/nitro/dev-runtime-artifacts.ts+++ b/packages/eve/src/internal/nitro/dev-runtime-artifacts.ts@@ -8,6 +8,7 @@ import { copyDevelopmentSourceSnapshot } from "#internal/nitro/dev-runtime-sourcimport { createDevelopmentSourceSnapshotPlan } from "#internal/nitro/dev-runtime-source-snapshot.js";const DEV_RUNTIME_ARTIFACTS_DIRECTORY = "dev-runtime";+const DEV_RUNTIME_ARTIFACTS_ACTIVATED_MARKER = "activated";const DEV_RUNTIME_ARTIFACTS_POINTER_VERSION = 2;const DEV_RUNTIME_SNAPSHOT_RECENT_WINDOW_MS = 15 * 60 * 1000;const DEV_RUNTIME_SNAPSHOT_RETAIN_COUNT = 5;@@ -36,6 +37,7 @@ export interface DevelopmentRuntimeArtifactsSnapshot {readonly runtimeAppRoot: string;readonly snapshotRoot: string;readonly snapshotSourceRoot: string;+ readonly sourceRoot: string;}/**@@ -50,20 +52,6 @@ function resolveDevelopmentRuntimeArtifactsSnapshotsDirectory(appRoot: string):return join(appRoot, ".eve", DEV_RUNTIME_ARTIFACTS_DIRECTORY, "snapshots");}-/**- * Publishes one immutable dev runtime snapshot and points future sessions at it.- */-export async function publishDevelopmentRuntimeArtifactsSnapshot(- compileResult: CompileAgentResult,-): Promise<DevelopmentRuntimeArtifactsSnapshot> {- const snapshot = await stageDevelopmentRuntimeArtifactsSnapshot(compileResult);- await activateDevelopmentRuntimeArtifactsSnapshot({- appRoot: compileResult.project.appRoot,- snapshot,- });- return snapshot;-}-/*** Stages one immutable dev runtime snapshot without moving the latest pointer.*/@@ -116,6 +104,7 @@ export async function stageDevelopmentRuntimeArtifactsSnapshot(runtimeAppRoot: sourceSnapshotPlan.runtimeAppRoot,snapshotRoot,snapshotSourceRoot: sourceSnapshotPlan.snapshotSourceRoot,+ sourceRoot: sourceSnapshotPlan.sourceRoot,};}@@ -126,6 +115,7 @@ export async function activateDevelopmentRuntimeArtifactsSnapshot(input: {readonly appRoot: string;readonly snapshot: DevelopmentRuntimeArtifactsSnapshot;}): Promise<void> {+ await writeFile(join(input.snapshot.snapshotRoot, DEV_RUNTIME_ARTIFACTS_ACTIVATED_MARKER), "");await writeDevelopmentRuntimeArtifactsPointer(input);}@@ -162,16 +152,6 @@ export function readDevelopmentRuntimeArtifactsRevision(};}-/**- * Starts best-effort cleanup for stale dev-runtime snapshots without delaying- * `eve dev` startup or rebuild handling.- */-export function pruneDevelopmentRuntimeArtifactsSnapshotsInBackground(appRoot: string): void {- void pruneDevelopmentRuntimeArtifactsSnapshots({ appRoot }).catch((error) => {- console.warn(`[eve:dev] failed to prune stale runtime snapshots: ${formatErrorMessage(error)}`);- });-}-export async function pruneDevelopmentRuntimeArtifactsSnapshots(input: {readonly appRoot: string;readonly now?: number;@@ -217,6 +197,7 @@ export async function pruneDevelopmentRuntimeArtifactsSnapshots(input: {await Promise.all(snapshots.map(async (snapshot, index) => {if (+ existsSync(join(snapshot.path, DEV_RUNTIME_ARTIFACTS_ACTIVATED_MARKER)) ||index < retainCount ||now - snapshot.mtimeMs <= recentWindowMs ||protectedPaths.some((protectedPath) => pathsOverlap(snapshot.path, protectedPath))@@ -416,10 +397,6 @@ function pathsOverlap(left: string, right: string): boolean {return isPathInsideOrEqual(left, right) || isPathInsideOrEqual(right, left);}-function formatErrorMessage(error: unknown): string {- return error instanceof Error ? error.message : String(error);-}-async function rewriteSnapshotCompiledManifest(input: {readonly appRoot: string;readonly manifestPath: string;diff --git a/packages/eve/src/internal/nitro/development-generation.ts b/packages/eve/src/internal/nitro/development-generation.tsnew file mode 100644index 000000000..6bbe2c464--- /dev/null+++ b/packages/eve/src/internal/nitro/development-generation.ts@@ -0,0 +1,70 @@+import { rm } from "node:fs/promises";++import type { CompileAgentResult } from "#compiler/compile-agent.js";+import { materializeAuthoredModules } from "#internal/materialized-authored-modules.js";+import {+ activateDevelopmentRuntimeArtifactsSnapshot,+ stageDevelopmentRuntimeArtifactsSnapshot,+ type DevelopmentRuntimeArtifactsSnapshot,+} from "#internal/nitro/dev-runtime-artifacts.js";++export interface DevelopmentGeneration extends DevelopmentRuntimeArtifactsSnapshot {+ readonly fingerprint: string;+}++export async function stageDevelopmentGeneration(+ compileResult: CompileAgentResult,+): Promise<DevelopmentGeneration> {+ const snapshot = await stageDevelopmentRuntimeArtifactsSnapshot(compileResult);++ try {+ const materialized = await materializeAuthoredModules({+ appRoot: compileResult.project.appRoot,+ runtimeAppRoot: snapshot.runtimeAppRoot,+ snapshotSourceRoot: snapshot.snapshotSourceRoot,+ sourceRoot: snapshot.sourceRoot,+ });++ return {+ ...snapshot,+ fingerprint: materialized.fingerprint,+ };+ } catch (error) {+ try {+ await rm(snapshot.snapshotRoot, { force: true, recursive: true });+ } catch (cleanupError) {+ throw new AggregateError(+ [error, cleanupError],+ `Failed to materialize and discard development generation "${snapshot.snapshotRoot}".`,+ );+ }+ throw error;+ }+}++export async function publishDevelopmentGeneration(+ compileResult: CompileAgentResult,+): Promise<DevelopmentGeneration> {+ const generation = await stageDevelopmentGeneration(compileResult);+ await activateDevelopmentGeneration({+ appRoot: compileResult.project.appRoot,+ generation,+ });+ return generation;+}++export async function activateDevelopmentGeneration(input: {+ readonly appRoot: string;+ readonly generation: DevelopmentGeneration;+}): Promise<void> {+ await activateDevelopmentRuntimeArtifactsSnapshot({+ appRoot: input.appRoot,+ snapshot: input.generation,+ });+}++export async function discardDevelopmentGeneration(+ generation: DevelopmentGeneration,+): Promise<void> {+ await rm(generation.snapshotRoot, { force: true, recursive: true });+}diff --git a/packages/eve/src/internal/nitro/host/dev-authored-source-watcher.scenario.test.ts b/packages/eve/src/internal/nitro/host/dev-authored-source-watcher.scenario.test.tsindex 44e919181..3678787e9 100644--- a/packages/eve/src/internal/nitro/host/dev-authored-source-watcher.scenario.test.ts+++ b/packages/eve/src/internal/nitro/host/dev-authored-source-watcher.scenario.test.ts@@ -105,7 +105,6 @@ const mockedWatcher = vi.hoisted(() => {const prepareDevelopmentApplicationHostMock = vi.hoisted(() => vi.fn());const clearCompiledRuntimeAgentBundleCacheMock = vi.hoisted(() => vi.fn());const startDevelopmentSandboxPrewarmInBackgroundMock = vi.hoisted(() => vi.fn());-const pruneDevelopmentRuntimeArtifactsSnapshotsInBackgroundMock = vi.hoisted(() => vi.fn());const resolveNitroCompiledArtifactsSourceMock = vi.hoisted(() =>vi.fn((config: { readonly appRoot?: string }) => ({appRoot: `${config.appRoot ?? "/tmp/eve-test"}/.eve/dev-runtime-test`,@@ -127,17 +126,6 @@ vi.mock("#execution/sandbox/development-prewarm.js", () => ({startDevelopmentSandboxPrewarmInBackground: startDevelopmentSandboxPrewarmInBackgroundMock,}));-vi.mock("#internal/nitro/dev-runtime-artifacts.js", async () => {- const actual = await vi.importActual<typeof import("#internal/nitro/dev-runtime-artifacts.js")>(- "#internal/nitro/dev-runtime-artifacts.js",- );- return {- ...actual,- pruneDevelopmentRuntimeArtifactsSnapshotsInBackground:- pruneDevelopmentRuntimeArtifactsSnapshotsInBackgroundMock,- };-});-vi.mock("#internal/nitro/routes/runtime-artifacts.js", () => ({resolveNitroCompiledArtifactsSource: resolveNitroCompiledArtifactsSourceMock,}));@@ -171,7 +159,6 @@ beforeEach(() => {prepareDevelopmentApplicationHostMock.mockReset();clearCompiledRuntimeAgentBundleCacheMock.mockReset();startDevelopmentSandboxPrewarmInBackgroundMock.mockReset();- pruneDevelopmentRuntimeArtifactsSnapshotsInBackgroundMock.mockReset();resolveNitroCompiledArtifactsSourceMock.mockClear();});@@ -204,9 +191,6 @@ describe("startAuthoredSourceWatcher", () => {await watcher.rebuild();expect(prepareDevelopmentApplicationHostMock).toHaveBeenCalledWith(previousHost.appRoot);- expect(pruneDevelopmentRuntimeArtifactsSnapshotsInBackgroundMock).toHaveBeenCalledWith(- nextHost.appRoot,- );expect(clearCompiledRuntimeAgentBundleCacheMock).toHaveBeenCalledTimes(1);} finally {await watcher.close();diff --git a/packages/eve/src/internal/nitro/host/dev-authored-source-watcher.ts b/packages/eve/src/internal/nitro/host/dev-authored-source-watcher.tsindex f36b75bdb..030cec474 100644--- a/packages/eve/src/internal/nitro/host/dev-authored-source-watcher.ts+++ b/packages/eve/src/internal/nitro/host/dev-authored-source-watcher.ts@@ -7,7 +7,6 @@ import { toErrorMessage } from "#shared/errors.js";import { resolveTsConfigDependencyPaths } from "#internal/application/tsconfig-dependencies.js";import { createDevelopmentNitroArtifactsConfig } from "#internal/nitro/host/artifacts-config.js";import { resolveDevelopmentSourceSnapshotWatchPaths } from "#internal/nitro/dev-runtime-source-snapshot.js";-import { pruneDevelopmentRuntimeArtifactsSnapshotsInBackground } from "#internal/nitro/dev-runtime-artifacts.js";import { startDevelopmentSandboxPrewarmInBackground } from "#execution/sandbox/development-prewarm.js";import {computeChannelRouteRegistrations,@@ -143,7 +142,6 @@ export async function startAuthoredSourceWatcher(input: {}const nextHost = await prepareDevelopmentApplicationHost(previousHost.appRoot);- pruneDevelopmentRuntimeArtifactsSnapshotsInBackground(nextHost.appRoot);const artifactsConfig = createDevelopmentNitroArtifactsConfig({appRoot: nextHost.appRoot,});diff --git a/packages/eve/src/internal/nitro/host/prepare-application-host.scenario.test.ts b/packages/eve/src/internal/nitro/host/prepare-application-host.scenario.test.tsindex 587d916ad..9728e8377 100644--- a/packages/eve/src/internal/nitro/host/prepare-application-host.scenario.test.ts+++ b/packages/eve/src/internal/nitro/host/prepare-application-host.scenario.test.ts@@ -92,7 +92,7 @@ describe("application host preparation", () => {}});- it("keeps Nitro host inputs stable when their runtime snapshot is pruned", async () => {+ it("keeps Nitro host inputs outside retained runtime generations", async () => {const { agentRoot, appRoot } = await createAppRoot("eve-stable-dev-host-artifacts-", {files: {"agent/instructions.md": "Use the configured model.",@@ -100,7 +100,9 @@ describe("application host preparation", () => {packageName: "stable-dev-host-artifacts",});const agentModulePath = join(agentRoot, "agent.mjs");+ const instrumentationModulePath = join(agentRoot, "instrumentation.mjs");await writeFile(agentModulePath, 'export default { model: "openai/gpt-5.4" };\n');+ await writeFile(instrumentationModulePath, "export default {};\n");const firstHost = await prepareDevelopmentApplicationHost(appRoot);const firstPointer = await readDevelopmentRuntimePointer(appRoot);@@ -118,9 +120,15 @@ describe("application host preparation", () => {join(stableHostDirectory, "compiled-artifacts-workflow-world.mjs"),);expect(firstHost.compiledArtifacts.bootstrapPath).not.toContain("/.eve/dev-runtime/snapshots/");- expect(await readFile(stableBootstrapPath, "utf8")).toContain(+ expect(firstHost.compiledArtifacts.instrumentationSourcePath).toBe(+ join(stableHostDirectory, "compiled-artifacts-instrumentation-source.mjs"),+ );+ expect(await readFile(stableBootstrapPath, "utf8")).not.toContain(normalizeEsmImportSpecifier(agentModulePath),);+ await expect(+ readFile(firstHost.compiledArtifacts.instrumentationPluginPath!, "utf8"),+ ).resolves.not.toContain(normalizeEsmImportSpecifier(instrumentationModulePath));expect(existsSync(snapshotBootstrapPath)).toBe(false);await writeFile(@@ -140,7 +148,7 @@ describe("application host preparation", () => {retainCount: 0,});- expect(existsSync(firstPointer.snapshotRoot)).toBe(false);+ expect(existsSync(firstPointer.snapshotRoot)).toBe(true);expect(existsSync(stableBootstrapPath)).toBe(true);});});diff --git a/packages/eve/src/internal/nitro/host/prepare-application-host.ts b/packages/eve/src/internal/nitro/host/prepare-application-host.tsindex 51d3842e0..c341cb8c4 100644--- a/packages/eve/src/internal/nitro/host/prepare-application-host.ts+++ b/packages/eve/src/internal/nitro/host/prepare-application-host.ts@@ -14,6 +14,7 @@ import { join } from "node:path";import {type BuiltInWorkflowWorldTarget,writeCompiledArtifactsFiles,+ writeDevelopmentCompiledArtifactsFiles,} from "#internal/application/compiled-artifacts.js";import {resolveApplicationHostArtifactsDirectory,@@ -21,9 +22,10 @@ import {} from "#internal/application/paths.js";import { createAuthoredSourceRuntimeCompiledArtifactsSource } from "#internal/application/runtime-compiled-artifacts-source.js";import {- activateDevelopmentRuntimeArtifactsSnapshot,- stageDevelopmentRuntimeArtifactsSnapshot,-} from "#internal/nitro/dev-runtime-artifacts.js";+ activateDevelopmentGeneration,+ discardDevelopmentGeneration,+ stageDevelopmentGeneration,+} from "#internal/nitro/development-generation.js";import type { PreparedApplicationHost } from "#internal/nitro/host/types.js";/**@@ -42,20 +44,28 @@ export async function prepareDevelopmentApplicationHost(compileResult.project.appRoot,),});- const runtimeArtifactsSnapshot = await stageDevelopmentRuntimeArtifactsSnapshot(compileResult);- const preparedHost = await materializeApplicationHost({- compileResult,- defaultWorkflowWorld: "local",- hostArtifactsDir: resolveApplicationHostArtifactsDirectory(compileResult.project.appRoot),- schedules,- workflowBuildDir: resolveWorkflowBuildDirectory(compileResult.project.appRoot),- });- await activateDevelopmentRuntimeArtifactsSnapshot({- appRoot: compileResult.project.appRoot,- snapshot: runtimeArtifactsSnapshot,- });+ const generation = await stageDevelopmentGeneration(compileResult);- return preparedHost;+ try {+ const compiledArtifacts = await writeDevelopmentCompiledArtifactsFiles({+ compileResult,+ outDir: resolveApplicationHostArtifactsDirectory(compileResult.project.appRoot),+ runtimeAppRoot: generation.runtimeAppRoot,+ });+ await activateDevelopmentGeneration({+ appRoot: compileResult.project.appRoot,+ generation,+ });+ return createPreparedApplicationHost({+ compileResult,+ compiledArtifacts,+ schedules,+ workflowBuildDir: resolveWorkflowBuildDirectory(compileResult.project.appRoot),+ });+ } catch (error) {+ await discardDevelopmentGeneration(generation);+ throw error;+ }}/**@@ -77,32 +87,30 @@ export async function prepareProductionApplicationHost(});const schedules = await resolveSchedules({ manifest: compileResult.manifest });- return await materializeApplicationHost({+ const compiledArtifacts = await writeCompiledArtifactsFiles({compileResult,defaultWorkflowWorld: resolveProductionWorkflowWorldTarget(),- hostArtifactsDir: workspace.host.artifactsDir,+ outDir: workspace.host.artifactsDir,+ });++ return createPreparedApplicationHost({+ compileResult,+ compiledArtifacts,schedules,workflowBuildDir: workspace.workflow.buildDir,});}-async function materializeApplicationHost(input: {+function createPreparedApplicationHost(input: {readonly compileResult: CompileAgentResult;- readonly defaultWorkflowWorld: BuiltInWorkflowWorldTarget;- readonly hostArtifactsDir: string;+ readonly compiledArtifacts: PreparedApplicationHost["compiledArtifacts"];readonly schedules: readonly ResolvedScheduleDefinition[];readonly workflowBuildDir: string;-}): Promise<PreparedApplicationHost> {- const compiledArtifacts = await writeCompiledArtifactsFiles({- compileResult: input.compileResult,- defaultWorkflowWorld: input.defaultWorkflowWorld,- outDir: input.hostArtifactsDir,- });-+}): PreparedApplicationHost {return {appRoot: input.compileResult.project.appRoot,compileResult: input.compileResult,- compiledArtifacts,+ compiledArtifacts: input.compiledArtifacts,scheduleRegistrations: createScheduleRegistrations(input.schedules),schedules: input.schedules,workflowBuildDir: input.workflowBuildDir,diff --git a/packages/eve/src/internal/nitro/host/start-development-server.test.ts b/packages/eve/src/internal/nitro/host/start-development-server.test.tsindex c9a06637e..abc70fb2e 100644--- a/packages/eve/src/internal/nitro/host/start-development-server.test.ts+++ b/packages/eve/src/internal/nitro/host/start-development-server.test.ts@@ -83,7 +83,6 @@ const mocks = vi.hoisted(() => {startDevelopmentSandboxPrewarmInBackground: vi.fn(() => undefined),pruneLocalSandboxTemplatesInBackground: vi.fn(() => undefined),stopDevelopmentSandboxResources: vi.fn(async () => undefined),- pruneDevelopmentRuntimeArtifactsSnapshotsInBackground: vi.fn(() => undefined),resolveDiscoveryProject: vi.fn(async () => ({agentRoot: "/tmp/eve-test/agent",appRoot: "/tmp/eve-test",@@ -154,16 +153,6 @@ vi.mock("#execution/sandbox/bindings/local.js", async (importOriginal) => {};});-vi.mock("#internal/nitro/dev-runtime-artifacts.js", async (importOriginal) => {- const actual = await importOriginal<typeof import("#internal/nitro/dev-runtime-artifacts.js")>();-- return {- ...actual,- pruneDevelopmentRuntimeArtifactsSnapshotsInBackground:- mocks.pruneDevelopmentRuntimeArtifactsSnapshotsInBackground,- };-});-function createRequest(): IncomingMessage {return {headers: {@@ -369,9 +358,6 @@ describe("createDevelopmentServer", () => {const server = await startDevelopmentServer("/tmp/eve-test");expect(mocks.prepareDevelopmentApplicationHost).toHaveBeenCalledWith("/tmp/eve-test");- expect(mocks.pruneDevelopmentRuntimeArtifactsSnapshotsInBackground).toHaveBeenCalledWith(- "/tmp/eve-test",- );expect(mocks.startDevelopmentSandboxPrewarmInBackground).toHaveBeenCalledWith({appRoot: "/tmp/eve-test",compiledArtifactsSource: {diff --git a/packages/eve/src/internal/nitro/host/start-development-server.ts b/packages/eve/src/internal/nitro/host/start-development-server.tsindex 411f2693c..4d3f84ece 100644--- a/packages/eve/src/internal/nitro/host/start-development-server.ts+++ b/packages/eve/src/internal/nitro/host/start-development-server.ts@@ -36,7 +36,6 @@ import type {StartedDevelopmentServer,} from "#internal/nitro/host/types.js";import { loadDevelopmentEnvironmentFiles } from "#cli/dev/environment.js";-import { pruneDevelopmentRuntimeArtifactsSnapshotsInBackground } from "#internal/nitro/dev-runtime-artifacts.js";import {DEFAULT_DEVELOPMENT_SERVER_PORT,MAX_DEVELOPMENT_SERVER_PORT_ATTEMPTS,@@ -461,7 +460,6 @@ async function startNitroDevelopmentServer(() => prepareDevelopmentApplicationHost(project.appRoot),options.onBootProgress,);- pruneDevelopmentRuntimeArtifactsSnapshotsInBackground(preparedHost.appRoot);const compiledArtifactsSource = resolveNitroCompiledArtifactsSource(createDevelopmentNitroArtifactsConfig({appRoot: preparedHost.appRoot,diff --git a/packages/eve/test/scenarios/dev-server.scenario.test.ts b/packages/eve/test/scenarios/dev-server.scenario.test.tsindex e207c02e6..be149c9fe 100644--- a/packages/eve/test/scenarios/dev-server.scenario.test.ts+++ b/packages/eve/test/scenarios/dev-server.scenario.test.ts@@ -1,6 +1,6 @@import { spawn, type ChildProcessByStdio } from "node:child_process";import { existsSync } from "node:fs";-import { writeFile } from "node:fs/promises";+import { rm, writeFile } from "node:fs/promises";import { join } from "node:path";import type { Readable } from "node:stream";@@ -8,7 +8,6 @@ import { describe, expect, it } from "vitest";import { EVE_HEALTH_ROUTE_PATH } from "../../src/protocol/routes.js";import {- pruneDevelopmentRuntimeArtifactsSnapshots,readDevelopmentRuntimeArtifactsSnapshotRoot,resolveDevelopmentRuntimeArtifactsPointerPath,} from "../../src/internal/nitro/dev-runtime-artifacts.js";@@ -258,7 +257,7 @@ async function startEveDev(appRoot: string): Promise<RunningEveDev> {describe("eve dev server", () => {it(- "rebuilds after pruning its startup runtime snapshot and completes a streamed turn",+ "rebuilds after its startup runtime generation is force-pruned and completes a streamed turn",async () => {const app = await scenarioApp(DEV_SERVER_AGENT_DESCRIPTOR);const server = await startEveDev(app.appRoot);@@ -301,12 +300,7 @@ describe("eve dev server", () => {throw new Error("Expected authored HMR to publish a runtime snapshot.");}- await pruneDevelopmentRuntimeArtifactsSnapshots({- appRoot: app.appRoot,- now: Date.now() + 1_000,- recentWindowMs: 0,- retainCount: 0,- });+ await rm(startupRuntimeRoot, { force: true, recursive: true });expect(existsSync(startupRuntimeRoot)).toBe(false);await writeFile(join(app.appRoot, ".env.local"), "EVE_SCENARIO_RELOAD=1\n");@@ -318,8 +312,8 @@ describe("eve dev server", () => {const currentRuntimeRoot = readDevelopmentRuntimeArtifactsSnapshotRoot(pointerPath);return currentRuntimeRoot !== undefined && currentRuntimeRoot !== authoredRuntimeRoot;}, `Timed out waiting for the structural reload snapshot.\n\nstdout:\n${server.stdout()}\n\nstderr:\n${server.stderr()}`);+ // Nitro exposes no replacement-ready signal while it owns the public listener.await wait(2_000);-let messageResult: Awaited<ReturnType<typeof sendDevelopmentMessage>>;try {messageResult = await sendDevelopmentMessage({@@ -347,8 +341,6 @@ describe("eve dev server", () => {`stderr:\n${server.stderr()}`,].join("\n\n"),).toBe(true);- await wait(1_000);-const output = `${server.stdout()}\n${server.stderr()}`;expect(hasKnownDevBundlingFailure(output)).toBe(false);} finally {