rivetkit 2.0.42 → 2.1.0-rc.1

package/dist/tsup/{config-CZB2-W8x.d.cts → config-CAZphOS1.d.cts}

@@ -1,32 +1,19 @@
-import { z } from 'zod';
+import { z as z$1 } from 'zod/v4';
 import { UniversalWebSocket } from '@rivetkit/virtual-websocket';
+import { A as AnyDatabaseProvider, D as DatabaseProvider, a as RawDatabaseClient } from './config-BiNoIHRs.cjs';
+import { Traces, OtlpExportTraceServiceRequestJson, SpanHandle, SpanStatusInput } from '@rivetkit/traces';
 import { Env, Context, Hono } from 'hono';
 import { VersionedDataHandler } from 'vbare';
 import { Logger } from 'pino';
 import { GetUpgradeWebSocket } from './utils.cjs';
+import { SqliteVfs } from '@rivetkit/sqlite-vfs';
+import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
+import { z } from 'zod';
+import { StandardSchemaV1 } from '@standard-schema/spec';
 import * as nanoevents from 'nanoevents';
-import { a1 as Event } from './v1-Gq4avTK3.cjs';
+import { W as WorkflowHistory, k as QueueStatus } from './v3-DnYObHH3.cjs';
 
 type InferDatabaseClient<DBProvider extends AnyDatabaseProvider> = DBProvider extends DatabaseProvider<any> ? Awaited<ReturnType<DBProvider["createClient"]>> : never;
-type AnyDatabaseProvider = DatabaseProvider<any> | undefined;
-type DatabaseProvider<DB extends {
-    execute: (query: string) => any;
-}> = {
-    /**
-     * Creates a new database client for the actor.
-     * The result is passed to the actor context as `c.db`.
-     * @experimental
-     */
-    createClient: (ctx: {
-        getDatabase: () => Promise<string | unknown>;
-    }) => Promise<DB>;
-    /**
-     * Runs before the actor has started.
-     * Use this to run migrations or other setup tasks.
-     * @experimental
-     */
-    onMigrate: (client: DB) => void | Promise<void>;
-};
 
 type ManagerDriverBuilder = (config: RegistryConfig) => ManagerDriver;
 interface ManagerDriver {
@@ -116,10 +103,28 @@ interface ActorDriver {
     /** ActorInstance ensure that only one instance of setAlarm is called in parallel at a time. */
     setAlarm(actor: AnyActorInstance, timestamp: number): Promise<void>;
     /**
+     * Override the default raw database client for the actor.
+     * If not provided, rivetkit will construct a KV-backed SQLite client.
      * @experimental
-     * This is an experimental API that may change in the future.
      */
-    getDatabase(actorId: string): Promise<unknown | undefined>;
+    overrideRawDatabaseClient?(actorId: string): Promise<RawDatabaseClient | undefined>;
+    /**
+     * Override the default Drizzle database client for the actor.
+     * If not provided, rivetkit will construct a KV-backed Drizzle client.
+     * @experimental
+     */
+    overrideDrizzleDatabaseClient?(actorId: string): Promise<BaseSQLiteDatabase<any, any, any, any> | undefined>;
+    /**
+     * Creates a SQLite VFS instance for creating KV-backed databases.
+     * If not provided, the database provider will need an override.
+     *
+     * @rivetkit/sqlite's async build is not re-entrant per module instance. Drivers
+     * should return a new instance per call for actor-level isolation.
+     *
+     * This is a method (not a property) so drivers can use dynamic imports,
+     * keeping the core driver tree-shakeable from @rivetkit/sqlite.
+     */
+    createSqliteVfs?(): SqliteVfs | Promise<SqliteVfs>;
     /**
      * Requests the actor to go to sleep.
      *
@@ -147,7 +152,7 @@ interface ActorDriver {
     onAfterPersistConn?(conn: AnyConn): void;
 }
 
-declare const ActorsSchema: z.ZodRecord<z.ZodString, z.ZodCustom<ActorDefinition<any, any, any, any, any, any, any>, ActorDefinition<any, any, any, any, any, any, any>>>;
+declare const ActorsSchema: z.ZodRecord<z.ZodString, z.ZodCustom<ActorDefinition<any, any, any, any, any, any, any, any, any>, ActorDefinition<any, any, any, any, any, any, any, any, any>>>;
 type RegistryActors = z.infer<typeof ActorsSchema>;
 declare const TestConfigSchema: z.ZodObject<{
     enabled: z.ZodBoolean;
@@ -165,6 +170,7 @@ declare const RegistryConfigSchema: z.ZodPipe<z.ZodObject<{
         actor: z.ZodCustom<ActorDriverBuilder, ActorDriverBuilder>;
         autoStartActorDriver: z.ZodBoolean;
     }, z.core.$strip>>;
+    storagePath: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
     maxIncomingMessageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     maxOutgoingMessageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     noWelcome: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -263,6 +269,7 @@ declare const RegistryConfigSchema: z.ZodPipe<z.ZodObject<{
     test: {
         enabled: boolean;
     };
+    storagePath: string | undefined;
     maxIncomingMessageSize: number;
     maxOutgoingMessageSize: number;
     noWelcome: boolean;
@@ -292,6 +299,7 @@ declare const RegistryConfigSchema: z.ZodPipe<z.ZodObject<{
     test: {
         enabled: boolean;
     };
+    storagePath: string | undefined;
     maxIncomingMessageSize: number;
     maxOutgoingMessageSize: number;
     noWelcome: boolean;
@@ -351,7 +359,7 @@ type RegistryConfigInput<A extends RegistryActors> = Omit<z.input<typeof Registr
     use: A;
 };
 declare function buildActorNames(config: RegistryConfig): Record<string, {
-    metadata: Record<string, any>;
+    metadata: Record<string, unknown>;
 }>;
 declare const DocInspectorConfigSchema: z.ZodOptional<z.ZodObject<{
     enabled: z.ZodOptional<z.ZodBoolean>;
@@ -397,6 +405,7 @@ declare const DocRunnerConfigSchema: z.ZodObject<{
 }, z.core.$strip>;
 declare const DocRegistryConfigSchema: z.ZodObject<{
     use: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    storagePath: z.ZodOptional<z.ZodString>;
     maxIncomingMessageSize: z.ZodOptional<z.ZodNumber>;
     maxOutgoingMessageSize: z.ZodOptional<z.ZodNumber>;
     noWelcome: z.ZodOptional<z.ZodBoolean>;
@@ -450,18 +459,69 @@ declare const DocRegistryConfigSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 
-type AnyActorDefinition = ActorDefinition<any, any, any, any, any, any, any>;
-declare class ActorDefinition<S, CP, CS, V, I, DB extends AnyDatabaseProvider, R extends Actions<S, CP, CS, V, I, DB>> {
+type SchemaHookResult = boolean | Promise<boolean>;
+type SchemaHook<TContext = any> = (ctx: TContext) => SchemaHookResult;
+interface EventTypeToken<T, TContext = any> {
+    readonly _eventType?: T;
+    readonly canSubscribe?: SchemaHook<TContext>;
+    readonly schema?: PrimitiveSchema;
+}
+interface QueueTypeToken<TMessage, TComplete = never, TContext = any> {
+    readonly _queueMessage?: TMessage;
+    readonly _queueComplete?: TComplete;
+    readonly canPublish?: SchemaHook<TContext>;
+    readonly message?: PrimitiveSchema;
+    readonly complete?: PrimitiveSchema;
+}
+/** @deprecated Use `event<T>()`. */
+type Type<T> = EventTypeToken<T, any>;
+interface EventOptions<TContext = any> {
+    canSubscribe?: SchemaHook<TContext>;
+    schema?: PrimitiveSchema;
+}
+interface QueueOptions<TContext = any> {
+    canPublish?: SchemaHook<TContext>;
+    message?: PrimitiveSchema;
+    complete?: PrimitiveSchema;
+}
+declare function event<T, TContext = any>(options?: EventOptions<TContext>): EventTypeToken<T, TContext>;
+declare function queue<TMessage, TComplete = never, TContext = any>(options?: QueueOptions<TContext>): QueueTypeToken<TMessage, TComplete, TContext>;
+type PrimitiveSchema = StandardSchemaV1 | EventTypeToken<unknown, any>;
+interface EventSchemaDefinition<TContext = any> {
+    schema: PrimitiveSchema;
+    canSubscribe?: SchemaHook<TContext>;
+}
+interface QueueSchemaDefinition<TContext = any> {
+    message: PrimitiveSchema;
+    complete?: PrimitiveSchema;
+    canPublish?: SchemaHook<TContext>;
+}
+type EventSchema<TContext = any> = PrimitiveSchema | EventSchemaDefinition<TContext>;
+type QueueSchema = PrimitiveSchema | QueueSchemaDefinition<any> | QueueTypeToken<unknown, unknown, any>;
+type EventSchemaConfig<TContext = any> = Record<string, EventSchema<TContext>>;
+type QueueSchemaConfig<TContext = any> = Record<string, QueueSchema>;
+type InferSchema<T> = T extends QueueSchemaDefinition<any> ? InferSchema<T["message"]> : T extends QueueTypeToken<infer M, unknown, any> ? M : T extends EventSchemaDefinition<any> ? InferSchema<T["schema"]> : T extends StandardSchemaV1<any, infer O> ? O : T extends EventTypeToken<infer R, any> ? R : never;
+type InferSchemaMap<T extends Record<string, unknown>> = {
+    [K in keyof T]: InferSchema<T[K]>;
+};
+type InferQueueComplete<T> = T extends QueueTypeToken<unknown, infer C, any> ? [C] extends [never] ? never : C : T extends QueueSchemaDefinition<any> ? T["complete"] extends PrimitiveSchema ? InferSchema<T["complete"]> : never : never;
+type InferQueueCompleteMap<T extends QueueSchemaConfig> = {
+    [K in keyof T]: InferQueueComplete<T[K]>;
+};
+type InferEventArgs<T> = T extends readonly unknown[] ? number extends T["length"] ? [T] : T : [T];
+
+type AnyActorDefinition = ActorDefinition<any, any, any, any, any, any, any, any, any>;
+declare class ActorDefinition<S, CP, CS, V, I, DB extends AnyDatabaseProvider, E extends EventSchemaConfig = Record<never, never>, Q extends QueueSchemaConfig = Record<never, never>, R extends Actions<S, CP, CS, V, I, DB, E, Q> = Actions<S, CP, CS, V, I, DB, E, Q>> {
     #private;
-    constructor(config: ActorConfig<S, CP, CS, V, I, DB>);
-    get config(): ActorConfig<S, CP, CS, V, I, DB>;
-    instantiate(): ActorInstance<S, CP, CS, V, I, DB>;
+    constructor(config: ActorConfig<S, CP, CS, V, I, DB, E, Q>);
+    get config(): ActorConfig<S, CP, CS, V, I, DB, E, Q>;
+    instantiate(): ActorInstance<S, CP, CS, V, I, DB, E, Q>;
 }
 declare function lookupInRegistry(config: RegistryConfig, name: string): AnyActorDefinition;
 
 /** Data that's been serialized. */
 type OutputData = string | Uint8Array;
-declare const EncodingSchema: z.ZodEnum<{
+declare const EncodingSchema: z$1.ZodEnum<{
     json: "json";
     cbor: "cbor";
     bare: "bare";
@@ -469,45 +529,45 @@ declare const EncodingSchema: z.ZodEnum<{
 /**
  * Encoding used to communicate between the client & actor.
  */
-type Encoding = z.infer<typeof EncodingSchema>;
+type Encoding = z$1.infer<typeof EncodingSchema>;
 /**
  * Helper class that helps serialize data without re-serializing for the same encoding.
  */
 declare class CachedSerializer<TBare, TJson, T = TBare> {
     #private;
-    constructor(data: T, versionedDataHandler: VersionedDataHandler<TBare>, version: number, zodSchema: z.ZodType<TJson>, toJson: (value: T) => TJson, toBare: (value: T) => TBare);
+    constructor(data: T, versionedDataHandler: VersionedDataHandler<TBare>, version: number, zodSchema: z$1.ZodType<TJson>, toJson: (value: T) => TJson, toBare: (value: T) => TBare);
     get rawData(): T;
     serialize(encoding: Encoding): OutputData;
 }
 
-declare const LegacyRunnerConfigSchema: z.ZodDefault<z.ZodPipe<z.ZodObject<{
-    driver: z.ZodOptional<z.ZodObject<{
-        name: z.ZodString;
-        manager: z.ZodCustom<ManagerDriverBuilder, ManagerDriverBuilder>;
-        actor: z.ZodCustom<ActorDriverBuilder, ActorDriverBuilder>;
-    }, z.core.$strip>>;
-    maxIncomingMessageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    maxOutgoingMessageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    inspector: z.ZodDefault<z.ZodOptional<z.ZodObject<{
-        enabled: z.ZodDefault<z.ZodBoolean>;
-        token: z.ZodDefault<z.ZodOptional<z.ZodCustom<() => string, () => string>>>;
-        defaultEndpoint: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    disableDefaultServer: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    defaultServerPort: z.ZodDefault<z.ZodNumber>;
-    runEngine: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    runEngineVersion: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-    overrideServerAddress: z.ZodOptional<z.ZodString>;
-    disableActorDriver: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    runnerKind: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+declare const LegacyRunnerConfigSchema: z$1.ZodDefault<z$1.ZodPipe<z$1.ZodObject<{
+    driver: z$1.ZodOptional<z$1.ZodObject<{
+        name: z$1.ZodString;
+        manager: z$1.ZodCustom<ManagerDriverBuilder, ManagerDriverBuilder>;
+        actor: z$1.ZodCustom<ActorDriverBuilder, ActorDriverBuilder>;
+    }, z$1.core.$strip>>;
+    maxIncomingMessageSize: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodNumber>>;
+    maxOutgoingMessageSize: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodNumber>>;
+    inspector: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodObject<{
+        enabled: z$1.ZodDefault<z$1.ZodBoolean>;
+        token: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodCustom<() => string, () => string>>>;
+        defaultEndpoint: z$1.ZodOptional<z$1.ZodString>;
+    }, z$1.core.$strip>>>;
+    disableDefaultServer: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodBoolean>>;
+    defaultServerPort: z$1.ZodDefault<z$1.ZodNumber>;
+    runEngine: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodBoolean>>;
+    runEngineVersion: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodString>>;
+    overrideServerAddress: z$1.ZodOptional<z$1.ZodString>;
+    disableActorDriver: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodBoolean>>;
+    runnerKind: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodEnum<{
         serverless: "serverless";
         normal: "normal";
     }>>>;
-    basePath: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-    noWelcome: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    logging: z.ZodDefault<z.ZodOptional<z.ZodObject<{
-        baseLogger: z.ZodOptional<z.ZodCustom<Logger, Logger>>;
-        level: z.ZodOptional<z.ZodEnum<{
+    basePath: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodString>>;
+    noWelcome: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodBoolean>>;
+    logging: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodObject<{
+        baseLogger: z$1.ZodOptional<z$1.ZodCustom<Logger, Logger>>;
+        level: z$1.ZodOptional<z$1.ZodEnum<{
             error: "error";
             trace: "trace";
             fatal: "fatal";
@@ -516,33 +576,33 @@ declare const LegacyRunnerConfigSchema: z.ZodDefault<z.ZodPipe<z.ZodObject<{
             debug: "debug";
             silent: "silent";
         }>>;
-    }, z.core.$strip>>>;
-    autoConfigureServerless: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
-        url: z.ZodOptional<z.ZodString>;
-        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        maxRunners: z.ZodOptional<z.ZodNumber>;
-        minRunners: z.ZodOptional<z.ZodNumber>;
-        requestLifespan: z.ZodOptional<z.ZodNumber>;
-        runnersMargin: z.ZodOptional<z.ZodNumber>;
-        slotsPerRunner: z.ZodOptional<z.ZodNumber>;
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>]>>;
-    endpoint: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string, string | undefined>>;
-    token: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
-    namespace: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
-    runnerName: z.ZodDefault<z.ZodString>;
-    encoding: z.ZodDefault<z.ZodEnum<{
+    }, z$1.core.$strip>>>;
+    autoConfigureServerless: z$1.ZodOptional<z$1.ZodUnion<readonly [z$1.ZodBoolean, z$1.ZodObject<{
+        url: z$1.ZodOptional<z$1.ZodString>;
+        headers: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodString>>;
+        maxRunners: z$1.ZodOptional<z$1.ZodNumber>;
+        minRunners: z$1.ZodOptional<z$1.ZodNumber>;
+        requestLifespan: z$1.ZodOptional<z$1.ZodNumber>;
+        runnersMargin: z$1.ZodOptional<z$1.ZodNumber>;
+        slotsPerRunner: z$1.ZodOptional<z$1.ZodNumber>;
+        metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+    }, z$1.core.$strip>]>>;
+    endpoint: z$1.ZodPipe<z$1.ZodOptional<z$1.ZodString>, z$1.ZodTransform<string, string | undefined>>;
+    token: z$1.ZodPipe<z$1.ZodOptional<z$1.ZodString>, z$1.ZodTransform<string | undefined, string | undefined>>;
+    namespace: z$1.ZodPipe<z$1.ZodOptional<z$1.ZodString>, z$1.ZodTransform<string | undefined, string | undefined>>;
+    runnerName: z$1.ZodDefault<z$1.ZodString>;
+    encoding: z$1.ZodDefault<z$1.ZodEnum<{
         json: "json";
         cbor: "cbor";
         bare: "bare";
     }>>;
-    headers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
-    getUpgradeWebSocket: z.ZodOptional<z.ZodCustom<GetUpgradeWebSocket, GetUpgradeWebSocket>>;
-    disableMetadataLookup: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    devtools: z.ZodDefault<z.ZodBoolean>;
-    runnerKey: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
-    totalSlots: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strip>, z.ZodTransform<{
+    headers: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodString>>>;
+    getUpgradeWebSocket: z$1.ZodOptional<z$1.ZodCustom<GetUpgradeWebSocket, GetUpgradeWebSocket>>;
+    disableMetadataLookup: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodBoolean>>;
+    devtools: z$1.ZodDefault<z$1.ZodBoolean>;
+    runnerKey: z$1.ZodPipe<z$1.ZodOptional<z$1.ZodString>, z$1.ZodTransform<string | undefined, string | undefined>>;
+    totalSlots: z$1.ZodDefault<z$1.ZodNumber>;
+}, z$1.core.$strip>, z$1.ZodTransform<{
     runnerKey: string | undefined;
     endpoint: string | undefined;
     namespace: string;
@@ -637,7 +697,7 @@ declare const LegacyRunnerConfigSchema: z.ZodDefault<z.ZodPipe<z.ZodObject<{
     } | undefined;
     getUpgradeWebSocket?: GetUpgradeWebSocket | undefined;
 }>>>;
-type LegacyRunnerConfigInput = z.input<typeof LegacyRunnerConfigSchema>;
+type LegacyRunnerConfigInput = z$1.input<typeof LegacyRunnerConfigSchema>;
 
 type FetchHandler = (request: Request, ...args: any) => Response | Promise<Response>;
 interface ServerlessHandler {
@@ -687,44 +747,44 @@ declare class Registry<A extends RegistryActors> {
 }
 declare function setup<A extends RegistryActors>(input: RegistryConfigInput<A>): Registry<A>;
 
-declare const ActorKeySchema: z.ZodArray<z.ZodString>;
-type ActorKey = z.infer<typeof ActorKeySchema>;
-declare const CreateRequestSchema: z.ZodObject<{
-    name: z.ZodString;
-    key: z.ZodArray<z.ZodString>;
-    input: z.ZodOptional<z.ZodUnknown>;
-    region: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-declare const ActorQuerySchema: z.ZodUnion<readonly [z.ZodObject<{
-    getForId: z.ZodObject<{
-        name: z.ZodString;
-        actorId: z.ZodString;
-    }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    getForKey: z.ZodObject<{
-        name: z.ZodString;
-        key: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    getOrCreateForKey: z.ZodObject<{
-        name: z.ZodString;
-        key: z.ZodArray<z.ZodString>;
-        input: z.ZodOptional<z.ZodUnknown>;
-        region: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    create: z.ZodObject<{
-        name: z.ZodString;
-        key: z.ZodArray<z.ZodString>;
-        input: z.ZodOptional<z.ZodUnknown>;
-        region: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip>]>;
-type ActorQuery = z.infer<typeof ActorQuerySchema>;
+declare const ActorKeySchema: z$1.ZodArray<z$1.ZodString>;
+type ActorKey = z$1.infer<typeof ActorKeySchema>;
+declare const CreateRequestSchema: z$1.ZodObject<{
+    name: z$1.ZodString;
+    key: z$1.ZodArray<z$1.ZodString>;
+    input: z$1.ZodOptional<z$1.ZodUnknown>;
+    region: z$1.ZodOptional<z$1.ZodString>;
+}, z$1.core.$strip>;
+declare const ActorQuerySchema: z$1.ZodUnion<readonly [z$1.ZodObject<{
+    getForId: z$1.ZodObject<{
+        name: z$1.ZodString;
+        actorId: z$1.ZodString;
+    }, z$1.core.$strip>;
+}, z$1.core.$strip>, z$1.ZodObject<{
+    getForKey: z$1.ZodObject<{
+        name: z$1.ZodString;
+        key: z$1.ZodArray<z$1.ZodString>;
+    }, z$1.core.$strip>;
+}, z$1.core.$strip>, z$1.ZodObject<{
+    getOrCreateForKey: z$1.ZodObject<{
+        name: z$1.ZodString;
+        key: z$1.ZodArray<z$1.ZodString>;
+        input: z$1.ZodOptional<z$1.ZodUnknown>;
+        region: z$1.ZodOptional<z$1.ZodString>;
+    }, z$1.core.$strip>;
+}, z$1.core.$strip>, z$1.ZodObject<{
+    create: z$1.ZodObject<{
+        name: z$1.ZodString;
+        key: z$1.ZodArray<z$1.ZodString>;
+        input: z$1.ZodOptional<z$1.ZodUnknown>;
+        region: z$1.ZodOptional<z$1.ZodString>;
+    }, z$1.core.$strip>;
+}, z$1.core.$strip>]>;
+type ActorQuery = z$1.infer<typeof ActorQuerySchema>;
 /**
  * Interface representing a request to create a actor.
  */
-type CreateRequest = z.infer<typeof CreateRequestSchema>;
+type CreateRequest = z$1.infer<typeof CreateRequestSchema>;
 
 /**
  * Action function returned by Actor connections and handles.
@@ -739,7 +799,7 @@ type ActorActionFunction<Args extends Array<unknown> = unknown[], Response = unk
 /**
  * Maps action methods from actor definition to typed function signatures.
  */
-type ActorDefinitionActions<AD extends AnyActorDefinition> = AD extends ActorDefinition<any, any, any, any, any, any, infer R> ? {
+type ActorDefinitionActions<AD extends AnyActorDefinition> = AD extends ActorDefinition<any, any, any, any, any, any, any, any, infer R> ? {
     [K in keyof R]: R[K] extends (...args: infer Args) => infer Return ? ActorActionFunction<Args, Return> : never;
 } : never;
 
@@ -764,6 +824,21 @@ declare class ActorConnDisposed extends ActorClientError {
     constructor();
 }
 
+interface QueueSendWaitOptions {
+    wait: true;
+    timeout?: number;
+    signal?: AbortSignal;
+}
+interface QueueSendNoWaitOptions {
+    wait?: false;
+    timeout?: never;
+    signal?: AbortSignal;
+}
+interface QueueSendResult {
+    status: "completed" | "timedOut";
+    response?: unknown;
+}
+
 /**
  * Connection status for an actor connection.
  *
@@ -813,6 +888,8 @@ declare class ActorConnRaw {
      * @protected
      */
     constructor(client: ClientRaw, driver: ManagerDriver, params: unknown, encoding: Encoding, actorQuery: ActorQuery);
+    send(name: string, body: unknown, options: QueueSendWaitOptions): Promise<QueueSendResult>;
+    send(name: string, body: unknown, options?: QueueSendNoWaitOptions): Promise<void>;
     /**
      * Call a raw action connection. See {@link ActorConn} for type-safe action calls.
      *
@@ -830,7 +907,6 @@ declare class ActorConnRaw {
     }): Promise<Response>;
     /**
      * Do not call this directly.
-enc
      * Establishes a connection to the server using the specified endpoint & encoding & driver.
      *
      * @protected
@@ -944,6 +1020,8 @@ declare class ActorHandleRaw {
      * @protected
      */
     constructor(client: any, driver: ManagerDriver, params: unknown, encoding: Encoding, actorQuery: ActorQuery);
+    send(name: string, body: unknown, options: QueueSendWaitOptions): Promise<QueueSendResult>;
+    send(name: string, body: unknown, options?: QueueSendNoWaitOptions): Promise<void>;
     /**
      * Call a raw action. This method sends an HTTP request to invoke the named action.
      *
@@ -964,27 +1042,18 @@ declare class ActorHandleRaw {
      */
     connect(): ActorConn<AnyActorDefinition>;
     /**
-     * Makes a raw HTTP request to the actor.
-     *
-     * @param input - The URL, path, or Request object
-     * @param init - Standard fetch RequestInit options
-     * @returns Promise<Response> - The raw HTTP response
+     * Fetches a resource from this actor via the /request endpoint. This is a
+     * convenience wrapper around the raw HTTP API.
      */
     fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
     /**
-     * Creates a raw WebSocket connection to the actor.
-     *
-     * @param path - The path for the WebSocket connection (e.g., "stream")
-     * @param protocols - Optional WebSocket subprotocols
-     * @returns WebSocket - A raw WebSocket connection
+     * Opens a raw WebSocket connection to this actor.
      */
-    websocket(path?: string, protocols?: string | string[]): Promise<WebSocket>;
+    webSocket(path?: string, protocols?: string | string[]): Promise<any>;
     /**
      * Resolves the actor to get its unique actor ID.
      */
-    resolve({ signal }?: {
-        signal?: AbortSignal;
-    }): Promise<string>;
+    resolve(): Promise<string>;
     /**
      * Returns the raw URL for routing traffic to the actor.
      */
@@ -1203,32 +1272,9 @@ declare function createClientWithDriver<A extends Registry<any>>(driver: Manager
 interface ActorInspectorEmitterEvents {
     stateUpdated: (state: unknown) => void;
     connectionsUpdated: () => void;
-    eventFired: (event: EventDetails) => void;
-    eventsChanged: () => void;
+    queueUpdated: () => void;
+    workflowHistoryUpdated: (history: WorkflowHistory) => void;
 }
-type EventDetails = {
-    type: "action";
-    name: string;
-    args: unknown[];
-    connId: string;
-} | {
-    type: "subscribe";
-    eventName: string;
-    connId: string;
-} | {
-    type: "unsubscribe";
-    eventName: string;
-    connId: string;
-} | {
-    type: "event";
-    eventName: string;
-    args: unknown[];
-    connId: string;
-} | {
-    type: "broadcast";
-    eventName: string;
-    args: unknown[];
-};
 /**
  * Provides a unified interface for inspecting actor external and internal state.
  */
@@ -1237,9 +1283,14 @@ declare class ActorInspector {
     private readonly actor;
     readonly emitter: nanoevents.Emitter<ActorInspectorEmitterEvents>;
     constructor(actor: AnyActorInstance);
-    getLastEvents(): Event[];
-    clearEvents(): void;
+    getQueueSize(): number;
+    getQueueStatus(limit: number): Promise<QueueStatus>;
+    updateQueueSize(size: number): void;
+    isWorkflowEnabled(): boolean;
+    getWorkflowHistory(): WorkflowHistory | null;
     isDatabaseEnabled(): boolean;
+    getDatabaseSchema(): Promise<ArrayBuffer>;
+    getDatabaseTableRows(table: string, limit: number, offset: number): Promise<ArrayBuffer>;
     isStateEnabled(): boolean;
     getState(): ArrayBuffer;
     getRpcs(): string[];
@@ -1250,6 +1301,35 @@ declare class ActorInspector {
     }[];
     setState(state: ArrayBuffer): Promise<void>;
     executeAction(name: string, params: ArrayBuffer): Promise<ArrayBuffer>;
+    getStateJson(): unknown;
+    setStateJson(state: unknown): Promise<void>;
+    getConnectionsJson(): {
+        id: string;
+        details: unknown;
+    }[];
+    executeActionJson(name: string, args: unknown[]): Promise<unknown>;
+    getTracesJson(options: {
+        startMs: number;
+        endMs: number;
+        limit: number;
+    }): Promise<{
+        otlp: unknown;
+        clamped: boolean;
+    }>;
+    getWorkflowHistoryJson(): {
+        history: unknown | null;
+        isWorkflowEnabled: boolean;
+    };
+    getQueueStatusJson(limit: number): Promise<{
+        size: number;
+        maxSize: number;
+        truncated: boolean;
+        messages: {
+            id: number;
+            name: string;
+            createdAtMs: number;
+        }[];
+    }>;
 }
 
 /**
@@ -1307,6 +1387,95 @@ declare class ActorKv {
     list<T extends KvValueType = "text", K extends KvKeyType = "text">(prefix: KvKeyTypeMap[K], options?: KvListOptions<T, K>): Promise<[KvKeyTypeMap[K], KvValueTypeMap[T]][]>;
 }
 
+interface QueueMessage {
+    id: bigint;
+    name: string;
+    body: unknown;
+    createdAt: number;
+}
+declare class QueueManager<S, CP, CS, V, I, DB extends AnyDatabaseProvider, E extends EventSchemaConfig = Record<never, never>, Q extends QueueSchemaConfig = Record<never, never>> {
+    #private;
+    constructor(actor: ActorInstance<S, CP, CS, V, I, DB, E, Q>, driver: ActorDriver);
+    /** Returns the current number of messages in the queue. */
+    get size(): number;
+    /** Loads queue metadata from storage and initializes internal state. */
+    initialize(): Promise<void>;
+    /** Adds a message to the queue with the given name and body. */
+    enqueue(name: string, body: unknown): Promise<QueueMessage>;
+    /**
+     * Adds a message and waits for completion.
+     */
+    enqueueAndWait(name: string, body: unknown, timeout?: number): Promise<{
+        status: "completed" | "timedOut";
+        response?: unknown;
+    }>;
+    completeMessage(message: QueueMessage, response?: unknown): Promise<void>;
+    completeMessageById(messageId: bigint, response?: unknown): Promise<void>;
+    /** Receives messages from the queue matching the given names. Waits until messages are available or timeout is reached. */
+    receive(names: string[] | undefined, count: number, timeout?: number, abortSignal?: AbortSignal, completable?: boolean): Promise<QueueMessage[]>;
+    waitForNames(names: readonly string[] | undefined, abortSignal?: AbortSignal): Promise<void>;
+    /** Returns all messages currently in the queue without removing them. */
+    getMessages(): Promise<QueueMessage[]>;
+    /** Deletes messages matching the provided IDs. Returns the IDs that were removed. */
+    deleteMessagesById(ids: bigint[]): Promise<bigint[]>;
+}
+
+type QueueMessageOf<Name extends string, Body> = Omit<QueueMessage, "name" | "body"> & {
+    name: Name;
+    body: Body;
+};
+type QueueName<TQueues extends QueueSchemaConfig> = keyof TQueues & string;
+type QueueFilterName<TQueues extends QueueSchemaConfig> = keyof TQueues extends never ? string : QueueName<TQueues>;
+type QueueMessageForName<TQueues extends QueueSchemaConfig, TName extends QueueFilterName<TQueues>> = keyof TQueues extends never ? QueueMessage : TName extends QueueName<TQueues> ? QueueMessageOf<TName, InferSchemaMap<TQueues>[TName]> : never;
+type QueueCompleteArgs<T> = undefined extends T ? [response?: T] : [response: T];
+type QueueCompleteArgsForName<TQueues extends QueueSchemaConfig, TName extends QueueFilterName<TQueues>> = keyof TQueues extends never ? [response?: unknown] : TName extends QueueName<TQueues> ? [InferQueueCompleteMap<TQueues>[TName]] extends [never] ? [response?: unknown] : QueueCompleteArgs<InferQueueCompleteMap<TQueues>[TName]> : [response?: unknown];
+type QueueCompletableMessageForName<TQueues extends QueueSchemaConfig, TName extends QueueFilterName<TQueues>> = QueueMessageForName<TQueues, TName> & {
+    complete(...args: QueueCompleteArgsForName<TQueues, TName>): Promise<void>;
+};
+type QueueResultMessageForName<TQueues extends QueueSchemaConfig, TName extends QueueFilterName<TQueues>, TCompletable extends boolean> = TCompletable extends true ? QueueCompletableMessageForName<TQueues, TName> : QueueMessageForName<TQueues, TName>;
+/** Options for receiving queue messages. */
+interface QueueNextOptions<TName extends string = string, TCompletable extends boolean = boolean> {
+    /** Queue names to receive from. If omitted, reads from all queue names. */
+    names?: readonly TName[];
+    /** Maximum number of messages to receive. Defaults to 1. */
+    count?: number;
+    /** Timeout in milliseconds. Omit to wait indefinitely. */
+    timeout?: number;
+    /** Optional abort signal for this receive call. */
+    signal?: AbortSignal;
+    /** Whether to return completable messages. */
+    completable?: TCompletable;
+}
+/** Options for non-blocking queue reads. */
+interface QueueTryNextOptions<TName extends string = string, TCompletable extends boolean = boolean> {
+    /** Queue names to receive from. If omitted, reads from all queue names. */
+    names?: readonly TName[];
+    /** Maximum number of messages to receive. Defaults to 1. */
+    count?: number;
+    /** Whether to return completable messages. */
+    completable?: TCompletable;
+}
+/** Options for queue async iteration. */
+interface QueueIterOptions<TName extends string = string, TCompletable extends boolean = boolean> {
+    /** Queue names to receive from. If omitted, reads from all queue names. */
+    names?: readonly TName[];
+    /** Optional abort signal for this iterator. */
+    signal?: AbortSignal;
+    /** Whether to return completable messages. */
+    completable?: TCompletable;
+}
+/** User-facing queue interface exposed on ActorContext. */
+declare class ActorQueue<S, CP, CS, V, I, DB extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> {
+    #private;
+    constructor(queueManager: QueueManager<S, CP, CS, V, I, DB, TEvents, TQueues>, abortSignal: AbortSignal);
+    next<const TName extends QueueFilterName<TQueues>, const TCompletable extends boolean = false>(opts?: QueueNextOptions<TName, TCompletable>): Promise<Array<QueueResultMessageForName<TQueues, TName, TCompletable>>>;
+    tryNext<const TName extends QueueFilterName<TQueues>, const TCompletable extends boolean = false>(opts?: QueueTryNextOptions<TName, TCompletable>): Promise<Array<QueueResultMessageForName<TQueues, TName, TCompletable>>>;
+    iter<const TName extends QueueFilterName<TQueues>, const TCompletable extends boolean = false>(opts?: QueueIterOptions<TName, TCompletable>): AsyncIterableIterator<QueueResultMessageForName<TQueues, TName, TCompletable>>;
+    /** Sends a message to the specified queue. */
+    send<K extends keyof TQueues & string>(name: K, body: InferSchemaMap<TQueues>[K]): Promise<QueueMessage>;
+    send(name: keyof TQueues extends never ? string : never, body: unknown): Promise<QueueMessage>;
+}
+
 declare class Schedule {
     #private;
     constructor(actor: AnyActorInstance);
@@ -1314,12 +1483,14 @@ declare class Schedule {
     at(timestamp: number, fn: string, ...args: unknown[]): Promise<void>;
 }
 
+declare const ACTOR_CONTEXT_INTERNAL_SYMBOL: unique symbol;
 /**
  * ActorContext class that provides access to actor methods and state
  */
-declare class ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> {
+declare class ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> {
     #private;
-    constructor(actor: ActorInstance<TState, TConnParams, TConnState, TVars, TInput, TDatabase>);
+    [ACTOR_CONTEXT_INTERNAL_SYMBOL]: AnyActorInstance;
+    constructor(actor: ActorInstance<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>);
     /**
      * Gets the KV storage interface.
      */
@@ -1344,11 +1515,16 @@ declare class ActorContext<TState, TConnParams, TConnState, TVars, TInput, TData
      * @param name - The name of the event.
      * @param args - The arguments to send with the event.
      */
-    broadcast<Args extends Array<unknown>>(name: string, ...args: Args): void;
+    broadcast<K extends keyof TEvents & string>(name: K, ...args: InferEventArgs<InferSchemaMap<TEvents>[K]>): void;
+    broadcast(name: keyof TEvents extends never ? string : never, ...args: Array<unknown>): void;
     /**
      * Gets the logger instance.
      */
     get log(): Logger;
+    /**
+     * Access to queue receive helpers.
+     */
+    get queue(): ActorQueue<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>;
     /**
      * Gets actor ID.
      */
@@ -1372,7 +1548,7 @@ declare class ActorContext<TState, TConnParams, TConnState, TVars, TInput, TData
     /**
      * Gets the map of connections.
      */
-    get conns(): Map<ConnId, Conn<TState, TConnParams, TConnState, TVars, TInput, TDatabase>>;
+    get conns(): Map<ConnId, Conn<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>>;
     /**
      * Returns the client for the given registry.
      */
@@ -1396,10 +1572,26 @@ declare class ActorContext<TState, TConnParams, TConnState, TVars, TInput, TData
      * Prevents the actor from sleeping until promise is complete.
      */
     waitUntil(promise: Promise<void>): void;
+    /**
+     * Prevents the actor from sleeping while the given promise is running.
+     *
+     * Use this when performing async operations in the `run` handler or other
+     * background contexts where you need to ensure the actor stays awake.
+     *
+     * Returns the resolved value and resets the sleep timer on completion.
+     * Errors are propagated to the caller.
+     */
+    keepAwake<T>(promise: Promise<T>): Promise<T>;
     /**
      * AbortSignal that fires when the actor is stopping.
      */
     get abortSignal(): AbortSignal;
+    /**
+     * True when the actor is stopping.
+     *
+     * Alias for `c.abortSignal.aborted`.
+     */
+    get aborted(): boolean;
     /**
      * Forces the actor to sleep.
      *
@@ -1417,141 +1609,153 @@ declare class ActorContext<TState, TConnParams, TConnState, TVars, TInput, TData
      */
     destroy(): void;
 }
-type ActorContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, any> ? ActorContext<S, CP, CS, V, I, DB> : never;
+type ActorContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, infer E extends EventSchemaConfig, infer Q extends QueueSchemaConfig, any> ? ActorContext<S, CP, CS, V, I, DB, E, Q> : never;
 
 /**
  * Base context for connection-based handlers.
  * Extends ActorContext with connection-specific functionality.
  */
-declare abstract class ConnContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase> {
-    readonly conn: Conn<TState, TConnParams, TConnState, TVars, TInput, TDatabase>;
+declare abstract class ConnContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
+    readonly conn: Conn<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>;
 }
-type ConnContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, any> ? ConnContext<S, CP, CS, V, I, DB> : never;
+type ConnContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, infer E extends EventSchemaConfig, infer Q extends QueueSchemaConfig, any> ? ConnContext<S, CP, CS, V, I, DB, E, Q> : never;
+
+/**
+ * Context for a remote procedure call.
+ */
+declare class ActionContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ConnContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
+}
+/**
+ * Extracts the ActionContext type from an ActorDefinition.
+ */
+type ActionContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, infer E extends EventSchemaConfig, infer Q extends QueueSchemaConfig, any> ? ActionContext<S, CP, CS, V, I, DB, E, Q> : never;
 
 /**
  * Base context for connection initialization handlers.
  * Extends ActorContext with request-specific functionality for connection lifecycle events.
  */
-declare abstract class ConnInitContext<TState, TVars, TInput, TDatabase extends AnyDatabaseProvider> extends ActorContext<TState, never, never, TVars, TInput, TDatabase> {
+declare abstract class ConnInitContext<TState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ActorContext<TState, never, never, TVars, TInput, TDatabase, TEvents, TQueues> {
     /**
      * The incoming request that initiated the connection.
      * May be undefined for connections initiated without a direct HTTP request.
      */
     readonly request: Request | undefined;
 }
-type ConnInitContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, any, any, infer V, infer I, infer DB extends AnyDatabaseProvider, any> ? ConnInitContext<S, V, I, DB> : never;
-
-/**
- * Context for a remote procedure call.
- */
-declare class ActionContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> extends ConnContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase> {
-}
-/**
- * Extracts the ActionContext type from an ActorDefinition.
- */
-type ActionContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, any> ? ActionContext<S, CP, CS, V, I, DB> : never;
+type ConnInitContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, any, any, infer V, infer I, infer DB extends AnyDatabaseProvider, infer E extends EventSchemaConfig, infer Q extends QueueSchemaConfig, any> ? ConnInitContext<S, V, I, DB, E, Q> : never;
 
 /**
  * Context for the onBeforeActionResponse lifecycle hook.
  */
-declare class BeforeActionResponseContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase> {
+declare class BeforeActionResponseContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
 }
-type BeforeActionResponseContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, any> ? BeforeActionResponseContext<S, CP, CS, V, I, DB> : never;
+type BeforeActionResponseContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, infer E extends EventSchemaConfig, infer Q extends QueueSchemaConfig, any> ? BeforeActionResponseContext<S, CP, CS, V, I, DB, E, Q> : never;
 
 /**
  * Context for the onBeforeConnect lifecycle hook.
  */
-declare class BeforeConnectContext<TState, TVars, TInput, TDatabase extends AnyDatabaseProvider> extends ConnInitContext<TState, TVars, TInput, TDatabase> {
+declare class BeforeConnectContext<TState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ConnInitContext<TState, TVars, TInput, TDatabase, TEvents, TQueues> {
 }
-type BeforeConnectContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, any, any, infer V, infer I, infer DB extends AnyDatabaseProvider, any> ? BeforeConnectContext<S, V, I, DB> : never;
+type BeforeConnectContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, any, any, infer V, infer I, infer DB extends AnyDatabaseProvider, infer E extends EventSchemaConfig, infer Q extends QueueSchemaConfig, any> ? BeforeConnectContext<S, V, I, DB, E, Q> : never;
 
 /**
  * Context for the onConnect lifecycle hook.
  */
-declare class ConnectContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> extends ConnContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase> {
+declare class ConnectContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ConnContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
 }
-type ConnectContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, any> ? ConnectContext<S, CP, CS, V, I, DB> : never;
+type ConnectContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, infer E extends EventSchemaConfig, infer Q extends QueueSchemaConfig, any> ? ConnectContext<S, CP, CS, V, I, DB, E, Q> : never;
 
 /**
  * Context for the onCreate lifecycle hook.
  */
-declare class CreateContext<TState, TInput, TDatabase extends AnyDatabaseProvider> extends ActorContext<TState, never, never, never, TInput, TDatabase> {
+declare class CreateContext<TState, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ActorContext<TState, never, never, never, TInput, TDatabase, TEvents, TQueues> {
 }
-type CreateContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, any, any, any, infer I, infer DB extends AnyDatabaseProvider, any> ? CreateContext<S, I, DB> : never;
+type CreateContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, any, any, any, infer I, infer DB extends AnyDatabaseProvider, infer E extends EventSchemaConfig, infer Q extends QueueSchemaConfig, any> ? CreateContext<S, I, DB, E, Q> : never;
 
 /**
  * Context for the createConnState lifecycle hook.
  * Called to initialize connection-specific state when a connection is created.
  */
-declare class CreateConnStateContext<TState, TVars, TInput, TDatabase extends AnyDatabaseProvider> extends ConnInitContext<TState, TVars, TInput, TDatabase> {
+declare class CreateConnStateContext<TState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ConnInitContext<TState, TVars, TInput, TDatabase, TEvents, TQueues> {
 }
-type CreateConnStateContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, any, any, infer V, infer I, infer DB extends AnyDatabaseProvider, any> ? CreateConnStateContext<S, V, I, DB> : never;
+type CreateConnStateContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, any, any, infer V, infer I, infer DB extends AnyDatabaseProvider, infer E extends EventSchemaConfig, infer Q extends QueueSchemaConfig, any> ? CreateConnStateContext<S, V, I, DB, E, Q> : never;
 
 /**
  * Context for the createVars lifecycle hook.
  */
-declare class CreateVarsContext<TState, TInput, TDatabase extends AnyDatabaseProvider> extends ActorContext<TState, never, never, never, TInput, TDatabase> {
+declare class CreateVarsContext<TState, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ActorContext<TState, never, never, never, TInput, TDatabase, TEvents, TQueues> {
 }
-type CreateVarsContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, any, any, any, infer I, infer DB extends AnyDatabaseProvider, any> ? CreateVarsContext<S, I, DB> : never;
+type CreateVarsContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, any, any, any, infer I, infer DB extends AnyDatabaseProvider, infer E extends EventSchemaConfig, infer Q extends QueueSchemaConfig, any> ? CreateVarsContext<S, I, DB, E, Q> : never;
 
 /**
  * Context for the onDestroy lifecycle hook.
  */
-declare class DestroyContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase> {
+declare class DestroyContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
 }
-type DestroyContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, any> ? DestroyContext<S, CP, CS, V, I, DB> : never;
+type DestroyContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, infer E extends EventSchemaConfig, infer Q extends QueueSchemaConfig, any> ? DestroyContext<S, CP, CS, V, I, DB, E, Q> : never;
 
 /**
  * Context for the onDisconnect lifecycle hook.
  */
-declare class DisconnectContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase> {
+declare class DisconnectContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
 }
-type DisconnectContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, any> ? DisconnectContext<S, CP, CS, V, I, DB> : never;
+type DisconnectContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, infer E extends EventSchemaConfig, infer Q extends QueueSchemaConfig, any> ? DisconnectContext<S, CP, CS, V, I, DB, E, Q> : never;
 
 /**
  * Context for raw HTTP request handlers (onRequest).
  */
-declare class RequestContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> extends ConnContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase> {
+declare class RequestContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ConnContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
     /**
      * The incoming HTTP request.
      * May be undefined for request contexts initiated without a direct HTTP request.
      */
     readonly request: Request | undefined;
 }
-type RequestContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, any> ? RequestContext<S, CP, CS, V, I, DB> : never;
+type RequestContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, infer E extends EventSchemaConfig, infer Q extends QueueSchemaConfig, any> ? RequestContext<S, CP, CS, V, I, DB, E, Q> : never;
+
+/**
+ * Context for the run lifecycle hook.
+ *
+ * This context is passed to the `run` handler which executes after the actor
+ * starts. It does not block actor startup and is intended for background tasks.
+ *
+ * Use `c.aborted` to detect when the actor is stopping and gracefully exit.
+ */
+declare class RunContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
+}
+type RunContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, infer E extends EventSchemaConfig, infer Q extends QueueSchemaConfig, any> ? RunContext<S, CP, CS, V, I, DB, E, Q> : never;
 
 /**
  * Context for the onSleep lifecycle hook.
  */
-declare class SleepContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase> {
+declare class SleepContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
 }
-type SleepContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, any> ? SleepContext<S, CP, CS, V, I, DB> : never;
+type SleepContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, infer E extends EventSchemaConfig, infer Q extends QueueSchemaConfig, any> ? SleepContext<S, CP, CS, V, I, DB, E, Q> : never;
 
 /**
  * Context for the onStateChange lifecycle hook.
  */
-declare class StateChangeContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase> {
+declare class StateChangeContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
 }
-type StateChangeContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, any> ? StateChangeContext<S, CP, CS, V, I, DB> : never;
+type StateChangeContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, infer E extends EventSchemaConfig, infer Q extends QueueSchemaConfig, any> ? StateChangeContext<S, CP, CS, V, I, DB, E, Q> : never;
 
 /**
  * Context for the onWake lifecycle hook.
  */
-declare class WakeContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase> {
+declare class WakeContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
 }
-type WakeContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, any> ? WakeContext<S, CP, CS, V, I, DB> : never;
+type WakeContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, infer E extends EventSchemaConfig, infer Q extends QueueSchemaConfig, any> ? WakeContext<S, CP, CS, V, I, DB, E, Q> : never;
 
 /**
  * Context for raw WebSocket handlers (onWebSocket).
  */
-declare class WebSocketContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> extends ConnContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase> {
+declare class WebSocketContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ConnContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
     /**
      * The incoming HTTP request that initiated the WebSocket upgrade.
      * May be undefined for WebSocket connections initiated without a direct HTTP request.
      */
     readonly request: Request | undefined;
 }
-type WebSocketContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, any> ? WebSocketContext<S, CP, CS, V, I, DB> : never;
+type WebSocketContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, infer E extends EventSchemaConfig, infer Q extends QueueSchemaConfig, any> ? WebSocketContext<S, CP, CS, V, I, DB, E, Q> : never;
 
 declare enum DriverReadyState {
     UNKNOWN = -1,
@@ -1625,18 +1829,19 @@ interface PersistedConn<CP, CS> {
  * Manages all connection-related operations for an actor instance.
  * Handles connection creation, tracking, hibernation, and cleanup.
  */
-declare class ConnectionManager<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
+declare class ConnectionManager<S, CP, CS, V, I, DB extends AnyDatabaseProvider, E extends EventSchemaConfig = Record<never, never>, Q extends QueueSchemaConfig = Record<never, never>> {
     #private;
-    constructor(actor: ActorInstance<S, CP, CS, V, I, DB>);
-    get connections(): Map<ConnId, Conn<S, CP, CS, V, I, DB>>;
-    getConnForId(id: string): Conn<S, CP, CS, V, I, DB> | undefined;
+    constructor(actor: ActorInstance<S, CP, CS, V, I, DB, E, Q>);
+    get connections(): Map<ConnId, Conn<S, CP, CS, V, I, DB, E, Q>>;
+    getConnForId(id: string): Conn<S, CP, CS, V, I, DB, E, Q> | undefined;
     get connsWithPersistChanged(): Set<ConnId>;
+    get pendingDisconnectCount(): number;
     clearConnWithPersistChanged(): void;
-    markConnWithPersistChanged(conn: Conn<S, CP, CS, V, I, DB>): void;
+    markConnWithPersistChanged(conn: Conn<S, CP, CS, V, I, DB, E, Q>): void;
     /**
      * Handles pre-connection logic (i.e. auth & create state) before actually connecting the connection.
      */
-    prepareConn(driver: ConnDriver, params: CP, request: Request | undefined, requestPath: string | undefined, requestHeaders: Record<string, string> | undefined, isHibernatable: boolean, isRestoringHibernatable: boolean): Promise<Conn<S, CP, CS, V, I, DB>>;
+    prepareConn(driver: ConnDriver, params: CP, request: Request | undefined, requestPath: string | undefined, requestHeaders: Record<string, string> | undefined, isHibernatable: boolean, isRestoringHibernatable: boolean): Promise<Conn<S, CP, CS, V, I, DB, E, Q>>;
     /**
      * Adds a connection form prepareConn to the actor and calls onConnect.
      *
@@ -1645,31 +1850,32 @@ declare class ConnectionManager<S, CP, CS, V, I, DB extends AnyDatabaseProvider>
      * be messed up and cause race conditions that can drop WebSocket messages.
      * So all async work in prepareConn.
      */
-    connectConn(conn: Conn<S, CP, CS, V, I, DB>): void;
+    connectConn(conn: Conn<S, CP, CS, V, I, DB, E, Q>): void;
     /**
      * Handle connection disconnection.
      *
      * This is called by `Conn.disconnect`. This should not call `Conn.disconnect.`
      */
-    connDisconnected(conn: Conn<S, CP, CS, V, I, DB>): Promise<void>;
+    connDisconnected(conn: Conn<S, CP, CS, V, I, DB, E, Q>): Promise<void>;
+    cleanupPersistedHibernatableConnections(reason?: string): Promise<number>;
     /**
      * Utilify function for call sites that don't need a separate prepare and connect phase.
      */
-    prepareAndConnectConn(driver: ConnDriver, params: CP, request: Request | undefined, requestPath: string | undefined, requestHeaders: Record<string, string> | undefined): Promise<Conn<S, CP, CS, V, I, DB>>;
+    prepareAndConnectConn(driver: ConnDriver, params: CP, request: Request | undefined, requestPath: string | undefined, requestHeaders: Record<string, string> | undefined): Promise<Conn<S, CP, CS, V, I, DB, E, Q>>;
     /**
      * Restores connections from persisted data during actor initialization.
      */
     restoreConnections(connections: PersistedConn<CP, CS>[]): void;
-    findHibernatableConn(gatewayIdBuf: ArrayBuffer, requestIdBuf: ArrayBuffer): Conn<S, CP, CS, V, I, DB> | undefined;
+    findHibernatableConn(gatewayIdBuf: ArrayBuffer, requestIdBuf: ArrayBuffer): Conn<S, CP, CS, V, I, DB, E, Q> | undefined;
 }
 
 /**
  * Manages event subscriptions and broadcasting for actor instances.
  * Handles subscription tracking and efficient message distribution to connected clients.
  */
-declare class EventManager<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
+declare class EventManager<S, CP, CS, V, I, DB extends AnyDatabaseProvider, E extends EventSchemaConfig = Record<never, never>, Q extends QueueSchemaConfig = Record<never, never>> {
     #private;
-    constructor(actor: ActorInstance<S, CP, CS, V, I, DB>);
+    constructor(actor: ActorInstance<S, CP, CS, V, I, DB, E, Q>);
     /**
      * Adds a subscription for a connection to an event.
      *
@@ -1677,7 +1883,7 @@ declare class EventManager<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
      * @param connection - The connection subscribing to the event
      * @param fromPersist - Whether this subscription is being restored from persistence
      */
-    addSubscription(eventName: string, connection: Conn<S, CP, CS, V, I, DB>, fromPersist: boolean): void;
+    addSubscription(eventName: string, connection: Conn<S, CP, CS, V, I, DB, E, Q>, fromPersist: boolean): void;
     /**
      * Removes a subscription for a connection from an event.
      *
@@ -1685,7 +1891,7 @@ declare class EventManager<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
      * @param connection - The connection unsubscribing from the event
      * @param fromRemoveConn - Whether this is being called as part of connection removal
      */
-    removeSubscription(eventName: string, connection: Conn<S, CP, CS, V, I, DB>, fromRemoveConn: boolean): void;
+    removeSubscription(eventName: string, connection: Conn<S, CP, CS, V, I, DB, E, Q>, fromRemoveConn: boolean): void;
     /**
      * Broadcasts an event to all subscribed connections.
      *
@@ -1699,7 +1905,7 @@ declare class EventManager<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
      * @param eventName - The name of the event
      * @returns Set of connections subscribed to the event, or undefined if no subscribers
      */
-    getSubscribers(eventName: string): Set<Conn<S, CP, CS, V, I, DB>> | undefined;
+    getSubscribers(eventName: string): Set<Conn<S, CP, CS, V, I, DB, E, Q>> | undefined;
     /**
      * Gets all events and their subscriber counts.
      *
@@ -1712,7 +1918,7 @@ declare class EventManager<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
      *
      * @param connection - The connection to clear subscriptions for
      */
-    clearConnectionSubscriptions(connection: Conn<S, CP, CS, V, I, DB>): void;
+    clearConnectionSubscriptions(connection: Conn<S, CP, CS, V, I, DB, E, Q>): void;
     /**
      * Gets the total number of unique events being subscribed to.
      */
@@ -1771,9 +1977,9 @@ interface SaveStateOptions {
  * Manages actor state persistence, proxying, and synchronization.
  * Handles automatic state change detection and throttled persistence to KV storage.
  */
-declare class StateManager$1<S, CP, CS, I> {
+declare class StateManager$1<S, CP, CS, I, E extends EventSchemaConfig = Record<never, never>, Q extends QueueSchemaConfig = Record<never, never>> {
     #private;
-    constructor(actor: ActorInstance<S, CP, CS, any, I, any>, actorDriver: ActorDriver, config: any);
+    constructor(actor: ActorInstance<S, CP, CS, any, I, any, E, Q>, actorDriver: ActorDriver, config: any);
     get persist(): PersistedActor<S, I>;
     get persistRaw(): PersistedActor<S, I>;
     get persistChanged(): boolean;
@@ -1810,15 +2016,16 @@ declare class StateManager$1<S, CP, CS, I> {
 }
 
 /** Actor type alias with all `any` types. Used for `extends` in classes referencing this actor. */
-type AnyActorInstance = ActorInstance<any, any, any, any, any, any>;
-declare class ActorInstance<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
+type AnyActorInstance = ActorInstance<any, any, any, any, any, any, any, any>;
+declare class ActorInstance<S, CP, CS, V, I, DB extends AnyDatabaseProvider, E extends EventSchemaConfig = Record<never, never>, Q extends QueueSchemaConfig = Record<never, never>> {
     #private;
-    actorContext: ActorContext<S, CP, CS, V, I, DB>;
+    actorContext: ActorContext<S, CP, CS, V, I, DB, E, Q>;
     driver: ActorDriver;
-    connectionManager: ConnectionManager<S, CP, CS, V, I, DB>;
-    stateManager: StateManager$1<S, CP, CS, I>;
-    eventManager: EventManager<S, CP, CS, V, I, DB>;
-    constructor(config: ActorConfig<S, CP, CS, V, I, DB>);
+    connectionManager: ConnectionManager<S, CP, CS, V, I, DB, E, Q>;
+    stateManager: StateManager$1<S, CP, CS, I, E, Q>;
+    eventManager: EventManager<S, CP, CS, V, I, DB, E, Q>;
+    queueManager: QueueManager<S, CP, CS, V, I, DB, E, Q>;
+    constructor(config: ActorConfig<S, CP, CS, V, I, DB, E, Q>);
     get log(): Logger;
     get rLog(): Logger;
     get isStopping(): boolean;
@@ -1828,12 +2035,18 @@ declare class ActorInstance<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
     get region(): string;
     get inlineClient(): Client<Registry<any>>;
     get inspector(): ActorInspector;
+    get traces(): Traces<OtlpExportTraceServiceRequestJson>;
     get inspectorToken(): string | undefined;
-    get conns(): Map<ConnId, Conn<S, CP, CS, V, I, DB>>;
+    getCurrentTraceSpan(): SpanHandle | null;
+    startTraceSpan(name: string, attributes?: Record<string, unknown>): SpanHandle;
+    endTraceSpan(handle: SpanHandle, status?: SpanStatusInput): void;
+    runInTraceSpan<T>(name: string, attributes: Record<string, unknown> | undefined, fn: () => T | Promise<T>): Promise<T>;
+    emitTraceEvent(name: string, attributes?: Record<string, unknown>, handle?: SpanHandle): void;
+    get conns(): Map<ConnId, Conn<S, CP, CS, V, I, DB, E, Q>>;
     get schedule(): Schedule;
     get abortSignal(): AbortSignal;
     get actions(): string[];
-    get config(): ActorConfig<S, CP, CS, V, I, DB>;
+    get config(): ActorConfig<S, CP, CS, V, I, DB, E, Q>;
     get persist(): PersistedActor<S, I>;
     get state(): S;
     set state(value: S);
@@ -1844,6 +2057,7 @@ declare class ActorInstance<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
     start(actorDriver: ActorDriver, inlineClient: Client<Registry<any>>, actorId: string, name: string, key: ActorKey, region: string): Promise<void>;
     isReady(): boolean;
     assertReady(allowStoppingState?: boolean): void;
+    cleanupPersistedConnections(reason?: string): Promise<number>;
     onStop(mode: "sleep" | "destroy"): Promise<void>;
     startSleep(): void;
     startDestroy(): void;
@@ -1864,13 +2078,27 @@ declare class ActorInstance<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
                 subscribe: boolean;
             };
         };
-    }, conn: Conn<S, CP, CS, V, I, DB>): Promise<void>;
-    executeAction(ctx: ActionContext<S, CP, CS, V, I, DB>, actionName: string, args: unknown[]): Promise<unknown>;
-    handleRawRequest(conn: Conn<S, CP, CS, V, I, DB>, request: Request): Promise<Response>;
-    handleRawWebSocket(conn: Conn<S, CP, CS, V, I, DB>, websocket: UniversalWebSocket, request?: Request): void;
+    }, conn: Conn<S, CP, CS, V, I, DB, E, Q>): Promise<void>;
+    assertCanSubscribe(ctx: ActionContext<S, CP, CS, V, I, DB, E, Q>, eventName: string): Promise<void>;
+    assertCanPublish(ctx: ActionContext<S, CP, CS, V, I, DB, E, Q>, queueName: string): Promise<void>;
+    executeAction(ctx: ActionContext<S, CP, CS, V, I, DB, E, Q>, actionName: string, args: unknown[]): Promise<unknown>;
+    handleRawRequest(conn: Conn<S, CP, CS, V, I, DB, E, Q>, request: Request): Promise<Response>;
+    handleRawWebSocket(conn: Conn<S, CP, CS, V, I, DB, E, Q>, websocket: UniversalWebSocket, request?: Request): void;
     scheduleEvent(timestamp: number, action: string, args: unknown[]): Promise<void>;
     onAlarm(): Promise<void>;
     waitUntil(promise: Promise<void>): void;
+    /**
+     * Prevents the actor from sleeping while the given promise is running.
+     *
+     * Use this when performing async operations in the `run` handler or other
+     * background contexts where you need to ensure the actor stays awake.
+     *
+     * Returns the resolved value and resets the sleep timer on completion.
+     * Errors are propagated to the caller.
+     */
+    keepAwake<T>(promise: Promise<T>): Promise<T>;
+    beginQueueWait(): void;
+    endQueueWait(): void;
     resetSleepTimer(): void;
 }
 
@@ -1887,7 +2115,7 @@ type ConnDataInput<CP, CS> = {
  */
 declare class StateManager<CP, CS> {
     #private;
-    constructor(conn: Conn<any, CP, CS, any, any, any>, data: ConnDataInput<CP, CS>);
+    constructor(conn: Conn<any, CP, CS, any, any, any, any, any>, data: ConnDataInput<CP, CS>);
     /**
      * Returns the ephemeral or persisted data for this connectioned.
      *
@@ -1910,7 +2138,7 @@ declare class StateManager<CP, CS> {
 }
 
 type ConnId = string;
-type AnyConn = Conn<any, any, any, any, any, any>;
+type AnyConn = Conn<any, any, any, any, any, any, any, any>;
 declare const CONN_CONNECTED_SYMBOL: unique symbol;
 declare const CONN_SPEAKS_RIVETKIT_SYMBOL: unique symbol;
 declare const CONN_DRIVER_SYMBOL: unique symbol;
@@ -1924,9 +2152,9 @@ declare const CONN_SEND_MESSAGE_SYMBOL: unique symbol;
  *
  * @see {@link https://rivet.dev/docs/connections|Connection Documentation}
  */
-declare class Conn<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
+declare class Conn<S, CP, CS, V, I, DB extends AnyDatabaseProvider, E extends EventSchemaConfig = Record<never, never>, Q extends QueueSchemaConfig = Record<never, never>> {
     #private;
-    get [CONN_ACTOR_SYMBOL](): ActorInstance<S, CP, CS, V, I, DB>;
+    get [CONN_ACTOR_SYMBOL](): ActorInstance<S, CP, CS, V, I, DB, E, Q>;
     get [CONN_STATE_MANAGER_SYMBOL](): StateManager<CP, CS>;
     /**
      * Connections exist before being connected to an actor. If true, this
@@ -1973,7 +2201,7 @@ declare class Conn<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
      *
      * @protected
      */
-    constructor(actor: ActorInstance<S, CP, CS, V, I, DB>, data: ConnDataInput<CP, CS>);
+    constructor(actor: ActorInstance<S, CP, CS, V, I, DB, E, Q>, data: ConnDataInput<CP, CS>);
     /**
      * Sends a raw message to the underlying connection.
      */
@@ -1985,7 +2213,8 @@ declare class Conn<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
      * @param args - The arguments for the event.
      * @see {@link https://rivet.dev/docs/events|Events Documentation}
      */
-    send(eventName: string, ...args: unknown[]): void;
+    send<K extends keyof E & string>(eventName: K, ...args: InferEventArgs<InferSchemaMap<E>[K]>): void;
+    send(eventName: keyof E extends never ? string : never, ...args: unknown[]): void;
     /**
      * Disconnects the client with an optional reason.
      *
@@ -2002,56 +2231,108 @@ interface ActorTypes<TState, TConnParams, TConnState, TVars, TInput, TDatabase e
     input?: TInput;
     database?: TDatabase;
 }
-declare const ActorConfigSchema: z.ZodObject<{
-    onCreate: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
-    onDestroy: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
-    onWake: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
-    onSleep: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
-    onStateChange: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
-    onBeforeConnect: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
-    onConnect: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
-    onDisconnect: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
-    onBeforeActionResponse: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
-    onRequest: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
-    onWebSocket: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
-    actions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>>;
-    state: z.ZodOptional<z.ZodAny>;
-    createState: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
-    connState: z.ZodOptional<z.ZodAny>;
-    createConnState: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
-    vars: z.ZodOptional<z.ZodAny>;
-    db: z.ZodOptional<z.ZodAny>;
-    createVars: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
-    options: z.ZodPrefault<z.ZodObject<{
-        createVarsTimeout: z.ZodDefault<z.ZodNumber>;
-        createConnStateTimeout: z.ZodDefault<z.ZodNumber>;
-        onConnectTimeout: z.ZodDefault<z.ZodNumber>;
-        onSleepTimeout: z.ZodDefault<z.ZodNumber>;
-        onDestroyTimeout: z.ZodDefault<z.ZodNumber>;
-        stateSaveInterval: z.ZodDefault<z.ZodNumber>;
-        actionTimeout: z.ZodDefault<z.ZodNumber>;
-        waitUntilTimeout: z.ZodDefault<z.ZodNumber>;
-        connectionLivenessTimeout: z.ZodDefault<z.ZodNumber>;
-        connectionLivenessInterval: z.ZodDefault<z.ZodNumber>;
-        noSleep: z.ZodDefault<z.ZodBoolean>;
-        sleepTimeout: z.ZodDefault<z.ZodNumber>;
-        canHibernateWebSocket: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodCustom<(request: Request) => boolean, (request: Request) => boolean>]>>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-type CreateState<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> = {
+type InspectorUnsubscribe = () => void;
+interface WorkflowInspectorConfig<THistory = unknown> {
+    getHistory: () => THistory | null;
+    onHistoryUpdated?: (listener: (history: THistory) => void) => InspectorUnsubscribe;
+}
+interface RunInspectorConfig<THistory = unknown> {
+    workflow?: WorkflowInspectorConfig<THistory>;
+}
+declare const RunConfigSchema: z$1.ZodObject<{
+    name: z$1.ZodOptional<z$1.ZodString>;
+    icon: z$1.ZodOptional<z$1.ZodString>;
+    run: z$1.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+    inspector: z$1.ZodOptional<z$1.ZodOptional<z$1.ZodObject<{
+        workflow: z$1.ZodOptional<z$1.ZodObject<{
+            getHistory: z$1.ZodCustom<() => unknown, () => unknown>;
+            onHistoryUpdated: z$1.ZodOptional<z$1.ZodCustom<(listener: (history: unknown) => void) => InspectorUnsubscribe, (listener: (history: unknown) => void) => InspectorUnsubscribe>>;
+        }, z$1.core.$strip>>;
+    }, z$1.core.$strip>>>;
+}, z$1.core.$strip>;
+type RunConfigRuntime = z$1.infer<typeof RunConfigSchema>;
+type RunConfig<TState = unknown, TConnParams = unknown, TConnState = unknown, TVars = unknown, TInput = unknown, TDatabase extends AnyDatabaseProvider = AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> = Omit<RunConfigRuntime, "run"> & {
+    run: (c: RunContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => void | Promise<void>;
+};
+type AnyRunConfig = RunConfig<any, any, any, any, any, AnyDatabaseProvider, any, any>;
+declare const RUN_FUNCTION_CONFIG_SYMBOL: unique symbol;
+/** Extract the run function from either a function or RunConfig object. */
+declare function getRunFunction(run: ((...args: any[]) => any) | AnyRunConfig | undefined): ((...args: any[]) => any) | undefined;
+/** Extract run metadata (name/icon) from RunConfig if provided. */
+declare function getRunMetadata(run: ((...args: any[]) => any) | AnyRunConfig | undefined): {
+    name?: string;
+    icon?: string;
+};
+/** Extract run inspector configuration if provided. */
+declare function getRunInspectorConfig(run: ((...args: any[]) => any) | AnyRunConfig | undefined): RunInspectorConfig | undefined;
+declare const ActorConfigSchema: z$1.ZodObject<{
+    onCreate: z$1.ZodOptional<z$1.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    onDestroy: z$1.ZodOptional<z$1.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    onWake: z$1.ZodOptional<z$1.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    onSleep: z$1.ZodOptional<z$1.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    run: z$1.ZodOptional<z$1.ZodUnion<readonly [z$1.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>, z$1.ZodObject<{
+        name: z$1.ZodOptional<z$1.ZodString>;
+        icon: z$1.ZodOptional<z$1.ZodString>;
+        run: z$1.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+        inspector: z$1.ZodOptional<z$1.ZodOptional<z$1.ZodObject<{
+            workflow: z$1.ZodOptional<z$1.ZodObject<{
+                getHistory: z$1.ZodCustom<() => unknown, () => unknown>;
+                onHistoryUpdated: z$1.ZodOptional<z$1.ZodCustom<(listener: (history: unknown) => void) => InspectorUnsubscribe, (listener: (history: unknown) => void) => InspectorUnsubscribe>>;
+            }, z$1.core.$strip>>;
+        }, z$1.core.$strip>>>;
+    }, z$1.core.$strip>]>>;
+    onStateChange: z$1.ZodOptional<z$1.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    onBeforeConnect: z$1.ZodOptional<z$1.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    onConnect: z$1.ZodOptional<z$1.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    onDisconnect: z$1.ZodOptional<z$1.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    onBeforeActionResponse: z$1.ZodOptional<z$1.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    onRequest: z$1.ZodOptional<z$1.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    onWebSocket: z$1.ZodOptional<z$1.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    actions: z$1.ZodDefault<z$1.ZodRecord<z$1.ZodString, z$1.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>>;
+    events: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodAny>>;
+    queues: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodAny>>;
+    state: z$1.ZodOptional<z$1.ZodAny>;
+    createState: z$1.ZodOptional<z$1.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    connState: z$1.ZodOptional<z$1.ZodAny>;
+    createConnState: z$1.ZodOptional<z$1.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    vars: z$1.ZodOptional<z$1.ZodAny>;
+    db: z$1.ZodOptional<z$1.ZodAny>;
+    createVars: z$1.ZodOptional<z$1.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    options: z$1.ZodPrefault<z$1.ZodObject<{
+        name: z$1.ZodOptional<z$1.ZodString>;
+        icon: z$1.ZodOptional<z$1.ZodString>;
+        createVarsTimeout: z$1.ZodDefault<z$1.ZodNumber>;
+        createConnStateTimeout: z$1.ZodDefault<z$1.ZodNumber>;
+        onConnectTimeout: z$1.ZodDefault<z$1.ZodNumber>;
+        onSleepTimeout: z$1.ZodDefault<z$1.ZodNumber>;
+        onDestroyTimeout: z$1.ZodDefault<z$1.ZodNumber>;
+        stateSaveInterval: z$1.ZodDefault<z$1.ZodNumber>;
+        actionTimeout: z$1.ZodDefault<z$1.ZodNumber>;
+        waitUntilTimeout: z$1.ZodDefault<z$1.ZodNumber>;
+        runStopTimeout: z$1.ZodDefault<z$1.ZodNumber>;
+        connectionLivenessTimeout: z$1.ZodDefault<z$1.ZodNumber>;
+        connectionLivenessInterval: z$1.ZodDefault<z$1.ZodNumber>;
+        noSleep: z$1.ZodDefault<z$1.ZodBoolean>;
+        sleepTimeout: z$1.ZodDefault<z$1.ZodNumber>;
+        maxQueueSize: z$1.ZodDefault<z$1.ZodNumber>;
+        maxQueueMessageSize: z$1.ZodDefault<z$1.ZodNumber>;
+        canHibernateWebSocket: z$1.ZodDefault<z$1.ZodUnion<readonly [z$1.ZodBoolean, z$1.ZodCustom<(request: Request) => boolean, (request: Request) => boolean>]>>;
+    }, z$1.core.$strict>>;
+}, z$1.core.$strict>;
+type CreateState<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig, TQueues extends QueueSchemaConfig> = {
     state: TState;
 } | {
-    createState: (c: CreateContext<TState, TInput, TDatabase>, input: TInput) => TState | Promise<TState>;
+    createState: (c: CreateContext<TState, TInput, TDatabase, TEvents, TQueues>, input: TInput) => TState | Promise<TState>;
 } | Record<never, never>;
-type CreateConnState<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> = {
+type CreateConnState<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig, TQueues extends QueueSchemaConfig> = {
     connState: TConnState;
 } | {
-    createConnState: (c: CreateConnStateContext<TState, TVars, TInput, TDatabase>, params: TConnParams) => TConnState | Promise<TConnState>;
+    createConnState: (c: CreateConnStateContext<TState, TVars, TInput, TDatabase, TEvents, TQueues>, params: TConnParams) => TConnState | Promise<TConnState>;
 } | Record<never, never>;
 /**
  * @experimental
  */
-type CreateVars<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> = {
+type CreateVars<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig, TQueues extends QueueSchemaConfig> = {
     /**
      * @experimental
      */
@@ -2060,27 +2341,27 @@ type CreateVars<TState, TConnParams, TConnState, TVars, TInput, TDatabase extend
     /**
      * @experimental
      */
-    createVars: (c: CreateVarsContext<TState, TInput, TDatabase>, driverCtx: any) => TVars | Promise<TVars>;
+    createVars: (c: CreateVarsContext<TState, TInput, TDatabase, TEvents, TQueues>, driverCtx: any) => TVars | Promise<TVars>;
 } | Record<never, never>;
-interface Actions<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> {
-    [Action: string]: (c: ActionContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>, ...args: any[]) => any;
+interface Actions<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> {
+    [Action: string]: (c: ActionContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>, ...args: any[]) => any;
 }
 /**
  * @experimental
  */
 type AuthIntent = "get" | "create" | "connect" | "action" | "message";
-interface BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TActions extends Actions<TState, TConnParams, TConnState, TVars, TInput, TDatabase>> {
+interface BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig, TQueues extends QueueSchemaConfig, TActions extends Actions<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>> {
     /**
      * Called when the actor is first initialized.
      *
      * Use this hook to initialize your actor's state.
      * This is called before any other lifecycle hooks.
      */
-    onCreate?: (c: CreateContext<TState, TInput, TDatabase>, input: TInput) => void | Promise<void>;
+    onCreate?: (c: CreateContext<TState, TInput, TDatabase, TEvents, TQueues>, input: TInput) => void | Promise<void>;
     /**
      * Called when the actor is destroyed.
      */
-    onDestroy?: (c: DestroyContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>) => void | Promise<void>;
+    onDestroy?: (c: DestroyContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => void | Promise<void>;
     /**
      * Called when the actor is started and ready to receive connections and action.
      *
@@ -2089,7 +2370,7 @@ interface BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatab
      *
      * @returns Void or a Promise that resolves when startup is complete
      */
-    onWake?: (c: WakeContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>) => void | Promise<void>;
+    onWake?: (c: WakeContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => void | Promise<void>;
     /**
      * Called when the actor is stopping or sleeping.
      *
@@ -2100,7 +2381,31 @@ interface BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatab
      *
      * @returns Void or a Promise that resolves when shutdown is complete
      */
-    onSleep?: (c: SleepContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>) => void | Promise<void>;
+    onSleep?: (c: SleepContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => void | Promise<void>;
+    /**
+     * Called after the actor starts up. Does not block actor startup.
+     *
+     * Use this for background tasks like:
+     * - Reading from queues in a loop
+     * - Tick loops for periodic work
+     * - Custom workflow logic
+     *
+     * **Important:** The actor may go to sleep at any time during the `run`
+     * handler. Use `c.keepAwake(promise)` to wrap async operations that should
+     * not be interrupted by sleep.
+     *
+     * The handler receives an abort signal via `c.abortSignal` and a
+     * `c.aborted` alias for loop checks. Use these to gracefully exit.
+     *
+     * If this handler exits or throws, the actor will crash and reschedule.
+     * On shutdown, the actor waits for this handler to complete with a
+     * configurable timeout (options.runStopTimeout, default 15s).
+     *
+     * Can be either a function or a RunConfig object with optional name/icon metadata.
+     *
+     * @returns Void or a Promise. If the promise exits, the actor crashes.
+     */
+    run?: ((c: RunContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => void | Promise<void>) | RunConfig<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>;
     /**
      * Called when the actor's state changes.
      *
@@ -2112,7 +2417,7 @@ interface BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatab
      *
      * @param newState The updated state
      */
-    onStateChange?: (c: StateChangeContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>, newState: TState) => void;
+    onStateChange?: (c: StateChangeContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>, newState: TState) => void;
     /**
      * Called before a client connects to the actor.
      *
@@ -2123,7 +2428,7 @@ interface BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatab
      * @returns The initial connection state or a Promise that resolves to it
      * @throws Throw an error to reject the connection
      */
-    onBeforeConnect?: (c: BeforeConnectContext<TState, TVars, TInput, TDatabase>, params: TConnParams) => void | Promise<void>;
+    onBeforeConnect?: (c: BeforeConnectContext<TState, TVars, TInput, TDatabase, TEvents, TQueues>, params: TConnParams) => void | Promise<void>;
     /**
      * Called when a client successfully connects to the actor.
      *
@@ -2133,7 +2438,7 @@ interface BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatab
      * @param conn The connection object
      * @returns Void or a Promise that resolves when connection handling is complete
      */
-    onConnect?: (c: ConnectContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>, conn: Conn<TState, TConnParams, TConnState, TVars, TInput, TDatabase>) => void | Promise<void>;
+    onConnect?: (c: ConnectContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>, conn: Conn<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => void | Promise<void>;
     /**
      * Called when a client disconnects from the actor.
      *
@@ -2143,7 +2448,7 @@ interface BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatab
      * @param conn The connection that is being closed
      * @returns Void or a Promise that resolves when disconnect handling is complete
      */
-    onDisconnect?: (c: DisconnectContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>, conn: Conn<TState, TConnParams, TConnState, TVars, TInput, TDatabase>) => void | Promise<void>;
+    onDisconnect?: (c: DisconnectContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>, conn: Conn<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => void | Promise<void>;
     /**
      * Called before sending an action response to the client.
      *
@@ -2156,7 +2461,7 @@ interface BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatab
      * @param output The output that will be sent to the client
      * @returns The modified output to send to the client
      */
-    onBeforeActionResponse?: <Out>(c: BeforeActionResponseContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>, name: string, args: unknown[], output: Out) => Out | Promise<Out>;
+    onBeforeActionResponse?: <Out>(c: BeforeActionResponseContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>, name: string, args: unknown[], output: Out) => Out | Promise<Out>;
     /**
      * Called when a raw HTTP request is made to the actor.
      *
@@ -2168,7 +2473,7 @@ interface BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatab
      * @param opts Additional options
      * @returns A Response object to send back, or void to continue with default routing
      */
-    onRequest?: (c: RequestContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>, request: Request) => Response | Promise<Response>;
+    onRequest?: (c: RequestContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>, request: Request) => Response | Promise<Response>;
     /**
      * Called when a raw WebSocket connection is established to the actor.
      *
@@ -2179,8 +2484,16 @@ interface BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatab
      * @param websocket The raw WebSocket connection
      * @param opts Additional options including the original HTTP upgrade request
      */
-    onWebSocket?: (c: WebSocketContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>, websocket: UniversalWebSocket) => void | Promise<void>;
+    onWebSocket?: (c: WebSocketContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>, websocket: UniversalWebSocket) => void | Promise<void>;
     actions?: TActions;
+    /**
+     * Schema map for events broadcasted by this actor.
+     */
+    events?: TEvents;
+    /**
+     * Schema map for queue payloads sent by this actor.
+     */
+    queues?: TQueues;
 }
 type ActorDatabaseConfig<TDatabase extends AnyDatabaseProvider> = {
     /**
@@ -2188,61 +2501,74 @@ type ActorDatabaseConfig<TDatabase extends AnyDatabaseProvider> = {
      */
     db: TDatabase;
 } | Record<never, never>;
-type ActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> = Omit<z.infer<typeof ActorConfigSchema>, "actions" | "onCreate" | "onDestroy" | "onWake" | "onStateChange" | "onBeforeConnect" | "onConnect" | "onDisconnect" | "onBeforeActionResponse" | "onRequest" | "onWebSocket" | "state" | "createState" | "connState" | "createConnState" | "vars" | "createVars" | "db"> & BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatabase, Actions<TState, TConnParams, TConnState, TVars, TInput, TDatabase>> & CreateState<TState, TConnParams, TConnState, TVars, TInput, TDatabase> & CreateConnState<TState, TConnParams, TConnState, TVars, TInput, TDatabase> & CreateVars<TState, TConnParams, TConnState, TVars, TInput, TDatabase> & ActorDatabaseConfig<TDatabase>;
-type ActorConfigInput<TState = undefined, TConnParams = undefined, TConnState = undefined, TVars = undefined, TInput = undefined, TDatabase extends AnyDatabaseProvider = undefined, TActions extends Actions<TState, TConnParams, TConnState, TVars, TInput, TDatabase> = Record<never, never>> = {
+type ActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> = Omit<z$1.infer<typeof ActorConfigSchema>, "actions" | "events" | "queues" | "onCreate" | "onDestroy" | "onWake" | "onSleep" | "run" | "onStateChange" | "onBeforeConnect" | "onConnect" | "onDisconnect" | "onBeforeActionResponse" | "onRequest" | "onWebSocket" | "state" | "createState" | "connState" | "createConnState" | "vars" | "createVars" | "db"> & BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues, Actions<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>> & CreateState<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> & CreateConnState<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> & CreateVars<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> & ActorDatabaseConfig<TDatabase>;
+type ActorConfigInput<TState = undefined, TConnParams = undefined, TConnState = undefined, TVars = undefined, TInput = undefined, TDatabase extends AnyDatabaseProvider = undefined, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>, TActions extends Actions<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> = Record<never, never>> = {
     types?: ActorTypes<TState, TConnParams, TConnState, TVars, TInput, TDatabase>;
-} & Omit<z.input<typeof ActorConfigSchema>, "actions" | "onCreate" | "onDestroy" | "onWake" | "onSleep" | "onStateChange" | "onBeforeConnect" | "onConnect" | "onDisconnect" | "onBeforeActionResponse" | "onRequest" | "onWebSocket" | "state" | "createState" | "connState" | "createConnState" | "vars" | "createVars" | "db"> & BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TActions> & CreateState<TState, TConnParams, TConnState, TVars, TInput, TDatabase> & CreateConnState<TState, TConnParams, TConnState, TVars, TInput, TDatabase> & CreateVars<TState, TConnParams, TConnState, TVars, TInput, TDatabase> & ActorDatabaseConfig<TDatabase>;
-declare function test<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TActions extends Actions<TState, TConnParams, TConnState, TVars, TInput, TDatabase>>(input: ActorConfigInput<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TActions>): ActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatabase>;
-declare const DocActorOptionsSchema: z.ZodObject<{
-    createVarsTimeout: z.ZodOptional<z.ZodNumber>;
-    createConnStateTimeout: z.ZodOptional<z.ZodNumber>;
-    onConnectTimeout: z.ZodOptional<z.ZodNumber>;
-    onSleepTimeout: z.ZodOptional<z.ZodNumber>;
-    onDestroyTimeout: z.ZodOptional<z.ZodNumber>;
-    stateSaveInterval: z.ZodOptional<z.ZodNumber>;
-    actionTimeout: z.ZodOptional<z.ZodNumber>;
-    waitUntilTimeout: z.ZodOptional<z.ZodNumber>;
-    connectionLivenessTimeout: z.ZodOptional<z.ZodNumber>;
-    connectionLivenessInterval: z.ZodOptional<z.ZodNumber>;
-    noSleep: z.ZodOptional<z.ZodBoolean>;
-    sleepTimeout: z.ZodOptional<z.ZodNumber>;
-    canHibernateWebSocket: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-declare const DocActorConfigSchema: z.ZodObject<{
-    state: z.ZodOptional<z.ZodUnknown>;
-    createState: z.ZodOptional<z.ZodUnknown>;
-    connState: z.ZodOptional<z.ZodUnknown>;
-    createConnState: z.ZodOptional<z.ZodUnknown>;
-    vars: z.ZodOptional<z.ZodUnknown>;
-    createVars: z.ZodOptional<z.ZodUnknown>;
-    db: z.ZodOptional<z.ZodUnknown>;
-    onCreate: z.ZodOptional<z.ZodUnknown>;
-    onDestroy: z.ZodOptional<z.ZodUnknown>;
-    onWake: z.ZodOptional<z.ZodUnknown>;
-    onSleep: z.ZodOptional<z.ZodUnknown>;
-    onStateChange: z.ZodOptional<z.ZodUnknown>;
-    onBeforeConnect: z.ZodOptional<z.ZodUnknown>;
-    onConnect: z.ZodOptional<z.ZodUnknown>;
-    onDisconnect: z.ZodOptional<z.ZodUnknown>;
-    onBeforeActionResponse: z.ZodOptional<z.ZodUnknown>;
-    onRequest: z.ZodOptional<z.ZodUnknown>;
-    onWebSocket: z.ZodOptional<z.ZodUnknown>;
-    actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    options: z.ZodOptional<z.ZodObject<{
-        createVarsTimeout: z.ZodOptional<z.ZodNumber>;
-        createConnStateTimeout: z.ZodOptional<z.ZodNumber>;
-        onConnectTimeout: z.ZodOptional<z.ZodNumber>;
-        onSleepTimeout: z.ZodOptional<z.ZodNumber>;
-        onDestroyTimeout: z.ZodOptional<z.ZodNumber>;
-        stateSaveInterval: z.ZodOptional<z.ZodNumber>;
-        actionTimeout: z.ZodOptional<z.ZodNumber>;
-        waitUntilTimeout: z.ZodOptional<z.ZodNumber>;
-        connectionLivenessTimeout: z.ZodOptional<z.ZodNumber>;
-        connectionLivenessInterval: z.ZodOptional<z.ZodNumber>;
-        noSleep: z.ZodOptional<z.ZodBoolean>;
-        sleepTimeout: z.ZodOptional<z.ZodNumber>;
-        canHibernateWebSocket: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+} & Omit<z$1.input<typeof ActorConfigSchema>, "actions" | "events" | "queues" | "onCreate" | "onDestroy" | "onWake" | "onSleep" | "run" | "onStateChange" | "onBeforeConnect" | "onConnect" | "onDisconnect" | "onBeforeActionResponse" | "onRequest" | "onWebSocket" | "state" | "createState" | "connState" | "createConnState" | "vars" | "createVars" | "db"> & BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues, TActions> & CreateState<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> & CreateConnState<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> & CreateVars<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> & ActorDatabaseConfig<TDatabase>;
+declare function test<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig, TQueues extends QueueSchemaConfig, TActions extends Actions<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>>(input: ActorConfigInput<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues, TActions>): ActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>;
+declare const DocActorOptionsSchema: z$1.ZodObject<{
+    name: z$1.ZodOptional<z$1.ZodString>;
+    icon: z$1.ZodOptional<z$1.ZodString>;
+    createVarsTimeout: z$1.ZodOptional<z$1.ZodNumber>;
+    createConnStateTimeout: z$1.ZodOptional<z$1.ZodNumber>;
+    onConnectTimeout: z$1.ZodOptional<z$1.ZodNumber>;
+    onSleepTimeout: z$1.ZodOptional<z$1.ZodNumber>;
+    onDestroyTimeout: z$1.ZodOptional<z$1.ZodNumber>;
+    stateSaveInterval: z$1.ZodOptional<z$1.ZodNumber>;
+    actionTimeout: z$1.ZodOptional<z$1.ZodNumber>;
+    waitUntilTimeout: z$1.ZodOptional<z$1.ZodNumber>;
+    runStopTimeout: z$1.ZodOptional<z$1.ZodNumber>;
+    connectionLivenessTimeout: z$1.ZodOptional<z$1.ZodNumber>;
+    connectionLivenessInterval: z$1.ZodOptional<z$1.ZodNumber>;
+    noSleep: z$1.ZodOptional<z$1.ZodBoolean>;
+    sleepTimeout: z$1.ZodOptional<z$1.ZodNumber>;
+    maxQueueSize: z$1.ZodOptional<z$1.ZodNumber>;
+    maxQueueMessageSize: z$1.ZodOptional<z$1.ZodNumber>;
+    canHibernateWebSocket: z$1.ZodOptional<z$1.ZodBoolean>;
+}, z$1.core.$strip>;
+declare const DocActorConfigSchema: z$1.ZodObject<{
+    state: z$1.ZodOptional<z$1.ZodUnknown>;
+    createState: z$1.ZodOptional<z$1.ZodUnknown>;
+    connState: z$1.ZodOptional<z$1.ZodUnknown>;
+    createConnState: z$1.ZodOptional<z$1.ZodUnknown>;
+    vars: z$1.ZodOptional<z$1.ZodUnknown>;
+    createVars: z$1.ZodOptional<z$1.ZodUnknown>;
+    db: z$1.ZodOptional<z$1.ZodUnknown>;
+    onCreate: z$1.ZodOptional<z$1.ZodUnknown>;
+    onDestroy: z$1.ZodOptional<z$1.ZodUnknown>;
+    onWake: z$1.ZodOptional<z$1.ZodUnknown>;
+    onSleep: z$1.ZodOptional<z$1.ZodUnknown>;
+    run: z$1.ZodOptional<z$1.ZodUnknown>;
+    onStateChange: z$1.ZodOptional<z$1.ZodUnknown>;
+    onBeforeConnect: z$1.ZodOptional<z$1.ZodUnknown>;
+    onConnect: z$1.ZodOptional<z$1.ZodUnknown>;
+    onDisconnect: z$1.ZodOptional<z$1.ZodUnknown>;
+    onBeforeActionResponse: z$1.ZodOptional<z$1.ZodUnknown>;
+    onRequest: z$1.ZodOptional<z$1.ZodUnknown>;
+    onWebSocket: z$1.ZodOptional<z$1.ZodUnknown>;
+    actions: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+    events: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+    queues: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+    options: z$1.ZodOptional<z$1.ZodObject<{
+        name: z$1.ZodOptional<z$1.ZodString>;
+        icon: z$1.ZodOptional<z$1.ZodString>;
+        createVarsTimeout: z$1.ZodOptional<z$1.ZodNumber>;
+        createConnStateTimeout: z$1.ZodOptional<z$1.ZodNumber>;
+        onConnectTimeout: z$1.ZodOptional<z$1.ZodNumber>;
+        onSleepTimeout: z$1.ZodOptional<z$1.ZodNumber>;
+        onDestroyTimeout: z$1.ZodOptional<z$1.ZodNumber>;
+        stateSaveInterval: z$1.ZodOptional<z$1.ZodNumber>;
+        actionTimeout: z$1.ZodOptional<z$1.ZodNumber>;
+        waitUntilTimeout: z$1.ZodOptional<z$1.ZodNumber>;
+        runStopTimeout: z$1.ZodOptional<z$1.ZodNumber>;
+        connectionLivenessTimeout: z$1.ZodOptional<z$1.ZodNumber>;
+        connectionLivenessInterval: z$1.ZodOptional<z$1.ZodNumber>;
+        noSleep: z$1.ZodOptional<z$1.ZodBoolean>;
+        sleepTimeout: z$1.ZodOptional<z$1.ZodNumber>;
+        maxQueueSize: z$1.ZodOptional<z$1.ZodNumber>;
+        maxQueueMessageSize: z$1.ZodOptional<z$1.ZodNumber>;
+        canHibernateWebSocket: z$1.ZodOptional<z$1.ZodBoolean>;
+    }, z$1.core.$strip>>;
+}, z$1.core.$strip>;
 
-export { StateChangeContext as $, type ActorDriver as A, ActionContext as B, type Client as C, DocActorOptionsSchema as D, type Encoding as E, type ActionContextOf as F, BeforeActionResponseContext as G, type BeforeActionResponseContextOf as H, BeforeConnectContext as I, type BeforeConnectContextOf as J, ConnectContext as K, type ConnectContextOf as L, CreateContext as M, type CreateContextOf as N, CreateConnStateContext as O, type CreateConnStateContextOf as P, CreateVarsContext as Q, type RegistryConfig as R, type CreateVarsContextOf as S, DestroyContext as T, type DestroyContextOf as U, DisconnectContext as V, type DisconnectContextOf as W, RequestContext as X, type RequestContextOf as Y, SleepContext as Z, type SleepContextOf as _, type AnyConn as a, type StateChangeContextOf as a0, WakeContext as a1, type WakeContextOf as a2, WebSocketContext as a3, type WebSocketContextOf as a4, type RegistryActors as a5, RegistryConfigSchema as a6, type FetchHandler as a7, type ServerlessHandler as a8, type LegacyStartServerOutput as a9, type ActorHandle as aA, ActorHandleRaw as aB, type ActorAccessor as aC, ClientRaw as aD, type CreateOptions as aE, type ExtractActorsFromRegistry as aF, type ExtractRegistryFromClient as aG, type GetOptions as aH, type GetWithIdOptions as aI, type QueryOptions as aJ, type Region as aK, type ManagerDriver as aL, ActorInstance as aM, type ActorOutput as aN, type CreateInput as aO, type GetForIdInput as aP, type GetOrCreateWithKeyInput as aQ, type GetWithKeyInput as aR, type ListActorsInput as aS, type ManagerDisplayInformation as aT, type ManagerDriverBuilder as aU, type ActorDriverBuilder as aV, Registry as aa, setup as ab, ActorsSchema as ac, TestConfigSchema as ad, type TestConfig as ae, type RegistryConfigInput as af, buildActorNames as ag, DocInspectorConfigSchema as ah, DocConfigureRunnerPoolSchema as ai, DocServerlessConfigSchema as aj, DocRunnerConfigSchema as ak, DocRegistryConfigSchema as al, ActorClientError as am, ActorConnDisposed as an, ActorError as ao, InternalError as ap, MalformedResponseMessage as aq, ManagerError as ar, type CreateRequest as as, type ActorActionFunction as at, type ActorConn as au, type ActorConnStatus as av, type ConnectionStateCallback as aw, type EventUnsubscribe as ax, type StatusChangeCallback as ay, ActorConnRaw as az, type AnyActorInstance as b, type AnyDatabaseProvider as c, type Actions as d, type ActorConfigInput as e, ActorDefinition as f, type AnyClient as g, createClientWithDriver as h, type ActorQuery as i, type ActorKey as j, Conn as k, type AnyActorDefinition as l, lookupInRegistry as m, ActorKv as n, type ActorTypes as o, ActorConfigSchema as p, type AuthIntent as q, type ActorConfig as r, DocActorConfigSchema as s, test as t, ActorContext as u, type ActorContextOf as v, ConnContext as w, type ConnContextOf as x, ConnInitContext as y, type ConnInitContextOf as z };
+export { DocRunnerConfigSchema as $, type ActorDriver as A, BeforeActionResponseContext as B, type Client as C, ConnContext as D, type Encoding as E, type ConnContextOf as F, ConnInitContext as G, type ConnInitContextOf as H, ConnectContext as I, type ConnectContextOf as J, CreateConnStateContext as K, type CreateConnStateContextOf as L, CreateContext as M, type CreateContextOf as N, CreateVarsContext as O, type CreateVarsContextOf as P, type QueueSchemaConfig as Q, type RegistryConfig as R, DestroyContext as S, type DestroyContextOf as T, DisconnectContext as U, type DisconnectContextOf as V, DocActorConfigSchema as W, DocActorOptionsSchema as X, DocConfigureRunnerPoolSchema as Y, DocInspectorConfigSchema as Z, DocRegistryConfigSchema as _, type AnyConn as a, ActorInstance as a$, DocServerlessConfigSchema as a0, type FetchHandler as a1, type InspectorUnsubscribe as a2, type LegacyStartServerOutput as a3, RUN_FUNCTION_CONFIG_SYMBOL as a4, Registry as a5, type RegistryActors as a6, type RegistryConfigInput as a7, RegistryConfigSchema as a8, RequestContext as a9, test as aA, type ActorAccessor as aB, type ActorActionFunction as aC, ActorClientError as aD, type ActorConn as aE, ActorConnDisposed as aF, ActorConnRaw as aG, type ActorConnStatus as aH, ActorError as aI, type ActorHandle as aJ, ActorHandleRaw as aK, ClientRaw as aL, type ConnectionStateCallback as aM, type CreateOptions as aN, type CreateRequest as aO, type EventUnsubscribe as aP, type ExtractActorsFromRegistry as aQ, type ExtractRegistryFromClient as aR, type GetOptions as aS, type GetWithIdOptions as aT, InternalError as aU, MalformedResponseMessage as aV, ManagerError as aW, type QueryOptions as aX, type Region as aY, type StatusChangeCallback as aZ, type ManagerDriver as a_, type RequestContextOf as aa, type RunConfig as ab, RunConfigSchema as ac, RunContext as ad, type RunContextOf as ae, type RunInspectorConfig as af, type ServerlessHandler as ag, SleepContext as ah, type SleepContextOf as ai, StateChangeContext as aj, type StateChangeContextOf as ak, type TestConfig as al, TestConfigSchema as am, type Type as an, WakeContext as ao, type WakeContextOf as ap, WebSocketContext as aq, type WebSocketContextOf as ar, type WorkflowInspectorConfig as as, buildActorNames as at, createClientWithDriver as au, getRunFunction as av, getRunInspectorConfig as aw, getRunMetadata as ax, lookupInRegistry as ay, setup as az, type AnyActorInstance as b, type ActorOutput as b0, type CreateInput as b1, type GetForIdInput as b2, type GetOrCreateWithKeyInput as b3, type GetWithKeyInput as b4, type ListActorsInput as b5, type ManagerDisplayInformation as b6, type ManagerDriverBuilder as b7, type ActorDriverBuilder as b8, type QueueFilterName as b9, type QueueNextOptions as ba, type QueueResultMessageForName as bb, type InferSchemaMap as bc, type InferDatabaseClient as bd, type InferEventArgs as be, type EventSchemaConfig as c, type Actions as d, type ActorConfigInput as e, ActorDefinition as f, event as g, ActionContext as h, type ActionContextOf as i, type ActorConfig as j, ActorConfigSchema as k, ActorContext as l, type ActorContextOf as m, type ActorKey as n, ActorKv as o, type ActorQuery as p, queue as q, type ActorTypes as r, ActorsSchema as s, type AnyActorDefinition as t, type AnyClient as u, type AuthIntent as v, type BeforeActionResponseContextOf as w, BeforeConnectContext as x, type BeforeConnectContextOf as y, Conn as z };