@mcp-b/do-runtime 0.1.0

package/dist/src/api/actor.d.ts

@@ -0,0 +1,306 @@
+/**
+ * ← workerd `src/workerd/api/actor.{h,c++}`
+ *
+ * Upstream's own opening comment is the best summary of why this file is named
+ * what it is: "'Actors' are the internal name for Durable Objects, because they
+ * implement a sort of actor model. We ended up not calling the product 'Actors'
+ * publicly because we found that people who were familiar with actor-model
+ * programming were more confused than helped by it."
+ *
+ * Five classes and three outgoing factories. The five are here:
+ * `ColoLocalActorNamespace` (`actor.h:25`), `DurableObjectId` (`:42`),
+ * `DurableObject` (`:87`), `DurableObjectNamespace` (`:142`) and
+ * `DurableObjectClass` (`:367`). The three factories — `GlobalActorOutgoingFactory`
+ * (`:293`), `LocalActorOutgoingFactory` (`:331`) and `ReplicaActorOutgoingFactory`
+ * (`:352`) — are **not**, and their absence is the whole of this file's seam:
+ * every one of them is a bag of addressing data plus a lazily-created actor
+ * channel, and `newSingleUseClient` returns a `WorkerInterface`, which is capnp
+ * dispatch with no port. `ActorChannelFactory` and `ColoLocalActorChannelFactory`
+ * below are the shape they plug into, holding exactly the fields the two
+ * reachable factories' constructors capture.
+ * `ActorRetryRequestMetadata` stays on that same omitted transport seam:
+ * upstream passes it from an outgoing factory to `ActorChannel`, while the
+ * host-provided `Fetcher` here already owns retry policy and exposes no metadata.
+ *
+ * **`ColoLocalActorNamespace` is ported, not treated as a substrate boundary**,
+ * and the reason is worth stating because the opposite call is easy to defend
+ * badly. It is the pre-SQLite, non-durable actor namespace, and this host cannot
+ * host one — there is no storage-less actor kind here, and `createActorContainer`
+ * requires a `SqlDatabaseProvider`. But *hosting* is not in this file. What is in
+ * this file is the JS-facing half: one argument check and one outgoing-stub
+ * request, which has precisely the same substrate needs as
+ * `DurableObjectNamespace.get()`, which nobody proposes cutting. The boundary, if
+ * there is one, sits in `server/` at the point something has to place an
+ * ephemeral actor — so there is nothing here to cut, and cutting it would be the
+ * feature subset the package README forbids.
+ *
+ * It is also not idle, though an earlier revision of this comment gave the wrong
+ * reason. It claimed `ctx.exports` surfaces a storage-less actor class as a
+ * `LoopbackColoLocalActorNamespace`; upstream's own comment
+ * (`api/export-loopback.h:111-115`) says that case is a
+ * `LoopbackDurableObjectClass`. `LoopbackColoLocalActorNamespace` is "for
+ * colo-local (ephemeral) actor namespaces" (`:191`) and is built from a
+ * *configured* binding, `Global::LoopbackEphemeralActorNamespace`
+ * (`server/workerd-api.c++:666-670`) — reachable through configuration rather
+ * than through a bare export. The conclusion stands; the path to it is that one.
+ *
+ * Two things are absent because there is nothing to resolve them against:
+ *
+ *  - **The numbered-channel arm of every binding.** Each of upstream's
+ *    `kj::OneOf<uint, IoOwn<...>>` keeps only its object arm. Upstream resolves a
+ *    binding to a `uint` at configuration time; here a binding is a property of
+ *    the `env` object the consumer supplies, and there is no channel table for a
+ *    number to index. The object arm is upstream's own alternative, offered on
+ *    `DurableObjectNamespace` for the case where one "is constructed dynamically
+ *    within an execution context, rather than being a long-lived binding" — which
+ *    is every binding here.
+ *  - **Compatibility flags.** `getEnableVersionApi`, `getReplicaRouting`,
+ *    `getDurableObjectGetExisting` and `getDurableObjectFetchRequiresSchemeAuthority`
+ *    are read four times in `actor.c++`. A runtime with no deployed history takes
+ *    the current behaviour, which is the same judgment `deleteAll()`'s
+ *    `deleteAllDeletesAlarm` row already records. The one that is not a flag
+ *    decision is `enableReplicaRouting`, which is `false` because replication is a
+ *    named substrate boundary in `io/actor-cache.ts`.
+ *
+ * `serialize`/`deserialize` on `DurableObjectClass` are a boundary of their own:
+ * they are built on `jsg::Serializer`, `Frankenvalue`, capnp `rpc::JsValue::External`
+ * and channel tokens, none of which has a port. Both throw one named message.
+ *
+ * Spec: §1.10, §1.11 in docs/decisions.md.
+ */
+import type { ActorGetMode, ActorId, ActorIdFactory, ActorRoutingMode, ActorVersion } from "../io/actor-id.js";
+import type { ActorClassChannel } from "../io/io-channels.js";
+/**
+ * ← the `[1, 2048]` bound in `ColoLocalActorNamespace::get`.
+ *
+ * Upstream compares `actorId.size()`, which for a `kj::String` is **bytes**, so
+ * this is measured in UTF-8 bytes rather than in UTF-16 code units. That costs
+ * one `TextEncoder` pass and buys an exact match on a bound a caller can hit.
+ */
+export declare const MAX_COLO_LOCAL_ACTOR_ID_BYTES = 2048;
+/**
+ * Upstream never faces this: JSG unwraps a `jsg::Ref<DurableObjectId>` parameter
+ * and throws a `TypeError` before the method body runs, so `getInner()` cannot be
+ * reached on something that is not one. Here the parameter type is
+ * workers-types' structural `DurableObjectId` interface, which any object with a
+ * `toString` and an `equals` satisfies — so the unwrap has to be written, and it
+ * fails closed rather than guessing at the string form.
+ */
+export declare const FOREIGN_ACTOR_ID_MESSAGE: string;
+/** Substrate boundary: `jsg::Serializer`, `Frankenvalue` and channel tokens have no port. */
+export declare const ACTOR_CLASS_SERIALIZATION_UNIMPLEMENTED_MESSAGE: string;
+/**
+ * ← what `GlobalActorOutgoingFactory`'s constructor captures (`actor.h:297-303`),
+ * one field per constructor parameter minus the channel number.
+ */
+export type GlobalActorRequest = {
+    readonly id: ActorId;
+    readonly locationHint: string | undefined;
+    readonly mode: ActorGetMode;
+    readonly enableReplicaRouting: boolean;
+    readonly routingMode: ActorRoutingMode;
+    readonly version: ActorVersion | undefined;
+};
+/**
+ * ← `DurableObjectNamespace::ActorChannelFactory` (`actor.h:147-157`) composed
+ * with `IoChannelFactory::getGlobalActor`, which is what its one implementation
+ * forwards to.
+ *
+ * The composition is not a shortcut. Upstream's `getGlobalActor` returns an
+ * `ActorChannel`, and the only thing done with one is `startRequest(...)` →
+ * `WorkerInterface`, which the `Fetcher` then drives. `WorkerInterface` has no
+ * port and `Fetcher` construction is `api/http.{h,c++}`'s, which is not ported,
+ * so the channel and the stub it produces are one object here — the same collapse
+ * `io/worker.ts`'s `FacetManager.getFacet` and `server/actor-container.ts`'s
+ * `FacetHandle.stub` already make.
+ *
+ * Section 7 implements this. The laziness upstream's factory has — "Lazily
+ * initialize actorChannel" — belongs to the implementation, not to the interface,
+ * because upstream's own laziness is per-`newSingleUseClient` and there is no
+ * per-request client here to be lazy about.
+ */
+export interface ActorChannelFactory {
+    getGlobalActor(request: GlobalActorRequest): Fetcher;
+}
+/** ← what `LocalActorOutgoingFactory`'s constructor captures (`actor.h:333-335`). */
+export type ColoLocalActorRequest = {
+    readonly actorId: string;
+};
+/**
+ * ← `IoChannelFactory::getColoLocalActor`, reached through
+ * `LocalActorOutgoingFactory`.
+ *
+ * Upstream gives `ColoLocalActorNamespace` only the numbered-channel arm, because
+ * an ephemeral namespace is always a configured binding there. With no channel
+ * table the factory arm is the only one available, so this is the same
+ * substitution upstream itself offers `DurableObjectNamespace` — applied to the
+ * one constructor that did not already have it.
+ */
+export interface ColoLocalActorChannelFactory {
+    getColoLocalActor(request: ColoLocalActorRequest): Fetcher;
+}
+/**
+ * ← `ColoLocalActorNamespace` (`actor.h:25-37`). "A capability to an ephemeral
+ * Actor namespace."
+ */
+export declare class ColoLocalActorNamespace implements globalThis.ColoLocalActorNamespace {
+    #private;
+    constructor(channel: ColoLocalActorChannelFactory);
+    /** ← `ColoLocalActorNamespace::get` (`actor.c++:116-129`). */
+    get(actorId: string): Fetcher;
+}
+/**
+ * ← `DurableObjectId` (`actor.h:42-84`). "DurableObjectId type seen by
+ * JavaScript."
+ *
+ * `name` and `jurisdiction` are read from the inner id **once, at construction**,
+ * where upstream's are `JSG_READONLY_INSTANCE_PROPERTY`s that re-read it on every
+ * access. That is not a preference: `@cloudflare/workers-types` declares both
+ * `readonly name?: string`, and under `exactOptionalPropertyTypes` a getter
+ * returning `string | undefined` does not satisfy an optional `string`. An own
+ * property assigned only when the value exists does, and it is what keeps this
+ * class assignable to the interface with no cast (§2.4). The one behaviour lost
+ * is `ActorIdImpl::clearName()` (`server/actor-id-impl.h`) taking effect on an
+ * already-wrapped id — a `server/`-internal that runs before the id reaches JS.
+ */
+export declare class DurableObjectId implements globalThis.DurableObjectId {
+    #private;
+    readonly name?: string;
+    readonly jurisdiction?: string;
+    constructor(id: ActorId);
+    /** ← `getInner()`. Not JS-visible upstream either; the outgoing factories take it. */
+    getInner(): ActorId;
+    /** "Converts to a string which can be passed back to the constructor to reproduce the same ID." */
+    toString(): string;
+    equals(other: globalThis.DurableObjectId): boolean;
+}
+/**
+ * ← `DurableObject` (`actor.h:87-139`). "Stub object used to send messages to a
+ * remote durable object."
+ *
+ * Upstream's carries its whole behaviour by `JSG_INHERIT(Fetcher)` and adds
+ * exactly two readonly properties. So does this: the `Fetcher` is the transport's
+ * and everything except `id` and `name` belongs to it. `asDurableObjectStub`
+ * below is where the inheritance goes.
+ */
+export declare class DurableObject {
+    #private;
+    constructor(id: DurableObjectId, fetcher: Fetcher);
+    /** ← `JSG_READONLY_INSTANCE_PROPERTY(id, getId)`. */
+    getId(): DurableObjectId;
+    /** ← `JSG_READONLY_INSTANCE_PROPERTY(name, getName)`. */
+    getName(): string | undefined;
+    /** The `Fetcher` upstream inherits from rather than holds. */
+    getFetcher(): Fetcher;
+}
+/**
+ * ← `js.alloc<DurableObject>(...)` plus `JSG_INHERIT(Fetcher)` plus the
+ * `JSG_TS_OVERRIDE` that renames the resource type to `DurableObjectStub`.
+ *
+ * The named assertion is the same one `io/worker.ts`'s `asFacetStub` makes and
+ * for the same reason: `DurableObjectStub<T>` is `Fetcher<T, …> & { id, name }`,
+ * and `Fetcher<T>` for an unresolved `T` is `Rpc.Provider<T, …>`, a conditional
+ * type TypeScript defers until `T` is known — where `T` is the caller's claim
+ * about a class it named, which no value can confirm. Upstream is in the same
+ * position and answers it the same way, with the parameter living only inside a
+ * `JSG_TS_OVERRIDE`.
+ *
+ * The `Proxy` is what JSG inheritance costs in JS. Two properties have to answer
+ * from the id and every other property — `fetch`, `connect`, and every RPC method
+ * name, which are the whole point of a stub — has to reach the transport with
+ * `this` still bound to it. Bound methods are memoised so `stub.foo === stub.foo`,
+ * which upstream gets for free by there being one object rather than two.
+ */
+export declare function asDurableObjectStub<T extends Rpc.DurableObjectBranded | undefined>(object: DurableObject): DurableObjectStub<T>;
+/** ← `DurableObjectNamespace::NewUniqueIdOptions` (`actor.h:166-177`). */
+export type NewUniqueIdOptions = {
+    /** "Restricts the new unique ID to a set of colos within a jurisdiction." */
+    readonly jurisdiction?: string | null;
+};
+/** ← `DurableObjectNamespace::GetDurableObjectOptions` (`actor.h:193-234`). */
+export type GetDurableObjectOptions = {
+    readonly locationHint?: string;
+    /**
+     * "`routingMode` may be be of interest to applications using Durable Objects
+     * replicas. It can be one of the following options: none: the default,
+     * indicates we will pick for the application. 'primary-only': guarantees we
+     * route directly to the primary (skip any replicas)."
+     */
+    readonly routingMode?: string;
+    readonly version?: {
+        readonly cohort?: string;
+    };
+};
+/**
+ * ← `DurableObjectNamespace` (`actor.h:142-291`). "Global durable object class
+ * binding type."
+ */
+export declare class DurableObjectNamespace<T extends Rpc.DurableObjectBranded | undefined = undefined> implements globalThis.DurableObjectNamespace<T> {
+    #private;
+    constructor(channel: ActorChannelFactory, idFactory: ActorIdFactory);
+    /**
+     * "Create a new unique ID for a durable object that will be allocated nearby
+     * the calling colo."
+     */
+    newUniqueId(options?: NewUniqueIdOptions): DurableObjectId;
+    /**
+     * "Create a name-derived ID. Passing in the same `name` (to the same class)
+     * will always produce the same ID."
+     */
+    idFromName(name: string): DurableObjectId;
+    /**
+     * "Create a DurableObjectId from the stringified form of the ID (as produced by
+     * calling `toString()` on a durable object ID). Throws if the ID is not a
+     * 64-digit hex number, or if the ID was not originally created for this class."
+     */
+    idFromString(id: string): DurableObjectId;
+    /** "Gets a durable object by ID or creates it if it doesn't already exist." */
+    get(id: globalThis.DurableObjectId, options?: GetDurableObjectOptions): DurableObjectStub<T>;
+    /**
+     * "Gets a durable object by name or creates it if it doesn't already exist.
+     * Short for `idFromName()` followed by `get()`."
+     */
+    getByName(name: string, options?: GetDurableObjectOptions): DurableObjectStub<T>;
+    /**
+     * "Experimental. Gets a durable object by ID if it already exists. Currently,
+     * gated for use by cloudflare only."
+     *
+     * Upstream exposes it only when the `durableObjectGetExisting` compat flag is
+     * on, and `@cloudflare/workers-types` 4.20260702.1 does not declare it. It is
+     * exposed unconditionally here, which is the current-behaviour reading every
+     * other compat flag in this file gets.
+     */
+    getExisting(id: globalThis.DurableObjectId, options?: GetDurableObjectOptions): DurableObjectStub<T>;
+    /**
+     * "Creates a subnamespace with the jurisdiction hardcoded."
+     *
+     * The argument is optional because upstream's is a
+     * `jsg::Optional<kj::Maybe<kj::String>>`, so both "omitted" and "null" mean the
+     * same thing — `cloneWithJurisdiction(kj::none)`, a subnamespace with none.
+     */
+    jurisdiction(jurisdiction?: string | null): DurableObjectNamespace<T>;
+}
+/**
+ * ← `DurableObjectClass` (`actor.h:367-393`). "DurableObjectClass represents a
+ * binding to a Durable Object class that can be used as a facet. The only use of
+ * this type is to pass to `ctx.facets.get()`."
+ *
+ * `getChannel()` takes no `IoContext` because the parameter existed to resolve the
+ * numbered-channel arm, and there is no numbered-channel arm here.
+ */
+export declare class DurableObjectClass<_T extends Rpc.DurableObjectBranded | undefined = undefined> implements globalThis.DurableObjectClass<_T> {
+    #private;
+    constructor(channel: ActorClassChannel);
+    /** ← `DurableObjectClass::getChannel` (`actor.c++:232-242`). */
+    getChannel(): ActorClassChannel;
+    /**
+     * ← `DurableObjectClass::serialize` (`actor.c++:244-306`). Substrate boundary.
+     *
+     * `requireAllowsTransfer()` runs first, exactly as upstream's does, so a class
+     * that refuses transfer reports that rather than the boundary — the refusal is
+     * the more specific answer and it is the one upstream would give too.
+     */
+    serialize(): never;
+    /** ← `DurableObjectClass::deserialize` (`actor.c++:308-359`). Substrate boundary. */
+    static deserialize(): never;
+}

package/dist/src/api/cloudflare-workers.d.ts

@@ -0,0 +1,259 @@
+/**
+ * ← workerd `src/cloudflare/workers.ts` — the built-in `cloudflare:workers`
+ * module.
+ *
+ * Upstream's own header explains the file's shape: "C++ built-in modules do not
+ * yet support named exports, so we must define this wrapper module that simply
+ * re-exports the classes from the built-in module." The classes come from
+ * `cloudflare-internal:workers` (`src/cloudflare/internal/workers.d.ts`); the
+ * behaviour this file owns is the two proxies and the three scope functions.
+ *
+ * **The export surface was re-derived, not inherited.** The extension shim this
+ * replaces (`offscreen/worker/host/shims/cloudflare-workers.ts`, 58 lines)
+ * documents its surface as the result of grepping `from "cloudflare:workers"`
+ * across `vendor/agents/packages/agents/src`. Re-running that grep across all of
+ * `vendor/agents` finds six values — `env` (178 imports), `exports` (48),
+ * `WorkerEntrypoint` (16), `RpcTarget` (16), `DurableObject` (13),
+ * `WorkflowEntrypoint` (3) — and **four types the shim does not have**:
+ * `WorkflowEvent` (8), `WorkflowSleepDuration` (4), `WorkflowStep` (3) and
+ * `WorkflowStepEvent` (2). `@cloudflare/workers-types` declares only
+ * `WorkflowSleepDuration` of those four globally, so the other three are
+ * declared here, where the module that exports them lives.
+ *
+ * Everything else upstream exports is ported too, per the package README's rule
+ * that consumer count is not the filter: `RpcStub`, `RpcPromise`, `RpcProperty`,
+ * `ServiceStub`, `waitUntil`, `cache`, `tracing` and `abortIsolate`. Each of
+ * those is a named throwing boundary, and each throw says which layer owns the
+ * thing that is missing rather than that it is missing.
+ *
+ * **The one thing to know before wiring this in.** `RpcTarget` is declared here,
+ * as upstream declares it — capnweb's own documentation says "on Cloudflare
+ * Workers, this `RpcTarget` is an alias for the one exported from the
+ * `cloudflare:workers` module, so they can be used interchangably." That alias is
+ * **unreachable** in capnweb 0.10.0: `let workersModule = globalThis[Symbol("workers-module")]`
+ * reads a symbol created fresh inside capnweb's own module and exported nowhere,
+ * so it is always `undefined` and capnweb falls back to its private `class {}`.
+ * `value instanceof RpcTarget` inside capnweb therefore tests capnweb's class,
+ * not this one, which is why today's extension shim re-exports capnweb's. The
+ * transport adaptation (`src/transport/`) owns reconciling the two; `api/` may not
+ * import a transport library, and inverting the dependency — making the module
+ * that defines the base class depend on the library that aliases it — is the
+ * layering upstream does not have.
+ *
+ * Spec: the shim-surface inventory in docs/shim-surface.md and decision 16 in
+ * docs/decisions.md.
+ */
+/**
+ * `entrypoints.waitUntil` reaches `IoContext::current()`, a thread-local this
+ * package deliberately does not port — `io/io-context.ts`'s invocation stack
+ * replaces it, and it is reachable only from inside a gated slice rather than
+ * from module scope.
+ */
+export declare const MODULE_WAIT_UNTIL_UNIMPLEMENTED_MESSAGE: string;
+/**
+ * Upstream: "In workerd, the handler aborts the process (unless used on a
+ * dynamic worker). In the edge runtime it will condemn and terminate the current
+ * isolate." There is no isolate to condemn, which is the same absence
+ * `DurableObjectState.abort()` records for `js.terminateExecutionNow()`.
+ */
+export declare const ABORT_ISOLATE_UNIMPLEMENTED_MESSAGE: string;
+/** The Workers Cache API is an edge facility; `caches` in a browser is a different contract. */
+export declare const CACHE_UNIMPLEMENTED_MESSAGE: string;
+/** The four stub types are the RPC system's, and the RPC system here is the transport adaptation. */
+export declare const RPC_STUB_UNIMPLEMENTED_MESSAGE: string;
+/**
+ * Upstream's `exports` proxy defines no `set` trap, so an assignment lands on the
+ * empty proxy target and is silently lost — its comment says "This proxy is
+ * read-only - mutations are not supported." A silent loss is the failure mode
+ * this repository's fail-closed tenet exists to prevent, so it throws instead.
+ */
+export declare const EXPORTS_READ_ONLY_MESSAGE: string;
+/**
+ * Upstream's scopes are `AsyncContext`-propagated, so an `async` callback keeps
+ * its bindings across an await. Decision 8's propagation is not built (and Part 4
+ * records that this package needs none), so the scope here is the synchronous
+ * call — which is exactly what upstream's `fn: () => unknown` signature describes
+ * and nothing more. A callback that returns a thenable would silently read the
+ * wrong bindings after its first await, so it is refused: the same guard, for the
+ * same reason, that `transactionSync` already applies to its callback.
+ */
+export declare const WITH_SCOPE_ASYNC_MESSAGE: string;
+/**
+ * ← `export const env: Cloudflare.Env`. `Cloudflare.Env` is generated per project
+ * from a `wrangler.jsonc`, and this package has neither, so the value type is the
+ * open record the extension shim already used.
+ */
+export type Bindings = Record<string, unknown>;
+/**
+ * ← the `env` proxy (`workers.ts:41-104`). Upstream's comment, which is the whole
+ * reason this is a proxy rather than an object: "Since env is imported as a
+ * module-level reference, the object identity cannot be changed. The proxy
+ * provides indirection, delegating to different underlying env objects based on
+ * async context (see withEnv()). Mutations via this proxy modify the current
+ * underlying env object in-place - if you're inside a withEnv() scope, mutations
+ * affect the override object, not the base environment."
+ */
+export declare const env: Bindings;
+/**
+ * ← the `exports` proxy (`workers.ts:109-147`). Same indirection as `env`, minus
+ * the mutating traps — with `set` and `defineProperty` throwing where upstream
+ * lets them fall through to the dead proxy target.
+ */
+export declare const exports: Bindings;
+/** ← `withEnv` (`workers.ts:21-23`). */
+export declare function withEnv(newEnv: unknown, fn: () => unknown): unknown;
+/** ← `withExports` (`workers.ts:25-27`). */
+export declare function withExports(newExports: unknown, fn: () => unknown): unknown;
+/** ← `withEnvAndExports` (`workers.ts:29-34`). */
+export declare function withEnvAndExports(newEnv: unknown, newExports: unknown, fn: () => unknown): unknown;
+/**
+ * ← `RpcTarget` (`cloudflare/internal/workers.d.ts`: `export class RpcTarget {}`).
+ *
+ * Upstream's public type declares it `abstract` with one branding member; the
+ * implementation declaration has neither, and this follows the implementation so
+ * that a marker instance can exist. See this file's header for the identity
+ * constraint capnweb imposes on it.
+ */
+export declare class RpcTarget {
+}
+/**
+ * ← `DurableObject` (`cloudflare/internal/workers.d.ts`; public shape in
+ * `@cloudflare/workers-types`).
+ *
+ * `extends RpcTarget` is this runtime's, not upstream's: workerd's RPC system
+ * knows the three entrypoint classes natively through `Rpc.*Branded`, and
+ * capnweb recognises only `RpcTarget`. Same observable behaviour — an instance
+ * may be passed by reference over RPC — through the mechanism the substrate has.
+ *
+ * `ctx` and `env` are `protected` because that is what the published types say,
+ * and upstream's comment on `WorkerEntrypoint` says why it matters rather than
+ * being style: "`protected` fields don't appear in `keyof`s, so can't be accessed
+ * over RPC." The extension shim had them public.
+ */
+export declare class DurableObject<Env = unknown, Props = unknown> extends RpcTarget {
+    protected ctx: DurableObjectState<Props>;
+    protected env: Env;
+    constructor(ctx: DurableObjectState<Props>, env: Env);
+}
+/** ← `WorkerEntrypoint`. */
+export declare class WorkerEntrypoint<Env = unknown, Props = unknown> extends RpcTarget {
+    protected ctx: ExecutionContext<Props>;
+    protected env: Env;
+    constructor(ctx: ExecutionContext<Props>, env: Env);
+}
+/**
+ * ← `WorkflowEntrypoint`.
+ *
+ * The extension shim threw from the constructor. That throw is dropped: the class
+ * is a plain base whose `run` a Workflows binding dispatches, and there is no
+ * Workflows binding here — so the absent thing is the binding, which nothing in
+ * this package offers, rather than the base class. Constructing one and never
+ * dispatching it is what happens today either way, and a constructor that throws
+ * would take down module evaluation for a consumer that merely declares a
+ * subclass.
+ */
+export declare class WorkflowEntrypoint<Env = unknown, T = unknown> extends RpcTarget {
+    protected ctx: ExecutionContext;
+    protected env: Env;
+    constructor(ctx: ExecutionContext, env: Env);
+    run(_event: Readonly<WorkflowEvent<T>>, _step: WorkflowStep): Promise<unknown>;
+}
+/** ← `RpcStub`. */
+export declare class RpcStub {
+    constructor(_server: object);
+}
+/** ← `RpcPromise`. */
+export declare class RpcPromise {
+    constructor();
+}
+/** ← `RpcProperty`. */
+export declare class RpcProperty {
+    constructor();
+}
+/** ← `ServiceStub`. */
+export declare class ServiceStub {
+    constructor();
+}
+/** ← `export const waitUntil = entrypoints.waitUntil.bind(entrypoints)`. */
+export declare function waitUntil(_promise: Promise<unknown>): never;
+/** ← `abortIsolate` (`workers.ts:206-215`). */
+export declare function abortIsolate(_reason?: string): never;
+export declare const cache: CacheContext;
+export declare const tracing: Tracing;
+/**
+ * `@cloudflare/workers-types` also declares these two globally, and this module
+ * declares its own for the reason upstream's module does: `export type {}` needs
+ * a local declaration, and the module is where the names belong.
+ */
+export type WorkflowDurationLabel = "second" | "minute" | "hour" | "day" | "week" | "month" | "year";
+export type WorkflowSleepDuration = `${number} ${WorkflowDurationLabel}${"s" | ""}` | number;
+export type WorkflowRetentionDuration = WorkflowSleepDuration;
+export type WorkflowDelayDuration = WorkflowSleepDuration;
+export type WorkflowTimeoutDuration = WorkflowSleepDuration;
+export type WorkflowBackoff = "constant" | "linear" | "exponential";
+export type WorkflowStepSensitivity = "output";
+export type WorkflowStepConfig = {
+    retries?: {
+        limit: number;
+        delay: WorkflowDelayDuration | number;
+        backoff?: WorkflowBackoff;
+    };
+    timeout?: WorkflowTimeoutDuration | number;
+    sensitive?: WorkflowStepSensitivity;
+};
+export type WorkflowStepRollbackConfig = Pick<WorkflowStepConfig, "retries" | "timeout">;
+export type WorkflowCronSchedule = {
+    /** Cron expression that triggered this event. */
+    cron: string;
+    /** Timestamp of the scheduled trigger, in milliseconds since the Unix epoch. */
+    scheduledTime: number;
+};
+export type WorkflowEvent<T> = {
+    payload: Readonly<T>;
+    timestamp: Date;
+    instanceId: string;
+    workflowName: string;
+    schedule?: WorkflowCronSchedule;
+};
+export type WorkflowStepEvent<T> = {
+    payload: Readonly<T>;
+    timestamp: Date;
+    type: string;
+    sensitive?: WorkflowStepSensitivity;
+};
+export type WorkflowStepContext = {
+    step: {
+        name: string;
+        count: number;
+    };
+    attempt: number;
+    config: WorkflowStepConfig;
+};
+export type WorkflowRollbackContext<T = unknown> = {
+    ctx: WorkflowStepContext;
+    error: Error;
+    output: T | undefined;
+    /** @deprecated Use `ctx.step.name` and `ctx.step.count` instead. */
+    stepName: string;
+};
+export type WorkflowRollbackHandler<T = unknown> = (ctx: WorkflowRollbackContext<T>) => Promise<void>;
+export type WorkflowStepRollbackOptions<T = unknown> = {
+    rollback: WorkflowRollbackHandler<T>;
+    rollbackConfig?: WorkflowStepRollbackConfig;
+};
+/**
+ * ← `WorkflowStep`, an abstract class in the module declaration. Declared and
+ * never implemented here for the same reason `WorkflowEntrypoint.run` throws: a
+ * `WorkflowStep` is handed to `run()` by a Workflows binding, and there is none.
+ */
+export declare abstract class WorkflowStep {
+    do<T>(name: string, callback: (ctx: WorkflowStepContext) => Promise<T>, rollbackOptions?: WorkflowStepRollbackOptions<T>): Promise<T>;
+    do<T>(name: string, config: WorkflowStepConfig, callback: (ctx: WorkflowStepContext) => Promise<T>, rollbackOptions?: WorkflowStepRollbackOptions<T>): Promise<T>;
+    sleep: (name: string, duration: WorkflowSleepDuration) => Promise<void>;
+    sleepUntil: (name: string, timestamp: Date | number) => Promise<void>;
+    waitForEvent<T>(name: string, options: {
+        type: string;
+        timeout?: WorkflowTimeoutDuration | number;
+    }): Promise<WorkflowStepEvent<T>>;
+}
+export type WorkflowInstanceStatus = "queued" | "running" | "paused" | "errored" | "terminated" | "complete" | "waiting" | "waitingForPause" | "unknown";