eve 0.62.0 → 0.64.0

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/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/execution/tasks/child/steps.d.ts

@@ -1,81 +0,0 @@
-import type { ActivityObserverConfig } from "#channel/types.js";
-import type { WorkflowToolAuthorizationRequest, WorkflowToolRunRequestMessage } from "#execution/tools/workflow/messages.js";
-import type { WorkflowToolRunTaskInputRequest } from "./workflow.js";
-import type { AnswerHookRoute } from "#harness/proxy-input-requests.js";
-import type { ActivityEventV1 } from "#protocol/activity.js";
-import { type TaskInboundAnswerInput, type TaskInboundMessage, type TaskInboundUpdate, type TaskProgress, type TaskView } from "#tasks/types.js";
-/**
- * Appends one full task view to the owning task run's `eve.task`
- * stream. Only the task run workflow calls this, which is what makes
- * the run the single writer readers can trust without re-validating.
- */
-export declare function appendTaskViewStep(input: {
-    readonly activityObserver?: ActivityObserverConfig;
-    readonly view: TaskView;
-}): Promise<void>;
-export declare function projectTaskActivity(input: {
-    readonly activityObserver: ActivityObserverConfig | undefined;
-    readonly settledAt: string;
-    readonly view: TaskView;
-}): readonly ActivityEventV1[];
-/** Appends task progress without starting a parent turn. */
-export declare function appendTaskProgressStep(input: {
-    readonly progress: TaskProgress;
-}): Promise<void>;
-/**
- * Wakes the parent session with a framework task notification.
- *
- * Rides the ordinary session delivery path: a parked parent starts a
- * turn carrying this message, while an active turn observes it at the
- * next safe boundary through the owner's normal delivery routing. A
- * parent whose session already ended is a tolerated no-op.
- */
-export declare function wakeTaskParentStep(input: {
-    readonly token: string;
-    readonly view: TaskView;
-}): Promise<void>;
-/** Forwards a running child's intermediate update to its parent session. */
-export declare function wakeTaskUpdateParentStep(input: {
-    readonly token: string;
-    readonly update: TaskInboundUpdate;
-    readonly view: TaskView;
-}): Promise<void>;
-/** Delivers one task-authored message to the parent as a new turn. */
-export declare function wakeTaskMessageParentStep(input: {
-    readonly message: TaskInboundMessage;
-    readonly taskId: string;
-    readonly token: string;
-}): Promise<void>;
-/** Forwards one agent spawn or settlement request to the parent session. */
-export declare function wakeTaskAgentRequestParentStep(input: {
-    readonly request: WorkflowToolRunRequestMessage;
-    readonly taskId: string;
-    readonly token: string;
-}): Promise<void>;
-/** Re-emits a task child's authorization event through the parent channel. */
-export declare function wakeTaskAuthorizationParentStep(input: {
-    readonly request: WorkflowToolAuthorizationRequest;
-    readonly taskId: string;
-    readonly token: string;
-}): Promise<void>;
-/** Sends a workflow-body question to the owning parent's pre-model router. */
-export declare function wakeWorkflowTaskInputRequestParentStep(input: {
-    readonly request: WorkflowToolRunTaskInputRequest;
-    readonly taskId: string;
-    readonly token: string;
-}): Promise<void>;
-/**
- * Forwards answered input to the blocked child.
- *
- * The task run performs this itself so the child unblocks and the
- * view leaves `input_required` under one durable decision. Returns
- * `unreachable` when the child hook is already gone, which leaves the
- * outstanding batch untouched rather than reporting a task as working
- * when nothing received the answer.
- */
-export declare function deliverTaskInputResponsesStep(input: {
-    readonly answer: TaskInboundAnswerInput;
-    readonly answerHook?: AnswerHookRoute;
-    readonly requestIds: readonly string[];
-}): Promise<"delivered" | "unreachable">;
-export declare function formatTaskNotification(view: TaskView): string;

package/dist/src/execution/tasks/child/steps.js

@@ -1 +0,0 @@
-import{createLogger}from"#internal/logging.js";import{getWritable}from"#compiled/@workflow/core/index.js";import{resumeSessionInbox}from"#execution/session-inbox/resume.js";import{resumeWorkflowToolRunAnswers}from"#execution/tools/workflow/answer.js";import{submitActivity}from"#execution/submit-activity.js";import{isTaskWorkflowTargetGone}from"#execution/tasks/workflow-target.js";import{TASK_PROGRESS_STREAM_NAMESPACE,TASK_VIEW_STREAM_NAMESPACE,isTerminalTaskStatus,taskAuthorizationRequestId}from"#tasks/types.js";const log=createLogger(`execution.tasks.run`);async function appendTaskViewStep(e){"use step";let t=getWritable({namespace:TASK_VIEW_STREAM_NAMESPACE}).getWriter();try{await t.write(e.view)}finally{t.releaseLock()}let n=projectTaskActivity({activityObserver:e.activityObserver,settledAt:new Date().toISOString(),view:e.view});await submitActivity({events:n,sink:e.activityObserver?.sink})}function projectTaskActivity(e){let t=e.activityObserver?.workIdentity;if(t===void 0)return[];let n=e.view.status;return n===`working`?[{eventId:`${t.id}:started`,kind:`work.started`,startedAt:e.settledAt,work:t}]:n!==`completed`&&n!==`failed`&&n!==`cancelled`?[]:[{eventId:`${t.id}:settled:${n}`,kind:`work.settled`,outcome:n,settledAt:e.settledAt,workId:t.id}]}async function appendTaskProgressStep(e){"use step";let t=getWritable({namespace:TASK_PROGRESS_STREAM_NAMESPACE}).getWriter();try{await t.write(e.progress)}finally{t.releaseLock()}}async function wakeTaskParentStep(e){"use step";let t={message:formatTaskNotification(e.view)};isTerminalTaskStatus(e.view.status)&&(t.task={views:[e.view]});let n={kind:`send`,payload:t,taskDeliveryId:`${e.view.taskId}:ready:${e.view.status}`};try{await resumeSessionInbox(e.token,n)}catch(t){if(isTaskWorkflowTargetGone(t)){log.warn(`task wake target is gone; the parent session already ended`,{status:e.view.status,taskId:e.view.taskId});return}throw t}}async function wakeTaskUpdateParentStep(e){"use step";let t={kind:`send`,payload:{message:`Background task ${e.view.taskId} (${e.view.metadata.name}) update: ${e.update.message}`},taskDeliveryId:`${e.view.taskId}:update:${e.update.updateEpoch}:${e.update.updateIndex}:${e.update.callId}`};try{await resumeSessionInbox(e.token,t)}catch(e){if(isTaskWorkflowTargetGone(e))return;throw e}}async function wakeTaskMessageParentStep(e){"use step";let t={kind:`send`,payload:{message:e.message.message},taskDeliveryId:`${e.taskId}:message:${e.message.messageEpoch}:${e.message.messageIndex}:${e.message.callId}`};try{await resumeSessionInbox(e.token,t)}catch(e){if(isTaskWorkflowTargetGone(e))return;throw e}}async function wakeTaskAgentRequestParentStep(e){"use step";let t=e.request.request;if(t.kind!==`agent-invoke`&&t.kind!==`agent-settled`)throw Error(`Cannot forward task input as an agent request.`);let n={replyTo:e.request.replyTo,request:t,taskId:e.taskId},r=t.kind===`agent-invoke`?t.invocationId:`${t.result.callId}:settled`,i={kind:`send`,payload:{task:{agentRequests:[n]}},taskDeliveryId:`${e.taskId}:agent:${e.request.from.runId}:${r}`};try{await resumeSessionInbox(e.token,i)}catch(e){if(!isTaskWorkflowTargetGone(e))throw e}}async function wakeTaskAuthorizationParentStep(e){"use step";let{event:t}=e.request,n=t.event.data,r={task:{authorizationEvents:[{hookPayload:t,taskId:e.taskId}]}};t.event.type===`authorization.required`&&(r.message=`Background task ${e.taskId} needs authorization.`);let i={kind:`send`,payload:r,taskDeliveryId:`${e.taskId}:authorization:${t.event.type}:${n.turnId}:${n.stepIndex}:${n.sequence}:${taskAuthorizationRequestId(t.event)}`};try{await resumeSessionInbox(e.token,i)}catch(e){if(!isTaskWorkflowTargetGone(e))throw e}}async function wakeWorkflowTaskInputRequestParentStep(e){"use step";let t={kind:`send`,payload:{task:{inputRequests:[e.request.requests===void 0?{replyTo:e.request.replyTo,request:e.request.request,sequence:e.request.sequence,stepIndex:e.request.stepIndex,taskId:e.taskId,turnId:e.request.turnId}:{replyTo:e.request.replyTo,requests:e.request.requests,sequence:e.request.sequence,stepIndex:e.request.stepIndex,taskId:e.taskId,turnId:e.request.turnId}]}},taskDeliveryId:`${e.taskId}:input:${e.request.turnId}:${e.request.stepIndex}:${e.request.sequence}`};try{await resumeSessionInbox(e.token,t)}catch(e){if(!isTaskWorkflowTargetGone(e))throw e}}async function deliverTaskInputResponsesStep(e){"use step";let t=new Set(e.requestIds),n={auth:e.answer.auth,kind:`send`,payload:{inputResponses:e.answer.inputResponses.filter(e=>t.has(e.requestId))},taskDeliveryId:`${e.answer.taskId}:${[...e.requestIds].sort().join(`,`)}`};try{if(e.answer.childResponseUrl!==void 0){let t=await fetch(e.answer.childResponseUrl,{body:JSON.stringify({inputResponses:n.payload.inputResponses}),headers:{"content-type":`application/json`},method:`POST`,redirect:`error`});if(t.status===404)return`unreachable`;if(!t.ok)throw Error(`Remote task input delivery failed with HTTP ${t.status}.`)}else e.answerHook===void 0?await resumeSessionInbox(e.answer.childSessionInbox??e.answer.childContinuationToken,n):await resumeWorkflowToolRunAnswers(e.answer.childContinuationToken,n.payload.inputResponses);return`delivered`}catch(t){if(isTaskWorkflowTargetGone(t))return log.warn(`task input answer target is gone; the child turn already ended`,{taskId:e.answer.taskId}),`unreachable`;throw t}}function formatTaskNotification(e){let t=`Background task ${e.taskId} (${e.metadata.name})`;return e.status===`input_required`?`${t} needs input.`:e.status===`completed`?`${t} is completed.\n\nResult:\n${formatTaskOutput(e.lastOutput.data)}`:e.status===`failed`?`${t} failed.\n\nError:\n${formatTaskOutput(e.lastOutput.data)}`:`${t} is cancelled.`}function formatTaskOutput(e){return typeof e==`string`?e:JSON.stringify(e)??`null`}export{appendTaskProgressStep,appendTaskViewStep,deliverTaskInputResponsesStep,formatTaskNotification,projectTaskActivity,wakeTaskAgentRequestParentStep,wakeTaskAuthorizationParentStep,wakeTaskMessageParentStep,wakeTaskParentStep,wakeTaskUpdateParentStep,wakeWorkflowTaskInputRequestParentStep};

package/dist/src/execution/tasks/child/workflow.d.ts

@@ -1,28 +0,0 @@
-import type { ActivityObserverConfig } from "#channel/types.js";
-import { type WorkflowBodyDefinition } from "#execution/tools/workflow/body.js";
-import { type TaskInputRequest, type TaskView } from "#tasks/types.js";
-export interface TaskRunWorkflowInput {
-    readonly activityObserver?: ActivityObserverConfig;
-    readonly initialView: TaskView;
-    readonly parentContinuationToken: string;
-    readonly taskInboxToken: string;
-    readonly workflow?: WorkflowBodyDefinition;
-}
-/** A workflow-body question routed through the task that owns the workflow tool run. */
-interface WorkflowToolRunTaskInputRequestBase {
-    readonly kind: "task-input-request";
-    readonly replyTo: string;
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly turnId: string;
-}
-export type WorkflowToolRunTaskInputRequest = WorkflowToolRunTaskInputRequestBase & ({
-    readonly request: TaskInputRequest;
-    readonly requests?: never;
-} | {
-    readonly request?: never;
-    readonly requests: readonly TaskInputRequest[];
-});
-/** Owns lifecycle for one background task and consumes its executor traffic. */
-export declare function taskRunWorkflow(input: TaskRunWorkflowInput): Promise<void>;
-export {};

package/dist/src/execution/tasks/child/workflow.js

@@ -1 +0,0 @@
-import{createHook}from"#compiled/@workflow/core/index.js";import{claimHookOwnership,isHookConflictError}from"#execution/hook-ownership.js";import{resumeHookStep}from"#execution/tools/workflow/resume-hook-step.js";import{workflowToolRunOutcomeToTaskCommand,workflowToolRunReportToTaskPayload,workflowToolRunRequestToTaskInputRequest}from"#execution/tools/workflow/owner-inbox.js";import{isReadyTaskStatus,isTerminalTaskStatus,readTaskInputRequestId}from"#tasks/types.js";import{appendTaskProgressStep,appendTaskViewStep,deliverTaskInputResponsesStep,wakeTaskAgentRequestParentStep,wakeTaskAuthorizationParentStep,wakeTaskMessageParentStep,wakeTaskParentStep,wakeTaskUpdateParentStep,wakeWorkflowTaskInputRequestParentStep}from"#execution/tasks/child/steps.js";import{createWorkflowBodyRef,executeWorkflowBody}from"#execution/tools/workflow/body.js";import{createChannelReader,raceChannelReads}from"#execution/tools/workflow/owner-channels.js";import{openWorkflowToolRunOwnerInbox}from"#execution/tools/workflow/owner.js";import{applyTaskTransition}from"#tasks/transitions.js";async function taskRunWorkflow(e){"use workflow";let t=createHook({token:e.taskInboxToken}),n=openWorkflowToolRunOwnerInbox(),r=[n.reader,createChannelReader(`commands`,t)],i=e.initialView,a=!1,o=!1,s,c=[],l=0,u={messages:[],ownerRequests:[]},d=new Map,f=new AbortController,p,m=e.workflow===void 0,h;try{await claimHookOwnership(t)}catch(e){if(isHookConflictError(e))return;throw e}for(await appendTaskViewStep({activityObserver:e.activityObserver,view:i});h!==void 0&&l>=h.reportCount&&(m=!0,await applyPayload({command:workflowToolRunOutcomeToTaskCommand({from:createWorkflowBodyRef({...e.workflow,execution:`background`}),result:h.outcome}),kind:`task-command`}),h=void 0,i.status===`cancelled`&&a&&!o&&await wakeTaskParentStep({token:e.parentContinuationToken,view:i})),!isFinished();){let e=await raceChannelReads(p===void 0?r:[...r,p]);if(e.channel===`body`){if(p=void 0,e.next.done)continue;h=e.next.value;continue}if(e.next.done)return;if(e.channel===`workflow`){let t=e.next.value;if(t.kind===`report`){await applyPayload(workflowToolRunReportToTaskPayload(t,i.taskId,l++));continue}if(t.kind===`outcome`){await applyPayload({command:workflowToolRunOutcomeToTaskCommand(t),kind:`task-command`});continue}let n=t,r=n.request.kind;if(r===`agent-invoke`||r===`agent-settled`||r===`authorization-request`){await handleOwnerRequest(n);continue}n.requestCoordinates===void 0&&d.set(n.replyTo,{runId:n.from.runId}),await applyPayload(workflowToolRunRequestToTaskInputRequest(n));continue}await applyPayload(e.next.value)}function isFinished(){return isTerminalTaskStatus(i.status)&&a&&m}async function handleUpdate(t){if(i.metadata.kind===`subagent`){if(o)return;a&&!isTerminalTaskStatus(i.status)?await wakeTaskUpdateParentStep({token:e.parentContinuationToken,update:t,view:i}):c.push(t);return}await appendTaskProgressStep({progress:{callId:t.callId,kind:`task-progress`,taskId:i.taskId,update:t.message,updateIndex:t.updateIndex}})}async function handleMessage(t){if(!(o||isTerminalTaskStatus(i.status))){if(!a){u.messages.push(t);return}await wakeTaskMessageParentStep({message:t,taskId:i.taskId,token:e.parentContinuationToken})}}async function applyPayload(t){let r=t.kind===`task-command`&&t.command.kind===`ready`,c=t.kind===`task-command`&&t.command.kind===`reject-dispatch`;if((r||c)&&(a=!0),c&&(o=!0),(r||c)&&(c||isTerminalTaskStatus(i.status)?m=!0:e.workflow!==void 0&&p===void 0&&h===void 0&&!m&&(p=createChannelReader(`body`,awaitBodyResult(executeWorkflowBody({...e.workflow,execution:`background`,owner:n.owner},f.signal)))),await flushPendingTraffic()),t.kind===`task-input-request`&&(s=t),t.kind===`task-message`){await handleMessage(t);return}if(t.kind===`task-update`){await handleUpdate(t);return}let l;if(t.kind===`input-response`)l=i.status===`input_required`?await resolveAnsweredCommand(i,t,d.get(t.childContinuationToken)):void 0;else if(t.kind===`task-input-request`)l={inputRequests:t.requests??[t.request],kind:`require-input`};else if(t.kind===`task-command`)l=t.command;else return;if(l===void 0)return;if(r&&isTerminalTaskStatus(i.status)){await flushUpdates(!0),await wakeTaskParentStep({token:e.parentContinuationToken,view:i});return}let u=i;await transitionTask(l)&&(l.kind===`cancel`&&(f.abort(Error(`Task ${i.taskId} was cancelled.`)),p===void 0&&(m=!0)),isTerminalTaskStatus(i.status)||await flushUpdates(),s!==void 0&&a&&i.status===`input_required`?(await wakeWorkflowTaskInputRequestParentStep({request:s,taskId:i.taskId,token:e.parentContinuationToken}),s=void 0):!o&&a&&(l.kind!==`cancel`||m)&&(!isTerminalTaskStatus(u.status)&&isTerminalTaskStatus(i.status)||!isReadyTaskStatus(u.status)&&isReadyTaskStatus(i.status)&&s===void 0)&&await wakeTaskParentStep({token:e.parentContinuationToken,view:i}),i.status!==`input_required`&&(s=void 0))}async function flushUpdates(t=!1){if(!(!a||isTerminalTaskStatus(i.status)&&!t)){for(let t of c)await wakeTaskUpdateParentStep({token:e.parentContinuationToken,update:t,view:i});c=[]}}async function transitionTask(t){let n=applyTaskTransition(i,t);return n.action===`accepted`&&(i=n.view,await appendTaskViewStep({activityObserver:e.activityObserver,view:i}),!0)}async function handleOwnerRequest(t){if(!a){u.ownerRequests.push(t);return}let{request:n,replyTo:r}=t;if(n.kind===`authorization-request`&&n.event.childSessionId===t.from.runId){await handleStepAuthorization(n,r);return}if(!(o||isTerminalTaskStatus(i.status))){if(n.kind===`authorization-request`){await wakeTaskAuthorizationParentStep({request:n,taskId:i.taskId,token:e.parentContinuationToken});return}await wakeTaskAgentRequestParentStep({request:t,taskId:i.taskId,token:e.parentContinuationToken})}}async function handleStepAuthorization(t,n){let r=t.event.event,a=r.type===`authorization.completed`;if(!o&&(!isTerminalTaskStatus(i.status)||a)){let n=`attemptId`in r.data?r.data.attemptId:void 0;n!==void 0&&r.type===`authorization.required`?await transitionTask({kind:`require-input`,inputRequests:[...i.status===`input_required`?i.inputRequests:[],{kind:`authorization`,requestId:n,name:r.data.name}]}):n!==void 0&&await transitionTask({kind:`answered`,requestIds:[n]}),await wakeTaskAuthorizationParentStep({request:t,taskId:i.taskId,token:e.parentContinuationToken})}await resumeHookStep(n,null,{ifPresent:!0})}async function flushPendingTraffic(){if(!o)for(let t of u.messages)await wakeTaskMessageParentStep({message:t,taskId:i.taskId,token:e.parentContinuationToken});for(let e of u.ownerRequests)await handleOwnerRequest(e);u.messages.length=0,u.ownerRequests.length=0}}async function*awaitBodyResult(e){yield await e}async function resolveAnsweredCommand(e,t,n){if(t.taskId!==e.taskId)return;let r=new Set(e.inputRequests.flatMap(e=>{let t=readTaskInputRequestId(e);return t===void 0?[]:[t]})),i=t.inputResponses.map(e=>e.requestId).filter(e=>r.has(e));if(i.length!==0)return await deliverTaskInputResponsesStep({answer:t,answerHook:n,requestIds:i})===`delivered`?{kind:`answered`,requestIds:i}:void 0}taskRunWorkflow.workflowId=`workflow//eve//taskRunWorkflow`;export{taskRunWorkflow};

package/dist/src/execution/tools/subagent/emit-called-step.d.ts

@@ -1,9 +0,0 @@
-import { type UnstampedMessageStreamEvent } from "#protocol/message.js";
-/** Emits an already-projected task-owned `subagent.called` event on the parent stream. */
-export declare function emitTaskSubagentCalledStep(input: {
-    readonly event: UnstampedMessageStreamEvent;
-    readonly sessionWritable: WritableStream<Uint8Array>;
-    readonly serializedContext: Record<string, unknown>;
-}): Promise<{
-    readonly serializedContext: Record<string, unknown>;
-}>;

package/dist/src/execution/tools/subagent/emit-called-step.js

@@ -1 +0,0 @@
-import{callAdapterEventHandler}from"#channel/adapter.js";import{encodeMessageStreamEvent,stampMessageStreamEvent}from"#protocol/message.js";import{ChannelKey}from"#runtime/sessions/runtime-context-keys.js";import{deserializeContext,serializeContext}from"#context/serialize.js";import{buildAdapterContext}from"#channel/adapter-context.js";async function emitTaskSubagentCalledStep(e){"use step";let t=await deserializeContext(e.serializedContext),n=t.require(ChannelKey),r=await callAdapterEventHandler(n,e.event,buildAdapterContext(n,t)),i=e.sessionWritable.getWriter();try{await i.write(encodeMessageStreamEvent(stampMessageStreamEvent(r)))}finally{i.releaseLock()}return{serializedContext:serializeContext(t)}}export{emitTaskSubagentCalledStep};

package/dist/src/execution/tools/workflow/run-control.d.ts

@@ -1,14 +0,0 @@
-/**
- * The run's control inbox. An unawaited hook read is not scheduled under
- * replay, so `cancelled` must be raced for a cancel to be observed at all.
- */
-export interface WorkflowToolRunControlInbox {
-    readonly signal: AbortSignal;
-    /** Rejects with {@link WorkflowToolRunCancelledError} when a cancel message arrives; never resolves. */
-    readonly cancelled: Promise<never>;
-    reason(): string | undefined;
-}
-export declare function openWorkflowToolRunControlInbox(hookToken: string): WorkflowToolRunControlInbox;
-export declare class WorkflowToolRunCancelledError extends Error {
-    constructor(reason: string);
-}

package/dist/src/execution/tools/workflow/run-control.js

@@ -1 +0,0 @@
-import{createHook}from"#compiled/@workflow/core/index.js";import{isWorkflowToolRunControlMessage}from"#execution/tools/workflow/messages.js";function openWorkflowToolRunControlInbox(e){let t=createHook({token:e})[Symbol.asyncIterator](),n=new AbortController,r,i=consumeCancel(t,e=>{r=e,n.abort(new WorkflowToolRunCancelledError(e))});return i.catch(()=>{}),{cancelled:i,reason:()=>r,signal:n.signal}}async function consumeCancel(e,t){for(;;){let n=await e.next();if(n.done===!0)return await new Promise(()=>{});if(isWorkflowToolRunControlMessage(n.value))throw t(n.value.reason),new WorkflowToolRunCancelledError(n.value.reason)}}var WorkflowToolRunCancelledError=class extends Error{constructor(e){super(e),this.name=`WorkflowToolRunCancelledError`}};export{WorkflowToolRunCancelledError,openWorkflowToolRunControlInbox};

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