rivetkit 2.3.18 → 2.3.20

package/dist/browser/client.d.ts

@@ -339,6 +339,29 @@ declare class UserError extends RivetError {
     constructor(message: string, options?: UserErrorOptions);
 }
 
+/** Sample rates keyed by action name, nested like the actor's action groups. */
+interface ActionSampleRates {
+    readonly [name: string]: number | ActionSampleRates;
+}
+/**
+ * {@link ActionSampleRates} limited to the actions of one actor, so a rate for
+ * an action that does not exist is a compile error.
+ */
+type ActionTraceSamplers<TActions> = {
+    readonly [K in keyof TActions]?: TActions[K] extends (...args: never[]) => unknown ? number : ActionTraceSamplers<TActions[K]>;
+};
+/** Trace sampling for one actor definition. */
+interface ActorTracingOptions<TActions> {
+    /**
+     * Share of this actor's invocations that are recorded, from 0 to 1. A rate
+     * lowers what is recorded and never raises it, so an invocation inside a
+     * trace the caller did not record is not recorded at any rate.
+     */
+    readonly sampler?: number;
+    /** Rates that replace `sampler` for single actions. */
+    readonly actions?: ActionTraceSamplers<TActions>;
+}
+
 type UpgradeWebSocket = (createEvents: (c: Context) => any) => Handler;
 type GetUpgradeWebSocket = () => UpgradeWebSocket;
 
@@ -420,216 +443,714 @@ interface ActorOutput {
     error?: unknown;
 }
 
-interface QueueSendWaitOptions {
-    wait: true;
-    timeout?: number;
-    signal?: AbortSignal;
-}
-interface QueueSendNoWaitOptions {
-    wait?: false;
-    timeout?: never;
-    signal?: AbortSignal;
-}
-interface QueueSendResult<TResponse = unknown> {
-    status: "completed" | "timedOut";
-    response?: TResponse;
+/** Correlation owned by the currently executing Core actor invocation. */
+interface ActorInvocationTraceContext {
+    /** Ray ID the invocation received, absent when nothing upstream supplied one. */
+    readonly rayId?: string;
+    /** Core-owned invocation span context, absent when tracing is disabled. */
+    readonly span?: ActorInvocationSpanContext;
+}
+/** W3C span context of the Core invocation span. */
+interface ActorInvocationSpanContext {
+    /** W3C trace identifier. */
+    readonly traceId: string;
+    /** W3C span identifier for the Core invocation. */
+    readonly spanId: string;
+    /** OpenTelemetry trace flags encoded as an integer. */
+    readonly traceFlags: number;
+    /** Optional vendor trace state inherited by the Core invocation. */
+    readonly tracestate?: string;
 }
 
-/**
- * Action function returned by Actor connections and handles.
- *
- * @typedef {Function} ActorActionFunction
- * @template Args
- * @template Response
- * @param {...Args} args - Arguments for the action function.
- * @returns {Promise<Response>}
- */
-type ActorActionFunction<Args extends Array<unknown> = unknown[], Response = unknown> = (...args: Args extends [unknown, ...infer Rest] ? Rest : Args) => Promise<Response>;
-type IsAny<T> = 0 extends 1 & T ? true : false;
-type LooseEventSubscribe = (eventName: string, callback: (...args: any[]) => void) => () => void;
-type ActorActionMap<R> = {
-    [K in keyof NonNullable<R>]: NonNullable<R>[K] extends (...args: infer Args) => infer Return ? ActorActionFunction<Args, Awaited<Return>> : NonNullable<R>[K] extends Record<string, unknown> ? ActorActionMap<NonNullable<R>[K]> : never;
+declare const handleBrand: unique symbol;
+type OpaqueHandle<Name extends string> = {
+    readonly [handleBrand]: Name;
 };
-type ActionsOf<AD extends AnyActorDefinition> = AD["config"] extends {
-    actions?: infer R;
-} ? R : never;
-interface ActorGatewayOptions {
-    skipReadyWait?: boolean;
+type RegistryHandle = OpaqueHandle<"registry">;
+type ActorFactoryHandle = OpaqueHandle<"actorFactory">;
+type ActorContextHandle = OpaqueHandle<"actorContext">;
+type ConnHandle = OpaqueHandle<"conn">;
+type WebSocketHandle = OpaqueHandle<"webSocket">;
+type CancellationTokenHandle = OpaqueHandle<"cancellationToken">;
+type ActorStateTransactionHandle = OpaqueHandle<"actorStateTransaction">;
+type SqliteTransactionHandle = OpaqueHandle<"sqliteTransaction">;
+type RuntimeBytes = Uint8Array;
+interface RuntimeActorKeySegment {
+    kind: string;
+    stringValue?: string;
+    numberValue?: number;
 }
-interface ActorActionOptions extends ActorGatewayOptions {
-    signal?: AbortSignal;
+/** Resolves correlation at operation time so retained clients cannot freeze stale context. */
+type CurrentActorInvocation = () => ActorInvocationTraceContext | undefined;
+/** One open call from an actor out to another actor. */
+interface RuntimeOutboundCall {
+    /**
+     * W3C context of the call's own span, to send to the callee so it parents to
+     * the call. Absent when tracing is disabled.
+     */
+    readonly span?: ActorInvocationSpanContext;
+    /**
+     * Records the call's outcome. `error` is the failure encoded the way the
+     * bridge encodes errors, so a structured error keeps its group and code.
+     */
+    finish(error?: string): void;
 }
-type ActorConnectOptions = ActorGatewayOptions;
-type ActorFetchInit = RequestInit & ActorGatewayOptions;
-type ActorWebSocketOptions = ActorGatewayOptions;
 /**
- * Maps action methods from actor definition to typed function signatures.
+ * Opens the span covering one call out to another actor, or returns `undefined`
+ * outside an invocation or on a runtime without invocation telemetry. Callers
+ * send their own context when it returns nothing.
  */
-type ActorDefinitionActions<AD extends AnyActorDefinition> = IsAny<AD> extends true ? Record<string, ActorActionFunction<any[], any>> : ActorActionMap<ActionsOf<AD>>;
-type ActorQueueSend<TQueues extends QueueSchemaConfig> = {
-    <K extends keyof TQueues & string>(name: K, body: InferSchemaMap<TQueues>[K], options: QueueSendWaitOptions): Promise<QueueSendResult<InferQueueCompleteMap<TQueues>[K]>>;
-    <K extends keyof TQueues & string>(name: K, body: InferSchemaMap<TQueues>[K], options?: QueueSendNoWaitOptions): Promise<void>;
-    (name: keyof TQueues extends never ? string : never, body: unknown, options: QueueSendWaitOptions): Promise<QueueSendResult>;
-    (name: keyof TQueues extends never ? string : never, body: unknown, options?: QueueSendNoWaitOptions): Promise<void>;
+type StartCallSpan = (actorName: string, actionName: string) => RuntimeOutboundCall | undefined;
+interface RuntimeHttpRequest {
+    method: string;
+    uri: string;
+    headers?: Record<string, string>;
+    body?: RuntimeBytes;
+}
+interface RuntimeHttpResponseBodyStream {
+    cancelled(): Promise<void>;
+    write(chunk: Uint8Array): Promise<void>;
+    end(): Promise<void>;
+    error(message: string): Promise<void>;
+}
+interface RuntimeStateDeltaPayload {
+    state?: RuntimeBytes;
+    connHibernation: Array<{
+        connId: string;
+        bytes: RuntimeBytes;
+    }>;
+    connHibernationRemoved: string[];
+}
+interface RuntimeWorkflowKvWrite {
+    key: RuntimeBytes;
+    value: RuntimeBytes;
+}
+interface RuntimeRequestSaveOpts {
+    immediate?: boolean;
+    maxWaitMs?: number;
+}
+interface RuntimeInspectorSnapshot {
+    stateRevision: number;
+    connectionsRevision: number;
+    queueRevision: number;
+    activeConnections: number;
+    queueSize: number;
+    connectedClients: number;
+}
+interface RuntimeQueueMessage {
+    id(): bigint;
+    name(): string;
+    body(): RuntimeBytes;
+    createdAt(): number;
+    isCompletable(): boolean;
+    complete(response?: RuntimeBytes | undefined | null): Promise<void>;
+}
+interface RuntimeQueueInspectMessage {
+    id: number;
+    name: string;
+    createdAtMs: number;
+}
+interface RuntimeScheduledEventInfo {
+    id: string;
+    action: string;
+    args: RuntimeBytes;
+    runAt: number;
+}
+interface RuntimeCronJobInfo {
+    name: string;
+    kind: "cron" | "every";
+    action: string;
+    args: RuntimeBytes;
+    nextRunAt: number;
+    lastRunAt?: number;
+    expression?: string;
+    timezone?: string;
+    intervalMs?: number;
+    maxHistory: number;
+}
+interface RuntimeScheduleErrorInfo {
+    group: string;
+    code: string;
+    message: string;
+    metadata?: unknown;
+}
+interface RuntimeCronFire {
+    action: string;
+    scheduledAt: number;
+    firedAt: number;
+    finishedAt?: number;
+    result: "running" | "ok" | "error" | "skipped";
+    error?: RuntimeScheduleErrorInfo;
+}
+interface RuntimeQueueNextBatchOptions {
+    names?: string[];
+    count?: number;
+    timeoutMs?: number;
+    completable?: boolean;
+}
+interface RuntimeQueueWaitOptions {
+    timeoutMs?: number;
+    completable?: boolean;
+}
+interface RuntimeQueueEnqueueAndWaitOptions {
+    timeoutMs?: number;
+}
+interface RuntimeQueueTryNextBatchOptions {
+    names?: string[];
+    count?: number;
+    completable?: boolean;
+}
+interface RuntimeKvListOptions {
+    reverse?: boolean;
+    limit?: number;
+}
+interface RuntimeKvEntry {
+    key: RuntimeBytes;
+    value: RuntimeBytes;
+}
+type RuntimeSqlBindNoValues = {
+    intValue?: never;
+    floatValue?: never;
+    textValue?: never;
+    blobValue?: never;
 };
-type ActorEventSubscribe<TEvents extends EventSchemaConfig> = {
-    <K extends keyof TEvents & string>(eventName: K, callback: (...args: InferEventArgs<InferSchemaMap<TEvents>[K]>) => void): () => void;
-    (eventName: keyof TEvents extends never ? string : never, callback: (...args: any[]) => void): () => void;
+type RuntimeSqlBindParam = ({
+    kind: "null";
+} & RuntimeSqlBindNoValues) | {
+    kind: "int";
+    intValue: number;
+    floatValue?: never;
+    textValue?: never;
+    blobValue?: never;
+} | {
+    kind: "float";
+    intValue?: never;
+    floatValue: number;
+    textValue?: never;
+    blobValue?: never;
+} | {
+    kind: "text";
+    intValue?: never;
+    floatValue?: never;
+    textValue: string;
+    blobValue?: never;
+} | {
+    kind: "blob";
+    intValue?: never;
+    floatValue?: never;
+    textValue?: never;
+    blobValue: RuntimeBytes;
 };
-type ActorDefinitionQueueSend<AD extends AnyActorDefinition> = IsAny<AD> extends true ? {
-    send: ActorQueueSend<Record<string, any>>;
-} : AD extends {
-    config: {
-        queues?: infer Q;
-    };
-} ? Q extends QueueSchemaConfig ? {
-    send: ActorQueueSend<Q>;
-} : {} : AD extends BaseActorDefinition<any, any, any, any, any, any, any, infer Q, any> ? Q extends QueueSchemaConfig ? {
-    send: ActorQueueSend<Q>;
-} : {} : {};
-type ActorDefinitionEventSubscriptions<AD extends AnyActorDefinition> = IsAny<AD> extends true ? {
-    on: LooseEventSubscribe;
-    once: LooseEventSubscribe;
-} : AD extends {
-    config: {
-        events?: infer E;
-    };
-} ? E extends EventSchemaConfig ? {
-    on: ActorEventSubscribe<E>;
-    once: ActorEventSubscribe<E>;
-} : {} : AD extends BaseActorDefinition<any, any, any, any, any, any, infer E, any, any> ? E extends EventSchemaConfig ? {
-    on: ActorEventSubscribe<E>;
-    once: ActorEventSubscribe<E>;
-} : {} : {};
-
-declare class ActorClientError extends Error {
+type RuntimeSqlBindParams = RuntimeSqlBindParam[] | null;
+interface RuntimeActorRuntimeSocketEndpointInfo {
+    path: string;
 }
-declare class ManagerError extends ActorClientError {
-    constructor(error: string, opts?: ErrorOptions);
+interface RuntimeSqlQueryResult {
+    columns: string[];
+    rows: unknown[][];
 }
-declare class MalformedResponseMessage extends ActorClientError {
-    constructor(cause?: unknown);
+type RuntimeSqlExecResult = RuntimeSqlQueryResult;
+interface RuntimeSqlExecuteResult extends RuntimeSqlQueryResult {
+    changes: number;
+    lastInsertRowId?: number | null;
 }
-
-declare class ActorConnDisposed extends ActorClientError {
-    constructor();
+interface RuntimeSqlBatchStatement {
+    sql: string;
+    params?: RuntimeSqlBindParams;
 }
-
-type ActorResolutionState = ActorQuery;
-
-/**
- * Connection status for an actor connection.
- *
- * - `"idle"`: Not connected, no auto-reconnect (initial state, after dispose, or disabled)
- * - `"connecting"`: Attempting to establish connection
- * - `"connected"`: Connection is active
- * - `"disconnected"`: Connection was lost, will auto-reconnect
- */
-type ActorConnStatus = "idle" | "connecting" | "connected" | "disconnected";
-/**
- * A function that unsubscribes from an event.
- *
- * @typedef {Function} EventUnsubscribe
- */
-type EventUnsubscribe = () => void;
-/**
- * A function that handles connection errors.
- *
- * @typedef {Function} ActorErrorCallback
- */
-type ActorErrorCallback = (error: RivetError) => void;
-/**
- * A callback for connection state changes.
- *
- * @typedef {Function} ConnectionStateCallback
- */
-type ConnectionStateCallback = () => void;
-/**
- * A callback for connection status changes.
- *
- * @typedef {Function} StatusChangeCallback
- */
-type StatusChangeCallback = (status: ActorConnStatus) => void;
-declare const CONNECT_SYMBOL: unique symbol;
-/**
- * Provides underlying functions for {@link ActorConn}. See {@link ActorConn} for using type-safe remote procedure calls.
- *
- * @see {@link ActorConn}
- */
-declare class ActorConnRaw {
-    #private;
+interface RuntimeSqlRunResult {
+    changes: number;
+}
+/** Sample rates for the traces an actor starts, in the shape core takes. */
+interface RuntimeActorTracingConfig {
+    sampler?: number;
+    /** Keyed by flattened, dot-separated action name. */
+    actions?: Record<string, number>;
+}
+interface RuntimeActorConfig {
+    name?: string;
+    icon?: string;
+    hasDatabase?: boolean;
+    remoteSqlite?: boolean;
+    sqliteProfiling?: SqliteProfilingOptions;
+    tracing?: RuntimeActorTracingConfig;
+    enableActorRuntimeSocket?: boolean;
+    hasState?: boolean;
+    canHibernateWebsocket?: boolean;
+    stateSaveIntervalMs?: number;
+    createStateTimeoutMs?: number;
+    onCreateTimeoutMs?: number;
+    createVarsTimeoutMs?: number;
+    createConnStateTimeoutMs?: number;
+    onBeforeConnectTimeoutMs?: number;
+    onConnectTimeoutMs?: number;
+    onMigrateTimeoutMs?: number;
+    onWakeTimeoutMs?: number;
+    onBeforeActorStartTimeoutMs?: number;
+    actionTimeoutMs?: number;
+    onRequestTimeoutMs?: number;
+    sleepTimeoutMs?: number;
+    noSleep?: boolean;
+    sleepGracePeriodMs?: number;
+    connectionLivenessTimeoutMs?: number;
+    connectionLivenessIntervalMs?: number;
+    maxQueueSize?: number;
+    maxSchedules?: number;
+    maxQueueMessageSize?: number;
+    maxIncomingMessageSize?: number;
+    maxOutgoingMessageSize?: number;
+    preloadMaxWorkflowBytes?: number;
+    preloadMaxConnectionsBytes?: number;
+    actions?: Array<{
+        name: string;
+    }>;
+    inspectorTabs?: Array<RuntimeInspectorTabEntry>;
+}
+interface RuntimeInspectorTabEntry {
+    id: string;
+    /** Required for custom entries; omitted for built-in hides. */
+    label?: string;
     /**
-     * Do not call this directly.
-     *
-     * Creates an instance of ActorConnRaw.
-     *
-     * @protected
+     * Required for custom entries — absolute path to the source directory.
+     * Resolved on the TS side before being handed to the runtime.
      */
-    constructor(client: ClientRaw, driver: EngineControlClient, params: unknown, getParams: (() => Promise<unknown>) | undefined, encoding: Encoding, actorResolutionState: ActorResolutionState, gatewayOptions?: ActorGatewayOptions);
-    send(name: string, body: unknown, options: QueueSendWaitOptions): Promise<QueueSendResult>;
-    send(name: string, body: unknown, options?: QueueSendNoWaitOptions): Promise<void>;
+    source?: string;
+    /** Optional icon id for custom entries. */
+    icon?: string;
+    /** Set to true for built-in hide entries. */
+    hidden?: boolean;
+}
+interface RuntimeServeConfig {
+    version: number;
+    endpoint: string;
+    token?: string;
+    namespace: string;
+    poolName: string;
+    engineBinaryPath?: string;
+    startServices?: boolean;
+    servicesBinaryPath?: string;
+    engineHost?: string;
+    enginePort?: number;
+    handleInspectorHttpInRuntime?: boolean;
+    inspectorTestToken?: string;
+    serverlessBasePath?: string;
+    serverlessPackageVersion: string;
+    serverlessClientEndpoint?: string;
+    serverlessClientNamespace?: string;
+    serverlessClientToken?: string;
+    serverlessValidateEndpoint: boolean;
+    serverlessMaxStartPayloadBytes: number;
+}
+interface RuntimeListenerConfig {
+    port: number;
+    host?: string;
+    publicDir?: string;
+    application?: RuntimeApplicationFetch;
+}
+interface RuntimeServerlessRequest {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body: RuntimeBytes;
+}
+interface RuntimeApplicationRequest extends RuntimeServerlessRequest {
+    cancelToken?: CancellationTokenHandle;
+}
+interface RuntimeApplicationResponse {
+    status: number;
+    headers: Record<string, string>;
+    body?: RuntimeBytes;
+    stream?: boolean;
+}
+type RuntimeApplicationFetch = (request: RuntimeApplicationRequest, responseBodyStream?: RuntimeHttpResponseBodyStream) => Promise<RuntimeApplicationResponse>;
+interface RuntimeApplicationListenerConfig extends RuntimeListenerConfig {
+    application: RuntimeApplicationFetch;
+}
+interface RuntimeServerlessResponseHead {
+    status: number;
+    headers: Record<string, string>;
+}
+interface RuntimeRegistryRouteResponse {
+    status: number;
+    headers: Record<string, string>;
+    body: RuntimeBytes;
+}
+type RuntimeServerlessStreamEvent = {
+    kind: "chunk";
+    chunk?: RuntimeBytes;
+} | {
+    kind: "end";
+    error?: {
+        group: string;
+        code: string;
+        message: string;
+    };
+};
+type RuntimeServerlessStreamCallback = (error: unknown, event?: RuntimeServerlessStreamEvent) => unknown;
+type RuntimeWebSocketEvent = {
+    kind: "message";
+    data: string | RuntimeBytes;
+    binary: boolean;
+    messageIndex?: number;
+} | {
+    kind: "close";
+    code: number;
+    reason: string;
+    wasClean: boolean;
+};
+interface CoreRuntime {
+    readonly kind: "napi" | "wasm";
+    createRegistry(): RegistryHandle;
+    registerActor(registry: RegistryHandle, name: string, factory: ActorFactoryHandle): void;
+    serveRegistry(registry: RegistryHandle, config: RuntimeServeConfig): Promise<void>;
+    waitRegistryReady(registry: RegistryHandle): Promise<void>;
+    shutdownRegistry(registry: RegistryHandle): Promise<void>;
+    shutdownTelemetry?(): Promise<void>;
+    registryActorStopThresholdMs?(registry: RegistryHandle): Promise<number | undefined>;
+    handleServerlessRequest(registry: RegistryHandle, req: RuntimeServerlessRequest, onStreamEvent: RuntimeServerlessStreamCallback, cancelToken: CancellationTokenHandle, config: RuntimeServeConfig): Promise<RuntimeServerlessResponseHead>;
+    serveListener(registry: RegistryHandle, listener: RuntimeListenerConfig, config: RuntimeServeConfig): Promise<void>;
+    serveApplicationListener(registry: RegistryHandle, listener: RuntimeApplicationListenerConfig, config: RuntimeServeConfig): Promise<void>;
+    registryHealth?(registry: RegistryHandle): Promise<RuntimeRegistryRouteResponse>;
+    registryMetadata?(registry: RegistryHandle): Promise<RuntimeRegistryRouteResponse>;
+    registryMetrics?(registry: RegistryHandle): Promise<RuntimeRegistryRouteResponse>;
+    createActorFactory(callbacks: object, config?: RuntimeActorConfig | undefined | null): ActorFactoryHandle;
+    createCancellationToken(): CancellationTokenHandle;
+    cancellationTokenAborted(token: CancellationTokenHandle): boolean;
+    cancelCancellationToken(token: CancellationTokenHandle): void;
+    onCancellationTokenCancelled(token: CancellationTokenHandle, callback: (...args: unknown[]) => unknown): void;
+    actorState(ctx: ActorContextHandle): RuntimeBytes;
+    actorBeginOnStateChange(ctx: ActorContextHandle): void;
+    actorEndOnStateChange(ctx: ActorContextHandle): void;
+    actorSetAlarm(ctx: ActorContextHandle, timestampMs?: number | undefined | null): void;
+    actorSetRunWakeAt(ctx: ActorContextHandle, timestampMs?: number | undefined | null): Promise<void>;
+    actorRequestSave(ctx: ActorContextHandle, opts?: RuntimeRequestSaveOpts | undefined | null): void;
+    actorRequestSaveAndWait(ctx: ActorContextHandle, opts?: RuntimeRequestSaveOpts | undefined | null): Promise<void>;
+    actorInspectorSnapshot(ctx: ActorContextHandle): RuntimeInspectorSnapshot;
+    actorDecodeInspectorRequest(ctx: ActorContextHandle, bytes: RuntimeBytes, advertisedVersion: number): RuntimeBytes;
+    actorEncodeInspectorResponse(ctx: ActorContextHandle, bytes: RuntimeBytes, targetVersion: number): RuntimeBytes;
+    actorVerifyInspectorAuth(ctx: ActorContextHandle, bearerToken?: string | undefined | null): Promise<void>;
+    actorQueueHibernationRemoval(ctx: ActorContextHandle, connId: string): void;
+    actorTakePendingHibernationChanges(ctx: ActorContextHandle): string[];
+    actorDirtyHibernatableConns(ctx: ActorContextHandle): ConnHandle[];
+    actorSaveState(ctx: ActorContextHandle, payload: RuntimeStateDeltaPayload): Promise<void>;
+    actorSaveStateAndWorkflowBatch(ctx: ActorContextHandle, writes: RuntimeWorkflowKvWrite[]): Promise<void>;
+    actorId(ctx: ActorContextHandle): string;
     /**
-     * Call a raw action connection. See {@link ActorConn} for type-safe action calls.
-     *
-     * @see {@link ActorConn}
-     * @template Args - The type of arguments to pass to the action function.
-     * @template Response - The type of the response returned by the action function.
-     * @param {string} name - The name of the action function to call.
-     * @param {...Args} args - The arguments to pass to the action function.
-     * @returns {Promise<Response>} - A promise that resolves to the response of the action function.
+     * Runs one actor callback with `ctx` as the current invocation: operations
+     * on retained handles for the same actor resolve to it, and its Core span
+     * is the active OpenTelemetry span for the duration of `run`. Only actions,
+     * raw requests, and queue dispatch run this way; other callbacks have no
+     * invocation span.
      */
-    action<Args extends Array<unknown> = unknown[], Response = unknown>(opts: {
-        name: string;
-        args: Args;
-        signal?: AbortSignal;
-    }): Promise<Response>;
+    runWithActorInvocationContext<T>(ctx: ActorContextHandle, run: () => T): T;
     /**
-     * Do not call this directly.
-     * Establishes a connection to the server using the specified endpoint & encoding & driver.
-     *
-     * @protected
+     * Correlation of the invocation currently executing for this actor, or
+     * `undefined` outside an invocation or after it finished. A sampled-out
+     * invocation can still expose valid span context for propagation.
      */
-    [CONNECT_SYMBOL](): void;
+    actorInvocationTraceContext(ctx: ActorContextHandle): ActorInvocationTraceContext | undefined;
     /**
-     * Subscribes to an event that will happen repeatedly.
-     *
-     * @template Args - The type of arguments the event callback will receive.
-     * @param {string} eventName - The name of the event to subscribe to.
-     * @param {(...args: Args) => void} callback - The callback function to execute when the event is triggered.
-     * @returns {EventUnsubscribe} - A function to unsubscribe from the event.
-     * @see {@link https://rivet.dev/docs/events|Events Documentation}
+     * Opens the span covering one call this actor makes to another actor. See
+     * `StartCallSpan` for when this returns nothing.
      */
-    on<Args extends Array<unknown> = unknown[]>(eventName: string, callback: (...args: Args) => void): EventUnsubscribe;
-    /**
-     * Subscribes to an event that will be triggered only once.
-     *
-     * @template Args - The type of arguments the event callback will receive.
-     * @param {string} eventName - The name of the event to subscribe to.
-     * @param {(...args: Args) => void} callback - The callback function to execute when the event is triggered.
-     * @returns {EventUnsubscribe} - A function to unsubscribe from the event.
-     * @see {@link https://rivet.dev/docs/events|Events Documentation}
-     */
-    once<Args extends Array<unknown> = unknown[]>(eventName: string, callback: (...args: Args) => void): EventUnsubscribe;
+    startCallSpan(ctx: ActorContextHandle, actorName: string, actionName: string): RuntimeOutboundCall | undefined;
+    /** Backs `ActorRun.startWorkflowSpan`. */
+    startWorkflowSpan(ctx: ActorContextHandle): Promise<WorkflowSpan>;
+    /** Backs `ActorRun.runOutsideWorkflowSpan`. */
+    runOutsideActorInvocationContext<T>(run: () => T): T;
+    /** Identity of the invocation the caller runs in, usable as a cache key. */
+    currentInvocationScope(): object | undefined;
+    actorName(ctx: ActorContextHandle): string;
+    actorKey(ctx: ActorContextHandle): RuntimeActorKeySegment[];
+    actorRegion(ctx: ActorContextHandle): string;
+    actorSleep(ctx: ActorContextHandle): void;
+    actorDestroy(ctx: ActorContextHandle): void;
+    actorAbortSignal(ctx: ActorContextHandle): AbortSignal;
+    actorConns(ctx: ActorContextHandle): ConnHandle[];
+    actorConnectConn(ctx: ActorContextHandle, params: RuntimeBytes, request?: RuntimeHttpRequest | undefined | null): Promise<ConnHandle>;
+    actorBroadcast(ctx: ActorContextHandle, name: string, args: RuntimeBytes): void;
+    actorWaitUntil(ctx: ActorContextHandle, promise: Promise<unknown>): void;
+    actorWaitForTrackedShutdownWork(ctx: ActorContextHandle): Promise<boolean>;
+    actorWaitForTrackedShutdownWorkUnbounded(ctx: ActorContextHandle): Promise<void>;
+    actorKeepAwake(ctx: ActorContextHandle, promise: Promise<unknown>): void;
+    actorBeginKeepAwake(ctx: ActorContextHandle): number;
+    actorEndKeepAwake(ctx: ActorContextHandle, regionId: number): void;
+    actorRegisterTask(ctx: ActorContextHandle, promise: Promise<unknown>): void;
+    actorRuntimeState(ctx: ActorContextHandle): object;
+    actorClearRuntimeState(ctx: ActorContextHandle): void;
+    actorRestartRunHandler(ctx: ActorContextHandle): void;
+    actorBeginWebsocketCallback(ctx: ActorContextHandle): number;
+    actorEndWebsocketCallback(ctx: ActorContextHandle, regionId: number): void;
+    actorKvGet(ctx: ActorContextHandle, key: RuntimeBytes): Promise<RuntimeBytes | null>;
+    actorKvPut(ctx: ActorContextHandle, key: RuntimeBytes, value: RuntimeBytes): Promise<void>;
+    actorKvDelete(ctx: ActorContextHandle, key: RuntimeBytes): Promise<void>;
+    actorKvDeleteRange(ctx: ActorContextHandle, start: RuntimeBytes, end: RuntimeBytes): Promise<void>;
+    actorKvListPrefix(ctx: ActorContextHandle, prefix: RuntimeBytes, options?: RuntimeKvListOptions | undefined | null): Promise<RuntimeKvEntry[]>;
+    actorKvListRange(ctx: ActorContextHandle, start: RuntimeBytes, end: RuntimeBytes, options?: RuntimeKvListOptions | undefined | null): Promise<RuntimeKvEntry[]>;
+    actorKvBatchGet(ctx: ActorContextHandle, keys: RuntimeBytes[]): Promise<Array<RuntimeBytes | undefined | null>>;
+    actorKvBatchPut(ctx: ActorContextHandle, entries: RuntimeKvEntry[]): Promise<void>;
+    actorKvBatchDelete(ctx: ActorContextHandle, keys: RuntimeBytes[]): Promise<void>;
+    actorSqlExec(ctx: ActorContextHandle, sql: string): Promise<RuntimeSqlExecResult>;
+    actorSqlExecute(ctx: ActorContextHandle, sql: string, params?: RuntimeSqlBindParams): Promise<RuntimeSqlExecuteResult>;
+    actorSqlExecuteBatch(ctx: ActorContextHandle, statements: RuntimeSqlBatchStatement[]): Promise<RuntimeSqlExecuteResult[]>;
+    actorSqlBeginTransaction(ctx: ActorContextHandle, timeoutMs?: number, name?: string): Promise<SqliteTransactionHandle>;
+    actorSqlTransactionExec(transaction: SqliteTransactionHandle, sql: string): Promise<RuntimeSqlExecResult>;
+    actorSqlTransactionExecute(transaction: SqliteTransactionHandle, sql: string, params?: RuntimeSqlBindParams): Promise<RuntimeSqlExecuteResult>;
+    actorSqlTransactionCommit(transaction: SqliteTransactionHandle): Promise<void>;
+    actorSqlTransactionRollback(transaction: SqliteTransactionHandle): Promise<void>;
+    actorBeginStateTransaction(ctx: ActorContextHandle, timeoutMs?: number): Promise<ActorStateTransactionHandle>;
+    actorStateTransactionExecute(transaction: ActorStateTransactionHandle, sql: string, params?: RuntimeSqlBindParams): Promise<RuntimeSqlExecuteResult>;
+    actorStateTransactionCommit(transaction: ActorStateTransactionHandle, payload: RuntimeStateDeltaPayload): Promise<void>;
+    actorStateTransactionRollback(transaction: ActorStateTransactionHandle): Promise<void>;
+    actorSqlQuery(ctx: ActorContextHandle, sql: string, params?: RuntimeSqlBindParams): Promise<RuntimeSqlQueryResult>;
+    actorSqlRun(ctx: ActorContextHandle, sql: string, params?: RuntimeSqlBindParams): Promise<RuntimeSqlRunResult>;
+    actorSqlMetrics(ctx: ActorContextHandle): SqliteNativeMetrics | null;
+    actorSqlTakeLastKvError(ctx: ActorContextHandle): string | null;
+    actorSqlClose(ctx: ActorContextHandle): Promise<void>;
+    actorRuntimeSocketProvision(ctx: ActorContextHandle): Promise<RuntimeActorRuntimeSocketEndpointInfo>;
+    actorQueueSend(ctx: ActorContextHandle, name: string, body: RuntimeBytes): Promise<RuntimeQueueMessage>;
+    actorQueueNextBatch(ctx: ActorContextHandle, options?: RuntimeQueueNextBatchOptions | undefined | null, signal?: CancellationTokenHandle | undefined | null): Promise<RuntimeQueueMessage[]>;
+    actorQueueWaitForNames(ctx: ActorContextHandle, names: string[], options?: RuntimeQueueWaitOptions | undefined | null, signal?: CancellationTokenHandle | undefined | null): Promise<RuntimeQueueMessage>;
+    actorQueueWaitForNamesAvailable(ctx: ActorContextHandle, names: string[], options?: RuntimeQueueWaitOptions | undefined | null, signal?: CancellationTokenHandle | undefined | null): Promise<void>;
+    actorQueueCompletePersisted(ctx: ActorContextHandle, messageId: bigint, expectedName: string, response?: RuntimeBytes | undefined | null): Promise<boolean>;
+    actorQueueEnqueueAndWait(ctx: ActorContextHandle, name: string, body: RuntimeBytes, options?: RuntimeQueueEnqueueAndWaitOptions | undefined | null, signal?: CancellationTokenHandle | undefined | null): Promise<RuntimeBytes | null>;
+    actorQueueTryNextBatch(ctx: ActorContextHandle, options?: RuntimeQueueTryNextBatchOptions | undefined | null): RuntimeQueueMessage[];
+    actorQueueMaxSize(ctx: ActorContextHandle): number;
+    actorQueueInspectMessages(ctx: ActorContextHandle): Promise<RuntimeQueueInspectMessage[]>;
+    actorQueueReset(ctx: ActorContextHandle): Promise<void>;
+    actorScheduleAfter(ctx: ActorContextHandle, durationMs: number, actionName: string, args: RuntimeBytes): Promise<string>;
+    actorScheduleAt(ctx: ActorContextHandle, timestampMs: number, actionName: string, args: RuntimeBytes): Promise<string>;
+    actorScheduleCancel(ctx: ActorContextHandle, id: string): Promise<boolean>;
+    actorScheduleGet(ctx: ActorContextHandle, id: string): Promise<RuntimeScheduledEventInfo | undefined>;
+    actorScheduleList(ctx: ActorContextHandle): Promise<RuntimeScheduledEventInfo[]>;
+    actorCronSet(ctx: ActorContextHandle, name: string, expression: string, timezone: string | undefined, actionName: string, args: RuntimeBytes, maxHistory: number | undefined): Promise<void>;
+    actorCronEvery(ctx: ActorContextHandle, name: string, intervalMs: number, actionName: string, args: RuntimeBytes, maxHistory: number | undefined): Promise<void>;
+    actorCronGet(ctx: ActorContextHandle, name: string): Promise<RuntimeCronJobInfo | undefined>;
+    actorCronList(ctx: ActorContextHandle): Promise<RuntimeCronJobInfo[]>;
+    actorCronDelete(ctx: ActorContextHandle, name: string): Promise<boolean>;
+    actorCronHistory(ctx: ActorContextHandle, name: string, limit: number | undefined): Promise<RuntimeCronFire[]>;
+    connId(conn: ConnHandle): string;
+    connParams(conn: ConnHandle): RuntimeBytes;
+    connState(conn: ConnHandle): RuntimeBytes;
+    connSetState(conn: ConnHandle, state: RuntimeBytes): void;
+    connIsHibernatable(conn: ConnHandle): boolean;
+    connSend(conn: ConnHandle, name: string, args: RuntimeBytes): void;
+    connDisconnect(conn: ConnHandle, reason?: string | undefined | null): Promise<void>;
+    webSocketSend(ws: WebSocketHandle, data: RuntimeBytes, binary: boolean): void;
+    webSocketClose(ws: WebSocketHandle, code?: number | undefined | null, reason?: string | undefined | null): Promise<void>;
+    webSocketSetEventCallback(ws: WebSocketHandle, callback: (event: RuntimeWebSocketEvent) => void): void;
+}
+
+interface QueueSendWaitOptions {
+    wait: true;
+    timeout?: number;
+    signal?: AbortSignal;
+}
+interface QueueSendNoWaitOptions {
+    wait?: false;
+    timeout?: never;
+    signal?: AbortSignal;
+}
+interface QueueSendResult<TResponse = unknown> {
+    status: "completed" | "timedOut";
+    response?: TResponse;
+}
+
+/**
+ * Action function returned by Actor connections and handles.
+ *
+ * @typedef {Function} ActorActionFunction
+ * @template Args
+ * @template Response
+ * @param {...Args} args - Arguments for the action function.
+ * @returns {Promise<Response>}
+ */
+type ActorActionFunction<Args extends Array<unknown> = unknown[], Response = unknown> = (...args: Args extends [unknown, ...infer Rest] ? Rest : Args) => Promise<Response>;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type LooseEventSubscribe = (eventName: string, callback: (...args: any[]) => void) => () => void;
+type ActorActionMap<R> = {
+    [K in keyof NonNullable<R>]: NonNullable<R>[K] extends (...args: infer Args) => infer Return ? ActorActionFunction<Args, Awaited<Return>> : NonNullable<R>[K] extends Record<string, unknown> ? ActorActionMap<NonNullable<R>[K]> : never;
+};
+type ActionsOf<AD extends AnyActorDefinition> = AD["config"] extends {
+    actions?: infer R;
+} ? R : never;
+interface ActorGatewayOptions {
+    skipReadyWait?: boolean;
+}
+interface ActorActionOptions extends ActorGatewayOptions {
+    signal?: AbortSignal;
+}
+type ActorConnectOptions = ActorGatewayOptions;
+type ActorFetchInit = RequestInit & ActorGatewayOptions;
+type ActorWebSocketOptions = ActorGatewayOptions;
+/**
+ * Maps action methods from actor definition to typed function signatures.
+ */
+type ActorDefinitionActions<AD extends AnyActorDefinition> = IsAny<AD> extends true ? Record<string, ActorActionFunction<any[], any>> : ActorActionMap<ActionsOf<AD>>;
+type ActorQueueSend<TQueues extends QueueSchemaConfig> = {
+    <K extends keyof TQueues & string>(name: K, body: InferSchemaMap<TQueues>[K], options: QueueSendWaitOptions): Promise<QueueSendResult<InferQueueCompleteMap<TQueues>[K]>>;
+    <K extends keyof TQueues & string>(name: K, body: InferSchemaMap<TQueues>[K], options?: QueueSendNoWaitOptions): Promise<void>;
+    (name: keyof TQueues extends never ? string : never, body: unknown, options: QueueSendWaitOptions): Promise<QueueSendResult>;
+    (name: keyof TQueues extends never ? string : never, body: unknown, options?: QueueSendNoWaitOptions): Promise<void>;
+};
+type ActorEventSubscribe<TEvents extends EventSchemaConfig> = {
+    <K extends keyof TEvents & string>(eventName: K, callback: (...args: InferEventArgs<InferSchemaMap<TEvents>[K]>) => void): () => void;
+    (eventName: keyof TEvents extends never ? string : never, callback: (...args: any[]) => void): () => void;
+};
+type ActorDefinitionQueueSend<AD extends AnyActorDefinition> = IsAny<AD> extends true ? {
+    send: ActorQueueSend<Record<string, any>>;
+} : AD extends {
+    config: {
+        queues?: infer Q;
+    };
+} ? Q extends QueueSchemaConfig ? {
+    send: ActorQueueSend<Q>;
+} : {} : AD extends BaseActorDefinition<any, any, any, any, any, any, any, infer Q, any> ? Q extends QueueSchemaConfig ? {
+    send: ActorQueueSend<Q>;
+} : {} : {};
+type ActorDefinitionEventSubscriptions<AD extends AnyActorDefinition> = IsAny<AD> extends true ? {
+    on: LooseEventSubscribe;
+    once: LooseEventSubscribe;
+} : AD extends {
+    config: {
+        events?: infer E;
+    };
+} ? E extends EventSchemaConfig ? {
+    on: ActorEventSubscribe<E>;
+    once: ActorEventSubscribe<E>;
+} : {} : AD extends BaseActorDefinition<any, any, any, any, any, any, infer E, any, any> ? E extends EventSchemaConfig ? {
+    on: ActorEventSubscribe<E>;
+    once: ActorEventSubscribe<E>;
+} : {} : {};
+
+declare class ActorClientError extends Error {
+}
+declare class ManagerError extends ActorClientError {
+    constructor(error: string, opts?: ErrorOptions);
+}
+declare class MalformedResponseMessage extends ActorClientError {
+    constructor(cause?: unknown);
+}
+
+declare class ActorConnDisposed extends ActorClientError {
+    constructor();
+}
+
+type ActorResolutionState = ActorQuery;
+
+/**
+ * Connection status for an actor connection.
+ *
+ * - `"idle"`: Not connected, no auto-reconnect (initial state, after dispose, or disabled)
+ * - `"connecting"`: Attempting to establish connection
+ * - `"connected"`: Connection is active
+ * - `"disconnected"`: Connection was lost, will auto-reconnect
+ */
+type ActorConnStatus = "idle" | "connecting" | "connected" | "disconnected";
+/**
+ * A function that unsubscribes from an event.
+ *
+ * @typedef {Function} EventUnsubscribe
+ */
+type EventUnsubscribe = () => void;
+/**
+ * A function that handles connection errors.
+ *
+ * @typedef {Function} ActorErrorCallback
+ */
+type ActorErrorCallback = (error: RivetError) => void;
+/**
+ * A callback for connection state changes.
+ *
+ * @typedef {Function} ConnectionStateCallback
+ */
+type ConnectionStateCallback = () => void;
+/**
+ * A callback for connection status changes.
+ *
+ * @typedef {Function} StatusChangeCallback
+ */
+type StatusChangeCallback = (status: ActorConnStatus) => void;
+declare const CONNECT_SYMBOL: unique symbol;
+/**
+ * Provides underlying functions for {@link ActorConn}. See {@link ActorConn} for using type-safe remote procedure calls.
+ *
+ * @see {@link ActorConn}
+ */
+declare class ActorConnRaw {
+    #private;
     /**
-     * Subscribes to connection errors.
+     * Do not call this directly.
      *
-     * @param {ActorErrorCallback} callback - The callback function to execute when a connection error occurs.
-     * @returns {() => void} - A function to unsubscribe from the error handler.
+     * Creates an instance of ActorConnRaw.
+     *
+     * @protected
      */
-    onError(callback: ActorErrorCallback): () => void;
+    constructor(client: ClientRaw, driver: EngineControlClient, params: unknown, getParams: (() => Promise<unknown>) | undefined, encoding: Encoding, actorResolutionState: ActorResolutionState, gatewayOptions?: ActorGatewayOptions, currentActorInvocation?: CurrentActorInvocation);
+    send(name: string, body: unknown, options: QueueSendWaitOptions): Promise<QueueSendResult>;
+    send(name: string, body: unknown, options?: QueueSendNoWaitOptions): Promise<void>;
     /**
-     * Returns the current connection status.
+     * Call a raw action connection. See {@link ActorConn} for type-safe action calls.
      *
-     * @returns {ActorConnStatus} - The current connection status.
+     * @see {@link ActorConn}
+     * @template Args - The type of arguments to pass to the action function.
+     * @template Response - The type of the response returned by the action function.
+     * @param {string} name - The name of the action function to call.
+     * @param {...Args} args - The arguments to pass to the action function.
+     * @returns {Promise<Response>} - A promise that resolves to the response of the action function.
      */
-    get connStatus(): ActorConnStatus;
+    action<Args extends Array<unknown> = unknown[], Response = unknown>(opts: {
+        name: string;
+        args: Args;
+        signal?: AbortSignal;
+    }): Promise<Response>;
     /**
-     * Returns whether the connection is currently open.
+     * Do not call this directly.
+     * Establishes a connection to the server using the specified endpoint & encoding & driver.
      *
-     * @deprecated Use `connStatus` instead.
-     * @returns {boolean} - True if the connection is open, false otherwise.
+     * @protected
      */
-    get isConnected(): boolean;
+    [CONNECT_SYMBOL](): void;
+    /**
+     * Subscribes to an event that will happen repeatedly.
+     *
+     * @template Args - The type of arguments the event callback will receive.
+     * @param {string} eventName - The name of the event to subscribe to.
+     * @param {(...args: Args) => void} callback - The callback function to execute when the event is triggered.
+     * @returns {EventUnsubscribe} - A function to unsubscribe from the event.
+     * @see {@link https://rivet.dev/docs/events|Events Documentation}
+     */
+    on<Args extends Array<unknown> = unknown[]>(eventName: string, callback: (...args: Args) => void): EventUnsubscribe;
+    /**
+     * Subscribes to an event that will be triggered only once.
+     *
+     * @template Args - The type of arguments the event callback will receive.
+     * @param {string} eventName - The name of the event to subscribe to.
+     * @param {(...args: Args) => void} callback - The callback function to execute when the event is triggered.
+     * @returns {EventUnsubscribe} - A function to unsubscribe from the event.
+     * @see {@link https://rivet.dev/docs/events|Events Documentation}
+     */
+    once<Args extends Array<unknown> = unknown[]>(eventName: string, callback: (...args: Args) => void): EventUnsubscribe;
+    /**
+     * Subscribes to connection errors.
+     *
+     * @param {ActorErrorCallback} callback - The callback function to execute when a connection error occurs.
+     * @returns {() => void} - A function to unsubscribe from the error handler.
+     */
+    onError(callback: ActorErrorCallback): () => void;
+    /**
+     * Returns the current connection status.
+     *
+     * @returns {ActorConnStatus} - The current connection status.
+     */
+    get connStatus(): ActorConnStatus;
+    /**
+     * Returns whether the connection is currently open.
+     *
+     * @deprecated Use `connStatus` instead.
+     * @returns {boolean} - True if the connection is open, false otherwise.
+     */
+    get isConnected(): boolean;
     /**
      * Resolves when this connection first reaches the connected state.
      */
@@ -701,7 +1222,7 @@ declare class ActorHandleRaw {
      *
      * @protected
      */
-    constructor(client: any, driver: EngineControlClient, params: unknown, getParams: (() => Promise<unknown>) | undefined, encoding: Encoding, actorResolutionState: ActorResolutionState, gatewayOptions?: ActorGatewayOptions, signal?: AbortSignal);
+    constructor(client: any, driver: EngineControlClient, params: unknown, getParams: (() => Promise<unknown>) | undefined, encoding: Encoding, actorResolutionState: ActorResolutionState, gatewayOptions?: ActorGatewayOptions, signal?: AbortSignal, currentActorInvocation?: CurrentActorInvocation, startCallSpan?: StartCallSpan);
     send(name: string, body: unknown, options: QueueSendWaitOptions): Promise<QueueSendResult>;
     send(name: string, body: unknown, options?: QueueSendNoWaitOptions): Promise<void>;
     /**
@@ -951,6 +1472,18 @@ interface Region {
 }
 declare const ACTOR_CONNS_SYMBOL: unique symbol;
 declare const CREATE_ACTOR_CONN_PROXY: unique symbol;
+/** Options for constructing a raw actor client. */
+interface ClientRawOptions {
+    encoding?: Encoding;
+    gateway?: ActorGatewayOptions;
+}
+/** Runtime-supplied wiring for clients created inside an actor. Set only by the native runtime. */
+interface ActorClientRuntimeOptions {
+    /** Supplies the calling actor's invocation so actor-to-actor clients propagate its trace and ray ID. */
+    currentActorInvocation?: CurrentActorInvocation;
+    /** Opens and finishes the Core span covering an actor-to-actor call. */
+    startCallSpan?: StartCallSpan;
+}
 /**
  * Client for managing & connecting to actors.
  *
@@ -963,7 +1496,7 @@ declare class ClientRaw {
     /**
      * Creates an instance of Client.
      */
-    constructor(driver: EngineControlClient, encoding: Encoding | undefined, gatewayOptions?: ActorGatewayOptions);
+    constructor(driver: EngineControlClient, options?: ClientRawOptions & ActorClientRuntimeOptions);
     /**
      * Gets a stateless handle to a actor by its ID.
      *
@@ -1270,6 +1803,28 @@ interface ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase
     client<T = any>(): ActorClientFor<T>;
     [key: string]: any;
 }
+/** @experimental How one run of a workflow function ended. */
+type WorkflowOutcome = "completed" | "sleeping" | "evicted" | "failed" | "cancelled";
+/** @experimental How one workflow step attempt ended. `retry` will be tried again, `failed` will not. */
+type WorkflowStepOutcome = "ok" | "retry" | "failed";
+/** @experimental One open run of a workflow function, traced as its own invocation. */
+interface WorkflowSpan {
+    /** Runs `body` attributed to this run. */
+    run<T>(body: () => Promise<T>): Promise<T>;
+    /**
+     * Called by a workflow engine before each attempt at a step. Returns
+     * nothing when tracing is off.
+     */
+    startStep(name: string, attempt: number): WorkflowStepSpan | undefined;
+    finish(outcome: WorkflowOutcome): Promise<void>;
+}
+/** @experimental One open attempt at one workflow step. */
+interface WorkflowStepSpan {
+    /** Runs `body` attributed to this attempt. */
+    run<T>(body: () => Promise<T>): Promise<T>;
+    /** `error` is what the step callback threw. */
+    finish(outcome: WorkflowStepOutcome, error?: unknown): void;
+}
 /** @experimental */
 interface ActorRun {
     /**
@@ -1277,6 +1832,13 @@ interface ActorRun {
      * ensures this actor's run handler is active, starting it if inactive.
      */
     setWakeAt(timestamp: number | null): Promise<void>;
+    /** @experimental Called by a workflow engine each time it runs the workflow function. */
+    startWorkflowSpan(): Promise<WorkflowSpan>;
+    /**
+     * @experimental Runs `body` outside the current workflow run, so a workflow
+     * engine's own history storage stays out of the trace.
+     */
+    runOutsideWorkflowSpan<T>(body: () => T): T;
 }
 type ActionContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> = ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> & {
     conn: Conn<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>;
@@ -1342,6 +1904,10 @@ declare const ActorConfigSchema: z.ZodObject<{
     onWebSocket: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
     actions: z.ZodDefault<z.ZodCustom<Record<string, unknown>, Record<string, unknown>>>;
     actionInputSchemas: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    tracing: z.ZodOptional<z.ZodObject<{
+        sampler: z.ZodOptional<z.ZodNumber>;
+        actions: z.ZodOptional<z.ZodType<ActionSampleRates, unknown, z.core.$ZodTypeInternals<ActionSampleRates, unknown>>>;
+    }, z.core.$strict>>;
     connParamsSchema: z.ZodOptional<z.ZodAny>;
     events: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     queues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
@@ -1389,8 +1955,8 @@ declare const ActorConfigSchema: z.ZodObject<{
                 state: "state";
                 database: "database";
                 console: "console";
-                workflow: "workflow";
                 queue: "queue";
+                workflow: "workflow";
                 schedules: "schedules";
                 connections: "connections";
             }>;
@@ -1582,6 +2148,11 @@ interface BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatab
      * May mirror nested action groups or use dot-separated low-level action names.
      */
     actionInputSchemas?: ActionInputSchemas;
+    /**
+     * How much of this actor's work is recorded in traces. Defaults to the
+     * process sampler from `OTEL_TRACES_SAMPLER`.
+     */
+    tracing?: ActorTracingOptions<TActions>;
     /**
      * Optional schema for validating connection params in native runtimes.
      */
@@ -1840,431 +2411,6 @@ type RegistryConfigInput<A extends RegistryActors> = Omit<z$2.input<typeof Regis
     use: A;
 };
 
-declare const handleBrand: unique symbol;
-type OpaqueHandle<Name extends string> = {
-    readonly [handleBrand]: Name;
-};
-type RegistryHandle = OpaqueHandle<"registry">;
-type ActorFactoryHandle = OpaqueHandle<"actorFactory">;
-type ActorContextHandle = OpaqueHandle<"actorContext">;
-type ConnHandle = OpaqueHandle<"conn">;
-type WebSocketHandle = OpaqueHandle<"webSocket">;
-type CancellationTokenHandle = OpaqueHandle<"cancellationToken">;
-type ActorStateTransactionHandle = OpaqueHandle<"actorStateTransaction">;
-type SqliteTransactionHandle = OpaqueHandle<"sqliteTransaction">;
-type RuntimeBytes = Uint8Array;
-interface RuntimeActorKeySegment {
-    kind: string;
-    stringValue?: string;
-    numberValue?: number;
-}
-interface RuntimeHttpRequest {
-    method: string;
-    uri: string;
-    headers?: Record<string, string>;
-    body?: RuntimeBytes;
-}
-interface RuntimeHttpResponseBodyStream {
-    cancelled(): Promise<void>;
-    write(chunk: Uint8Array): Promise<void>;
-    end(): Promise<void>;
-    error(message: string): Promise<void>;
-}
-interface RuntimeStateDeltaPayload {
-    state?: RuntimeBytes;
-    connHibernation: Array<{
-        connId: string;
-        bytes: RuntimeBytes;
-    }>;
-    connHibernationRemoved: string[];
-}
-interface RuntimeWorkflowKvWrite {
-    key: RuntimeBytes;
-    value: RuntimeBytes;
-}
-interface RuntimeRequestSaveOpts {
-    immediate?: boolean;
-    maxWaitMs?: number;
-}
-interface RuntimeInspectorSnapshot {
-    stateRevision: number;
-    connectionsRevision: number;
-    queueRevision: number;
-    activeConnections: number;
-    queueSize: number;
-    connectedClients: number;
-}
-interface RuntimeQueueMessage {
-    id(): bigint;
-    name(): string;
-    body(): RuntimeBytes;
-    createdAt(): number;
-    isCompletable(): boolean;
-    complete(response?: RuntimeBytes | undefined | null): Promise<void>;
-}
-interface RuntimeQueueInspectMessage {
-    id: number;
-    name: string;
-    createdAtMs: number;
-}
-interface RuntimeScheduledEventInfo {
-    id: string;
-    action: string;
-    args: RuntimeBytes;
-    runAt: number;
-}
-interface RuntimeCronJobInfo {
-    name: string;
-    kind: "cron" | "every";
-    action: string;
-    args: RuntimeBytes;
-    nextRunAt: number;
-    lastRunAt?: number;
-    expression?: string;
-    timezone?: string;
-    intervalMs?: number;
-    maxHistory: number;
-}
-interface RuntimeScheduleErrorInfo {
-    group: string;
-    code: string;
-    message: string;
-    metadata?: unknown;
-}
-interface RuntimeCronFire {
-    action: string;
-    scheduledAt: number;
-    firedAt: number;
-    finishedAt?: number;
-    result: "running" | "ok" | "error" | "skipped";
-    error?: RuntimeScheduleErrorInfo;
-}
-interface RuntimeQueueNextBatchOptions {
-    names?: string[];
-    count?: number;
-    timeoutMs?: number;
-    completable?: boolean;
-}
-interface RuntimeQueueWaitOptions {
-    timeoutMs?: number;
-    completable?: boolean;
-}
-interface RuntimeQueueEnqueueAndWaitOptions {
-    timeoutMs?: number;
-}
-interface RuntimeQueueTryNextBatchOptions {
-    names?: string[];
-    count?: number;
-    completable?: boolean;
-}
-interface RuntimeKvListOptions {
-    reverse?: boolean;
-    limit?: number;
-}
-interface RuntimeKvEntry {
-    key: RuntimeBytes;
-    value: RuntimeBytes;
-}
-type RuntimeSqlBindNoValues = {
-    intValue?: never;
-    floatValue?: never;
-    textValue?: never;
-    blobValue?: never;
-};
-type RuntimeSqlBindParam = ({
-    kind: "null";
-} & RuntimeSqlBindNoValues) | {
-    kind: "int";
-    intValue: number;
-    floatValue?: never;
-    textValue?: never;
-    blobValue?: never;
-} | {
-    kind: "float";
-    intValue?: never;
-    floatValue: number;
-    textValue?: never;
-    blobValue?: never;
-} | {
-    kind: "text";
-    intValue?: never;
-    floatValue?: never;
-    textValue: string;
-    blobValue?: never;
-} | {
-    kind: "blob";
-    intValue?: never;
-    floatValue?: never;
-    textValue?: never;
-    blobValue: RuntimeBytes;
-};
-type RuntimeSqlBindParams = RuntimeSqlBindParam[] | null;
-interface RuntimeActorRuntimeSocketEndpointInfo {
-    path: string;
-}
-interface RuntimeSqlQueryResult {
-    columns: string[];
-    rows: unknown[][];
-}
-type RuntimeSqlExecResult = RuntimeSqlQueryResult;
-interface RuntimeSqlExecuteResult extends RuntimeSqlQueryResult {
-    changes: number;
-    lastInsertRowId?: number | null;
-}
-interface RuntimeSqlBatchStatement {
-    sql: string;
-    params?: RuntimeSqlBindParams;
-}
-interface RuntimeSqlRunResult {
-    changes: number;
-}
-interface RuntimeActorConfig {
-    name?: string;
-    icon?: string;
-    hasDatabase?: boolean;
-    remoteSqlite?: boolean;
-    sqliteProfiling?: SqliteProfilingOptions;
-    enableActorRuntimeSocket?: boolean;
-    hasState?: boolean;
-    canHibernateWebsocket?: boolean;
-    stateSaveIntervalMs?: number;
-    createStateTimeoutMs?: number;
-    onCreateTimeoutMs?: number;
-    createVarsTimeoutMs?: number;
-    createConnStateTimeoutMs?: number;
-    onBeforeConnectTimeoutMs?: number;
-    onConnectTimeoutMs?: number;
-    onMigrateTimeoutMs?: number;
-    onWakeTimeoutMs?: number;
-    onBeforeActorStartTimeoutMs?: number;
-    actionTimeoutMs?: number;
-    onRequestTimeoutMs?: number;
-    sleepTimeoutMs?: number;
-    noSleep?: boolean;
-    sleepGracePeriodMs?: number;
-    connectionLivenessTimeoutMs?: number;
-    connectionLivenessIntervalMs?: number;
-    maxQueueSize?: number;
-    maxSchedules?: number;
-    maxQueueMessageSize?: number;
-    maxIncomingMessageSize?: number;
-    maxOutgoingMessageSize?: number;
-    preloadMaxWorkflowBytes?: number;
-    preloadMaxConnectionsBytes?: number;
-    actions?: Array<{
-        name: string;
-    }>;
-    inspectorTabs?: Array<RuntimeInspectorTabEntry>;
-}
-interface RuntimeInspectorTabEntry {
-    id: string;
-    /** Required for custom entries; omitted for built-in hides. */
-    label?: string;
-    /**
-     * Required for custom entries — absolute path to the source directory.
-     * Resolved on the TS side before being handed to the runtime.
-     */
-    source?: string;
-    /** Optional icon id for custom entries. */
-    icon?: string;
-    /** Set to true for built-in hide entries. */
-    hidden?: boolean;
-}
-interface RuntimeServeConfig {
-    version: number;
-    endpoint: string;
-    token?: string;
-    namespace: string;
-    poolName: string;
-    engineBinaryPath?: string;
-    startServices?: boolean;
-    servicesBinaryPath?: string;
-    engineHost?: string;
-    enginePort?: number;
-    handleInspectorHttpInRuntime?: boolean;
-    inspectorTestToken?: string;
-    serverlessBasePath?: string;
-    serverlessPackageVersion: string;
-    serverlessClientEndpoint?: string;
-    serverlessClientNamespace?: string;
-    serverlessClientToken?: string;
-    serverlessValidateEndpoint: boolean;
-    serverlessMaxStartPayloadBytes: number;
-}
-interface RuntimeListenerConfig {
-    port: number;
-    host?: string;
-    publicDir?: string;
-    application?: RuntimeApplicationFetch;
-}
-interface RuntimeServerlessRequest {
-    method: string;
-    url: string;
-    headers: Record<string, string>;
-    body: RuntimeBytes;
-}
-interface RuntimeApplicationRequest extends RuntimeServerlessRequest {
-    cancelToken?: CancellationTokenHandle;
-}
-interface RuntimeApplicationResponse {
-    status: number;
-    headers: Record<string, string>;
-    body?: RuntimeBytes;
-    stream?: boolean;
-}
-type RuntimeApplicationFetch = (request: RuntimeApplicationRequest, responseBodyStream?: RuntimeHttpResponseBodyStream) => Promise<RuntimeApplicationResponse>;
-interface RuntimeApplicationListenerConfig extends RuntimeListenerConfig {
-    application: RuntimeApplicationFetch;
-}
-interface RuntimeServerlessResponseHead {
-    status: number;
-    headers: Record<string, string>;
-}
-interface RuntimeRegistryRouteResponse {
-    status: number;
-    headers: Record<string, string>;
-    body: RuntimeBytes;
-}
-type RuntimeServerlessStreamEvent = {
-    kind: "chunk";
-    chunk?: RuntimeBytes;
-} | {
-    kind: "end";
-    error?: {
-        group: string;
-        code: string;
-        message: string;
-    };
-};
-type RuntimeServerlessStreamCallback = (error: unknown, event?: RuntimeServerlessStreamEvent) => unknown;
-type RuntimeWebSocketEvent = {
-    kind: "message";
-    data: string | RuntimeBytes;
-    binary: boolean;
-    messageIndex?: number;
-} | {
-    kind: "close";
-    code: number;
-    reason: string;
-    wasClean: boolean;
-};
-interface CoreRuntime {
-    readonly kind: "napi" | "wasm";
-    createRegistry(): RegistryHandle;
-    registerActor(registry: RegistryHandle, name: string, factory: ActorFactoryHandle): void;
-    serveRegistry(registry: RegistryHandle, config: RuntimeServeConfig): Promise<void>;
-    waitRegistryReady(registry: RegistryHandle): Promise<void>;
-    shutdownRegistry(registry: RegistryHandle): Promise<void>;
-    registryActorStopThresholdMs?(registry: RegistryHandle): Promise<number | undefined>;
-    handleServerlessRequest(registry: RegistryHandle, req: RuntimeServerlessRequest, onStreamEvent: RuntimeServerlessStreamCallback, cancelToken: CancellationTokenHandle, config: RuntimeServeConfig): Promise<RuntimeServerlessResponseHead>;
-    serveListener(registry: RegistryHandle, listener: RuntimeListenerConfig, config: RuntimeServeConfig): Promise<void>;
-    serveApplicationListener(registry: RegistryHandle, listener: RuntimeApplicationListenerConfig, config: RuntimeServeConfig): Promise<void>;
-    registryHealth?(registry: RegistryHandle): Promise<RuntimeRegistryRouteResponse>;
-    registryMetadata?(registry: RegistryHandle): Promise<RuntimeRegistryRouteResponse>;
-    registryMetrics?(registry: RegistryHandle): Promise<RuntimeRegistryRouteResponse>;
-    createActorFactory(callbacks: object, config?: RuntimeActorConfig | undefined | null): ActorFactoryHandle;
-    createCancellationToken(): CancellationTokenHandle;
-    cancellationTokenAborted(token: CancellationTokenHandle): boolean;
-    cancelCancellationToken(token: CancellationTokenHandle): void;
-    onCancellationTokenCancelled(token: CancellationTokenHandle, callback: (...args: unknown[]) => unknown): void;
-    actorState(ctx: ActorContextHandle): RuntimeBytes;
-    actorBeginOnStateChange(ctx: ActorContextHandle): void;
-    actorEndOnStateChange(ctx: ActorContextHandle): void;
-    actorSetAlarm(ctx: ActorContextHandle, timestampMs?: number | undefined | null): void;
-    actorSetRunWakeAt(ctx: ActorContextHandle, timestampMs?: number | undefined | null): Promise<void>;
-    actorRequestSave(ctx: ActorContextHandle, opts?: RuntimeRequestSaveOpts | undefined | null): void;
-    actorRequestSaveAndWait(ctx: ActorContextHandle, opts?: RuntimeRequestSaveOpts | undefined | null): Promise<void>;
-    actorInspectorSnapshot(ctx: ActorContextHandle): RuntimeInspectorSnapshot;
-    actorDecodeInspectorRequest(ctx: ActorContextHandle, bytes: RuntimeBytes, advertisedVersion: number): RuntimeBytes;
-    actorEncodeInspectorResponse(ctx: ActorContextHandle, bytes: RuntimeBytes, targetVersion: number): RuntimeBytes;
-    actorVerifyInspectorAuth(ctx: ActorContextHandle, bearerToken?: string | undefined | null): Promise<void>;
-    actorQueueHibernationRemoval(ctx: ActorContextHandle, connId: string): void;
-    actorTakePendingHibernationChanges(ctx: ActorContextHandle): string[];
-    actorDirtyHibernatableConns(ctx: ActorContextHandle): ConnHandle[];
-    actorSaveState(ctx: ActorContextHandle, payload: RuntimeStateDeltaPayload): Promise<void>;
-    actorSaveStateAndWorkflowBatch(ctx: ActorContextHandle, writes: RuntimeWorkflowKvWrite[]): Promise<void>;
-    actorId(ctx: ActorContextHandle): string;
-    actorName(ctx: ActorContextHandle): string;
-    actorKey(ctx: ActorContextHandle): RuntimeActorKeySegment[];
-    actorRegion(ctx: ActorContextHandle): string;
-    actorSleep(ctx: ActorContextHandle): void;
-    actorDestroy(ctx: ActorContextHandle): void;
-    actorAbortSignal(ctx: ActorContextHandle): AbortSignal;
-    actorConns(ctx: ActorContextHandle): ConnHandle[];
-    actorConnectConn(ctx: ActorContextHandle, params: RuntimeBytes, request?: RuntimeHttpRequest | undefined | null): Promise<ConnHandle>;
-    actorBroadcast(ctx: ActorContextHandle, name: string, args: RuntimeBytes): void;
-    actorWaitUntil(ctx: ActorContextHandle, promise: Promise<unknown>): void;
-    actorWaitForTrackedShutdownWork(ctx: ActorContextHandle): Promise<boolean>;
-    actorWaitForTrackedShutdownWorkUnbounded(ctx: ActorContextHandle): Promise<void>;
-    actorKeepAwake(ctx: ActorContextHandle, promise: Promise<unknown>): void;
-    actorBeginKeepAwake(ctx: ActorContextHandle): number;
-    actorEndKeepAwake(ctx: ActorContextHandle, regionId: number): void;
-    actorRegisterTask(ctx: ActorContextHandle, promise: Promise<unknown>): void;
-    actorRuntimeState(ctx: ActorContextHandle): object;
-    actorClearRuntimeState(ctx: ActorContextHandle): void;
-    actorRestartRunHandler(ctx: ActorContextHandle): void;
-    actorBeginWebsocketCallback(ctx: ActorContextHandle): number;
-    actorEndWebsocketCallback(ctx: ActorContextHandle, regionId: number): void;
-    actorKvGet(ctx: ActorContextHandle, key: RuntimeBytes): Promise<RuntimeBytes | null>;
-    actorKvPut(ctx: ActorContextHandle, key: RuntimeBytes, value: RuntimeBytes): Promise<void>;
-    actorKvDelete(ctx: ActorContextHandle, key: RuntimeBytes): Promise<void>;
-    actorKvDeleteRange(ctx: ActorContextHandle, start: RuntimeBytes, end: RuntimeBytes): Promise<void>;
-    actorKvListPrefix(ctx: ActorContextHandle, prefix: RuntimeBytes, options?: RuntimeKvListOptions | undefined | null): Promise<RuntimeKvEntry[]>;
-    actorKvListRange(ctx: ActorContextHandle, start: RuntimeBytes, end: RuntimeBytes, options?: RuntimeKvListOptions | undefined | null): Promise<RuntimeKvEntry[]>;
-    actorKvBatchGet(ctx: ActorContextHandle, keys: RuntimeBytes[]): Promise<Array<RuntimeBytes | undefined | null>>;
-    actorKvBatchPut(ctx: ActorContextHandle, entries: RuntimeKvEntry[]): Promise<void>;
-    actorKvBatchDelete(ctx: ActorContextHandle, keys: RuntimeBytes[]): Promise<void>;
-    actorSqlExec(ctx: ActorContextHandle, sql: string): Promise<RuntimeSqlExecResult>;
-    actorSqlExecute(ctx: ActorContextHandle, sql: string, params?: RuntimeSqlBindParams): Promise<RuntimeSqlExecuteResult>;
-    actorSqlExecuteBatch(ctx: ActorContextHandle, statements: RuntimeSqlBatchStatement[]): Promise<RuntimeSqlExecuteResult[]>;
-    actorSqlBeginTransaction(ctx: ActorContextHandle, timeoutMs?: number, name?: string): Promise<SqliteTransactionHandle>;
-    actorSqlTransactionExec(transaction: SqliteTransactionHandle, sql: string): Promise<RuntimeSqlExecResult>;
-    actorSqlTransactionExecute(transaction: SqliteTransactionHandle, sql: string, params?: RuntimeSqlBindParams): Promise<RuntimeSqlExecuteResult>;
-    actorSqlTransactionCommit(transaction: SqliteTransactionHandle): Promise<void>;
-    actorSqlTransactionRollback(transaction: SqliteTransactionHandle): Promise<void>;
-    actorBeginStateTransaction(ctx: ActorContextHandle, timeoutMs?: number): Promise<ActorStateTransactionHandle>;
-    actorStateTransactionExecute(transaction: ActorStateTransactionHandle, sql: string, params?: RuntimeSqlBindParams): Promise<RuntimeSqlExecuteResult>;
-    actorStateTransactionCommit(transaction: ActorStateTransactionHandle, payload: RuntimeStateDeltaPayload): Promise<void>;
-    actorStateTransactionRollback(transaction: ActorStateTransactionHandle): Promise<void>;
-    actorSqlQuery(ctx: ActorContextHandle, sql: string, params?: RuntimeSqlBindParams): Promise<RuntimeSqlQueryResult>;
-    actorSqlRun(ctx: ActorContextHandle, sql: string, params?: RuntimeSqlBindParams): Promise<RuntimeSqlRunResult>;
-    actorSqlMetrics(ctx: ActorContextHandle): SqliteNativeMetrics | null;
-    actorSqlTakeLastKvError(ctx: ActorContextHandle): string | null;
-    actorSqlClose(ctx: ActorContextHandle): Promise<void>;
-    actorRuntimeSocketProvision(ctx: ActorContextHandle): Promise<RuntimeActorRuntimeSocketEndpointInfo>;
-    actorQueueSend(ctx: ActorContextHandle, name: string, body: RuntimeBytes): Promise<RuntimeQueueMessage>;
-    actorQueueNextBatch(ctx: ActorContextHandle, options?: RuntimeQueueNextBatchOptions | undefined | null, signal?: CancellationTokenHandle | undefined | null): Promise<RuntimeQueueMessage[]>;
-    actorQueueWaitForNames(ctx: ActorContextHandle, names: string[], options?: RuntimeQueueWaitOptions | undefined | null, signal?: CancellationTokenHandle | undefined | null): Promise<RuntimeQueueMessage>;
-    actorQueueWaitForNamesAvailable(ctx: ActorContextHandle, names: string[], options?: RuntimeQueueWaitOptions | undefined | null, signal?: CancellationTokenHandle | undefined | null): Promise<void>;
-    actorQueueCompletePersisted(ctx: ActorContextHandle, messageId: bigint, expectedName: string, response?: RuntimeBytes | undefined | null): Promise<boolean>;
-    actorQueueEnqueueAndWait(ctx: ActorContextHandle, name: string, body: RuntimeBytes, options?: RuntimeQueueEnqueueAndWaitOptions | undefined | null, signal?: CancellationTokenHandle | undefined | null): Promise<RuntimeBytes | null>;
-    actorQueueTryNextBatch(ctx: ActorContextHandle, options?: RuntimeQueueTryNextBatchOptions | undefined | null): RuntimeQueueMessage[];
-    actorQueueMaxSize(ctx: ActorContextHandle): number;
-    actorQueueInspectMessages(ctx: ActorContextHandle): Promise<RuntimeQueueInspectMessage[]>;
-    actorQueueReset(ctx: ActorContextHandle): Promise<void>;
-    actorScheduleAfter(ctx: ActorContextHandle, durationMs: number, actionName: string, args: RuntimeBytes): Promise<string>;
-    actorScheduleAt(ctx: ActorContextHandle, timestampMs: number, actionName: string, args: RuntimeBytes): Promise<string>;
-    actorScheduleCancel(ctx: ActorContextHandle, id: string): Promise<boolean>;
-    actorScheduleGet(ctx: ActorContextHandle, id: string): Promise<RuntimeScheduledEventInfo | undefined>;
-    actorScheduleList(ctx: ActorContextHandle): Promise<RuntimeScheduledEventInfo[]>;
-    actorCronSet(ctx: ActorContextHandle, name: string, expression: string, timezone: string | undefined, actionName: string, args: RuntimeBytes, maxHistory: number | undefined): Promise<void>;
-    actorCronEvery(ctx: ActorContextHandle, name: string, intervalMs: number, actionName: string, args: RuntimeBytes, maxHistory: number | undefined): Promise<void>;
-    actorCronGet(ctx: ActorContextHandle, name: string): Promise<RuntimeCronJobInfo | undefined>;
-    actorCronList(ctx: ActorContextHandle): Promise<RuntimeCronJobInfo[]>;
-    actorCronDelete(ctx: ActorContextHandle, name: string): Promise<boolean>;
-    actorCronHistory(ctx: ActorContextHandle, name: string, limit: number | undefined): Promise<RuntimeCronFire[]>;
-    connId(conn: ConnHandle): string;
-    connParams(conn: ConnHandle): RuntimeBytes;
-    connState(conn: ConnHandle): RuntimeBytes;
-    connSetState(conn: ConnHandle, state: RuntimeBytes): void;
-    connIsHibernatable(conn: ConnHandle): boolean;
-    connSend(conn: ConnHandle, name: string, args: RuntimeBytes): void;
-    connDisconnect(conn: ConnHandle, reason?: string | undefined | null): Promise<void>;
-    webSocketSend(ws: WebSocketHandle, data: RuntimeBytes, binary: boolean): void;
-    webSocketClose(ws: WebSocketHandle, code?: number | undefined | null, reason?: string | undefined | null): Promise<void>;
-    webSocketSetEventCallback(ws: WebSocketHandle, callback: (event: RuntimeWebSocketEvent) => void): void;
-}
-
 declare function buildConfiguredRegistry(config: RegistryConfig): Promise<{
     runtime: CoreRuntime;
     registry: RegistryHandle;