agents 0.24.0 → 0.26.0

package/dist/index-kbSUIer3.d.ts

@@ -0,0 +1,343 @@
+import { ToolSet } from "ai";
+
+//#region src/skills/frontmatter.d.ts
+interface ParsedSkillMarkdown {
+  data: Record<string, unknown>;
+  body: string;
+}
+declare function parseSkillFrontmatter(raw: string): ParsedSkillMarkdown;
+declare function parseSkillMarkdown(raw: string): {
+  name: string;
+  description: string;
+  body: string;
+  compatibility?: string;
+  license?: string;
+  allowedTools?: string;
+  metadata?: Record<string, unknown>;
+} | null;
+//#endregion
+//#region src/skills/types.d.ts
+interface SkillDescriptor {
+  name: string;
+  description: string;
+  compatibility?: string;
+  license?: string;
+  allowedTools?: string;
+  metadata?: Record<string, unknown>;
+  sourceId?: string;
+  version?: string;
+}
+interface SkillContent extends SkillDescriptor {
+  body: string;
+  rawContent?: string;
+  resources?: SkillResourceDescriptor[];
+}
+interface SkillResourceDescriptor {
+  path: string;
+  kind: "reference" | "script" | "asset" | "file";
+  size?: number;
+  encoding?: "text" | "base64";
+  mimeType?: string;
+  /**
+   * Set when a script resource was compiled to a self-contained JavaScript
+   * module ahead of time — by the Agents Vite plugin for bundled skills, or via
+   * `compileSkillScript` from `agents/skills/compile` for R2/dynamic skills. The
+   * runtime runs precompiled scripts directly; the runtime ships no in-Worker
+   * bundler, so non-precompiled TypeScript or multi-file scripts cannot run.
+   */
+  precompiled?: boolean;
+}
+interface SkillResource extends SkillResourceDescriptor {
+  content: string;
+}
+interface SkillScriptContext {
+  skill: SkillDescriptor;
+}
+/**
+ * The `ctx` object passed as the second argument to function-style JS/TS
+ * skill scripts (`export default async function run(input, ctx)`).
+ *
+ * Capabilities are gated by the runner: `workspace` throws unless workspace
+ * access is enabled, and `tools` only resolves tools the runner was given.
+ */
+interface SkillRunContext {
+  /** Metadata for the skill that owns this script. */
+  skill: SkillDescriptor;
+  /** Text bundled resources by relative path (e.g. `references/style-guide.md`). */
+  files: Record<string, string>;
+  /** Workspace access, gated by the runner's `workspace` permission. */
+  workspace: {
+    readFile(path: string): Promise<string | null>;
+    listFiles(path?: string): Promise<unknown>;
+    glob(pattern: string): Promise<unknown>;
+    stat(path: string): Promise<{
+      type: string;
+      size: number;
+    } | null>;
+    writeFile(path: string, content: string): Promise<void>;
+  };
+  /** Explicitly granted tools: `tools.call(name, input)` or `tools.<name>(input)`. */
+  tools: {
+    call(name: string, input?: unknown): Promise<unknown>;
+  } & Record<string, (input?: unknown) => Promise<unknown>>;
+  /** Scratch artifacts returned to the model as `outputFiles`. */
+  output: {
+    writeFile(name: string, content: string): Promise<void>;
+  };
+}
+interface SkillScriptRequest {
+  skill: SkillContent;
+  path: string;
+  source: string;
+  input: unknown;
+  resources?: SkillResource[];
+}
+interface SkillScriptRunner {
+  run(request: SkillScriptRequest): Promise<unknown>;
+}
+interface SkillSource {
+  id: string;
+  fingerprint: string;
+  list(): Promise<SkillDescriptor[]>;
+  load(name: string): Promise<SkillContent | null>;
+  readResource?(name: string, path: string): Promise<SkillResource | null>;
+  refresh?(): Promise<void>;
+}
+interface SkillManifestResource extends SkillResourceDescriptor {
+  content: string;
+}
+interface SkillManifestEntry {
+  name: string;
+  description: string;
+  body: string;
+  rawContent?: string;
+  compatibility?: string;
+  license?: string;
+  allowedTools?: string;
+  metadata?: Record<string, unknown>;
+  version?: string;
+  resources?: SkillManifestResource[];
+}
+interface SkillManifest {
+  id: string;
+  fingerprint: string;
+  skills: SkillManifestEntry[];
+}
+interface SkillRegistrySnapshot {
+  fingerprint: string;
+  catalogPrompt: string | null;
+}
+//#endregion
+//#region src/skills/manifest.d.ts
+declare function fromManifest(manifest: SkillManifest): SkillSource;
+//#endregion
+//#region src/skills/r2.d.ts
+interface R2SkillSourceOptions {
+  prefix?: string;
+  skills?: string[];
+  id?: string;
+  fingerprint?: "metadata" | "content";
+  refreshIntervalMs?: number;
+}
+declare function r2(
+  bucket: R2Bucket,
+  options?: R2SkillSourceOptions
+): SkillSource;
+//#endregion
+//#region src/skills/runner.d.ts
+/**
+ * Minimal workspace surface the skill runner needs. A concrete `Workspace`
+ * from `@cloudflare/shell` (or Think's `WorkspaceLike`) satisfies this
+ * structurally, so the runner does not depend on a filesystem package.
+ */
+interface SkillWorkspace {
+  readFile(path: string): Promise<string | null>;
+  writeFile(path: string, content: string): Promise<void>;
+  readDir(path: string): Promise<unknown>;
+  glob(pattern: string): Promise<unknown>;
+  stat(path: string): Promise<{
+    type: string;
+    size?: number;
+  } | null>;
+}
+/**
+ * Options for {@link runner}.
+ *
+ * @experimental Skill script execution is experimental and the option shape
+ * may change before stabilizing.
+ */
+interface WorkerSkillScriptRunnerOptions {
+  loader: WorkerLoader;
+  timeout?: number;
+  network?: boolean;
+  workspace?: "none" | "read" | "read-write";
+  workspaceInstance?: SkillWorkspace;
+  tools?: ToolSet | (() => ToolSet | Promise<ToolSet>);
+}
+/**
+ * Create a skill script runner backed by a Worker Loader.
+ *
+ * Capabilities are opt-in and enforced by a single host bridge: no network and
+ * no tools by default, read-only workspace access when `workspaceInstance` is
+ * provided. JS/TS scripts are function-style (`export default run(input, ctx)`)
+ * and receive `ctx = { skill, files, workspace, tools, output }`. Python and
+ * Bash use the path-based `/skill`, `/input.json`, `/output` contract.
+ *
+ * @experimental Skill script execution is experimental and may change before
+ * stabilizing.
+ */
+declare function runner(
+  options: WorkerSkillScriptRunnerOptions
+): SkillScriptRunner;
+//#endregion
+//#region src/skills/workspace.d.ts
+/**
+ * Computer-style Workspace shape used for Agent Skills projection.
+ * `@cloudflare/computer.Workspace` satisfies this through `workspace.fs`.
+ */
+interface ComputerSkillWorkspace {
+  readonly fs: {
+    stat(path: string): Promise<unknown>;
+    readFile(
+      path: string,
+      options?: {
+        byteOffset?: number;
+        byteLength?: number;
+      }
+    ): Promise<ReadableStream<Uint8Array>>;
+    readFile(path: string, encoding: "utf8"): Promise<string>;
+    writeFile(path: string, content: string | Uint8Array): Promise<void>;
+    mkdir(
+      path: string,
+      options?: {
+        recursive?: boolean;
+      }
+    ): Promise<void>;
+  };
+}
+/**
+ * Legacy direct filesystem shape used for Agent Skills projection.
+ * `@cloudflare/shell.Workspace` and Think `WorkspaceLike` satisfy this shape.
+ */
+interface LegacySkillWorkspace {
+  stat(path: string): Promise<unknown | null>;
+  readFile(path: string): Promise<string | null>;
+  readFileBytes(path: string): Promise<Uint8Array | null>;
+  writeFile(path: string, content: string): Promise<void>;
+  writeFileBytes(
+    path: string,
+    content: Uint8Array | ArrayBuffer,
+    mediaType?: string
+  ): Promise<void>;
+  mkdir(
+    path: string,
+    options?: {
+      recursive?: boolean;
+    }
+  ): Promise<void>;
+}
+/** Workspace accepted by `SkillRegistry.seedWorkspace()`. */
+type SkillProjectionWorkspace = ComputerSkillWorkspace | LegacySkillWorkspace;
+/** Options for projecting Agent Skills into a Workspace. */
+interface SkillWorkspaceSeedOptions {
+  /**
+   * Destination directory. Defaults to `/workspace/.agents/skills` for a
+   * Computer Workspace and `/.agents/skills` for a legacy Shell Workspace.
+   */
+  readonly root?: string;
+  /** Existing-file policy. Default `"preserve"` keeps Workspace edits. */
+  readonly onConflict?: "preserve" | "replace";
+}
+/** Summary returned after projecting Agent Skills into a Workspace. */
+interface SkillWorkspaceSeedResult {
+  /** Files written from source content. */
+  readonly written: number;
+  /** Existing files preserved without a write. */
+  readonly preserved: number;
+  /** Files skipped because their source content could not be read or written. */
+  readonly skipped: number;
+  /** Non-fatal per-file diagnostics. */
+  readonly warnings: readonly string[];
+  /** Absolute Workspace directory containing the projected skills. */
+  readonly root: string;
+}
+//#endregion
+//#region src/skills/registry.d.ts
+declare class SkillRegistry {
+  readonly contextLabel = "think_skills";
+  /**
+   * Non-fatal diagnostics collected during the most recent {@link load} or
+   * {@link refresh} (duplicate skill names, sources that failed to list).
+   * Reset on every load so it never grows unbounded across refreshes.
+   */
+  readonly warnings: string[];
+  private sources;
+  private scriptRunner;
+  private descriptors;
+  private sourceBySkill;
+  private loaded;
+  private workspaceFiles;
+  private workspaceSkillNames;
+  private workspaceResources;
+  constructor(sources: SkillSource[], scriptRunner?: SkillScriptRunner | null);
+  get fingerprint(): string;
+  load(): Promise<void>;
+  refresh(): Promise<void>;
+  /**
+   * Seed resolved Agent Skills into Computer or legacy Shell storage.
+   * Existing files are preserved by default, and become authoritative for
+   * activation, resource reads, and script execution.
+   */
+  seedWorkspace(
+    workspace: SkillProjectionWorkspace,
+    options?: SkillWorkspaceSeedOptions
+  ): Promise<SkillWorkspaceSeedResult>;
+  /**
+   * Route skill reads through an already-seeded Workspace without probing or
+   * rewriting its files. Hosts use this when the durable source fingerprint
+   * matches the recorded projection fingerprint.
+   */
+  useWorkspace(
+    workspace: SkillProjectionWorkspace,
+    options?: SkillWorkspaceSeedOptions
+  ): Promise<void>;
+  private writeSeedFile;
+  snapshot(): Promise<SkillRegistrySnapshot>;
+  systemPrompt(): Promise<string | null>;
+  loadSkill(name: string): Promise<SkillContent | null>;
+  private resolveResourceTarget;
+  private readResource;
+  private readSkillResources;
+  tools(): ToolSet;
+}
+//#endregion
+export {
+  SkillScriptRequest as C,
+  parseSkillMarkdown as D,
+  parseSkillFrontmatter as E,
+  SkillScriptContext as S,
+  SkillSource as T,
+  SkillManifestResource as _,
+  SkillWorkspaceSeedOptions as a,
+  SkillResourceDescriptor as b,
+  WorkerSkillScriptRunnerOptions as c,
+  r2 as d,
+  fromManifest as f,
+  SkillManifestEntry as g,
+  SkillManifest as h,
+  SkillProjectionWorkspace as i,
+  runner as l,
+  SkillDescriptor as m,
+  ComputerSkillWorkspace as n,
+  SkillWorkspaceSeedResult as o,
+  SkillContent as p,
+  LegacySkillWorkspace as r,
+  SkillWorkspace as s,
+  SkillRegistry as t,
+  R2SkillSourceOptions as u,
+  SkillRegistrySnapshot as v,
+  SkillScriptRunner as w,
+  SkillRunContext as x,
+  SkillResource as y
+};
+//# sourceMappingURL=index-kbSUIer3.d.ts.map

package/dist/index.d.ts

@@ -3,89 +3,90 @@ import {
   S as ConnectionContext,
   T as WSMessage,
   x as Connection
-} from "./capability-runner-BUBa6Ake.js";
+} from "./capability-runner-DBAnGr6L.js";
 import {
-  i as isDurableObjectStorageReset,
+  a as isDurableObjectStorageReset,
+  c as isPlatformTransientError,
   n as isDurableObjectCodeUpdateReset,
   r as isDurableObjectMemoryLimitReset,
-  s as isPlatformTransientError,
   t as RetryOptions
-} from "./retries-D9B2UCq3.js";
-import { i as __DO_NOT_USE_WILL_BREAK__agentContext } from "./current-agent-C4w86kcN.js";
+} from "./retries-CV6AkXmQ.js";
+import { i as __DO_NOT_USE_WILL_BREAK__agentContext } from "./current-agent-vAk_5JMt.js";
 import {
-  $ as DetachedAgentToolConfig,
+  $ as ChatCapableAgentClass,
   A as getCurrentAgent,
-  An as withInvocationScope,
-  At as MCPAIToolSet,
-  B as AgentToolInterruptedReason,
+  An as getSubAgentByName,
+  B as AgentToolFailure,
   C as MCPServersState,
-  Cn as buildAgentPath,
+  Cn as BuildAgentPathOptions,
   D as StartFiberResult,
-  Dn as getSubAgentByName,
+  Dn as buildAgentUrl,
   E as StartFiberOptions,
+  En as buildAgentPath,
   F as AgentToolDisplayMetadata,
-  G as AgentToolRunInfo,
-  Gt as normalizeServerId,
-  H as AgentToolMilestone,
-  Ht as MCP_SERVER_ID_MAX_LENGTH,
+  G as AgentToolProgressSnapshot,
+  Gt as MCP_SERVER_ID_MAX_LENGTH,
+  H as AgentToolLifecycleResult,
   I as AgentToolEvent,
-  J as AgentToolRunState,
-  K as AgentToolRunInspection,
-  L as AgentToolEventMessage,
+  J as AgentToolRunPart,
+  Jt as normalizeServerId,
+  K as AgentToolRunInfo,
+  L as AgentToolEventDelivery,
   M as AGENT_TOOL_MILESTONE_PART,
+  Mn as routeSubAgentRequest,
+  Mt as MCPAITool,
   N as AGENT_TOOL_PROGRESS_PART,
+  Nn as withInvocationScope,
+  Nt as MCPAIToolSet,
   O as StateUpdateMessage,
-  On as parseSubAgentPath,
   P as AgentToolChildAdapter,
-  Q as ChatCapableAgentClass,
-  R as AgentToolEventState,
+  Q as AgentToolTerminalStatus,
+  R as AgentToolEventMessage,
   S as MCPServerMessage,
-  Sn as SubAgentPathMatch,
+  Sn as AgentPathStep,
   T as RPCResponse,
-  U as AgentToolProgress,
-  V as AgentToolLifecycleResult,
-  W as AgentToolProgressSnapshot,
-  X as AgentToolStoredChunk,
-  Y as AgentToolRunStatus,
-  Z as AgentToolTerminalStatus,
+  Tn as SubAgentPathMatch,
+  U as AgentToolMilestone,
+  V as AgentToolInterruptedReason,
+  W as AgentToolProgress,
+  X as AgentToolRunStatus,
+  Y as AgentToolRunState,
+  Z as AgentToolStoredChunk,
   _ as FiberRecoveryContext,
-  _n as DynamicAgentClass,
   a as routeAgentRequest,
   b as ListFibersOptions,
-  bn as BuildAgentPathOptions,
+  bn as DynamicAgentClass,
   c as Agent,
   d as AgentStaticOptions,
-  et as DetachedRunAgentToolResult,
+  et as DetachedAgentToolConfig,
   f as DEFAULT_AGENT_STATIC_OPTIONS,
   g as FiberInspection,
   h as FiberContext,
   i as getAgentByName,
   j as routeAgentEmail,
+  jn as parseSubAgentPath,
   k as StreamingResponse,
-  kn as routeSubAgentRequest,
-  kt as MCPAITool,
   l as AgentContext,
   m as EmailRoutingOptions,
   n as AgentOptions,
-  nt as RunAgentToolResult,
+  nt as RunAgentToolOptions,
   o as AddMcpServerOptions,
   p as DeleteFibersOptions,
-  q as AgentToolRunPart,
+  q as AgentToolRunInspection,
   r as RoutingRetryOptions,
+  rt as RunAgentToolResult,
   s as AddRpcMcpServerOptions,
   t as AgentGetOptions,
-  tt as RunAgentToolOptions,
+  tt as DetachedRunAgentToolResult,
   u as AgentNamespace,
   v as FiberRecoveryResult,
-  vn as DynamicAgentStub,
   w as RPCRequest,
-  wn as buildAgentUrl,
+  wn as SUB_PREFIX,
   x as MCPServer,
-  xn as SUB_PREFIX,
+  xn as DynamicAgentStub,
   y as FiberStatus,
-  yn as AgentPathStep,
-  z as AgentToolFailure
-} from "./agent-routing-B2XLNMxq.js";
+  z as AgentToolEventState
+} from "./agent-routing-0DR0Tk2v.js";
 import {
   a as EmailSendBinding,
   d as createHeaderBasedEmailResolver,
@@ -103,8 +104,8 @@ import {
   a as ScheduleCriteria,
   i as Schedule,
   o as ScheduleOptions
-} from "./scheduler-BGq6M5Kd.js";
-import { i as QueueItem } from "./types-DCD6BNZH.js";
+} from "./scheduler-RdACNXDP.js";
+import { i as QueueItem } from "./types-BA4anrjI.js";
 import {
   n as callable,
   s as unstable_callable,
@@ -127,6 +128,7 @@ export {
   type AgentToolChildAdapter,
   type AgentToolDisplayMetadata,
   type AgentToolEvent,
+  type AgentToolEventDelivery,
   type AgentToolEventMessage,
   type AgentToolEventState,
   type AgentToolFailure,

package/dist/index.js

@@ -7,7 +7,7 @@ import { MessageType } from "./types.js";
 import { createHeaderBasedEmailResolver } from "./email.js";
 import { n as withInvocationScope } from "./cloudflare-Dzvc7V2N.js";
 import { SUB_PREFIX, buildAgentPath, buildAgentUrl, getSubAgentByName, parseSubAgentPath, routeSubAgentRequest } from "./sub-routing.js";
-import { a as routeAgentEmail, i as getCurrentAgent, n as DEFAULT_AGENT_STATIC_OPTIONS, r as StreamingResponse, t as Agent } from "./src-BNU3ZiJM.js";
+import { a as routeAgentEmail, i as getCurrentAgent, n as DEFAULT_AGENT_STATIC_OPTIONS, r as StreamingResponse, t as Agent } from "./src-BZeu-SCD.js";
 import { isDurableObjectCodeUpdateReset, isDurableObjectMemoryLimitReset, isDurableObjectStorageReset, isPlatformTransientError } from "./retries.js";
 import { SqlError } from "./sql-error.js";
 import { i as normalizeServerId, n as MCP_SERVER_ID_MAX_LENGTH } from "./client-fyQrLGkD.js";

package/dist/internal_context.d.ts

@@ -2,7 +2,7 @@ import {
   i as __DO_NOT_USE_WILL_BREAK__agentContext,
   n as CurrentAgentContext,
   t as AgentContextStore
-} from "./current-agent-C4w86kcN.js";
+} from "./current-agent-vAk_5JMt.js";
 import { t as AgentEmail } from "./internal_context-BlxFEWfn.js";
 export {
   type AgentContextStore,

package/dist/lifecycle/index.d.ts

@@ -24,16 +24,16 @@ import {
   w as ConnectionState,
   x as Connection,
   y as LifecycleJobPushOptions
-} from "../capability-runner-BUBa6Ake.js";
+} from "../capability-runner-DBAnGr6L.js";
 import {
   n as LifecycleOptions,
   t as Lifecycle
-} from "../durable-object-lifecycle-ei7M7lqB.js";
+} from "../durable-object-lifecycle-HhgOMWq9.js";
 import {
   a as getCurrentAgent,
   n as CurrentAgentContext,
   r as LifecycleObject
-} from "../current-agent-C4w86kcN.js";
+} from "../current-agent-vAk_5JMt.js";
 export {
   type CapabilityRequestContext,
   type CapabilityStartContext,

package/dist/lifecycle/index.js

@@ -1,4 +1,4 @@
 import { n as getCurrentAgent } from "../current-agent-DhoDkSnH.js";
 import { t as LifecycleCapability } from "../capability-B4WbF81e.js";
-import { t as Lifecycle } from "../lifecycle-Mm_jQh7r.js";
+import { t as Lifecycle } from "../lifecycle-CFu6OV03.js";
 export { Lifecycle, LifecycleCapability, getCurrentAgent };

package/dist/{lifecycle-Mm_jQh7r.js → lifecycle-CFu6OV03.js}

@@ -1,7 +1,7 @@
 import { i as runWithoutCurrentAgent, r as runInLifecycleHostContext } from "./current-agent-DhoDkSnH.js";
 import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-DZBYAB34.js";
-import { n as bindLifecycleCapability, r as lifecycleCapabilityId, t as LifecycleCapability } from "./capability-B4WbF81e.js";
 import { t as _classPrivateMethodInitSpec } from "./classPrivateMethodInitSpec-qMjJ6sHQ.js";
+import { n as bindLifecycleCapability, r as lifecycleCapabilityId, t as LifecycleCapability } from "./capability-B4WbF81e.js";
 import { n as publishDiagnosticsEvent } from "./diagnostics-BzvaX2UT.js";
 import { isDurableObjectCodeUpdateReset, isDurableObjectMemoryLimitReset, isPlatformFailure, tryN } from "./retries.js";
 import { SqlError } from "./sql-error.js";
@@ -806,6 +806,8 @@ function decodeProps(header) {
 const lifecycleEventSinks = /* @__PURE__ */ new WeakMap();
 const lifecycleRouteTransports = /* @__PURE__ */ new WeakMap();
 const lifecycleHostInvokers = /* @__PURE__ */ new WeakMap();
+/** Lifecycles whose startup the current async context is running inside. */
+const lifecycleStartupScope = new AsyncLocalStorage();
 /** @internal Adapt the host invocation boundary at a composition root. */
 function setLifecycleHostInvoker(lifecycle, invoker) {
 	lifecycleHostInvokers.set(lifecycle, invoker);
@@ -844,6 +846,7 @@ var _alarmsDisabled = /* @__PURE__ */ new WeakMap();
 var _capabilitiesLocked = /* @__PURE__ */ new WeakMap();
 var _handlersInstalled = /* @__PURE__ */ new WeakMap();
 var _Lifecycle_brand = /* @__PURE__ */ new WeakSet();
+var _startup = /* @__PURE__ */ new WeakMap();
 var _legacyName = /* @__PURE__ */ new WeakMap();
 var _props = /* @__PURE__ */ new WeakMap();
 var Lifecycle = class Lifecycle {
@@ -880,6 +883,7 @@ var Lifecycle = class Lifecycle {
 		_classPrivateFieldInitSpec(this, _alarmsDisabled, false);
 		_classPrivateFieldInitSpec(this, _capabilitiesLocked, false);
 		_classPrivateFieldInitSpec(this, _handlersInstalled, false);
+		_classPrivateFieldInitSpec(this, _startup, void 0);
 		_classPrivateFieldInitSpec(this, _legacyName, void 0);
 		_classPrivateFieldInitSpec(this, _props, void 0);
 		_classPrivateFieldSet2(_host, this, host);
@@ -1061,13 +1065,26 @@ var Lifecycle = class Lifecycle {
 	* Runtime fetch, alarm, and WebSocket entry points call this automatically.
 	* RPC methods may call it explicitly because native RPC bypasses fetch.
 	*
+	* Concurrent callers share one startup and all observe its outcome. A call
+	* made from inside that startup, such as a capability or `onStart` calling
+	* back into the host, returns immediately instead of waiting on itself.
+	*
 	* @param props - Optional properties supplied to capability and host startup.
+	*   Ignored while a startup is already in flight.
 	*/
 	async start(props) {
-		if (props !== void 0) _classPrivateFieldSet2(_props, this, props);
+		if (props !== void 0 && _classPrivateFieldGet2(_startup, this) === void 0) _classPrivateFieldSet2(_props, this, props);
 		await _assertClassBrand(_Lifecycle_brand, this, _ensureInitialized).call(this);
 	}
 	/**
+	* Whether lifecycle startup has completed for this instance.
+	*
+	* @returns `true` after capabilities and the host `onStart` have finished.
+	*/
+	isStarted() {
+		return _classPrivateFieldGet2(_status, this) === "started";
+	}
+	/**
 	* The name used to address this Durable Object.
 	*
 	* Native `ctx.id.name` is authoritative. A read-only legacy storage fallback
@@ -1198,9 +1215,8 @@ function _runInHostBoundary(fn, scope) {
 		request: scope?.request
 	}, fn));
 }
-async function _readyForCapabilityOperation() {
-	if (_classPrivateFieldGet2(_status, this) === "starting" || _classPrivateFieldGet2(_status, this) === "started") return;
-	await this.start();
+function _readyForCapabilityOperation() {
+	return _assertClassBrand(_Lifecycle_brand, this, _ensureInitialized).call(this);
 }
 async function _dispatchRoute(envelope) {
 	await _assertClassBrand(_Lifecycle_brand, this, _ensureInitialized).call(this);
@@ -1247,13 +1263,26 @@ function _reportEventSinkFailure(event, error) {
 function _deliverPendingEvents() {
 	for (const event of _classPrivateFieldGet2(_pendingEvents, this).splice(0)) _assertClassBrand(_Lifecycle_brand, this, _publishCapabilityEvent).call(this, event);
 }
-async function _ensureInitialized() {
-	if (_classPrivateFieldGet2(_status, this) === "started") return;
+function _ensureInitialized() {
+	if (_classPrivateFieldGet2(_status, this) === "started") return Promise.resolve();
+	if (_classPrivateFieldGet2(_startup, this) === void 0) {
+		const startup = Promise.resolve().then(() => _assertClassBrand(_Lifecycle_brand, this, _runStartup).call(this)).finally(() => {
+			if (_classPrivateFieldGet2(_startup, this) === startup) _classPrivateFieldSet2(_startup, this, void 0);
+		});
+		_classPrivateFieldSet2(_startup, this, startup);
+		return startup;
+	}
+	if (lifecycleStartupScope.getStore()?.has(this)) return Promise.resolve();
+	return _classPrivateFieldGet2(_startup, this);
+}
+async function _runStartup() {
 	if (_classPrivateFieldGet2(_ctx, this).id.name === void 0 && _classPrivateFieldGet2(_legacyName, this) === void 0) _classPrivateFieldSet2(_legacyName, this, await _classPrivateFieldGet2(_ctx, this).storage.get(LEGACY_NAME_STORAGE_KEY));
 	this.name;
 	_classPrivateFieldSet2(_capabilitiesLocked, this, true);
+	const scope = new Set(lifecycleStartupScope.getStore());
+	scope.add(this);
 	let error;
-	await _classPrivateFieldGet2(_ctx, this).blockConcurrencyWhile(async () => {
+	await _classPrivateFieldGet2(_ctx, this).blockConcurrencyWhile(() => lifecycleStartupScope.run(scope, async () => {
 		_classPrivateFieldSet2(_status, this, "starting");
 		try {
 			await runWithoutCurrentAgent(() => _classPrivateFieldGet2(_capabilityRunner, this).start({ props: _classPrivateFieldGet2(_props, this) }));
@@ -1263,7 +1292,7 @@ async function _ensureInitialized() {
 			_classPrivateFieldSet2(_status, this, "zero");
 			error = cause;
 		}
-	});
+	}));
 	if (error) {
 		_classPrivateFieldSet2(_rearmRequestedDuringStart, this, false);
 		_classPrivateFieldGet2(_pendingEvents, this).length = 0;
@@ -1311,4 +1340,4 @@ async function _resolveJobDispatch(owner) {
 //#endregion
 export { abortWithoutAlarmRetry as a, setLifecycleRouteTransport as i, setLifecycleEventSink as n, setLifecycleHostInvoker as r, Lifecycle as t };
 
-//# sourceMappingURL=lifecycle-Mm_jQh7r.js.map
+//# sourceMappingURL=lifecycle-CFu6OV03.js.map