eve 0.63.0 → 0.64.1

package/dist/src/execution/sandbox/bindings/local-backend-utils.js

@@ -1 +0,0 @@
-import{randomUUID}from"node:crypto";import{access,cp,mkdir,rename,rm,utimes}from"node:fs/promises";import{dirname,join}from"node:path";import{resolveSandboxModelPath}from"#shared/skill-paths.js";import{WORKSPACE_ROOT}from"#runtime/workspace/types.js";import{bufferToStream,streamToBuffer}from"#execution/sandbox/stream-utils.js";function createFileBackedInternalSandboxSession(e){return{id:e.id,resolvePath:resolveWorkspacePath,async spawn(t){return await e.sandbox.spawn(t)},async readFile(t){let n=await e.sandbox.readFileBytes(t.path);return n===null?null:bufferToStream(n)},async removePath(t){await e.sandbox.removePath(t)},async writeFile(t){let n=await streamToBuffer(t.content);await e.sandbox.writeFiles([{content:n,path:t.path}])}}}function resolveWorkspacePath(e){return e.startsWith(`/`)?e:`${WORKSPACE_ROOT}/${e}`}async function pathExists(e){try{return await access(e),!0}catch{return!1}}async function copyDirectoryAtomically(e,t){let n=`${t}.${randomUUID()}.tmp`;await rm(n,{force:!0,recursive:!0}),await mkdir(dirname(t),{recursive:!0});try{await cp(e,n,{recursive:!0}),await rename(n,t)}catch(e){if(await rm(n,{force:!0,recursive:!0}).catch(()=>{}),await pathExists(t))return;throw e}}async function touchDirectory(e){let t=new Date;await utimes(e,t,t)}function resolveLocalBackendTemplateRootPath(e,t,n){return join(resolveLocalBackendTemplatesDirectory(e,t),n)}function resolveLocalBackendTemplatesDirectory(e,t){return join(e,t,`templates`)}function resolveLocalBackendSessionRootPath(e,t,n){return join(e,t,`sessions`,n)}async function writeSandboxSeedFiles(e,t){for(let n of t){let t=await resolveSandboxModelPath({path:n.path,sandbox:e});typeof n.content==`string`?await e.writeTextFile({content:n.content,path:t}):await e.writeBinaryFile({content:n.content,path:t})}}export{copyDirectoryAtomically,createFileBackedInternalSandboxSession,pathExists,resolveLocalBackendSessionRootPath,resolveLocalBackendTemplateRootPath,resolveLocalBackendTemplatesDirectory,resolveWorkspacePath,touchDirectory,writeSandboxSeedFiles};

package/dist/src/execution/sandbox/development-prewarm.d.ts

@@ -1,15 +0,0 @@
-import { type RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
-export declare function startDevelopmentSandboxPrewarmInBackground(input: {
-    readonly appRoot: string;
-    readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
-    readonly log?: (message: string) => void;
-}): void;
-export declare function subscribeDevelopmentSandboxPrewarmLogs(input: {
-    readonly appRoot: string;
-    readonly log: (message: string) => void;
-}): () => void;
-export declare function waitForDevelopmentSandboxPrewarm(input: {
-    readonly appRoot: string;
-    readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
-    readonly log?: (message: string) => void;
-}): Promise<void>;

package/dist/src/execution/sandbox/development-prewarm.js

@@ -1 +0,0 @@
-import{prewarmAppSandboxes}from"./prewarm.js";import{toErrorMessage}from"#shared/errors.js";import{getRuntimeCompiledArtifactsAppRoot,getRuntimeCompiledArtifactsSandboxAppRoot}from"#runtime/compiled-artifacts-source.js";const pendingDevelopmentPrewarms=new Map,retainedDevelopmentPrewarmLogs=new Map,completedDevelopmentPrewarmSignatures=new Map;function startDevelopmentSandboxPrewarmInBackground(e){let t=resolvePrewarmKeys(e),n=findPendingPrewarm(t);if(n!==void 0){registerPrewarmAliases(t,n);return}let r={logs:[],promise:Promise.resolve(),subscribers:new Set};for(let e of t)retainedDevelopmentPrewarmLogs.delete(e);let i=resolvePrewarmSignatureCacheKey(e),a=prewarmAppSandboxes({appRoot:e.appRoot,compiledArtifactsSource:e.compiledArtifactsSource,log:t=>recordPrewarmLog(r,t,e.log),onPrewarmSignature:e=>{completedDevelopmentPrewarmSignatures.set(i,e)},shouldPrewarmSignature:e=>completedDevelopmentPrewarmSignatures.get(i)!==e});r.promise=a,registerPrewarmAliases(t,r),a.catch(t=>{recordPrewarmLog(r,`eve: failed to initialize sandbox templates in the background: ${toErrorMessage(t)}`,e.log)}).finally(()=>{for(let e of t)pendingDevelopmentPrewarms.get(e)===r&&pendingDevelopmentPrewarms.delete(e),r.subscribers.size===0&&r.logs.length>0&&retainedDevelopmentPrewarmLogs.set(e,[...r.logs])})}function subscribeDevelopmentSandboxPrewarmLogs(e){let t=findPendingPrewarm([e.appRoot]);if(t!==void 0){for(let n of t.logs)e.log(n);return t.subscribers.add(e.log),()=>t.subscribers.delete(e.log)}let n=retainedDevelopmentPrewarmLogs.get(e.appRoot);if(n===void 0)return()=>{};retainedDevelopmentPrewarmLogs.delete(e.appRoot);for(let t of n)e.log(t);return()=>{}}async function waitForDevelopmentSandboxPrewarm(e){let t=findPendingPrewarm(resolvePrewarmKeys(e));if(t===void 0)return;let unsubscribe;if(e.log!==void 0){for(let n of t.logs)e.log(n);let subscriber=t=>e.log?.(t);t.subscribers.add(subscriber),unsubscribe=()=>t.subscribers.delete(subscriber)}try{await withProgressHeartbeat(`waiting for background sandbox template prewarm`,e.log,()=>t.promise)}finally{unsubscribe?.()}}function resolvePrewarmKeys(e){let t=new Set([e.appRoot]),n=getRuntimeCompiledArtifactsAppRoot(e.compiledArtifactsSource);n!==void 0&&t.add(n);let r=getRuntimeCompiledArtifactsSandboxAppRoot(e.compiledArtifactsSource);return r!==void 0&&t.add(r),[...t]}function resolvePrewarmSignatureCacheKey(e){return getRuntimeCompiledArtifactsSandboxAppRoot(e.compiledArtifactsSource)??e.appRoot}function findPendingPrewarm(e){for(let t of e){let e=pendingDevelopmentPrewarms.get(t);if(e!==void 0)return e}}function registerPrewarmAliases(e,t){for(let n of e)pendingDevelopmentPrewarms.set(n,t)}function recordPrewarmLog(e,t,n){e.logs.push(t),e.logs.length>50&&e.logs.splice(0,e.logs.length-50),n?.(t);for(let n of e.subscribers)n(t)}async function withProgressHeartbeat(e,t,n){if(t===void 0)return await n();let r=Date.now(),i=setInterval(()=>{t(`${e} (${Math.round((Date.now()-r)/1e3)}s elapsed)`)},1e4);i.unref?.();try{return await n()}finally{clearInterval(i)}}export{startDevelopmentSandboxPrewarmInBackground,subscribeDevelopmentSandboxPrewarmLogs,waitForDevelopmentSandboxPrewarm};

package/dist/src/execution/sandbox/lazy-backend.d.ts

@@ -1,15 +0,0 @@
-import type { SandboxBackend } from "#public/definitions/sandbox-backend.js";
-/**
- * Wraps a backend-producing function in a `SandboxBackend` proxy that
- * invokes the function exactly once, on first access to any of `.name`,
- * `.create`, or `.prewarm`. Subsequent accesses return the same cached
- * underlying backend.
- *
- * Used by `defaultSandbox()` for env-conditional selection, and by the
- * authored-definition normalizer when an author passes a callback to
- * `SandboxDefinition.backend` (e.g. `backend: () => vercel({...})`)
- * so the factory runs at first use rather than at module load — while
- * still preserving backend-internal state (such as the Vercel backend's
- * prewarmed-templates map) across every framework call.
- */
-export declare function lazyBackend<BO, SO>(factory: () => SandboxBackend<BO, SO>): SandboxBackend<BO, SO>;

package/dist/src/execution/sandbox/lazy-backend.js

@@ -1 +0,0 @@
-function lazyBackend(e){let t;function resolve(){return t===void 0&&(t=e()),t}return{get name(){return resolve().name},create(e){return resolve().create(e)},prewarm(e){return resolve().prewarm(e)}}}export{lazyBackend};

package/dist/src/execution/sandbox/template-prewarm-lock.d.ts

@@ -1,8 +0,0 @@
-export interface SandboxTemplatePrewarmLockInput {
-    readonly appRoot: string;
-    readonly backendName: string;
-    readonly log?: (message: string) => void;
-    readonly templateKey: string;
-}
-export declare function waitForSandboxTemplatePrewarmLock(input: SandboxTemplatePrewarmLockInput): Promise<void>;
-export declare function withSandboxTemplatePrewarmLock<T>(input: SandboxTemplatePrewarmLockInput, callback: () => Promise<T>): Promise<T>;

package/dist/src/execution/sandbox/template-prewarm-lock.js

@@ -1 +0,0 @@
-import{mkdir,rm,stat,writeFile}from"node:fs/promises";import{dirname,join}from"node:path";import{resolveSandboxCacheDirectory}from"#internal/application/paths.js";const LOCK_TIMEOUT_MS=9e5;async function waitForSandboxTemplatePrewarmLock(e){await waitForLockRelease(resolveSandboxTemplatePrewarmLockPath(e),e.log)}async function withSandboxTemplatePrewarmLock(e,t){let n=resolveSandboxTemplatePrewarmLockPath(e);await acquireLock(n);try{return await t()}finally{await rm(n,{force:!0,recursive:!0}).catch(()=>{})}}function resolveSandboxTemplatePrewarmLockPath(e){return join(resolveSandboxCacheDirectory(e.appRoot),`template-locks`,e.backendName,`${e.templateKey}.lock`)}async function acquireLock(e){let t=Date.now();for(;;){await mkdir(dirname(e),{recursive:!0});try{await mkdir(e),await writeFile(join(e,`owner.json`),`${JSON.stringify({createdAt:new Date().toISOString(),pid:process.pid})}\n`);return}catch(n){if(!isFileExistsError(n))throw n;await waitForExistingLock(e,t,void 0)}}}async function waitForLockRelease(e,t){let n=Date.now(),r=n+1e4;for(;;){try{await stat(e)}catch(e){if(isNotFoundError(e))return;throw e}let i=Date.now();if(t!==void 0&&i>=r){let e=Math.round((i-n)/1e3);t(e===0?`waiting for sandbox template prewarm to finish`:`waiting for sandbox template prewarm to finish (${e}s elapsed)`),r=i+1e4}await waitForExistingLock(e,n,t)}}async function waitForExistingLock(e,t,n){let r=await stat(e).catch(e=>{if(isNotFoundError(e))return null;throw e});if(r!==null){if(Date.now()-r.mtimeMs>18e5){n?.(`removing stale sandbox template prewarm lock`),await rm(e,{force:!0,recursive:!0}).catch(()=>{});return}if(Date.now()-t>LOCK_TIMEOUT_MS)throw Error(`Timed out waiting for sandbox template prewarm lock "${e}" after ${LOCK_TIMEOUT_MS}ms.`);await new Promise(e=>setTimeout(e,250))}}function isFileExistsError(e){return typeof e==`object`&&!!e&&`code`in e&&e.code===`EEXIST`}function isNotFoundError(e){return typeof e==`object`&&!!e&&`code`in e&&e.code===`ENOENT`}export{waitForSandboxTemplatePrewarmLock,withSandboxTemplatePrewarmLock};

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

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

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

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

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

@@ -1,16 +0,0 @@
-interface BundlerPluginShape {
-    readonly name: string;
-    load?(id: string): string | null | undefined;
-    resolveId?(source: string, importer: string | undefined): string | {
-        id: string;
-    } | null | undefined;
-}
-/**
- * Creates the bundler plugin that prunes the local sandbox backends
- * (Docker, just-bash, microsandbox) from hosted Nitro server bundles.
- * Every local-engine export flows through `bindings/local.js`, so
- * stubbing that one module removes all of them; the stub mirrors the
- * facade's export surface.
- */
-export declare function createCompiledSandboxBackendPrunePlugin(): BundlerPluginShape;
-export {};

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

@@ -1,2 +0,0 @@
-const PRUNED_LOCAL_SANDBOX_MODULE_ID=`\0eve-pruned-local-sandbox-backends`,LOCAL_BINDING_SOURCE_RE=/[/\\]bindings[/\\]local\.js$/;function createCompiledSandboxBackendPrunePlugin(){return{name:`eve-hosted-sandbox-backend-prune`,load(e){return e===PRUNED_LOCAL_SANDBOX_MODULE_ID?[`function pruned() {`,`  throw new Error("Local sandbox backends are pruned from hosted server bundles.");`,`}`,`export const createDockerSandboxBackend = pruned;`,`export const createJustBashSandboxBackend = pruned;`,`export const createMicrosandboxSandboxBackend = pruned;`,`export const DOCKER_BACKEND_NAME = "docker";`,`export const JUST_BASH_BACKEND_NAME = "just-bash";`,`export const MICROSANDBOX_BACKEND_NAME = "microsandbox";`,`export const isLinuxDockerDaemonAvailableSync = () => false;`,`export const isMicrosandboxPlatformSupported = () => false;`,`export const pruneDockerSandboxTemplates = pruned;`,`export const pruneJustBashSandboxTemplates = pruned;`,`export const pruneMicrosandboxTemplates = pruned;`,`export const pruneLocalSandboxTemplates = pruned;`,`export const pruneLocalSandboxTemplatesInBackground = pruned;`,`export const stopDevelopmentSandboxResources = pruned;`,``].join(`
-`):null},resolveId(e){return LOCAL_BINDING_SOURCE_RE.test(e)?PRUNED_LOCAL_SANDBOX_MODULE_ID:null}}}export{createCompiledSandboxBackendPrunePlugin};

package/dist/src/public/definitions/sandbox-backend.d.ts

@@ -1,17 +0,0 @@
-export type { SandboxBackendHandle, SandboxBackendSessionState, SandboxDeleteOptions, SandboxSeedFile, SandboxBackendTags, SandboxBackendRuntimeContext, SandboxBackendCreateInput, SandboxBackendPrewarmInput, SandboxBackendPrewarmResult, SandboxBackend, } from "#shared/sandbox-backend.js";
-/**
- * Thrown by a backend's `create` when the requested template was never
- * provisioned. Run `eve build` or call `prewarmAppSandboxes()` before
- * serving traffic. `backendName` and `templateKey` identify the missing
- * template. Use {@link SandboxTemplateNotProvisionedError.is} to narrow.
- */
-export declare class SandboxTemplateNotProvisionedError extends Error {
-    readonly backendName: string;
-    readonly templateKey: string;
-    constructor(input: {
-        readonly backendName: string;
-        readonly templateKey: string;
-    });
-    /** Type guard for {@link SandboxTemplateNotProvisionedError}. */
-    static is(error: unknown): error is SandboxTemplateNotProvisionedError;
-}

package/dist/src/public/definitions/sandbox-backend.js

@@ -1 +0,0 @@
-var SandboxTemplateNotProvisionedError=class SandboxTemplateNotProvisionedError extends Error{backendName;templateKey;constructor(e){super(`Sandbox template "${e.templateKey}" is not provisioned for backend "${e.backendName}". Run \`eve build\` or invoke \`prewarmAppSandboxes()\` before serving traffic.`),this.name=`SandboxTemplateNotProvisionedError`,this.backendName=e.backendName,this.templateKey=e.templateKey}static is(e){return e instanceof SandboxTemplateNotProvisionedError||typeof e==`object`&&!!e&&e.name===`SandboxTemplateNotProvisionedError`&&typeof e.backendName==`string`&&typeof e.templateKey==`string`}};export{SandboxTemplateNotProvisionedError};

package/dist/src/public/sandbox/backends/default.d.ts

@@ -1 +0,0 @@
-export * from "#sandbox/backends/default.js";

package/dist/src/public/sandbox/backends/default.js

@@ -1 +0,0 @@
-export*from"#sandbox/backends/default.js";export{};

package/dist/src/public/sandbox/backends/docker.d.ts

@@ -1 +0,0 @@
-export * from "#sandbox/backends/docker.js";

package/dist/src/public/sandbox/backends/docker.js

@@ -1 +0,0 @@
-export*from"#sandbox/backends/docker.js";export{};

package/dist/src/public/sandbox/backends/just-bash.d.ts

@@ -1 +0,0 @@
-export * from "#sandbox/backends/just-bash.js";

package/dist/src/public/sandbox/backends/just-bash.js

@@ -1 +0,0 @@
-export*from"#sandbox/backends/just-bash.js";export{};

package/dist/src/public/sandbox/backends/microsandbox.d.ts

@@ -1 +0,0 @@
-export * from "#sandbox/backends/microsandbox.js";

package/dist/src/public/sandbox/backends/microsandbox.js

@@ -1 +0,0 @@
-export*from"#sandbox/backends/microsandbox.js";export{};

package/dist/src/public/sandbox/backends/vercel.d.ts

@@ -1 +0,0 @@
-export * from "#sandbox/backends/vercel.js";

package/dist/src/public/sandbox/backends/vercel.js

@@ -1 +0,0 @@
-export*from"#sandbox/backends/vercel.js";export{};

package/dist/src/runtime/sandbox/keys.d.ts

@@ -1,42 +0,0 @@
-import { type RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
-import type { RuntimeSandboxTemplatePlan } from "#runtime/sandbox/template-plan.js";
-/**
- * Input for deriving the stable runtime keys used for one sandbox definition.
- */
-interface CreateRuntimeSandboxKeysInput {
-    readonly backendName: string;
-    readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
-    readonly nodeId: string;
-    readonly sessionId: string;
-    readonly sourceId: string;
-    readonly templatePlan: RuntimeSandboxTemplatePlan;
-}
-/**
- * Creates the stable runtime template and session keys for one sandbox
- * definition under the current artifact source and backend.
- *
- * Both keys derive from one {@link RuntimeSandboxKeyParts} value, so the
- * coupling holds by construction: the session key rotates exactly when
- * the template content rotates.
- */
-export declare function createRuntimeSandboxKeys(input: CreateRuntimeSandboxKeysInput): Promise<{
-    readonly sessionKey: string;
-    readonly templateKey: string | null;
-}>;
-/**
- * Creates the stable reusable template key for one sandbox definition,
- * or `null` when the sandbox should start from a fresh backend runtime.
- *
- * The template key factors in the graph `nodeId` so that two
- * runtime agents (root and subagents) do not collide on the same
- * template when they each own a sandbox authored at the same logical
- * path.
- */
-export declare function createRuntimeSandboxTemplateKey(input: {
-    readonly backendName: string;
-    readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
-    readonly nodeId: string;
-    readonly sourceId: string;
-    readonly templatePlan: RuntimeSandboxTemplatePlan;
-}): Promise<string | null>;
-export {};

package/dist/src/runtime/sandbox/keys.js

@@ -1 +0,0 @@
-import{createHash}from"node:crypto";import{realpath}from"node:fs/promises";import{resolveVercelProjectIdFromEnvironment}from"#shared/vercel-project.js";import{resolveInstalledPackageInfo}from"#internal/application/package.js";import{getRuntimeCompiledArtifactsCacheKey,getRuntimeCompiledArtifactsSandboxAppRoot}from"#runtime/compiled-artifacts-source.js";import{loadCompileMetadata}from"#runtime/loaders/compile-metadata.js";async function createRuntimeSandboxKeys(e){let t=await deriveRuntimeSandboxKeyParts(e);return{sessionKey:buildRuntimeSandboxSessionKey(e,t),templateKey:buildRuntimeSandboxTemplateKey(e,t)}}async function createRuntimeSandboxTemplateKey(e){return buildRuntimeSandboxTemplateKey(e,await deriveRuntimeSandboxKeyParts(e))}async function deriveRuntimeSandboxKeyParts(e){return{metadata:await loadCompileMetadataForKeys(e.compiledArtifactsSource),scope:await resolveRuntimeSandboxScope(e),versionHash:e.templatePlan.kind===`none`?null:resolveRuntimeSandboxVersionHash({nodeId:e.nodeId,sourceId:e.sourceId,templatePlan:e.templatePlan})}}function buildRuntimeSandboxTemplateKey(e,t){if(t.versionHash===null)return null;let n=createStableHash(`${resolvePackageVersionForTemplateKey(t.metadata)}:7:${t.versionHash}`).slice(0,20);return sanitizeRuntimeSandboxKey(`eve-sbx-tpl-${e.backendName}-${t.scope}-${n}`)}function buildRuntimeSandboxSessionKey(e,t){let n=createStableHash(`7:${t.versionHash??`none`}`).slice(0,12),r=sanitizeRuntimeSandboxKey(e.nodeId);return sanitizeRuntimeSandboxKey(`eve-sbx-ses-${e.backendName}-${t.scope}-${n}-${e.sessionId}-${r}`)}function resolvePackageVersionForTemplateKey(e){return e?.generator.version??resolveInstalledPackageInfo().version}async function loadCompileMetadataForKeys(e){try{return await loadCompileMetadata({compiledArtifactsSource:e})}catch{return null}}async function resolveRuntimeSandboxScope(e){if(e.backendName===`vercel`){let e=resolveVercelProjectIdFromEnvironment();if(e!==void 0)return createStableHash(`vercel-project:${e}`).slice(0,16)}let t=getRuntimeCompiledArtifactsSandboxAppRoot(e.compiledArtifactsSource);return t===void 0?createStableHash(getRuntimeCompiledArtifactsCacheKey(e.compiledArtifactsSource)).slice(0,16):createStableHash(await realpath(t)).slice(0,16)}function resolveRuntimeSandboxVersionHash(e){let t=e.templatePlan.contentHash??``;return e.templatePlan.kind===`bootstrap`?createStableHash(`bootstrap:${e.templatePlan.revalidationKey??``}:${e.templatePlan.sourceHash}:${t}:${e.nodeId}:${e.sourceId}`):createStableHash(`workspace-content:${t}:${e.nodeId}:${e.sourceId}`)}function createStableHash(e){return createHash(`sha256`).update(e).digest(`hex`)}function sanitizeRuntimeSandboxKey(e){return e.replaceAll(/[^a-zA-Z0-9._-]+/g,`-`).slice(0,120)}export{createRuntimeSandboxKeys,createRuntimeSandboxTemplateKey};

package/dist/src/runtime/sandbox/template-plan.d.ts

@@ -1,24 +0,0 @@
-import type { CompiledWorkspaceResourceRoot } from "#compiler/manifest.js";
-import type { ResolvedSandboxDefinition } from "#runtime/types.js";
-/**
- * Describes whether one sandbox needs a prewarmed template and, if so,
- * which inputs must participate in the template key.
- */
-export type RuntimeSandboxTemplatePlan = {
-    readonly kind: "none";
-} | {
-    readonly contentHash?: string;
-    readonly kind: "workspace-content";
-} | {
-    readonly contentHash?: string;
-    readonly kind: "bootstrap";
-    readonly revalidationKey?: string;
-    readonly sourceHash: string;
-};
-/**
- * Chooses the template strategy for one resolved sandbox definition.
- */
-export declare function createRuntimeSandboxTemplatePlan(input: {
-    readonly definition: ResolvedSandboxDefinition;
-    readonly workspaceResourceRoot: CompiledWorkspaceResourceRoot;
-}): RuntimeSandboxTemplatePlan;

package/dist/src/runtime/sandbox/template-plan.js

@@ -1 +0,0 @@
-function createRuntimeSandboxTemplatePlan(e){if(e.definition.bootstrap!==void 0){if(e.definition.sourceHash===void 0)throw Error(`Sandbox "${e.definition.logicalPath}" defines bootstrap() but has no compiled sourceHash.`);return{contentHash:e.workspaceResourceRoot.contentHash,kind:`bootstrap`,revalidationKey:e.definition.revalidationKey,sourceHash:e.definition.sourceHash}}return e.workspaceResourceRoot.contentHash===void 0&&e.workspaceResourceRoot.rootEntries.length===0?{kind:`none`}:{contentHash:e.workspaceResourceRoot.contentHash,kind:`workspace-content`}}export{createRuntimeSandboxTemplatePlan};

package/dist/src/sandbox/backends/default.d.ts

@@ -1,42 +0,0 @@
-import { type DefaultSandboxProbes } from "./probes.js";
-import type { SandboxBackend } from "#public/definitions/sandbox-backend.js";
-import type { DockerSandboxCreateOptions } from "#public/sandbox/docker-sandbox.js";
-import type { JustBashSandboxCreateOptions } from "#public/sandbox/just-bash-sandbox.js";
-import type { MicrosandboxSandboxCreateOptions } from "#public/sandbox/microsandbox-sandbox.js";
-import type { VercelSandboxCreateOptions } from "#public/sandbox/vercel-sandbox.js";
-export { SANDBOX_BACKEND_PROBES, type DefaultSandboxProbes } from "./probes.js";
-/**
- * Input to {@link defaultSandbox}: a separate options bag per inner
- * backend. The framework picks one backend at runtime based on
- * availability and passes it the matching bag; the others are ignored.
- */
-export interface DefaultSandboxOptions {
-    readonly docker?: DockerSandboxCreateOptions;
-    readonly justBash?: JustBashSandboxCreateOptions;
-    readonly microsandbox?: MicrosandboxSandboxCreateOptions;
-    readonly vercel?: VercelSandboxCreateOptions;
-}
-/**
- * Constructs an availability-aware sandbox backend. On first use it
- * picks the best backend the host supports, in priority order:
- *
- * 1. **Vercel Sandbox** when deploying on Vercel (`process.env.VERCEL`
- *    is set) — local container/VM runtimes cannot run there.
- * 2. **Docker** when a Linux-container Docker daemon is reachable.
- * 3. **microsandbox** when the host supports it (macOS on Apple
- *    Silicon, or glibc Linux with KVM); `eve dev` auto-installs the
- *    package into the project.
- * 4. **just-bash** as the dependency-free fallback; `eve dev`
- *    auto-installs the package into the project.
- *
- * The selection is cached for the process lifetime. To pin a backend
- * unconditionally, configure its factory directly (`docker()`,
- * `microsandbox()`, `justbash()`,
- * `vercel()`).
- */
-export declare function defaultSandbox(opts?: DefaultSandboxOptions): SandboxBackend;
-/**
- * The selection chain behind {@link defaultSandbox}. Internal —
- * exported for tests, which inject probes.
- */
-export declare function selectDefaultSandbox(opts: DefaultSandboxOptions | undefined, probes: DefaultSandboxProbes): SandboxBackend;

package/dist/src/sandbox/backends/default.js

@@ -1 +0,0 @@
-import{SANDBOX_BACKEND_PROBES}from"./probes.js";import{lazyBackend}from"#execution/sandbox/lazy-backend.js";import{docker}from"#sandbox/backends/docker.js";import{justbash}from"#sandbox/backends/just-bash.js";import{microsandbox}from"#sandbox/backends/microsandbox.js";import{vercel}from"#sandbox/backends/vercel.js";function defaultSandbox(e){return lazyBackend(()=>selectDefaultSandbox(e,SANDBOX_BACKEND_PROBES))}function selectDefaultSandbox(e,t){return t.isDeployedOnVercel()?vercel(e?.vercel):t.isDockerAvailable()?docker(e?.docker):t.isMicrosandboxSupported()?microsandbox(e?.microsandbox):justbash(e?.justBash)}export{SANDBOX_BACKEND_PROBES,defaultSandbox,selectDefaultSandbox};

package/dist/src/sandbox/backends/docker.d.ts

@@ -1,14 +0,0 @@
-import type { SandboxBackend } from "#public/definitions/sandbox-backend.js";
-import type { DockerSandboxCreateOptions } from "#public/sandbox/docker-sandbox.js";
-/**
- * Constructs the Docker sandbox backend: the workspace runs inside a
- * real Linux container driven through the Docker CLI, using the
- * official Ubuntu 26.04 image by default.
- *
- * Requires a running Docker-compatible daemon reachable through a
- * `docker` CLI (Docker Desktop, OrbStack, Colima, Podman via its
- * docker-compatible CLI, …; override the binary with `EVE_DOCKER_PATH`).
- * Configuring this backend pins it unconditionally — when you want
- * fallback behavior, use `defaultBackend()` instead.
- */
-export declare function docker(opts?: DockerSandboxCreateOptions): SandboxBackend;

package/dist/src/sandbox/backends/docker.js

@@ -1 +0,0 @@
-import{createDockerSandboxBackend}from"#execution/sandbox/bindings/local.js";function docker(e){return createDockerSandboxBackend({createOptions:e})}export{docker};

package/dist/src/sandbox/backends/just-bash.d.ts

@@ -1,17 +0,0 @@
-import type { SandboxBackend } from "#public/definitions/sandbox-backend.js";
-import type { JustBashSandboxCreateOptions } from "#public/sandbox/just-bash-sandbox.js";
-/**
- * Constructs the just-bash sandbox backend: a pure-JS bash interpreter
- * over a virtual filesystem stored under `.eve/sandbox-cache/`. It
- * needs no daemon or VM, but commands run in a simulated shell — no
- * real binaries (`git`, `node`, package managers) and no network
- * isolation.
- *
- * The `just-bash` package is not bundled with eve. When it is missing,
- * `eve dev` installs it into the application automatically (disable
- * with `autoInstall: false`); production processes fail with an
- * actionable install error instead. Configuring this backend pins it
- * unconditionally — when you want fallback behavior, use
- * `defaultBackend()` instead.
- */
-export declare function justbash(opts?: JustBashSandboxCreateOptions): SandboxBackend;

package/dist/src/sandbox/backends/just-bash.js

@@ -1 +0,0 @@
-import{createJustBashSandboxBackend}from"#execution/sandbox/bindings/local.js";function justbash(e){return createJustBashSandboxBackend({createOptions:e})}export{justbash};

package/dist/src/sandbox/backends/microsandbox.d.ts

@@ -1,17 +0,0 @@
-import type { SandboxBackend } from "#public/definitions/sandbox-backend.js";
-import type { MicrosandboxBootstrapUseOptions, MicrosandboxSandboxCreateOptions, MicrosandboxSessionUseOptions } from "#public/sandbox/microsandbox-sandbox.js";
-/**
- * Constructs the microsandbox sandbox backend: lightweight local VMs
- * via [microsandbox](https://www.npmjs.com/package/microsandbox) with
- * snapshot-backed templates and a firewall capable of domain-level
- * network policies and credential brokering.
- *
- * Supported hosts: macOS on Apple Silicon, or Linux (glibc) with KVM
- * enabled. The `microsandbox` package is not bundled with eve. When it
- * (or its VM runtime) is missing, `eve dev` installs both
- * automatically (disable with `setup: { autoInstall: false }`);
- * production processes fail with actionable errors instead.
- * Configuring this backend pins it unconditionally — when you want
- * fallback behavior, use `defaultBackend()` instead.
- */
-export declare function microsandbox(opts?: MicrosandboxSandboxCreateOptions): SandboxBackend<MicrosandboxBootstrapUseOptions, MicrosandboxSessionUseOptions>;

package/dist/src/sandbox/backends/microsandbox.js

@@ -1 +0,0 @@
-import{createMicrosandboxSandboxBackend}from"#execution/sandbox/bindings/local.js";function microsandbox(e){return createMicrosandboxSandboxBackend({createOptions:e})}export{microsandbox};

package/dist/src/sandbox/backends/vercel.d.ts

@@ -1,30 +0,0 @@
-import type { SandboxBackend } from "#public/definitions/sandbox-backend.js";
-import type { VercelSandboxBootstrapUseOptions, VercelSandboxOptions, VercelSandboxSessionUseOptions } from "#public/sandbox/vercel-sandbox.js";
-/**
- * Constructs the [Vercel Sandbox](https://vercel.com/docs/sandbox)
- * backend. Configuring this backend pins it unconditionally —
- * including for local development, where it creates real hosted
- * sandboxes (requires Vercel credentials).
- *
- * The optional provider creation fields are forwarded to Vercel Sandbox creation
- * for every fresh sandbox the framework creates (template at prewarm,
- * session at first-time create). On resume (`Sandbox.get`), no create
- * happens, so opts are not re-applied. `networkPolicy` is applied after
- * framework-owned base setup for fresh templates and template-less
- * sessions, before authored bootstrap code runs.
- *
- * `opts.source`, if supplied, is used only on the template create:
- * the author's snapshot, git revision, or tarball becomes the base
- * layer of the template. Bootstrap, seed files, and framework setup
- * still run on top, and every session derives from the resulting
- * eve-owned snapshot. `source` is stripped from session creates so the
- * framework's snapshot always wins.
- *
- * `bootstrap({ use })` applies its options to the template via
- * `sandbox.update(...)`; those settings persist into the snapshot.
- * `onSession({ use })` applies its options to the live session via the
- * SDK's `update` under the hood, overriding any overlapping field
- * from `opts`. `sessionCreateOptions`, when provided, is resolved only
- * when creating a fresh live session and can attach session-specific Drives.
- */
-export declare function vercel(opts?: VercelSandboxOptions): SandboxBackend<VercelSandboxBootstrapUseOptions, VercelSandboxSessionUseOptions>;

package/dist/src/sandbox/backends/vercel.js

@@ -1 +0,0 @@
-import{createVercelSandbox}from"#execution/sandbox/bindings/vercel.js";function vercel(e){let{sessionCreateOptions:t,...n}=e??{};return createVercelSandbox({createOptions:n,resolveSessionCreateOptions:t})}export{vercel};

package/dist/src/shared/sandbox-backend.d.ts

@@ -1,176 +0,0 @@
-import type { SandboxBootstrapContext, SandboxSessionUseFn } from "#shared/sandbox-definition.js";
-import type { SandboxSession } from "#shared/sandbox-session.js";
-/**
- * Live sandbox handle returned by a {@link SandboxBackend}.
- *
- * Wraps the public {@link SandboxSession} with lifecycle methods so the
- * runtime orchestrator can persist reconnect metadata and release
- * resources.
- */
-export interface SandboxBackendHandle<SO = Record<string, never>> {
-    readonly session: SandboxSession;
-    readonly useSessionFn: SandboxSessionUseFn<SO>;
-    captureState(): Promise<SandboxBackendSessionState>;
-    /**
-     * Permanently deletes this sandbox and its disposable backend state.
-     * Reusable or shared template state must not be deleted.
-     */
-    delete(options?: SandboxDeleteOptions): Promise<void>;
-    /**
-     * Stops the underlying compute at an authored runtime boundary while
-     * preserving any backend state needed to reopen the durable session.
-     * Provider errors must reject this call.
-     */
-    stop(): Promise<void>;
-    /**
-     * Stops the underlying compute because the eve server is shutting
-     * down; nothing may be left running afterwards. The session must
-     * remain reattachable from persisted state on the next server start
-     * when the backend supports durable sessions.
-     */
-    shutdown(): Promise<void>;
-}
-/** Options for permanently deleting one sandbox. */
-export interface SandboxDeleteOptions {
-    readonly abortSignal?: AbortSignal;
-}
-/**
- * Serializable per-sandbox reconnect record stored on the harness session.
- *
- * `backendName` matches the {@link SandboxBackend.name} of the backend
- * that produced this state. The runtime reads it to decide whether a
- * previously persisted handle is still compatible with the current
- * backend.
- */
-export interface SandboxBackendSessionState {
-    readonly backendName: string;
-    readonly metadata: Record<string, unknown>;
-    readonly sessionKey: string;
-}
-/**
- * One file written into a sandbox template before template state capture.
- */
-export interface SandboxSeedFile {
-    readonly path: string;
-    readonly content: string | Buffer;
-}
-/**
- * Diagnostic tags attached to provider-owned sandbox resources.
- *
- * Built-in backends may forward these into their hosting platform's
- * native tagging system. eve supplies stable tags such as the active
- * agent, channel, and session id so sandboxes can be found and
- * attributed in provider dashboards.
- */
-export type SandboxBackendTags = Readonly<Record<string, string>>;
-/**
- * Framework-owned runtime context handed to a backend on every
- * {@link SandboxBackend.create} call.
- *
- * Backends use this to derive any per-call state that depends on the
- * surrounding application. For example, the local backend computes its
- * cache directory from `appRoot`. Backends that don't need anything
- * here may ignore the field entirely.
- */
-export interface SandboxBackendRuntimeContext {
-    readonly appRoot: string;
-}
-/**
- * Input passed to {@link SandboxBackend.create} when the runtime needs a
- * live sandbox session.
- */
-export interface SandboxBackendCreateInput {
-    /**
-     * Reusable template key to open this session from. `null` means eve
-     * intentionally skipped template prewarm because the sandbox has no
-     * `bootstrap()` and no seed files, so the backend should create a
-     * fresh session from its default base runtime.
-     */
-    readonly templateKey: string | null;
-    readonly sessionKey: string;
-    readonly existingMetadata?: Record<string, unknown>;
-    /**
-     * Runtime tags the backend should attach to sandbox resources when
-     * the underlying provider supports tags.
-     */
-    readonly tags?: SandboxBackendTags;
-    readonly runtimeContext: SandboxBackendRuntimeContext;
-}
-/**
- * Input passed to {@link SandboxBackend.prewarm} when the build pipeline
- * is preparing reusable templates.
- *
- * Every authored sandbox in the compiled graph receives exactly one
- * `prewarm(...)` call before runtime opens its first session. The
- * backend captures reusable template state from the supplied
- * `bootstrap` hook and `seedFiles`, then `backend.create(...)` opens
- * durable sessions from that state.
- */
-export interface SandboxBackendPrewarmInput<BO = Record<string, never>> {
-    readonly templateKey: string;
-    readonly bootstrap?: (input: SandboxBootstrapContext<BO>) => void | Promise<void>;
-    /**
-     * Optional progress logger for backend-specific prewarm phases.
-     */
-    readonly log?: (message: string) => void;
-    readonly runtimeContext: SandboxBackendRuntimeContext;
-    readonly seedFiles: ReadonlyArray<SandboxSeedFile>;
-}
-/**
- * Outcome of one {@link SandboxBackend.prewarm} call.
- *
- * The build pipeline uses this to report in the build logs whether a
- * template state was reused from a prior deploy or captured fresh, so
- * a cache hit is distinguishable from an expensive rebuild.
- */
-export interface SandboxBackendPrewarmResult {
-    /**
-     * `true` when existing template state was reused without rebuilding it;
-     * `false` when the backend captured fresh template state.
-     */
-    readonly reused: boolean;
-}
-/**
- * Pluggable sandbox backend.
- *
- * A `SandboxBackend` is a value an author attaches to a
- * {@link SandboxDefinition} to choose which underlying runtime hosts the
- * sandbox. eve ships built-in backends (`docker()`,
- * `justbash()`, `microsandbox()`,
- * `vercel()`, and the availability-aware
- * `defaultSandbox()`), but the interface is public so authors can write
- * their own.
- *
- * A backend implements the full two-phase lifecycle:
- * {@link SandboxBackend.prewarm} captures reusable template state at
- * build time, and {@link SandboxBackend.create} starts or reattaches a
- * live session from that template at runtime.
- */
-export interface SandboxBackend<BO = Record<string, never>, SO = Record<string, never>> {
-    /**
-     * Stable identifier for this backend implementation.
-     *
-     * Participates in cache-key derivation and the persisted reconnect
-     * state, so two backends that should not share template state
-     * must use distinct names. Built-in backends use `"vercel"` and
-     * `"local"`. Custom backends pick a unique string.
-     */
-    readonly name: string;
-    /**
-     * Creates or reattaches one live sandbox session from a template
-     * previously captured by {@link SandboxBackend.prewarm}. Throws
-     * {@link SandboxTemplateNotProvisionedError} when the requested
-     * template is missing.
-     */
-    create(input: SandboxBackendCreateInput): Promise<SandboxBackendHandle<SO>>;
-    /**
-     * Build-time prewarm hook. eve invokes this for every authored
-     * sandbox in the compiled graph before serving traffic so the backend
-     * can capture reusable template state. Idempotent against existing state
-     * keyed by `templateKey`.
-     *
-     * Returns whether the state was reused from a prior run or captured
-     * fresh so the build pipeline can surface that in its logs.
-     */
-    prewarm(input: SandboxBackendPrewarmInput<BO>): Promise<SandboxBackendPrewarmResult>;
-}

package/dist/src/shared/sandbox-backend.js

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