rivetkit 2.0.42 → 2.1.0-rc.1

package/dist/{tsup/config-CLnylLYY.d.ts → browser/client.d.ts}

@@ -1,691 +1,572 @@
-import { z } from 'zod';
+import z$2, { z } from 'zod/v4';
 import { UniversalWebSocket } from '@rivetkit/virtual-websocket';
-import { Env, Context, Hono } from 'hono';
-import { VersionedDataHandler } from 'vbare';
+import { SqliteVfs } from '@rivetkit/sqlite-vfs';
+import { Traces, OtlpExportTraceServiceRequestJson, SpanHandle, SpanStatusInput } from '@rivetkit/traces';
+import { Context, Handler, Env, Hono } from 'hono';
+import { z as z$1 } from 'zod';
 import { Logger } from 'pino';
-import { GetUpgradeWebSocket } from './utils.js';
+import { VersionedDataHandler } from 'vbare';
+import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
 import * as nanoevents from 'nanoevents';
-import { a1 as Event } from './v1-Gq4avTK3.js';
+import { W as WorkflowHistory, k as QueueStatus } from './v3-DnYObHH3.js';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import '@rivetkit/bare-ts';
 
-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;
-}> = {
+/**
+ * Context provided to database providers for creating database clients
+ */
+interface DatabaseProviderContext {
+    /**
+     * Actor ID
+     */
+    actorId: string;
+    /**
+     * Override the default raw database client (optional).
+     * If not provided, a KV-backed client will be constructed.
+     */
+    overrideRawDatabaseClient?: () => Promise<RawDatabaseClient | undefined>;
+    /**
+     * Override the default Drizzle database client (optional).
+     * If not provided, a KV-backed client will be constructed.
+     */
+    overrideDrizzleDatabaseClient?: () => Promise<DrizzleDatabaseClient | undefined>;
+    /**
+     * KV operations for constructing KV-backed database clients
+     */
+    kv: {
+        batchPut: (entries: [Uint8Array, Uint8Array][]) => Promise<void>;
+        batchGet: (keys: Uint8Array[]) => Promise<(Uint8Array | null)[]>;
+        batchDelete: (keys: Uint8Array[]) => Promise<void>;
+    };
+    /**
+     * SQLite VFS instance for creating KV-backed databases.
+     * This should be actor-scoped because @rivetkit/sqlite is not re-entrant per
+     * module instance.
+     */
+    sqliteVfs?: SqliteVfs;
+}
+type DatabaseProvider<DB extends RawAccess> = {
     /**
      * 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>;
+    createClient: (ctx: DatabaseProviderContext) => Promise<DB>;
     /**
      * Runs before the actor has started.
      * Use this to run migrations or other setup tasks.
      * @experimental
      */
     onMigrate: (client: DB) => void | Promise<void>;
+    /**
+     * Runs when the actor is being destroyed.
+     * Use this to clean up database connections and release resources.
+     * @experimental
+     */
+    onDestroy?: (client: DB) => void | Promise<void>;
+};
+/**
+ * Raw database client with basic exec method
+ */
+interface RawDatabaseClient {
+    exec: <TRow extends Record<string, unknown> = Record<string, unknown>>(query: string, ...args: unknown[]) => Promise<TRow[]> | TRow[];
+}
+/**
+ * Drizzle database client interface (will be extended by drizzle-orm types)
+ */
+interface DrizzleDatabaseClient {
+}
+type ExecuteFunction = <TRow extends Record<string, unknown> = Record<string, unknown>>(query: string, ...args: unknown[]) => Promise<TRow[]>;
+type RawAccess = {
+    /**
+     * Executes a raw SQL query.
+     */
+    execute: ExecuteFunction;
+    /**
+     * Closes the database connection and releases resources.
+     */
+    close: () => Promise<void>;
 };
 
-type ManagerDriverBuilder = (config: RegistryConfig) => ManagerDriver;
-interface ManagerDriver {
-    getForId(input: GetForIdInput): Promise<ActorOutput | undefined>;
-    getWithKey(input: GetWithKeyInput): Promise<ActorOutput | undefined>;
-    getOrCreateWithKey(input: GetOrCreateWithKeyInput): Promise<ActorOutput>;
-    createActor(input: CreateInput): Promise<ActorOutput>;
-    listActors(input: ListActorsInput): Promise<ActorOutput[]>;
-    sendRequest(actorId: string, actorRequest: Request): Promise<Response>;
-    openWebSocket(path: string, actorId: string, encoding: Encoding, params: unknown): Promise<UniversalWebSocket>;
-    proxyRequest(c: Context, actorRequest: Request, actorId: string): Promise<Response>;
-    proxyWebSocket(c: Context, path: string, actorId: string, encoding: Encoding, params: unknown): Promise<Response>;
+type InferDatabaseClient<DBProvider extends AnyDatabaseProvider> = DBProvider extends DatabaseProvider<any> ? Awaited<ReturnType<DBProvider["createClient"]>> : never;
+
+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;
+}
+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];
+
+/**
+ * User-facing KV storage interface exposed on ActorContext.
+ */
+type KvValueType = "text" | "arrayBuffer" | "binary";
+type KvKeyType = "text" | "binary";
+type KvKey = Uint8Array | string;
+type KvValueTypeMap = {
+    text: string;
+    arrayBuffer: ArrayBuffer;
+    binary: Uint8Array;
+};
+type KvKeyTypeMap = {
+    text: string;
+    binary: Uint8Array;
+};
+type KvValueOptions<T extends KvValueType = "text"> = {
+    type?: T;
+};
+type KvListOptions<T extends KvValueType = "text", K extends KvKeyType = "text"> = KvValueOptions<T> & {
+    keyType?: K;
+};
+declare class ActorKv {
+    #private;
+    constructor(driver: ActorDriver, actorId: string);
     /**
-     * Build a public gateway URL for a specific actor.
-     *
-     * This lives on the driver because the base endpoint varies by runtime.
+     * Get a single value by key.
      */
-    buildGatewayUrl(actorId: string): Promise<string>;
-    displayInformation(): ManagerDisplayInformation;
-    extraStartupLog?: () => Record<string, unknown>;
-    modifyManagerRouter?: (config: RegistryConfig, router: Hono) => void;
+    get<T extends KvValueType = "text">(key: KvKey, options?: KvValueOptions<T>): Promise<KvValueTypeMap[T] | null>;
     /**
-     * Allows lazily setting getUpgradeWebSocket after the manager router has
-     * been initialized.
-     **/
-    setGetUpgradeWebSocket(getUpgradeWebSocket: GetUpgradeWebSocket): void;
-    /** Read a key. Returns null if the key doesn't exist. */
-    kvGet(actorId: string, key: Uint8Array): Promise<string | null>;
-}
-interface ManagerDisplayInformation {
-    properties: Record<string, string>;
-}
-interface GetForIdInput<E extends Env = any> {
-    c?: Context | undefined;
-    name: string;
-    actorId: string;
+     * Get multiple values by keys.
+     */
+    getBatch<T extends KvValueType = "text">(keys: KvKey[], options?: KvValueOptions<T>): Promise<(KvValueTypeMap[T] | null)[]>;
+    /**
+     * Put a single key-value pair.
+     */
+    put<T extends KvValueType = KvValueType>(key: KvKey, value: KvValueTypeMap[T], options?: KvValueOptions<T>): Promise<void>;
+    /**
+     * Put multiple key-value pairs.
+     */
+    putBatch<T extends KvValueType = KvValueType>(entries: [KvKey, KvValueTypeMap[T]][], options?: KvValueOptions<T>): Promise<void>;
+    /**
+     * Delete a single key.
+     */
+    delete(key: KvKey): Promise<void>;
+    /**
+     * Delete multiple keys.
+     */
+    deleteBatch(keys: KvKey[]): Promise<void>;
+    /**
+     * List all keys with a given prefix.
+     * Returns key-value pairs where keys have the user prefix removed.
+     */
+    list<T extends KvValueType = "text", K extends KvKeyType = "text">(prefix: KvKeyTypeMap[K], options?: KvListOptions<T, K>): Promise<[KvKeyTypeMap[K], KvValueTypeMap[T]][]>;
 }
-interface GetWithKeyInput<E extends Env = any> {
-    c?: Context | undefined;
+
+interface QueueMessage {
+    id: bigint;
     name: string;
-    key: ActorKey;
+    body: unknown;
+    createdAt: number;
 }
-interface GetOrCreateWithKeyInput<E extends Env = any> {
-    c?: Context | undefined;
-    name: string;
-    key: ActorKey;
-    input?: unknown;
-    region?: string;
+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[]>;
 }
-interface CreateInput<E extends Env = any> {
-    c?: Context | undefined;
-    name: string;
-    key: ActorKey;
-    input?: unknown;
-    region?: string;
+
+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;
 }
-interface ListActorsInput<E extends Env = any> {
-    c?: Context | undefined;
-    name: string;
-    key?: string;
-    includeDestroyed?: boolean;
+/** 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>;
 }
-interface ActorOutput {
-    actorId: string;
-    name: string;
-    key: ActorKey;
-    createTs?: number;
-    startTs?: number | null;
-    connectableTs?: number | null;
-    sleepTs?: number | null;
-    destroyTs?: number | null;
-    error?: unknown;
+
+declare class Schedule {
+    #private;
+    constructor(actor: AnyActorInstance);
+    after(duration: number, fn: string, ...args: unknown[]): Promise<void>;
+    at(timestamp: number, fn: string, ...args: unknown[]): Promise<void>;
 }
 
-type ActorDriverBuilder = (config: RegistryConfig, managerDriver: ManagerDriver, inlineClient: AnyClient) => ActorDriver;
-interface ActorDriver {
-    loadActor(actorId: string): Promise<AnyActorInstance>;
-    getContext(actorId: string): unknown;
-    /** Batch write multiple key-value pairs. Keys and values are Uint8Arrays. */
-    kvBatchPut(actorId: string, entries: [Uint8Array, Uint8Array][]): Promise<void>;
-    /** Batch read multiple keys. Returns null for keys that don't exist. */
-    kvBatchGet(actorId: string, keys: Uint8Array[]): Promise<(Uint8Array | null)[]>;
-    /** Batch delete multiple keys. */
-    kvBatchDelete(actorId: string, keys: Uint8Array[]): Promise<void>;
-    /** List all keys with a given prefix. */
-    kvListPrefix(actorId: string, prefix: Uint8Array): Promise<[Uint8Array, Uint8Array][]>;
-    /** ActorInstance ensure that only one instance of setAlarm is called in parallel at a time. */
-    setAlarm(actor: AnyActorInstance, timestamp: number): 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, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> {
+    #private;
+    [ACTOR_CONTEXT_INTERNAL_SYMBOL]: AnyActorInstance;
+    constructor(actor: ActorInstance<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>);
     /**
-     * @experimental
-     * This is an experimental API that may change in the future.
+     * Gets the KV storage interface.
      */
-    getDatabase(actorId: string): Promise<unknown | undefined>;
+    get kv(): ActorKv;
     /**
-     * Requests the actor to go to sleep.
+     * Get the actor state
      *
-     * This will call `ActorInstance.onStop` independently.
+     * @remarks
+     * This property is not available in `createState` since the state hasn't been created yet.
      */
-    startSleep?(actorId: string): void;
+    get state(): TState extends never ? never : TState;
     /**
-     * Destroys the actor and its associated data.
+     * Get the actor variables
      *
-     * This will call `ActorInstance.onStop` independently.
+     * @remarks
+     * This property is not available in `createVars` since the variables haven't been created yet.
+     * Variables are only available if you define `vars` or `createVars` in your actor config.
      */
-    startDestroy(actorId: string): void;
+    get vars(): TVars extends never ? never : TVars;
     /**
-     * Shuts down the actor runner.
+     * Broadcasts an event to all connected clients.
+     * @param name - The name of the event.
+     * @param args - The arguments to send with the event.
      */
-    shutdownRunner?(immediate: boolean): Promise<void>;
-    /** This handles the serverless start request. This should manage the lifecycle of the runner tied to the request lifecycle. */
-    serverlessHandleStart?(c: Context): Promise<Response>;
-    /** Extra properties to add to logs for each actor. */
-    getExtraActorLogParams?(): Record<string, string>;
-    onBeforeActorStart?(actor: AnyActorInstance): Promise<void>;
-    onCreateConn?(conn: AnyConn): void;
-    onDestroyConn?(conn: AnyConn): void;
-    onBeforePersistConn?(conn: AnyConn): void;
-    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>>>;
-type RegistryActors = z.infer<typeof ActorsSchema>;
-declare const TestConfigSchema: z.ZodObject<{
-    enabled: z.ZodBoolean;
-}, z.core.$strip>;
-type TestConfig = z.infer<typeof TestConfigSchema>;
-declare const RegistryConfigSchema: z.ZodPipe<z.ZodObject<{
-    use: z.ZodRecord<z.ZodString, z.ZodCustom<AnyActorDefinition, AnyActorDefinition>>;
-    test: z.ZodDefault<z.ZodOptional<z.ZodObject<{
-        enabled: z.ZodBoolean;
-    }, z.core.$strip>>>;
-    driver: z.ZodOptional<z.ZodObject<{
-        name: z.ZodString;
-        displayName: z.ZodString;
-        manager: z.ZodCustom<ManagerDriverBuilder, ManagerDriverBuilder>;
-        actor: z.ZodCustom<ActorDriverBuilder, ActorDriverBuilder>;
-        autoStartActorDriver: z.ZodBoolean;
-    }, z.core.$strip>>;
-    maxIncomingMessageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    maxOutgoingMessageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    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<{
-            error: "error";
-            trace: "trace";
-            fatal: "fatal";
-            warn: "warn";
-            info: "info";
-            debug: "debug";
-            silent: "silent";
-        }>>;
-    }, z.core.$strip>>>;
-    endpoint: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, 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>>;
-    headers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
-    serveManager: z.ZodOptional<z.ZodBoolean>;
-    managerBasePath: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-    managerPort: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    managerHost: z.ZodOptional<z.ZodString>;
-    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>>>;
-    serverless: z.ZodDefault<z.ZodOptional<z.ZodObject<{
-        spawnEngine: z.ZodDefault<z.ZodBoolean>;
-        engineVersion: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-        configureRunnerPool: z.ZodOptional<z.ZodOptional<z.ZodObject<{
-            name: z.ZodOptional<z.ZodString>;
-            url: 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>>;
-            metadataPollInterval: z.ZodOptional<z.ZodNumber>;
-            drainOnVersionUpgrade: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>>>;
-        basePath: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-        publicEndpoint: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
-        publicToken: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
-    }, z.core.$strip>>>;
-    runner: z.ZodDefault<z.ZodOptional<z.ZodObject<{
-        totalSlots: z.ZodDefault<z.ZodNumber>;
-        runnerName: z.ZodDefault<z.ZodString>;
-        runnerKey: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
-        version: z.ZodDefault<z.ZodNumber>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>, z.ZodTransform<{
-    endpoint: string | undefined;
-    namespace: string;
-    token: string | undefined;
-    serveManager: boolean;
-    publicEndpoint: string | undefined;
-    publicNamespace: string | undefined;
-    publicToken: string | undefined;
-    inspector: {
-        enabled: boolean;
-        token: () => string;
-        defaultEndpoint?: string | undefined;
-    } | {
-        enabled: {
-            manager: boolean;
-            actor: boolean;
-        };
-        token: () => string;
-        defaultEndpoint?: string | undefined;
-    };
-    serverless: {
-        publicEndpoint: string | undefined;
-        spawnEngine: boolean;
-        engineVersion: string;
-        basePath: string;
-        publicToken: string | undefined;
-        configureRunnerPool?: {
-            url: string;
-            name?: string | undefined;
-            headers?: Record<string, string> | undefined;
-            maxRunners?: number | undefined;
-            minRunners?: number | undefined;
-            requestLifespan?: number | undefined;
-            runnersMargin?: number | undefined;
-            slotsPerRunner?: number | undefined;
-            metadata?: Record<string, unknown> | undefined;
-            metadataPollInterval?: number | undefined;
-            drainOnVersionUpgrade?: boolean | undefined;
-        } | undefined;
-    };
-    use: Record<string, AnyActorDefinition>;
-    test: {
-        enabled: boolean;
-    };
-    maxIncomingMessageSize: number;
-    maxOutgoingMessageSize: number;
-    noWelcome: boolean;
-    logging: {
-        baseLogger?: Logger | undefined;
-        level?: "error" | "trace" | "fatal" | "warn" | "info" | "debug" | "silent" | undefined;
-    };
-    headers: Record<string, string>;
-    managerBasePath: string;
-    managerPort: number;
-    runner: {
-        totalSlots: number;
-        runnerName: string;
-        runnerKey: string | undefined;
-        version: number;
-    };
-    driver?: {
-        name: string;
-        displayName: string;
-        manager: ManagerDriverBuilder;
-        actor: ActorDriverBuilder;
-        autoStartActorDriver: boolean;
-    } | undefined;
-    managerHost?: string | undefined;
-}, {
-    use: Record<string, AnyActorDefinition>;
-    test: {
-        enabled: boolean;
-    };
-    maxIncomingMessageSize: number;
-    maxOutgoingMessageSize: number;
-    noWelcome: boolean;
-    logging: {
-        baseLogger?: Logger | undefined;
-        level?: "error" | "trace" | "fatal" | "warn" | "info" | "debug" | "silent" | undefined;
-    };
-    endpoint: string | undefined;
-    token: string | undefined;
-    namespace: string | undefined;
-    headers: Record<string, string>;
-    managerBasePath: string;
-    managerPort: number;
-    inspector: {
-        enabled: boolean;
-        token: () => string;
-        defaultEndpoint?: string | undefined;
-    };
-    serverless: {
-        spawnEngine: boolean;
-        engineVersion: string;
-        basePath: string;
-        publicEndpoint: string | undefined;
-        publicToken: string | undefined;
-        configureRunnerPool?: {
-            url: string;
-            name?: string | undefined;
-            headers?: Record<string, string> | undefined;
-            maxRunners?: number | undefined;
-            minRunners?: number | undefined;
-            requestLifespan?: number | undefined;
-            runnersMargin?: number | undefined;
-            slotsPerRunner?: number | undefined;
-            metadata?: Record<string, unknown> | undefined;
-            metadataPollInterval?: number | undefined;
-            drainOnVersionUpgrade?: boolean | undefined;
-        } | undefined;
-    };
-    runner: {
-        totalSlots: number;
-        runnerName: string;
-        runnerKey: string | undefined;
-        version: number;
-    };
-    driver?: {
-        name: string;
-        displayName: string;
-        manager: ManagerDriverBuilder;
-        actor: ActorDriverBuilder;
-        autoStartActorDriver: boolean;
-    } | undefined;
-    serveManager?: boolean | undefined;
-    managerHost?: string | undefined;
-}>>;
-type RegistryConfig = z.infer<typeof RegistryConfigSchema>;
-type RegistryConfigInput<A extends RegistryActors> = Omit<z.input<typeof RegistryConfigSchema>, "use"> & {
-    use: A;
-};
-declare function buildActorNames(config: RegistryConfig): Record<string, {
-    metadata: Record<string, any>;
-}>;
-declare const DocInspectorConfigSchema: z.ZodOptional<z.ZodObject<{
-    enabled: z.ZodOptional<z.ZodBoolean>;
-    token: z.ZodOptional<z.ZodString>;
-    defaultEndpoint: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>;
-declare const DocConfigureRunnerPoolSchema: z.ZodOptional<z.ZodObject<{
-    name: z.ZodOptional<z.ZodString>;
-    url: 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>>;
-    metadataPollInterval: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>>;
-declare const DocServerlessConfigSchema: z.ZodObject<{
-    spawnEngine: z.ZodOptional<z.ZodBoolean>;
-    engineVersion: z.ZodOptional<z.ZodString>;
-    configureRunnerPool: z.ZodOptional<z.ZodObject<{
-        name: z.ZodOptional<z.ZodString>;
-        url: 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>>;
-        metadataPollInterval: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    basePath: z.ZodOptional<z.ZodString>;
-    publicEndpoint: z.ZodOptional<z.ZodString>;
-    publicToken: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-declare const DocRunnerConfigSchema: z.ZodObject<{
-    totalSlots: z.ZodOptional<z.ZodNumber>;
-    runnerName: z.ZodOptional<z.ZodString>;
-    runnerKey: z.ZodOptional<z.ZodString>;
-    version: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-declare const DocRegistryConfigSchema: z.ZodObject<{
-    use: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    maxIncomingMessageSize: z.ZodOptional<z.ZodNumber>;
-    maxOutgoingMessageSize: z.ZodOptional<z.ZodNumber>;
-    noWelcome: z.ZodOptional<z.ZodBoolean>;
-    logging: z.ZodOptional<z.ZodObject<{
-        level: z.ZodOptional<z.ZodEnum<{
-            error: "error";
-            trace: "trace";
-            fatal: "fatal";
-            warn: "warn";
-            info: "info";
-            debug: "debug";
-            silent: "silent";
-        }>>;
-    }, z.core.$strip>>;
-    endpoint: z.ZodOptional<z.ZodString>;
-    token: z.ZodOptional<z.ZodString>;
-    namespace: z.ZodOptional<z.ZodString>;
-    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    serveManager: z.ZodOptional<z.ZodBoolean>;
-    managerBasePath: z.ZodOptional<z.ZodString>;
-    managerPort: z.ZodOptional<z.ZodNumber>;
-    inspector: z.ZodOptional<z.ZodObject<{
-        enabled: z.ZodOptional<z.ZodBoolean>;
-        token: z.ZodOptional<z.ZodString>;
-        defaultEndpoint: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    serverless: z.ZodOptional<z.ZodObject<{
-        spawnEngine: z.ZodOptional<z.ZodBoolean>;
-        engineVersion: z.ZodOptional<z.ZodString>;
-        configureRunnerPool: z.ZodOptional<z.ZodObject<{
-            name: z.ZodOptional<z.ZodString>;
-            url: 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>>;
-            metadataPollInterval: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-        basePath: z.ZodOptional<z.ZodString>;
-        publicEndpoint: z.ZodOptional<z.ZodString>;
-        publicToken: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    runner: z.ZodOptional<z.ZodObject<{
-        totalSlots: z.ZodOptional<z.ZodNumber>;
-        runnerName: z.ZodOptional<z.ZodString>;
-        runnerKey: z.ZodOptional<z.ZodString>;
-        version: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+    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.
+     */
+    get actorId(): string;
+    /**
+     * Gets the actor name.
+     */
+    get name(): string;
+    /**
+     * Gets the actor key.
+     */
+    get key(): ActorKey;
+    /**
+     * Gets the region.
+     */
+    get region(): string;
+    /**
+     * Gets the scheduler.
+     */
+    get schedule(): Schedule;
+    /**
+     * Gets the map of connections.
+     */
+    get conns(): Map<ConnId, Conn<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>>;
+    /**
+     * Returns the client for the given registry.
+     */
+    client<R extends Registry<any>>(): Client<R>;
+    /**
+     * Gets the database.
+     *
+     * @experimental
+     * @remarks
+     * This property is only available if you define a `db` provider in your actor config.
+     * @throws {DatabaseNotEnabled} If the database is not enabled.
+     */
+    get db(): TDatabase extends never ? never : InferDatabaseClient<TDatabase>;
+    /**
+     * Forces the state to get saved.
+     *
+     * @param opts - Options for saving the state.
+     */
+    saveState(opts: SaveStateOptions): Promise<void>;
+    /**
+     * 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.
+     *
+     * Not supported on all drivers.
+     *
+     * @experimental
+     */
+    sleep(): void;
+    /**
+     * Forces the actor to destroy.
+     *
+     * This will return immediately, then call `onStop` and `onDestroy`.
+     *
+     * @experimental
+     */
+    destroy(): void;
+}
 
-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>> {
-    #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>;
+/**
+ * Base context for connection-based handlers.
+ * Extends ActorContext with connection-specific functionality.
+ */
+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>;
 }
-declare function lookupInRegistry(config: RegistryConfig, name: string): AnyActorDefinition;
 
-/** Data that's been serialized. */
-type OutputData = string | Uint8Array;
-declare const EncodingSchema: z.ZodEnum<{
-    json: "json";
-    cbor: "cbor";
-    bare: "bare";
-}>;
 /**
- * Encoding used to communicate between the client & actor.
+ * Context for a remote procedure call.
  */
-type Encoding = z.infer<typeof EncodingSchema>;
+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> {
+}
+
 /**
- * Helper class that helps serialize data without re-serializing for the same encoding.
+ * Base context for connection initialization handlers.
+ * Extends ActorContext with request-specific functionality for connection lifecycle events.
  */
-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);
-    get rawData(): T;
-    serialize(encoding: Encoding): OutputData;
+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;
 }
 
-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<{
-        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<{
-            error: "error";
-            trace: "trace";
-            fatal: "fatal";
-            warn: "warn";
-            info: "info";
-            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<{
-        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<{
-    runnerKey: string | undefined;
-    endpoint: string | undefined;
-    namespace: string;
-    token: string | undefined;
-    runnerName: string;
-    encoding: "json" | "cbor" | "bare";
-    headers: Record<string, string>;
-    disableMetadataLookup: boolean;
-    devtools: boolean;
-    getUpgradeWebSocket?: GetUpgradeWebSocket | undefined;
-    maxIncomingMessageSize: number;
-    maxOutgoingMessageSize: number;
-    inspector: {
-        enabled: boolean;
-        token: () => string;
-        defaultEndpoint?: string | undefined;
-    };
-    disableDefaultServer: boolean;
-    defaultServerPort: number;
-    runEngine: boolean;
-    runEngineVersion: string;
-    disableActorDriver: boolean;
-    runnerKind: "serverless" | "normal";
-    basePath: string;
-    noWelcome: boolean;
-    logging: {
-        baseLogger?: Logger | undefined;
-        level?: "error" | "trace" | "fatal" | "warn" | "info" | "debug" | "silent" | undefined;
-    };
-    totalSlots: number;
-    driver?: {
-        name: string;
-        manager: ManagerDriverBuilder;
-        actor: ActorDriverBuilder;
-    } | undefined;
-    overrideServerAddress?: string | undefined;
-    autoConfigureServerless?: boolean | {
-        url?: string | undefined;
-        headers?: Record<string, string> | undefined;
-        maxRunners?: number | undefined;
-        minRunners?: number | undefined;
-        requestLifespan?: number | undefined;
-        runnersMargin?: number | undefined;
-        slotsPerRunner?: number | undefined;
-        metadata?: Record<string, unknown> | undefined;
-    } | undefined;
-}, {
-    maxIncomingMessageSize: number;
-    maxOutgoingMessageSize: number;
-    inspector: {
-        enabled: boolean;
-        token: () => string;
-        defaultEndpoint?: string | undefined;
-    };
-    disableDefaultServer: boolean;
-    defaultServerPort: number;
-    runEngine: boolean;
-    runEngineVersion: string;
-    disableActorDriver: boolean;
-    runnerKind: "serverless" | "normal";
-    basePath: string;
-    noWelcome: boolean;
-    logging: {
-        baseLogger?: Logger | undefined;
-        level?: "error" | "trace" | "fatal" | "warn" | "info" | "debug" | "silent" | undefined;
-    };
-    endpoint: string;
-    token: string | undefined;
-    namespace: string | undefined;
-    runnerName: string;
-    encoding: "json" | "cbor" | "bare";
-    headers: Record<string, string>;
-    disableMetadataLookup: boolean;
-    devtools: boolean;
-    runnerKey: string | undefined;
-    totalSlots: number;
-    driver?: {
-        name: string;
-        manager: ManagerDriverBuilder;
-        actor: ActorDriverBuilder;
-    } | undefined;
-    overrideServerAddress?: string | undefined;
-    autoConfigureServerless?: boolean | {
-        url?: string | undefined;
-        headers?: Record<string, string> | undefined;
-        maxRunners?: number | undefined;
-        minRunners?: number | undefined;
-        requestLifespan?: number | undefined;
-        runnersMargin?: number | undefined;
-        slotsPerRunner?: number | undefined;
-        metadata?: Record<string, unknown> | undefined;
-    } | undefined;
-    getUpgradeWebSocket?: GetUpgradeWebSocket | undefined;
-}>>>;
-type LegacyRunnerConfigInput = z.input<typeof LegacyRunnerConfigSchema>;
+/**
+ * Context for the onBeforeActionResponse lifecycle hook.
+ */
+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 FetchHandler = (request: Request, ...args: any) => Response | Promise<Response>;
-interface ServerlessHandler {
-    fetch: FetchHandler;
+/**
+ * Context for the onBeforeConnect lifecycle hook.
+ */
+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> {
 }
-interface LegacyStartServerOutput<A extends Registry<any>> {
-    /** Client to communicate with the actors. */
-    client: Client<A>;
-    /** Fetch handler to manually route requests to the Rivet manager API. */
-    fetch: FetchHandler;
+
+/**
+ * Context for the onConnect lifecycle hook.
+ */
+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> {
 }
-declare class Registry<A extends RegistryActors> {
-    #private;
-    get config(): RegistryConfigInput<A>;
-    parseConfig(): RegistryConfig;
-    constructor(config: RegistryConfigInput<A>);
-    /**
-     * Handle an incoming HTTP request for serverless deployments.
-     *
-     * @example
-     * ```ts
-     * const app = new Hono();
-     * app.all("/api/rivet/*", (c) => registry.handler(c.req.raw));
-     * export default app;
-     * ```
-     */
-    handler(request: Request): Promise<Response>;
-    /**
-     * Returns a fetch handler for serverless deployments.
-     *
-     * @example
-     * ```ts
-     * export default registry.serve();
-     * ```
-     */
-    serve(): ServerlessHandler;
+
+/**
+ * Context for the onCreate lifecycle hook.
+ */
+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> {
+}
+
+/**
+ * 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, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ConnInitContext<TState, TVars, TInput, TDatabase, TEvents, TQueues> {
+}
+
+/**
+ * Context for the createVars lifecycle hook.
+ */
+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> {
+}
+
+/**
+ * Context for the onDestroy lifecycle hook.
+ */
+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> {
+}
+
+/**
+ * Context for the onDisconnect lifecycle hook.
+ */
+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> {
+}
+
+/**
+ * Context for raw HTTP request handlers (onRequest).
+ */
+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> {
     /**
-     * Starts an actor runner for standalone server deployments.
+     * The incoming HTTP request.
+     * May be undefined for request contexts initiated without a direct HTTP request.
      */
-    startRunner(): void;
+    readonly request: Request | undefined;
+}
+
+/**
+ * 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> {
+}
+
+/**
+ * Context for the onSleep lifecycle hook.
+ */
+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> {
+}
+
+/**
+ * Context for the onStateChange lifecycle hook.
+ */
+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> {
+}
+
+/**
+ * Context for the onWake lifecycle hook.
+ */
+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> {
+}
+
+/**
+ * Context for raw WebSocket handlers (onWebSocket).
+ */
+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> {
     /**
-     * Runs the registry for a server.
-     *
-     * @deprecated Use {@link Registry.startRunner} for long-running servers or {@link Registry.handler} for serverless deployments.
+     * The incoming HTTP request that initiated the WebSocket upgrade.
+     * May be undefined for WebSocket connections initiated without a direct HTTP request.
      */
-    start(inputConfig?: LegacyRunnerConfigInput): LegacyStartServerOutput<this>;
+    readonly request: Request | undefined;
+}
+
+/** Data that's been serialized. */
+type OutputData = string | Uint8Array;
+declare const EncodingSchema: z.ZodEnum<{
+    json: "json";
+    cbor: "cbor";
+    bare: "bare";
+}>;
+/**
+ * Encoding used to communicate between the client & actor.
+ */
+type Encoding = z.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);
+    get rawData(): T;
+    serialize(encoding: Encoding): OutputData;
 }
-declare function setup<A extends RegistryActors>(input: RegistryConfigInput<A>): Registry<A>;
+
+type UpgradeWebSocket = (createEvents: (c: Context) => any) => Handler;
+type GetUpgradeWebSocket = () => UpgradeWebSocket;
+
+declare const KEYS: {
+    PERSIST_DATA: Uint8Array<ArrayBuffer>;
+    CONN_PREFIX: Uint8Array<ArrayBuffer>;
+    INSPECTOR_TOKEN: Uint8Array<ArrayBuffer>;
+    KV: Uint8Array<ArrayBuffer>;
+    QUEUE_PREFIX: Uint8Array<ArrayBuffer>;
+    WORKFLOW_PREFIX: Uint8Array<ArrayBuffer>;
+    TRACES_PREFIX: Uint8Array<ArrayBuffer>;
+    SQLITE_PREFIX: Uint8Array<ArrayBuffer>;
+};
 
 declare const ActorKeySchema: z.ZodArray<z.ZodString>;
 type ActorKey = z.infer<typeof ActorKeySchema>;
@@ -726,1523 +607,1859 @@ type ActorQuery = z.infer<typeof ActorQuerySchema>;
  */
 type CreateRequest = z.infer<typeof CreateRequestSchema>;
 
+interface ActorInspectorEmitterEvents {
+    stateUpdated: (state: unknown) => void;
+    connectionsUpdated: () => void;
+    queueUpdated: () => void;
+    workflowHistoryUpdated: (history: WorkflowHistory) => void;
+}
 /**
- * Action function returned by Actor connections and handles.
- *
- * @typedef {Function} ActorActionFunction
- * @template Args
- * @template Response
- * @param {...Args} args - Arguments for the action function.
- * @returns {Promise<Response>}
- */
-type ActorActionFunction<Args extends Array<unknown> = unknown[], Response = unknown> = (...args: Args extends [unknown, ...infer Rest] ? Rest : Args) => Promise<Response>;
-/**
- * Maps action methods from actor definition to typed function signatures.
+ * Provides a unified interface for inspecting actor external and internal state.
  */
-type ActorDefinitionActions<AD extends AnyActorDefinition> = AD extends ActorDefinition<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;
-
-declare class ActorClientError extends Error {
-}
-declare class InternalError extends ActorClientError {
-}
-declare class ManagerError extends ActorClientError {
-    constructor(error: string, opts?: ErrorOptions);
-}
-declare class MalformedResponseMessage extends ActorClientError {
-    constructor(cause?: unknown);
+declare class ActorInspector {
+    #private;
+    private readonly actor;
+    readonly emitter: nanoevents.Emitter<ActorInspectorEmitterEvents>;
+    constructor(actor: AnyActorInstance);
+    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[];
+    getConnections(): {
+        type: string | undefined;
+        id: string;
+        details: ArrayBuffer;
+    }[];
+    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;
+        }[];
+    }>;
 }
-declare class ActorError extends ActorClientError {
-    readonly group: string;
-    readonly code: string;
-    readonly metadata?: unknown | undefined;
-    __type: string;
-    constructor(group: string, code: string, message: string, metadata?: unknown | undefined);
+
+declare enum DriverReadyState {
+    UNKNOWN = -1,
+    CONNECTING = 0,
+    OPEN = 1,
+    CLOSING = 2,
+    CLOSED = 3
 }
-declare class ActorConnDisposed extends ActorClientError {
-    constructor();
+interface ConnDriver {
+    /** The type of driver. Used for debug purposes only. */
+    type: string;
+    /**
+     * If defined, this connection driver talks the RivetKit client driver (see
+     * schemas/client-protocol/).
+     *
+     * If enabled, events like `Init`, subscription events, etc. will be sent
+     * to this connection.
+     */
+    rivetKitProtocol?: {
+        /** Sends a RivetKit client message. */
+        sendMessage(actor: AnyActorInstance, conn: AnyConn, message: CachedSerializer<any, any, any>): void;
+    };
+    /**
+     * If the connection can be hibernated. If true, this will allow the actor to go to sleep while the connection is still active.
+     **/
+    hibernatable?: {
+        gatewayId: ArrayBuffer;
+        requestId: ArrayBuffer;
+    };
+    /**
+     * This returns a promise since we commonly disconnect at the end of a program, and not waiting will cause the socket to not close cleanly.
+     */
+    disconnect(actor: AnyActorInstance, conn: AnyConn, reason?: string): Promise<void>;
+    /** Terminates the connection without graceful handling. */
+    terminate?(actor: AnyActorInstance, conn: AnyConn): void;
+    /**
+     * Returns the ready state of the connection.
+     * This is used to determine if the connection is ready to send messages, or if the connection is stale.
+     */
+    getConnectionReadyState(actor: AnyActorInstance, conn: AnyConn): DriverReadyState | undefined;
 }
 
 /**
- * Connection status for an actor connection.
- *
- * - `"idle"`: Not connected, no auto-reconnect (initial state, after dispose, or disabled)
- * - `"connecting"`: Attempting to establish connection
- * - `"connected"`: Connection is active
- * - `"disconnected"`: Connection was lost, will auto-reconnect
- */
-type ActorConnStatus = "idle" | "connecting" | "connected" | "disconnected";
-/**
- * A function that unsubscribes from an event.
- *
- * @typedef {Function} EventUnsubscribe
- */
-type EventUnsubscribe = () => void;
-/**
- * A function that handles connection errors.
- *
- * @typedef {Function} ActorErrorCallback
- */
-type ActorErrorCallback = (error: ActorError) => void;
-/**
- * A callback for connection state changes.
- *
- * @typedef {Function} ConnectionStateCallback
- */
-type ConnectionStateCallback = () => void;
-/**
- * A callback for connection status changes.
+ * Persisted data structures for connections.
  *
- * @typedef {Function} StatusChangeCallback
+ * Keep this file in sync with the Connection section of rivetkit-typescript/packages/rivetkit/schemas/actor-persist/
  */
-type StatusChangeCallback = (status: ActorConnStatus) => void;
-declare const CONNECT_SYMBOL: unique symbol;
+
+type GatewayId = ArrayBuffer;
+type RequestId = ArrayBuffer;
+/** Event subscription for connection */
+interface PersistedSubscription {
+    eventName: string;
+}
+/** Connection associated with hibernatable WebSocket that should persist across lifecycles */
+interface PersistedConn<CP, CS> {
+    /** Connection ID generated by RivetKit */
+    id: string;
+    parameters: CP;
+    state: CS;
+    subscriptions: PersistedSubscription[];
+    gatewayId: GatewayId;
+    requestId: RequestId;
+    serverMessageIndex: number;
+    clientMessageIndex: number;
+    requestPath: string;
+    requestHeaders: Record<string, string>;
+}
+
 /**
- * Provides underlying functions for {@link ActorConn}. See {@link ActorConn} for using type-safe remote procedure calls.
- *
- * @see {@link ActorConn}
+ * Manages all connection-related operations for an actor instance.
+ * Handles connection creation, tracking, hibernation, and cleanup.
  */
-declare class ActorConnRaw {
+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, 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, E, Q>): void;
     /**
-     * Do not call this directly.
-     *
-     * Creates an instance of ActorConnRaw.
-     *
-     * @protected
+     * Handles pre-connection logic (i.e. auth & create state) before actually connecting the connection.
      */
-    constructor(client: ClientRaw, driver: ManagerDriver, params: unknown, encoding: Encoding, actorQuery: ActorQuery);
+    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>>;
     /**
-     * Call a raw action connection. See {@link ActorConn} for type-safe action calls.
+     * Adds a connection form prepareConn to the actor and calls onConnect.
      *
-     * @see {@link ActorConn}
-     * @template Args - The type of arguments to pass to the action function.
-     * @template Response - The type of the response returned by the action function.
-     * @param {string} name - The name of the action function to call.
-     * @param {...Args} args - The arguments to pass to the action function.
-     * @returns {Promise<Response>} - A promise that resolves to the response of the action function.
+     * This method is intentionally not async since it needs to be called in
+     * `onOpen` for WebSockets. If this is async, the order of open events will
+     * be messed up and cause race conditions that can drop WebSocket messages.
+     * So all async work in prepareConn.
      */
-    action<Args extends Array<unknown> = unknown[], Response = unknown>(opts: {
-        name: string;
-        args: Args;
-        signal?: AbortSignal;
-    }): Promise<Response>;
+    connectConn(conn: Conn<S, CP, CS, V, I, DB, E, Q>): void;
     /**
-     * Do not call this directly.
-enc
-     * Establishes a connection to the server using the specified endpoint & encoding & driver.
+     * Handle connection disconnection.
      *
-     * @protected
+     * This is called by `Conn.disconnect`. This should not call `Conn.disconnect.`
      */
-    [CONNECT_SYMBOL](): void;
+    connDisconnected(conn: Conn<S, CP, CS, V, I, DB, E, Q>): Promise<void>;
+    cleanupPersistedHibernatableConnections(reason?: string): Promise<number>;
     /**
-     * Subscribes to an event that will happen repeatedly.
+     * 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, 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, 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, E extends EventSchemaConfig = Record<never, never>, Q extends QueueSchemaConfig = Record<never, never>> {
+    #private;
+    constructor(actor: ActorInstance<S, CP, CS, V, I, DB, E, Q>);
+    /**
+     * Adds a subscription for a connection to an event.
      *
-     * @template Args - The type of arguments the event callback will receive.
-     * @param {string} eventName - The name of the event to subscribe to.
-     * @param {(...args: Args) => void} callback - The callback function to execute when the event is triggered.
-     * @returns {EventUnsubscribe} - A function to unsubscribe from the event.
-     * @see {@link https://rivet.dev/docs/events|Events Documentation}
+     * @param eventName - The name of the event to subscribe to
+     * @param connection - The connection subscribing to the event
+     * @param fromPersist - Whether this subscription is being restored from persistence
      */
-    on<Args extends Array<unknown> = unknown[]>(eventName: string, callback: (...args: Args) => void): EventUnsubscribe;
+    addSubscription(eventName: string, connection: Conn<S, CP, CS, V, I, DB, E, Q>, fromPersist: boolean): void;
     /**
-     * Subscribes to an event that will be triggered only once.
+     * Removes a subscription for a connection from an event.
      *
-     * @template Args - The type of arguments the event callback will receive.
-     * @param {string} eventName - The name of the event to subscribe to.
-     * @param {(...args: Args) => void} callback - The callback function to execute when the event is triggered.
-     * @returns {EventUnsubscribe} - A function to unsubscribe from the event.
-     * @see {@link https://rivet.dev/docs/events|Events Documentation}
+     * @param eventName - The name of the event to unsubscribe from
+     * @param connection - The connection unsubscribing from the event
+     * @param fromRemoveConn - Whether this is being called as part of connection removal
      */
-    once<Args extends Array<unknown> = unknown[]>(eventName: string, callback: (...args: Args) => void): EventUnsubscribe;
+    removeSubscription(eventName: string, connection: Conn<S, CP, CS, V, I, DB, E, Q>, fromRemoveConn: boolean): void;
     /**
-     * Subscribes to connection errors.
+     * Broadcasts an event to all subscribed connections.
      *
-     * @param {ActorErrorCallback} callback - The callback function to execute when a connection error occurs.
-     * @returns {() => void} - A function to unsubscribe from the error handler.
+     * @param name - The name of the event to broadcast
+     * @param args - The arguments to send with the event
      */
-    onError(callback: ActorErrorCallback): () => void;
+    broadcast<Args extends Array<unknown>>(name: string, ...args: Args): void;
     /**
-     * Returns the current connection status.
+     * Gets all subscribers for a specific event.
      *
-     * @returns {ActorConnStatus} - The current connection status.
+     * @param eventName - The name of the event
+     * @returns Set of connections subscribed to the event, or undefined if no subscribers
      */
-    get connStatus(): ActorConnStatus;
+    getSubscribers(eventName: string): Set<Conn<S, CP, CS, V, I, DB, E, Q>> | undefined;
     /**
-     * Returns whether the connection is currently open.
+     * Gets all events and their subscriber counts.
      *
-     * @deprecated Use `connStatus` instead.
-     * @returns {boolean} - True if the connection is open, false otherwise.
+     * @returns Map of event names to subscriber counts
      */
-    get isConnected(): boolean;
+    getEventStats(): Map<string, number>;
     /**
-     * Subscribes to connection open events.
+     * Clears all subscriptions for a connection.
+     * Used during connection cleanup.
      *
-     * This is called when the WebSocket connection is established and the Init message is received.
+     * @param connection - The connection to clear subscriptions for
+     */
+    clearConnectionSubscriptions(connection: Conn<S, CP, CS, V, I, DB, E, Q>): void;
+    /**
+     * Gets the total number of unique events being subscribed to.
+     */
+    get eventCount(): number;
+    /**
+     * Gets the total number of subscriptions across all events.
+     */
+    get totalSubscriptionCount(): number;
+    /**
+     * Checks if an event has any subscribers.
      *
-     * @param {ConnectionStateCallback} callback - The callback function to execute when the connection opens.
-     * @returns {() => void} - A function to unsubscribe from the open handler.
+     * @param eventName - The name of the event to check
+     * @returns True if the event has at least one subscriber
      */
-    onOpen(callback: ConnectionStateCallback): () => void;
+    hasSubscribers(eventName: string): boolean;
+}
+
+/**
+ * Persisted data structures for actors.
+ *
+ * Keep this file in sync with the Connection section of rivetkit-typescript/packages/rivetkit/schemas/actor-persist/
+ */
+
+type Cbor = ArrayBuffer;
+/** Scheduled event to be executed at a specific timestamp */
+interface PersistedScheduleEvent {
+    eventId: string;
+    timestamp: number;
+    action: string;
+    args?: Cbor;
+}
+/** State object that gets automatically persisted to storage */
+interface PersistedActor<S, I> {
+    /** Input data passed to the actor on initialization */
+    input?: I;
+    hasInitialized: boolean;
+    state: S;
+    scheduledEvents: PersistedScheduleEvent[];
+}
+
+interface SaveStateOptions {
     /**
-     * Subscribes to connection close events.
+     * Forces the state to be saved immediately. This function will return when the state has saved successfully.
+     */
+    immediate?: boolean;
+    /** Bypass ready check for stopping. */
+    allowStoppingState?: boolean;
+    /**
+     * Maximum time in milliseconds to wait before forcing a save.
      *
-     * This is called when the WebSocket connection is closed. The connection will automatically
-     * attempt to reconnect unless disposed.
+     * If a save is already scheduled to occur later than this deadline, it will be rescheduled earlier.
+     */
+    maxWait?: number;
+}
+/**
+ * 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, E extends EventSchemaConfig = Record<never, never>, Q extends QueueSchemaConfig = Record<never, never>> {
+    #private;
+    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;
+    get state(): S;
+    set state(value: S);
+    get stateEnabled(): boolean;
+    /**
+     * Initializes state from persisted data or creates new state.
+     */
+    initializeState(persistData: PersistedActor<S, I>): Promise<void>;
+    /**
+     * Creates proxy for persist object that handles automatic state change detection.
+     */
+    initPersistProxy(target: PersistedActor<S, I>): undefined;
+    /**
+     * Forces the state to get saved.
+     */
+    saveState(opts: SaveStateOptions): Promise<void>;
+    /**
+     * Throttled save state method. Used to write to KV at a reasonable cadence.
      *
-     * @param {ConnectionStateCallback} callback - The callback function to execute when the connection closes.
-     * @returns {() => void} - A function to unsubscribe from the close handler.
+     * Passing a maxWait will override the stateSaveInterval with the min
+     * between that and the maxWait.
      */
-    onClose(callback: ConnectionStateCallback): () => void;
+    savePersistThrottled(maxWait?: number): void;
+    /**
+     * Clears any pending save timeout.
+     */
+    clearPendingSaveTimeout(): void;
+    /**
+     * Waits for any pending write operations to complete.
+     */
+    waitForPendingWrites(): Promise<void>;
+}
+
+/** Actor type alias with all `any` types. Used for `extends` in classes referencing this actor. */
+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, E, Q>;
+    driver: ActorDriver;
+    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;
+    get id(): string;
+    get name(): string;
+    get key(): ActorKey;
+    get region(): string;
+    get inlineClient(): Client<Registry<any>>;
+    get inspector(): ActorInspector;
+    get traces(): Traces<OtlpExportTraceServiceRequestJson>;
+    get inspectorToken(): string | undefined;
+    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, E, Q>;
+    get persist(): PersistedActor<S, I>;
+    get state(): S;
+    set state(value: S);
+    get stateEnabled(): boolean;
+    get connStateEnabled(): boolean;
+    get vars(): V;
+    get db(): InferDatabaseClient<DB>;
+    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;
+    beginHonoHttpRequest(): void;
+    endHonoHttpRequest(): void;
+    processMessage(message: {
+        body: {
+            tag: "ActionRequest";
+            val: {
+                id: bigint;
+                name: string;
+                args: unknown;
+            };
+        } | {
+            tag: "SubscriptionRequest";
+            val: {
+                eventName: string;
+                subscribe: boolean;
+            };
+        };
+    }, 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;
     /**
-     * Subscribes to connection status changes.
+     * Prevents the actor from sleeping while the given promise is running.
      *
-     * This is called whenever the connection status changes between Disconnected, Connecting, and Connected.
+     * Use this when performing async operations in the `run` handler or other
+     * background contexts where you need to ensure the actor stays awake.
      *
-     * @param {StatusChangeCallback} callback - The callback function to execute when the status changes.
-     * @returns {() => void} - A function to unsubscribe from the status change handler.
+     * Returns the resolved value and resets the sleep timer on completion.
+     * Errors are propagated to the caller.
      */
-    onStatusChange(callback: StatusChangeCallback): () => void;
+    keepAwake<T>(promise: Promise<T>): Promise<T>;
+    beginQueueWait(): void;
+    endQueueWait(): void;
+    resetSleepTimer(): void;
+}
+
+/** Pick a subset of persisted data used to represent ephemeral connections */
+type EphemeralConn<CP, CS> = Pick<PersistedConn<CP, CS>, "id" | "parameters" | "state">;
+type ConnDataInput<CP, CS> = {
+    ephemeral: EphemeralConn<CP, CS>;
+} | {
+    hibernatable: PersistedConn<CP, CS>;
+};
+/**
+ * Manages connection state persistence, proxying, and change tracking.
+ * Handles automatic state change detection for connection-specific state.
+ */
+declare class StateManager<CP, CS> {
+    #private;
+    constructor(conn: Conn<any, CP, CS, any, any, any, any, any>, data: ConnDataInput<CP, CS>);
     /**
-     * Disconnects from the actor.
+     * Returns the ephemeral or persisted data for this connectioned.
      *
-     * @returns {Promise<void>} A promise that resolves when the socket is gracefully closed.
+     * This property is used to be able to treat both memory & persist conns
+     * identical by looking up the correct underlying data structure.
      */
-    dispose(): Promise<void>;
+    get ephemeralData(): EphemeralConn<CP, CS>;
+    get hibernatableData(): PersistedConn<CP, CS> | undefined;
+    hibernatableDataOrError(): PersistedConn<CP, CS>;
+    get hibernatableDataRaw(): PersistedConn<CP, CS> | undefined;
+    get stateEnabled(): boolean;
+    get state(): CS;
+    set state(value: CS);
+    addSubscription({ eventName }: {
+        eventName: string;
+    }): void;
+    removeSubscription({ eventName }: {
+        eventName: string;
+    }): boolean | undefined;
 }
-/**
- * Connection to a actor. Allows calling actor's remote procedure calls with inferred types. See {@link ActorConnRaw} for underlying methods.
- *
- * @example
- * ```
- * const room = client.connect<ChatRoom>(...etc...);
- * // This calls the action named `sendMessage` on the `ChatRoom` actor.
- * await room.sendMessage('Hello, world!');
- * ```
- *
- * Private methods (e.g. those starting with `_`) are automatically excluded.
- *
- * @template AD The actor class that this connection is for.
- * @see {@link ActorConnRaw}
- */
-type ActorConn<AD extends AnyActorDefinition> = ActorConnRaw & ActorDefinitionActions<AD>;
 
+type ConnId = string;
+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;
+declare const CONN_ACTOR_SYMBOL: unique symbol;
+declare const CONN_STATE_MANAGER_SYMBOL: unique symbol;
+declare const CONN_SEND_MESSAGE_SYMBOL: unique symbol;
 /**
- * Provides underlying functions for stateless {@link ActorHandle} for action calls.
- * Similar to ActorConnRaw but doesn't maintain a connection.
+ * Represents a client connection to a actor.
  *
- * @see {@link ActorHandle}
+ * Manages connection-specific data and controls the connection lifecycle.
+ *
+ * @see {@link https://rivet.dev/docs/connections|Connection Documentation}
  */
-declare class ActorHandleRaw {
+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, E, Q>;
+    get [CONN_STATE_MANAGER_SYMBOL](): StateManager<CP, CS>;
     /**
-     * Do not call this directly.
-     *
-     * Creates an instance of ActorHandleRaw.
-     *
-     * @protected
+     * Connections exist before being connected to an actor. If true, this
+     * connection has been connected.
+     **/
+    [CONN_CONNECTED_SYMBOL]: boolean;
+    /**
+     * If undefined, then no socket is connected to this conn
      */
-    constructor(client: any, driver: ManagerDriver, params: unknown, encoding: Encoding, actorQuery: ActorQuery);
+    [CONN_DRIVER_SYMBOL]?: ConnDriver;
     /**
-     * Call a raw action. This method sends an HTTP request to invoke the named action.
+     * If this connection is speaking the RivetKit protocol. If false, this is
+     * a raw connection for WebSocket or fetch or inspector.
+     **/
+    get [CONN_SPEAKS_RIVETKIT_SYMBOL](): boolean;
+    subscriptions: Set<string>;
+    get params(): CP;
+    /**
+     * Gets the current state of the connection.
      *
-     * @see {@link ActorHandle}
-     * @template Args - The type of arguments to pass to the action function.
-     * @template Response - The type of the response returned by the action function.
+     * Throws an error if the state is not enabled.
      */
-    action<Args extends Array<unknown> = unknown[], Response = unknown>(opts: {
-        name: string;
-        args: Args;
-        signal?: AbortSignal;
-    }): Promise<Response>;
+    get state(): CS;
     /**
-     * Establishes a persistent connection to the actor.
+     * Sets the state of the connection.
      *
-     * @template AD The actor class that this connection is for.
-     * @returns {ActorConn<AD>} A connection to the actor.
+     * Throws an error if the state is not enabled.
      */
-    connect(): ActorConn<AnyActorDefinition>;
+    set state(value: CS);
+    /**
+     * Unique identifier for the connection.
+     */
+    get id(): ConnId;
     /**
-     * Makes a raw HTTP request to the actor.
+     * @experimental
      *
-     * @param input - The URL, path, or Request object
-     * @param init - Standard fetch RequestInit options
-     * @returns Promise<Response> - The raw HTTP response
+     * If the underlying connection can hibernate.
      */
-    fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
+    get isHibernatable(): boolean;
     /**
-     * Creates a raw WebSocket connection to the actor.
+     * Initializes a new instance of the Connection class.
+     *
+     * This should only be constructed by {@link Actor}.
      *
-     * @param path - The path for the WebSocket connection (e.g., "stream")
-     * @param protocols - Optional WebSocket subprotocols
-     * @returns WebSocket - A raw WebSocket connection
+     * @protected
      */
-    websocket(path?: string, protocols?: string | string[]): Promise<WebSocket>;
+    constructor(actor: ActorInstance<S, CP, CS, V, I, DB, E, Q>, data: ConnDataInput<CP, CS>);
     /**
-     * Resolves the actor to get its unique actor ID.
+     * Sends a raw message to the underlying connection.
      */
-    resolve({ signal }?: {
-        signal?: AbortSignal;
-    }): Promise<string>;
+    [CONN_SEND_MESSAGE_SYMBOL](message: CachedSerializer<any, any, any>): void;
     /**
-     * Returns the raw URL for routing traffic to the actor.
+     * Sends an event with arguments to the client.
+     *
+     * @param eventName - The name of the event.
+     * @param args - The arguments for the event.
+     * @see {@link https://rivet.dev/docs/events|Events Documentation}
      */
-    getGatewayUrl(): Promise<string>;
+    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.
+     *
+     * @param reason - The reason for disconnection.
+     */
+    disconnect(reason?: string): Promise<void>;
 }
-/**
- * Stateless handle to a actor. Allows calling actor's remote procedure calls with inferred types
- * without establishing a persistent connection.
- *
- * @example
- * ```
- * const room = client.get<ChatRoom>(...etc...);
- * // This calls the action named `sendMessage` on the `ChatRoom` actor without a connection.
- * await room.sendMessage('Hello, world!');
- * ```
- *
- * Private methods (e.g. those starting with `_`) are automatically excluded.
- *
- * @template AD The actor class that this handle is for.
- * @see {@link ActorHandleRaw}
- */
-type ActorHandle<AD extends AnyActorDefinition> = Omit<ActorHandleRaw, "connect"> & {
-    connect(): ActorConn<AD>;
-    resolve(): Promise<string>;
-} & ActorDefinitionActions<AD>;
 
-/** Extract the actor registry from the registry definition. */
-type ExtractActorsFromRegistry<A extends Registry<any>> = A extends Registry<infer Actors> ? Actors : never;
-/** Extract the registry definition from the client. */
-type ExtractRegistryFromClient<C extends Client<Registry<{}>>> = C extends Client<infer A> ? A : never;
+type InspectorUnsubscribe = () => void;
+declare const RunConfigSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    run: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+    inspector: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        workflow: z.ZodOptional<z.ZodObject<{
+            getHistory: z.ZodCustom<() => unknown, () => unknown>;
+            onHistoryUpdated: z.ZodOptional<z.ZodCustom<(listener: (history: unknown) => void) => InspectorUnsubscribe, (listener: (history: unknown) => void) => InspectorUnsubscribe>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type RunConfigRuntime = z.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>;
+};
+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>>;
+    run: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        run: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+        inspector: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            workflow: z.ZodOptional<z.ZodObject<{
+                getHistory: z.ZodCustom<() => unknown, () => unknown>;
+                onHistoryUpdated: z.ZodOptional<z.ZodCustom<(listener: (history: unknown) => void) => InspectorUnsubscribe, (listener: (history: unknown) => void) => InspectorUnsubscribe>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>]>>;
+    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>>>;
+    events: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    queues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    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<{
+        name: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        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>;
+        runStopTimeout: z.ZodDefault<z.ZodNumber>;
+        connectionLivenessTimeout: z.ZodDefault<z.ZodNumber>;
+        connectionLivenessInterval: z.ZodDefault<z.ZodNumber>;
+        noSleep: z.ZodDefault<z.ZodBoolean>;
+        sleepTimeout: z.ZodDefault<z.ZodNumber>;
+        maxQueueSize: z.ZodDefault<z.ZodNumber>;
+        maxQueueMessageSize: 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, TEvents extends EventSchemaConfig, TQueues extends QueueSchemaConfig> = {
+    state: 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, TEvents extends EventSchemaConfig, TQueues extends QueueSchemaConfig> = {
+    connState: TConnState;
+} | {
+    createConnState: (c: CreateConnStateContext<TState, TVars, TInput, TDatabase, TEvents, TQueues>, params: TConnParams) => TConnState | Promise<TConnState>;
+} | Record<never, never>;
 /**
- * Represents a actor accessor that provides methods to interact with a specific actor.
+ * @experimental
  */
-interface ActorAccessor<AD extends AnyActorDefinition> {
+type CreateVars<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig, TQueues extends QueueSchemaConfig> = {
     /**
-     * Gets a stateless handle to a actor by its key, but does not create the actor if it doesn't exist.
-     * The actor name is automatically injected from the property accessor.
+     * @experimental
+     */
+    vars: TVars;
+} | {
+    /**
+     * @experimental
+     */
+    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, 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;
+}
+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.
      *
-     * @template AD The actor class that this handle is for.
-     * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.
-     * @param {GetWithIdOptions} [opts] - Options for getting the actor.
-     * @returns {ActorHandle<AD>} - A handle to the actor.
+     * Use this hook to initialize your actor's state.
+     * This is called before any other lifecycle hooks.
+     */
+    onCreate?: (c: CreateContext<TState, TInput, TDatabase, TEvents, TQueues>, input: TInput) => void | Promise<void>;
+    /**
+     * Called when the actor is destroyed.
      */
-    get(key?: string | string[], opts?: GetWithIdOptions): ActorHandle<AD>;
+    onDestroy?: (c: DestroyContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => void | Promise<void>;
     /**
-     * Gets a stateless handle to a actor by its key, creating it if necessary.
-     * The actor name is automatically injected from the property accessor.
+     * Called when the actor is started and ready to receive connections and action.
      *
-     * @template AD The actor class that this handle is for.
-     * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.
-     * @param {GetOptions} [opts] - Options for getting the actor.
-     * @returns {ActorHandle<AD>} - A handle to the actor.
+     * Use this hook to initialize resources needed for the actor's operation
+     * (timers, external connections, etc.)
+     *
+     * @returns Void or a Promise that resolves when startup is complete
      */
-    getOrCreate(key?: string | string[], opts?: GetOrCreateOptions): ActorHandle<AD>;
+    onWake?: (c: WakeContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => void | Promise<void>;
     /**
-     * Gets a stateless handle to a actor by its ID.
+     * Called when the actor is stopping or sleeping.
      *
-     * @template AD The actor class that this handle is for.
-     * @param {string} actorId - The ID of the actor.
-     * @param {GetWithIdOptions} [opts] - Options for getting the actor.
-     * @returns {ActorHandle<AD>} - A handle to the actor.
+     * Use this hook to clean up resources, save state, or perform
+     * any shutdown operations before the actor sleeps or stops.
+     *
+     * Not supported on all platforms.
+     *
+     * @returns Void or a Promise that resolves when shutdown is complete
      */
-    getForId(actorId: string, opts?: GetWithIdOptions): ActorHandle<AD>;
+    onSleep?: (c: SleepContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => void | Promise<void>;
     /**
-     * Creates a new actor with the name automatically injected from the property accessor,
-     * and returns a stateless handle to it with the actor ID resolved.
+     * Called after the actor starts up. Does not block actor startup.
      *
-     * @template AD The actor class that this handle is for.
-     * @param {string | string[]} key - The key to identify the actor. Can be a single string or an array of strings.
-     * @param {CreateOptions} [opts] - Options for creating the actor (excluding name and key).
-     * @returns {Promise<ActorHandle<AD>>} - A promise that resolves to a handle to the actor.
+     * 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.
      */
-    create(key?: string | string[], opts?: CreateOptions): Promise<ActorHandle<AD>>;
-}
-/**
- * Options for querying actors.
- * @typedef {Object} QueryOptions
- * @property {unknown} [parameters] - Parameters to pass to the connection.
- */
-interface QueryOptions {
-    /** Parameters to pass to the connection. */
-    params?: unknown;
-    /** Signal to abort the request. */
-    signal?: AbortSignal;
-}
-/**
- * Options for getting a actor by ID.
- * @typedef {QueryOptions} GetWithIdOptions
- */
-interface GetWithIdOptions extends QueryOptions {
-}
-/**
- * Options for getting a actor.
- * @typedef {QueryOptions} GetOptions
- */
-interface GetOptions extends QueryOptions {
-}
-/**
- * Options for getting or creating a actor.
- * @typedef {QueryOptions} GetOrCreateOptions
- * @property {string} [createInRegion] - Region to create the actor in if it doesn't exist.
- */
-interface GetOrCreateOptions extends QueryOptions {
-    /** Region to create the actor in if it doesn't exist. */
-    createInRegion?: string;
-    /** Input data to pass to the actor. */
-    createWithInput?: unknown;
-}
-/**
- * Options for creating a actor.
- * @typedef {QueryOptions} CreateOptions
- * @property {string} [region] - The region to create the actor in.
- */
-interface CreateOptions extends QueryOptions {
-    /** The region to create the actor in. */
-    region?: string;
-    /** Input data to pass to the actor. */
-    input?: unknown;
-}
-/**
- * Represents a region to connect to.
- * @typedef {Object} Region
- * @property {string} id - The region ID.
- * @property {string} name - The region name.
- * @see {@link https://rivet.dev/docs/edge|Edge Networking}
- * @see {@link https://rivet.dev/docs/regions|Available Regions}
- */
-interface Region {
+    run?: ((c: RunContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => void | Promise<void>) | RunConfig<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>;
     /**
-     * The region slug.
+     * Called when the actor's state changes.
+     *
+     * Use this hook to react to state changes, such as updating
+     * external systems or triggering events.
+     *
+     * State changes made within this hook will NOT trigger
+     * another onStateChange call, preventing infinite recursion.
+     *
+     * @param newState The updated state
      */
-    id: string;
+    onStateChange?: (c: StateChangeContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>, newState: TState) => void;
     /**
-     * The human-friendly region name.
+     * Called before a client connects to the actor.
+     *
+     * Use this hook to determine if a connection should be accepted
+     * and to initialize connection-specific state.
+     *
+     * @param opts Connection parameters including client-provided data
+     * @returns The initial connection state or a Promise that resolves to it
+     * @throws Throw an error to reject the connection
      */
-    name: string;
-}
-declare const ACTOR_CONNS_SYMBOL: unique symbol;
-declare const CREATE_ACTOR_CONN_PROXY: unique symbol;
-/**
- * Client for managing & connecting to actors.
- *
- * @template A The actors map type that defines the available actors.
- * @see {@link https://rivet.dev/docs/manage|Create & Manage Actors}
- */
-declare class ClientRaw {
-    #private;
-    [ACTOR_CONNS_SYMBOL]: Set<ActorConnRaw>;
+    onBeforeConnect?: (c: BeforeConnectContext<TState, TVars, TInput, TDatabase, TEvents, TQueues>, params: TConnParams) => void | Promise<void>;
     /**
-     * Creates an instance of Client.
+     * Called when a client successfully connects to the actor.
+     *
+     * Use this hook to perform actions when a connection is established,
+     * such as sending initial data or updating the actor's state.
+     *
+     * @param conn The connection object
+     * @returns Void or a Promise that resolves when connection handling is complete
      */
-    constructor(driver: ManagerDriver, encoding: Encoding | undefined);
+    onConnect?: (c: ConnectContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>, conn: Conn<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => void | Promise<void>;
     /**
-     * Gets a stateless handle to a actor by its ID.
+     * Called when a client disconnects from the actor.
      *
-     * @template AD The actor class that this handle is for.
-     * @param {string} name - The name of the actor.
-     * @param {string} actorId - The ID of the actor.
-     * @param {GetWithIdOptions} [opts] - Options for getting the actor.
-     * @returns {ActorHandle<AD>} - A handle to the actor.
+     * Use this hook to clean up resources associated with the connection
+     * or update the actor's state.
+     *
+     * @param conn The connection that is being closed
+     * @returns Void or a Promise that resolves when disconnect handling is complete
      */
-    getForId<AD extends AnyActorDefinition>(name: string, actorId: string, opts?: GetWithIdOptions): ActorHandle<AD>;
+    onDisconnect?: (c: DisconnectContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>, conn: Conn<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => void | Promise<void>;
     /**
-     * Gets a stateless handle to a actor by its key, but does not create the actor if it doesn't exist.
+     * Called before sending an action response to the client.
      *
-     * @template AD The actor class that this handle is for.
-     * @param {string} name - The name of the actor.
-     * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.
-     * @param {GetWithIdOptions} [opts] - Options for getting the actor.
-     * @returns {ActorHandle<AD>} - A handle to the actor.
+     * Use this hook to modify or transform the output of an action before it's sent
+     * to the client. This is useful for formatting responses, adding metadata,
+     * or applying transformations to the output.
+     *
+     * @param name The name of the action that was called
+     * @param args The arguments that were passed to the action
+     * @param output The output that will be sent to the client
+     * @returns The modified output to send to the client
      */
-    get<AD extends AnyActorDefinition>(name: string, key?: string | string[], opts?: GetWithIdOptions): ActorHandle<AD>;
+    onBeforeActionResponse?: <Out>(c: BeforeActionResponseContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>, name: string, args: unknown[], output: Out) => Out | Promise<Out>;
     /**
-     * Gets a stateless handle to a actor by its key, creating it if necessary.
+     * Called when a raw HTTP request is made to the actor.
      *
-     * @template AD The actor class that this handle is for.
-     * @param {string} name - The name of the actor.
-     * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.
-     * @param {GetOptions} [opts] - Options for getting the actor.
-     * @returns {ActorHandle<AD>} - A handle to the actor.
+     * This handler receives raw HTTP requests made to `/actors/{actorName}/http/*` endpoints.
+     * Use this hook to handle custom HTTP patterns, REST APIs, or other HTTP-based protocols.
+     *
+     * @param c The request context with access to the connection
+     * @param request The raw HTTP request object
+     * @param opts Additional options
+     * @returns A Response object to send back, or void to continue with default routing
      */
-    getOrCreate<AD extends AnyActorDefinition>(name: string, key?: string | string[], opts?: GetOrCreateOptions): ActorHandle<AD>;
+    onRequest?: (c: RequestContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>, request: Request) => Response | Promise<Response>;
     /**
-     * Creates a new actor with the provided key and returns a stateless handle to it.
-     * Resolves the actor ID and returns a handle with getForId query.
+     * Called when a raw WebSocket connection is established to the actor.
      *
-     * @template AD The actor class that this handle is for.
-     * @param {string} name - The name of the actor.
-     * @param {string | string[]} key - The key to identify the actor. Can be a single string or an array of strings.
-     * @param {CreateOptions} [opts] - Options for creating the actor (excluding name and key).
-     * @returns {Promise<ActorHandle<AD>>} - A promise that resolves to a handle to the actor.
+     * This handler receives WebSocket connections made to `/actors/{actorName}/websocket/*` endpoints.
+     * Use this hook to handle custom WebSocket protocols, binary streams, or other WebSocket-based communication.
+     *
+     * @param c The WebSocket context with access to the connection
+     * @param websocket The raw WebSocket connection
+     * @param opts Additional options including the original HTTP upgrade request
      */
-    create<AD extends AnyActorDefinition>(name: string, key?: string | string[], opts?: CreateOptions): Promise<ActorHandle<AD>>;
-    [CREATE_ACTOR_CONN_PROXY]<AD extends AnyActorDefinition>(conn: ActorConnRaw): ActorConn<AD>;
+    onWebSocket?: (c: WebSocketContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>, websocket: UniversalWebSocket) => void | Promise<void>;
+    actions?: TActions;
     /**
-     * Disconnects from all actors.
+     * 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> = {
+    /**
+     * @experimental
+     */
+    db: 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.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 ManagerDriverBuilder = (config: RegistryConfig) => ManagerDriver;
+interface ManagerDriver {
+    getForId(input: GetForIdInput): Promise<ActorOutput | undefined>;
+    getWithKey(input: GetWithKeyInput): Promise<ActorOutput | undefined>;
+    getOrCreateWithKey(input: GetOrCreateWithKeyInput): Promise<ActorOutput>;
+    createActor(input: CreateInput): Promise<ActorOutput>;
+    listActors(input: ListActorsInput): Promise<ActorOutput[]>;
+    sendRequest(actorId: string, actorRequest: Request): Promise<Response>;
+    openWebSocket(path: string, actorId: string, encoding: Encoding, params: unknown): Promise<UniversalWebSocket>;
+    proxyRequest(c: Context, actorRequest: Request, actorId: string): Promise<Response>;
+    proxyWebSocket(c: Context, path: string, actorId: string, encoding: Encoding, params: unknown): Promise<Response>;
+    /**
+     * Build a public gateway URL for a specific actor.
      *
-     * @returns {Promise<void>} A promise that resolves when all connections are closed.
+     * This lives on the driver because the base endpoint varies by runtime.
      */
-    dispose(): Promise<void>;
+    buildGatewayUrl(actorId: string): Promise<string>;
+    displayInformation(): ManagerDisplayInformation;
+    extraStartupLog?: () => Record<string, unknown>;
+    modifyManagerRouter?: (config: RegistryConfig, router: Hono) => void;
+    /**
+     * Allows lazily setting getUpgradeWebSocket after the manager router has
+     * been initialized.
+     **/
+    setGetUpgradeWebSocket(getUpgradeWebSocket: GetUpgradeWebSocket): void;
+    /** Read a key. Returns null if the key doesn't exist. */
+    kvGet(actorId: string, key: Uint8Array): Promise<string | null>;
+}
+interface ManagerDisplayInformation {
+    properties: Record<string, string>;
+}
+interface GetForIdInput<E extends Env = any> {
+    c?: Context | undefined;
+    name: string;
+    actorId: string;
+}
+interface GetWithKeyInput<E extends Env = any> {
+    c?: Context | undefined;
+    name: string;
+    key: ActorKey;
+}
+interface GetOrCreateWithKeyInput<E extends Env = any> {
+    c?: Context | undefined;
+    name: string;
+    key: ActorKey;
+    input?: unknown;
+    region?: string;
 }
-/**
- * Client type with actor accessors.
- * This adds property accessors for actor names to the ClientRaw base class.
- *
- * @template A The actor registry type.
- */
-type Client<A extends Registry<any>> = ClientRaw & {
-    [K in keyof ExtractActorsFromRegistry<A>]: ActorAccessor<ExtractActorsFromRegistry<A>[K]>;
-};
-type AnyClient = Client<Registry<any>>;
-declare function createClientWithDriver<A extends Registry<any>>(driver: ManagerDriver, config?: {
-    encoding?: Encoding;
-}): Client<A>;
-
-interface ActorInspectorEmitterEvents {
-    stateUpdated: (state: unknown) => void;
-    connectionsUpdated: () => void;
-    eventFired: (event: EventDetails) => void;
-    eventsChanged: () => void;
+interface CreateInput<E extends Env = any> {
+    c?: Context | undefined;
+    name: string;
+    key: ActorKey;
+    input?: unknown;
+    region?: string;
 }
-type EventDetails = {
-    type: "action";
+interface ListActorsInput<E extends Env = any> {
+    c?: Context | undefined;
     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.
- */
-declare class ActorInspector {
-    #private;
-    private readonly actor;
-    readonly emitter: nanoevents.Emitter<ActorInspectorEmitterEvents>;
-    constructor(actor: AnyActorInstance);
-    getLastEvents(): Event[];
-    clearEvents(): void;
-    isDatabaseEnabled(): boolean;
-    isStateEnabled(): boolean;
-    getState(): ArrayBuffer;
-    getRpcs(): string[];
-    getConnections(): {
-        type: string | undefined;
-        id: string;
-        details: ArrayBuffer;
-    }[];
-    setState(state: ArrayBuffer): Promise<void>;
-    executeAction(name: string, params: ArrayBuffer): Promise<ArrayBuffer>;
+    key?: string;
+    includeDestroyed?: boolean;
+}
+interface ActorOutput {
+    actorId: string;
+    name: string;
+    key: ActorKey;
+    createTs?: number;
+    startTs?: number | null;
+    connectableTs?: number | null;
+    sleepTs?: number | null;
+    destroyTs?: number | null;
+    error?: unknown;
 }
 
-/**
- * User-facing KV storage interface exposed on ActorContext.
- */
-type KvValueType = "text" | "arrayBuffer" | "binary";
-type KvKeyType = "text" | "binary";
-type KvKey = Uint8Array | string;
-type KvValueTypeMap = {
-    text: string;
-    arrayBuffer: ArrayBuffer;
-    binary: Uint8Array;
-};
-type KvKeyTypeMap = {
-    text: string;
-    binary: Uint8Array;
-};
-type KvValueOptions<T extends KvValueType = "text"> = {
-    type?: T;
-};
-type KvListOptions<T extends KvValueType = "text", K extends KvKeyType = "text"> = KvValueOptions<T> & {
-    keyType?: K;
-};
-declare class ActorKv {
-    #private;
-    constructor(driver: ActorDriver, actorId: string);
-    /**
-     * Get a single value by key.
-     */
-    get<T extends KvValueType = "text">(key: KvKey, options?: KvValueOptions<T>): Promise<KvValueTypeMap[T] | null>;
+type ActorDriverBuilder = (config: RegistryConfig, managerDriver: ManagerDriver, inlineClient: AnyClient) => ActorDriver;
+interface ActorDriver {
+    loadActor(actorId: string): Promise<AnyActorInstance>;
+    getContext(actorId: string): unknown;
+    /** Batch write multiple key-value pairs. Keys and values are Uint8Arrays. */
+    kvBatchPut(actorId: string, entries: [Uint8Array, Uint8Array][]): Promise<void>;
+    /** Batch read multiple keys. Returns null for keys that don't exist. */
+    kvBatchGet(actorId: string, keys: Uint8Array[]): Promise<(Uint8Array | null)[]>;
+    /** Batch delete multiple keys. */
+    kvBatchDelete(actorId: string, keys: Uint8Array[]): Promise<void>;
+    /** List all keys with a given prefix. */
+    kvListPrefix(actorId: string, prefix: Uint8Array): Promise<[Uint8Array, Uint8Array][]>;
+    /** ActorInstance ensure that only one instance of setAlarm is called in parallel at a time. */
+    setAlarm(actor: AnyActorInstance, timestamp: number): Promise<void>;
     /**
-     * Get multiple values by keys.
+     * Override the default raw database client for the actor.
+     * If not provided, rivetkit will construct a KV-backed SQLite client.
+     * @experimental
      */
-    getBatch<T extends KvValueType = "text">(keys: KvKey[], options?: KvValueOptions<T>): Promise<(KvValueTypeMap[T] | null)[]>;
+    overrideRawDatabaseClient?(actorId: string): Promise<RawDatabaseClient | undefined>;
     /**
-     * Put a single key-value pair.
+     * Override the default Drizzle database client for the actor.
+     * If not provided, rivetkit will construct a KV-backed Drizzle client.
+     * @experimental
      */
-    put<T extends KvValueType = KvValueType>(key: KvKey, value: KvValueTypeMap[T], options?: KvValueOptions<T>): Promise<void>;
+    overrideDrizzleDatabaseClient?(actorId: string): Promise<BaseSQLiteDatabase<any, any, any, any> | undefined>;
     /**
-     * Put multiple key-value pairs.
+     * 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.
      */
-    putBatch<T extends KvValueType = KvValueType>(entries: [KvKey, KvValueTypeMap[T]][], options?: KvValueOptions<T>): Promise<void>;
+    createSqliteVfs?(): SqliteVfs | Promise<SqliteVfs>;
     /**
-     * Delete a single key.
+     * Requests the actor to go to sleep.
+     *
+     * This will call `ActorInstance.onStop` independently.
      */
-    delete(key: KvKey): Promise<void>;
+    startSleep?(actorId: string): void;
     /**
-     * Delete multiple keys.
+     * Destroys the actor and its associated data.
+     *
+     * This will call `ActorInstance.onStop` independently.
      */
-    deleteBatch(keys: KvKey[]): Promise<void>;
+    startDestroy(actorId: string): void;
     /**
-     * List all keys with a given prefix.
-     * Returns key-value pairs where keys have the user prefix removed.
+     * Shuts down the actor runner.
      */
-    list<T extends KvValueType = "text", K extends KvKeyType = "text">(prefix: KvKeyTypeMap[K], options?: KvListOptions<T, K>): Promise<[KvKeyTypeMap[K], KvValueTypeMap[T]][]>;
+    shutdownRunner?(immediate: boolean): Promise<void>;
+    /** This handles the serverless start request. This should manage the lifecycle of the runner tied to the request lifecycle. */
+    serverlessHandleStart?(c: Context): Promise<Response>;
+    /** Extra properties to add to logs for each actor. */
+    getExtraActorLogParams?(): Record<string, string>;
+    onBeforeActorStart?(actor: AnyActorInstance): Promise<void>;
+    onCreateConn?(conn: AnyConn): void;
+    onDestroyConn?(conn: AnyConn): void;
+    onBeforePersistConn?(conn: AnyConn): void;
+    onAfterPersistConn?(conn: AnyConn): void;
 }
 
-declare class Schedule {
+declare const ActorsSchema: z$1.ZodRecord<z$1.ZodString, z$1.ZodCustom<ActorDefinition<any, any, any, any, any, any, any, any, any>, ActorDefinition<any, any, any, any, any, any, any, any, any>>>;
+type RegistryActors = z$1.infer<typeof ActorsSchema>;
+declare const RegistryConfigSchema: z$1.ZodPipe<z$1.ZodObject<{
+    use: z$1.ZodRecord<z$1.ZodString, z$1.ZodCustom<AnyActorDefinition, AnyActorDefinition>>;
+    test: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodObject<{
+        enabled: z$1.ZodBoolean;
+    }, z$1.core.$strip>>>;
+    driver: z$1.ZodOptional<z$1.ZodObject<{
+        name: z$1.ZodString;
+        displayName: z$1.ZodString;
+        manager: z$1.ZodCustom<ManagerDriverBuilder, ManagerDriverBuilder>;
+        actor: z$1.ZodCustom<ActorDriverBuilder, ActorDriverBuilder>;
+        autoStartActorDriver: z$1.ZodBoolean;
+    }, z$1.core.$strip>>;
+    storagePath: z$1.ZodPipe<z$1.ZodOptional<z$1.ZodString>, z$1.ZodTransform<string | undefined, string | undefined>>;
+    maxIncomingMessageSize: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodNumber>>;
+    maxOutgoingMessageSize: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodNumber>>;
+    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";
+            warn: "warn";
+            info: "info";
+            debug: "debug";
+            silent: "silent";
+        }>>;
+    }, z$1.core.$strip>>>;
+    endpoint: z$1.ZodPipe<z$1.ZodOptional<z$1.ZodString>, z$1.ZodTransform<string | undefined, 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>>;
+    headers: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodString>>>;
+    serveManager: z$1.ZodOptional<z$1.ZodBoolean>;
+    managerBasePath: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodString>>;
+    managerPort: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodNumber>>;
+    managerHost: z$1.ZodOptional<z$1.ZodString>;
+    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>>>;
+    serverless: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodObject<{
+        spawnEngine: z$1.ZodDefault<z$1.ZodBoolean>;
+        engineVersion: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodString>>;
+        configureRunnerPool: z$1.ZodOptional<z$1.ZodOptional<z$1.ZodObject<{
+            name: z$1.ZodOptional<z$1.ZodString>;
+            url: 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>>;
+            metadataPollInterval: z$1.ZodOptional<z$1.ZodNumber>;
+            drainOnVersionUpgrade: z$1.ZodOptional<z$1.ZodBoolean>;
+        }, z$1.core.$strip>>>;
+        basePath: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodString>>;
+        publicEndpoint: z$1.ZodPipe<z$1.ZodOptional<z$1.ZodString>, z$1.ZodTransform<string | undefined, string | undefined>>;
+        publicToken: z$1.ZodPipe<z$1.ZodOptional<z$1.ZodString>, z$1.ZodTransform<string | undefined, string | undefined>>;
+    }, z$1.core.$strip>>>;
+    runner: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodObject<{
+        totalSlots: z$1.ZodDefault<z$1.ZodNumber>;
+        runnerName: z$1.ZodDefault<z$1.ZodString>;
+        runnerKey: z$1.ZodPipe<z$1.ZodOptional<z$1.ZodString>, z$1.ZodTransform<string | undefined, string | undefined>>;
+        version: z$1.ZodDefault<z$1.ZodNumber>;
+    }, z$1.core.$strip>>>;
+}, z$1.core.$strip>, z$1.ZodTransform<{
+    endpoint: string | undefined;
+    namespace: string;
+    token: string | undefined;
+    serveManager: boolean;
+    publicEndpoint: string | undefined;
+    publicNamespace: string | undefined;
+    publicToken: string | undefined;
+    inspector: {
+        enabled: boolean;
+        token: () => string;
+        defaultEndpoint?: string | undefined;
+    } | {
+        enabled: {
+            manager: boolean;
+            actor: boolean;
+        };
+        token: () => string;
+        defaultEndpoint?: string | undefined;
+    };
+    serverless: {
+        publicEndpoint: string | undefined;
+        spawnEngine: boolean;
+        engineVersion: string;
+        basePath: string;
+        publicToken: string | undefined;
+        configureRunnerPool?: {
+            url: string;
+            name?: string | undefined;
+            headers?: Record<string, string> | undefined;
+            maxRunners?: number | undefined;
+            minRunners?: number | undefined;
+            requestLifespan?: number | undefined;
+            runnersMargin?: number | undefined;
+            slotsPerRunner?: number | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            metadataPollInterval?: number | undefined;
+            drainOnVersionUpgrade?: boolean | undefined;
+        } | undefined;
+    };
+    use: Record<string, AnyActorDefinition>;
+    test: {
+        enabled: boolean;
+    };
+    storagePath: string | undefined;
+    maxIncomingMessageSize: number;
+    maxOutgoingMessageSize: number;
+    noWelcome: boolean;
+    logging: {
+        baseLogger?: Logger | undefined;
+        level?: "error" | "trace" | "fatal" | "warn" | "info" | "debug" | "silent" | undefined;
+    };
+    headers: Record<string, string>;
+    managerBasePath: string;
+    managerPort: number;
+    runner: {
+        totalSlots: number;
+        runnerName: string;
+        runnerKey: string | undefined;
+        version: number;
+    };
+    driver?: {
+        name: string;
+        displayName: string;
+        manager: ManagerDriverBuilder;
+        actor: ActorDriverBuilder;
+        autoStartActorDriver: boolean;
+    } | undefined;
+    managerHost?: string | undefined;
+}, {
+    use: Record<string, AnyActorDefinition>;
+    test: {
+        enabled: boolean;
+    };
+    storagePath: string | undefined;
+    maxIncomingMessageSize: number;
+    maxOutgoingMessageSize: number;
+    noWelcome: boolean;
+    logging: {
+        baseLogger?: Logger | undefined;
+        level?: "error" | "trace" | "fatal" | "warn" | "info" | "debug" | "silent" | undefined;
+    };
+    endpoint: string | undefined;
+    token: string | undefined;
+    namespace: string | undefined;
+    headers: Record<string, string>;
+    managerBasePath: string;
+    managerPort: number;
+    inspector: {
+        enabled: boolean;
+        token: () => string;
+        defaultEndpoint?: string | undefined;
+    };
+    serverless: {
+        spawnEngine: boolean;
+        engineVersion: string;
+        basePath: string;
+        publicEndpoint: string | undefined;
+        publicToken: string | undefined;
+        configureRunnerPool?: {
+            url: string;
+            name?: string | undefined;
+            headers?: Record<string, string> | undefined;
+            maxRunners?: number | undefined;
+            minRunners?: number | undefined;
+            requestLifespan?: number | undefined;
+            runnersMargin?: number | undefined;
+            slotsPerRunner?: number | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            metadataPollInterval?: number | undefined;
+            drainOnVersionUpgrade?: boolean | undefined;
+        } | undefined;
+    };
+    runner: {
+        totalSlots: number;
+        runnerName: string;
+        runnerKey: string | undefined;
+        version: number;
+    };
+    driver?: {
+        name: string;
+        displayName: string;
+        manager: ManagerDriverBuilder;
+        actor: ActorDriverBuilder;
+        autoStartActorDriver: boolean;
+    } | undefined;
+    serveManager?: boolean | undefined;
+    managerHost?: string | undefined;
+}>>;
+type RegistryConfig = z$1.infer<typeof RegistryConfigSchema>;
+type RegistryConfigInput<A extends RegistryActors> = Omit<z$1.input<typeof RegistryConfigSchema>, "use"> & {
+    use: A;
+};
+
+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(actor: AnyActorInstance);
-    after(duration: number, fn: string, ...args: unknown[]): Promise<void>;
-    at(timestamp: number, fn: string, ...args: unknown[]): Promise<void>;
+    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>;
 }
 
 /**
- * ActorContext class that provides access to actor methods and state
+ * Action function returned by Actor connections and handles.
+ *
+ * @typedef {Function} ActorActionFunction
+ * @template Args
+ * @template Response
+ * @param {...Args} args - Arguments for the action function.
+ * @returns {Promise<Response>}
  */
-declare class ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> {
-    #private;
-    constructor(actor: ActorInstance<TState, TConnParams, TConnState, TVars, TInput, TDatabase>);
-    /**
-     * Gets the KV storage interface.
-     */
-    get kv(): ActorKv;
-    /**
-     * Get the actor state
-     *
-     * @remarks
-     * This property is not available in `createState` since the state hasn't been created yet.
-     */
-    get state(): TState extends never ? never : TState;
-    /**
-     * Get the actor variables
-     *
-     * @remarks
-     * This property is not available in `createVars` since the variables haven't been created yet.
-     * Variables are only available if you define `vars` or `createVars` in your actor config.
-     */
-    get vars(): TVars extends never ? never : TVars;
-    /**
-     * Broadcasts an event to all connected clients.
-     * @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;
-    /**
-     * Gets the logger instance.
-     */
-    get log(): Logger;
-    /**
-     * Gets actor ID.
-     */
-    get actorId(): string;
-    /**
-     * Gets the actor name.
-     */
-    get name(): string;
-    /**
-     * Gets the actor key.
-     */
-    get key(): ActorKey;
-    /**
-     * Gets the region.
-     */
-    get region(): string;
-    /**
-     * Gets the scheduler.
-     */
-    get schedule(): Schedule;
-    /**
-     * Gets the map of connections.
-     */
-    get conns(): Map<ConnId, Conn<TState, TConnParams, TConnState, TVars, TInput, TDatabase>>;
-    /**
-     * Returns the client for the given registry.
-     */
-    client<R extends Registry<any>>(): Client<R>;
-    /**
-     * Gets the database.
-     *
-     * @experimental
-     * @remarks
-     * This property is only available if you define a `db` provider in your actor config.
-     * @throws {DatabaseNotEnabled} If the database is not enabled.
-     */
-    get db(): TDatabase extends never ? never : InferDatabaseClient<TDatabase>;
-    /**
-     * Forces the state to get saved.
-     *
-     * @param opts - Options for saving the state.
-     */
-    saveState(opts: SaveStateOptions): Promise<void>;
-    /**
-     * Prevents the actor from sleeping until promise is complete.
-     */
-    waitUntil(promise: Promise<void>): void;
-    /**
-     * AbortSignal that fires when the actor is stopping.
-     */
-    get abortSignal(): AbortSignal;
-    /**
-     * Forces the actor to sleep.
-     *
-     * Not supported on all drivers.
-     *
-     * @experimental
-     */
-    sleep(): void;
-    /**
-     * Forces the actor to destroy.
-     *
-     * This will return immediately, then call `onStop` and `onDestroy`.
-     *
-     * @experimental
-     */
-    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 ActorActionFunction<Args extends Array<unknown> = unknown[], Response = unknown> = (...args: Args extends [unknown, ...infer Rest] ? Rest : Args) => Promise<Response>;
 /**
- * Base context for connection-based handlers.
- * Extends ActorContext with connection-specific functionality.
+ * Maps action methods from actor definition to typed function signatures.
  */
-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>;
-}
-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 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;
 
-/**
- * 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> {
-    /**
-     * The incoming request that initiated the connection.
-     * May be undefined for connections initiated without a direct HTTP request.
-     */
-    readonly request: Request | undefined;
+declare class ActorClientError extends Error {
 }
-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> {
+declare class InternalError extends ActorClientError {
 }
-/**
- * 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;
-
-/**
- * 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 ManagerError extends ActorClientError {
+    constructor(error: string, opts?: ErrorOptions);
 }
-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;
-
-/**
- * Context for the onBeforeConnect lifecycle hook.
- */
-declare class BeforeConnectContext<TState, TVars, TInput, TDatabase extends AnyDatabaseProvider> extends ConnInitContext<TState, TVars, TInput, TDatabase> {
+declare class MalformedResponseMessage extends ActorClientError {
+    constructor(cause?: unknown);
+}
+declare class ActorError extends ActorClientError {
+    readonly group: string;
+    readonly code: string;
+    readonly metadata?: unknown | undefined;
+    __type: string;
+    constructor(group: string, code: string, message: string, metadata?: unknown | undefined);
+}
+declare class ActorConnDisposed extends ActorClientError {
+    constructor();
 }
-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;
 
-/**
- * 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> {
+interface QueueSendWaitOptions {
+    wait: true;
+    timeout?: number;
+    signal?: AbortSignal;
+}
+interface QueueSendNoWaitOptions {
+    wait?: false;
+    timeout?: never;
+    signal?: AbortSignal;
+}
+interface QueueSendResult {
+    status: "completed" | "timedOut";
+    response?: unknown;
 }
-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;
 
 /**
- * Context for the onCreate lifecycle hook.
+ * Connection status for an actor connection.
+ *
+ * - `"idle"`: Not connected, no auto-reconnect (initial state, after dispose, or disabled)
+ * - `"connecting"`: Attempting to establish connection
+ * - `"connected"`: Connection is active
+ * - `"disconnected"`: Connection was lost, will auto-reconnect
  */
-declare class CreateContext<TState, TInput, TDatabase extends AnyDatabaseProvider> extends ActorContext<TState, never, never, never, TInput, TDatabase> {
-}
-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 ActorConnStatus = "idle" | "connecting" | "connected" | "disconnected";
 /**
- * Context for the createConnState lifecycle hook.
- * Called to initialize connection-specific state when a connection is created.
+ * A function that unsubscribes from an event.
+ *
+ * @typedef {Function} EventUnsubscribe
  */
-declare class CreateConnStateContext<TState, TVars, TInput, TDatabase extends AnyDatabaseProvider> extends ConnInitContext<TState, TVars, TInput, TDatabase> {
-}
-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 EventUnsubscribe = () => void;
 /**
- * Context for the createVars lifecycle hook.
+ * A function that handles connection errors.
+ *
+ * @typedef {Function} ActorErrorCallback
  */
-declare class CreateVarsContext<TState, TInput, TDatabase extends AnyDatabaseProvider> extends ActorContext<TState, never, never, never, TInput, TDatabase> {
-}
-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 ActorErrorCallback = (error: ActorError) => void;
 /**
- * Context for the onDestroy lifecycle hook.
+ * A callback for connection state changes.
+ *
+ * @typedef {Function} ConnectionStateCallback
  */
-declare class DestroyContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase> {
-}
-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 ConnectionStateCallback = () => void;
 /**
- * Context for the onDisconnect lifecycle hook.
+ * A callback for connection status changes.
+ *
+ * @typedef {Function} StatusChangeCallback
  */
-declare class DisconnectContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase> {
-}
-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 StatusChangeCallback = (status: ActorConnStatus) => void;
+declare const CONNECT_SYMBOL: unique symbol;
 /**
- * Context for raw HTTP request handlers (onRequest).
+ * Provides underlying functions for {@link ActorConn}. See {@link ActorConn} for using type-safe remote procedure calls.
+ *
+ * @see {@link ActorConn}
  */
-declare class RequestContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> extends ConnContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase> {
+declare class ActorConnRaw {
+    #private;
+    /**
+     * Do not call this directly.
+     *
+     * Creates an instance of 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.
+     *
+     * @see {@link ActorConn}
+     * @template Args - The type of arguments to pass to the action function.
+     * @template Response - The type of the response returned by the action function.
+     * @param {string} name - The name of the action function to call.
+     * @param {...Args} args - The arguments to pass to the action function.
+     * @returns {Promise<Response>} - A promise that resolves to the response of the action function.
+     */
+    action<Args extends Array<unknown> = unknown[], Response = unknown>(opts: {
+        name: string;
+        args: Args;
+        signal?: AbortSignal;
+    }): Promise<Response>;
+    /**
+     * Do not call this directly.
+     * Establishes a connection to the server using the specified endpoint & encoding & driver.
+     *
+     * @protected
+     */
+    [CONNECT_SYMBOL](): void;
     /**
-     * The incoming HTTP request.
-     * May be undefined for request contexts initiated without a direct HTTP request.
+     * Subscribes to an event that will happen repeatedly.
+     *
+     * @template Args - The type of arguments the event callback will receive.
+     * @param {string} eventName - The name of the event to subscribe to.
+     * @param {(...args: Args) => void} callback - The callback function to execute when the event is triggered.
+     * @returns {EventUnsubscribe} - A function to unsubscribe from the event.
+     * @see {@link https://rivet.dev/docs/events|Events Documentation}
      */
-    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;
-
-/**
- * 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> {
-}
-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;
-
-/**
- * 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> {
-}
-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;
-
-/**
- * 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> {
-}
-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;
-
-/**
- * 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> {
+    on<Args extends Array<unknown> = unknown[]>(eventName: string, callback: (...args: Args) => void): EventUnsubscribe;
     /**
-     * The incoming HTTP request that initiated the WebSocket upgrade.
-     * May be undefined for WebSocket connections initiated without a direct HTTP request.
+     * Subscribes to an event that will be triggered only once.
+     *
+     * @template Args - The type of arguments the event callback will receive.
+     * @param {string} eventName - The name of the event to subscribe to.
+     * @param {(...args: Args) => void} callback - The callback function to execute when the event is triggered.
+     * @returns {EventUnsubscribe} - A function to unsubscribe from the event.
+     * @see {@link https://rivet.dev/docs/events|Events Documentation}
      */
-    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;
-
-declare enum DriverReadyState {
-    UNKNOWN = -1,
-    CONNECTING = 0,
-    OPEN = 1,
-    CLOSING = 2,
-    CLOSED = 3
-}
-interface ConnDriver {
-    /** The type of driver. Used for debug purposes only. */
-    type: string;
+    once<Args extends Array<unknown> = unknown[]>(eventName: string, callback: (...args: Args) => void): EventUnsubscribe;
     /**
-     * If defined, this connection driver talks the RivetKit client driver (see
-     * schemas/client-protocol/).
+     * Subscribes to connection errors.
      *
-     * If enabled, events like `Init`, subscription events, etc. will be sent
-     * to this connection.
+     * @param {ActorErrorCallback} callback - The callback function to execute when a connection error occurs.
+     * @returns {() => void} - A function to unsubscribe from the error handler.
      */
-    rivetKitProtocol?: {
-        /** Sends a RivetKit client message. */
-        sendMessage(actor: AnyActorInstance, conn: AnyConn, message: CachedSerializer<any, any, any>): void;
-    };
+    onError(callback: ActorErrorCallback): () => void;
     /**
-     * If the connection can be hibernated. If true, this will allow the actor to go to sleep while the connection is still active.
-     **/
-    hibernatable?: {
-        gatewayId: ArrayBuffer;
-        requestId: ArrayBuffer;
-    };
+     * Returns the current connection status.
+     *
+     * @returns {ActorConnStatus} - The current connection status.
+     */
+    get connStatus(): ActorConnStatus;
     /**
-     * This returns a promise since we commonly disconnect at the end of a program, and not waiting will cause the socket to not close cleanly.
+     * Returns whether the connection is currently open.
+     *
+     * @deprecated Use `connStatus` instead.
+     * @returns {boolean} - True if the connection is open, false otherwise.
      */
-    disconnect(actor: AnyActorInstance, conn: AnyConn, reason?: string): Promise<void>;
-    /** Terminates the connection without graceful handling. */
-    terminate?(actor: AnyActorInstance, conn: AnyConn): void;
+    get isConnected(): boolean;
     /**
-     * Returns the ready state of the connection.
-     * This is used to determine if the connection is ready to send messages, or if the connection is stale.
+     * Subscribes to connection open events.
+     *
+     * This is called when the WebSocket connection is established and the Init message is received.
+     *
+     * @param {ConnectionStateCallback} callback - The callback function to execute when the connection opens.
+     * @returns {() => void} - A function to unsubscribe from the open handler.
      */
-    getConnectionReadyState(actor: AnyActorInstance, conn: AnyConn): DriverReadyState | undefined;
+    onOpen(callback: ConnectionStateCallback): () => void;
+    /**
+     * Subscribes to connection close events.
+     *
+     * This is called when the WebSocket connection is closed. The connection will automatically
+     * attempt to reconnect unless disposed.
+     *
+     * @param {ConnectionStateCallback} callback - The callback function to execute when the connection closes.
+     * @returns {() => void} - A function to unsubscribe from the close handler.
+     */
+    onClose(callback: ConnectionStateCallback): () => void;
+    /**
+     * Subscribes to connection status changes.
+     *
+     * This is called whenever the connection status changes between Disconnected, Connecting, and Connected.
+     *
+     * @param {StatusChangeCallback} callback - The callback function to execute when the status changes.
+     * @returns {() => void} - A function to unsubscribe from the status change handler.
+     */
+    onStatusChange(callback: StatusChangeCallback): () => void;
+    /**
+     * Disconnects from the actor.
+     *
+     * @returns {Promise<void>} A promise that resolves when the socket is gracefully closed.
+     */
+    dispose(): Promise<void>;
 }
-
 /**
- * Persisted data structures for connections.
+ * Connection to a actor. Allows calling actor's remote procedure calls with inferred types. See {@link ActorConnRaw} for underlying methods.
  *
- * Keep this file in sync with the Connection section of rivetkit-typescript/packages/rivetkit/schemas/actor-persist/
+ * @example
+ * ```
+ * const room = client.connect<ChatRoom>(...etc...);
+ * // This calls the action named `sendMessage` on the `ChatRoom` actor.
+ * await room.sendMessage('Hello, world!');
+ * ```
+ *
+ * Private methods (e.g. those starting with `_`) are automatically excluded.
+ *
+ * @template AD The actor class that this connection is for.
+ * @see {@link ActorConnRaw}
  */
-
-type GatewayId = ArrayBuffer;
-type RequestId = ArrayBuffer;
-/** Event subscription for connection */
-interface PersistedSubscription {
-    eventName: string;
-}
-/** Connection associated with hibernatable WebSocket that should persist across lifecycles */
-interface PersistedConn<CP, CS> {
-    /** Connection ID generated by RivetKit */
-    id: string;
-    parameters: CP;
-    state: CS;
-    subscriptions: PersistedSubscription[];
-    gatewayId: GatewayId;
-    requestId: RequestId;
-    serverMessageIndex: number;
-    clientMessageIndex: number;
-    requestPath: string;
-    requestHeaders: Record<string, string>;
-}
+type ActorConn<AD extends AnyActorDefinition> = ActorConnRaw & ActorDefinitionActions<AD>;
 
 /**
- * Manages all connection-related operations for an actor instance.
- * Handles connection creation, tracking, hibernation, and cleanup.
+ * Provides underlying functions for stateless {@link ActorHandle} for action calls.
+ * Similar to ActorConnRaw but doesn't maintain a connection.
+ *
+ * @see {@link ActorHandle}
  */
-declare class ConnectionManager<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
+declare class ActorHandleRaw {
     #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;
-    get connsWithPersistChanged(): Set<ConnId>;
-    clearConnWithPersistChanged(): void;
-    markConnWithPersistChanged(conn: Conn<S, CP, CS, V, I, DB>): void;
     /**
-     * Handles pre-connection logic (i.e. auth & create state) before actually connecting the connection.
+     * Do not call this directly.
+     *
+     * Creates an instance of ActorHandleRaw.
+     *
+     * @protected
      */
-    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>>;
+    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>;
     /**
-     * Adds a connection form prepareConn to the actor and calls onConnect.
+     * Call a raw action. This method sends an HTTP request to invoke the named action.
      *
-     * This method is intentionally not async since it needs to be called in
-     * `onOpen` for WebSockets. If this is async, the order of open events will
-     * be messed up and cause race conditions that can drop WebSocket messages.
-     * So all async work in prepareConn.
+     * @see {@link ActorHandle}
+     * @template Args - The type of arguments to pass to the action function.
+     * @template Response - The type of the response returned by the action function.
      */
-    connectConn(conn: Conn<S, CP, CS, V, I, DB>): void;
+    action<Args extends Array<unknown> = unknown[], Response = unknown>(opts: {
+        name: string;
+        args: Args;
+        signal?: AbortSignal;
+    }): Promise<Response>;
     /**
-     * Handle connection disconnection.
+     * Establishes a persistent connection to the actor.
      *
-     * This is called by `Conn.disconnect`. This should not call `Conn.disconnect.`
+     * @template AD The actor class that this connection is for.
+     * @returns {ActorConn<AD>} A connection to the actor.
+     */
+    connect(): ActorConn<AnyActorDefinition>;
+    /**
+     * Fetches a resource from this actor via the /request endpoint. This is a
+     * convenience wrapper around the raw HTTP API.
      */
-    connDisconnected(conn: Conn<S, CP, CS, V, I, DB>): Promise<void>;
+    fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
     /**
-     * Utilify function for call sites that don't need a separate prepare and connect phase.
+     * Opens a raw WebSocket connection to this actor.
      */
-    prepareAndConnectConn(driver: ConnDriver, params: CP, request: Request | undefined, requestPath: string | undefined, requestHeaders: Record<string, string> | undefined): Promise<Conn<S, CP, CS, V, I, DB>>;
+    webSocket(path?: string, protocols?: string | string[]): Promise<any>;
     /**
-     * Restores connections from persisted data during actor initialization.
+     * Resolves the actor to get its unique actor ID.
      */
-    restoreConnections(connections: PersistedConn<CP, CS>[]): void;
-    findHibernatableConn(gatewayIdBuf: ArrayBuffer, requestIdBuf: ArrayBuffer): Conn<S, CP, CS, V, I, DB> | undefined;
+    resolve(): Promise<string>;
+    /**
+     * Returns the raw URL for routing traffic to the actor.
+     */
+    getGatewayUrl(): Promise<string>;
 }
+/**
+ * Stateless handle to a actor. Allows calling actor's remote procedure calls with inferred types
+ * without establishing a persistent connection.
+ *
+ * @example
+ * ```
+ * const room = client.get<ChatRoom>(...etc...);
+ * // This calls the action named `sendMessage` on the `ChatRoom` actor without a connection.
+ * await room.sendMessage('Hello, world!');
+ * ```
+ *
+ * Private methods (e.g. those starting with `_`) are automatically excluded.
+ *
+ * @template AD The actor class that this handle is for.
+ * @see {@link ActorHandleRaw}
+ */
+type ActorHandle<AD extends AnyActorDefinition> = Omit<ActorHandleRaw, "connect"> & {
+    connect(): ActorConn<AD>;
+    resolve(): Promise<string>;
+} & ActorDefinitionActions<AD>;
+
+declare const ClientConfigSchema: z$2.ZodPipe<z$2.ZodObject<{
+    endpoint: z$2.ZodPipe<z$2.ZodOptional<z$2.ZodString>, z$2.ZodTransform<string, string | undefined>>;
+    token: z$2.ZodPipe<z$2.ZodOptional<z$2.ZodString>, z$2.ZodTransform<string | undefined, string | undefined>>;
+    namespace: z$2.ZodPipe<z$2.ZodOptional<z$2.ZodString>, z$2.ZodTransform<string | undefined, string | undefined>>;
+    runnerName: z$2.ZodDefault<z$2.ZodString>;
+    encoding: z$2.ZodDefault<z$2.ZodEnum<{
+        json: "json";
+        cbor: "cbor";
+        bare: "bare";
+    }>>;
+    headers: z$2.ZodDefault<z$2.ZodOptional<z$2.ZodRecord<z$2.ZodString, z$2.ZodString>>>;
+    getUpgradeWebSocket: z$2.ZodOptional<z$2.ZodCustom<GetUpgradeWebSocket, GetUpgradeWebSocket>>;
+    disableMetadataLookup: z$2.ZodDefault<z$2.ZodOptional<z$2.ZodBoolean>>;
+    devtools: z$2.ZodDefault<z$2.ZodBoolean>;
+}, z$2.core.$strip>, z$2.ZodTransform<{
+    endpoint: string | undefined;
+    namespace: string;
+    token: string | undefined;
+    runnerName: string;
+    encoding: "json" | "cbor" | "bare";
+    headers: Record<string, string>;
+    disableMetadataLookup: boolean;
+    devtools: boolean;
+    getUpgradeWebSocket?: GetUpgradeWebSocket | undefined;
+}, {
+    endpoint: string;
+    token: string | undefined;
+    namespace: string | undefined;
+    runnerName: string;
+    encoding: "json" | "cbor" | "bare";
+    headers: Record<string, string>;
+    disableMetadataLookup: boolean;
+    devtools: boolean;
+    getUpgradeWebSocket?: GetUpgradeWebSocket | undefined;
+}>>;
+type ClientConfigInput = z$2.input<typeof ClientConfigSchema>;
 
+/** Extract the actor registry from the registry definition. */
+type ExtractActorsFromRegistry<A extends Registry<any>> = A extends Registry<infer Actors> ? Actors : never;
+/** Extract the registry definition from the client. */
+type ExtractRegistryFromClient<C extends Client<Registry<{}>>> = C extends Client<infer A> ? A : never;
 /**
- * Manages event subscriptions and broadcasting for actor instances.
- * Handles subscription tracking and efficient message distribution to connected clients.
+ * Represents a actor accessor that provides methods to interact with a specific actor.
  */
-declare class EventManager<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
-    #private;
-    constructor(actor: ActorInstance<S, CP, CS, V, I, DB>);
-    /**
-     * Adds a subscription for a connection to an event.
-     *
-     * @param eventName - The name of the event to subscribe to
-     * @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;
-    /**
-     * Removes a subscription for a connection from an event.
-     *
-     * @param eventName - The name of the event to unsubscribe from
-     * @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;
-    /**
-     * Broadcasts an event to all subscribed connections.
-     *
-     * @param name - The name of the event to broadcast
-     * @param args - The arguments to send with the event
-     */
-    broadcast<Args extends Array<unknown>>(name: string, ...args: Args): void;
+interface ActorAccessor<AD extends AnyActorDefinition> {
     /**
-     * Gets all subscribers for a specific event.
+     * Gets a stateless handle to a actor by its key, but does not create the actor if it doesn't exist.
+     * The actor name is automatically injected from the property accessor.
      *
-     * @param eventName - The name of the event
-     * @returns Set of connections subscribed to the event, or undefined if no subscribers
+     * @template AD The actor class that this handle is for.
+     * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.
+     * @param {GetWithIdOptions} [opts] - Options for getting the actor.
+     * @returns {ActorHandle<AD>} - A handle to the actor.
      */
-    getSubscribers(eventName: string): Set<Conn<S, CP, CS, V, I, DB>> | undefined;
+    get(key?: string | string[], opts?: GetWithIdOptions): ActorHandle<AD>;
     /**
-     * Gets all events and their subscriber counts.
+     * Gets a stateless handle to a actor by its key, creating it if necessary.
+     * The actor name is automatically injected from the property accessor.
      *
-     * @returns Map of event names to subscriber counts
+     * @template AD The actor class that this handle is for.
+     * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.
+     * @param {GetOptions} [opts] - Options for getting the actor.
+     * @returns {ActorHandle<AD>} - A handle to the actor.
      */
-    getEventStats(): Map<string, number>;
+    getOrCreate(key?: string | string[], opts?: GetOrCreateOptions): ActorHandle<AD>;
     /**
-     * Clears all subscriptions for a connection.
-     * Used during connection cleanup.
+     * Gets a stateless handle to a actor by its ID.
      *
-     * @param connection - The connection to clear subscriptions for
-     */
-    clearConnectionSubscriptions(connection: Conn<S, CP, CS, V, I, DB>): void;
-    /**
-     * Gets the total number of unique events being subscribed to.
-     */
-    get eventCount(): number;
-    /**
-     * Gets the total number of subscriptions across all events.
+     * @template AD The actor class that this handle is for.
+     * @param {string} actorId - The ID of the actor.
+     * @param {GetWithIdOptions} [opts] - Options for getting the actor.
+     * @returns {ActorHandle<AD>} - A handle to the actor.
      */
-    get totalSubscriptionCount(): number;
+    getForId(actorId: string, opts?: GetWithIdOptions): ActorHandle<AD>;
     /**
-     * Checks if an event has any subscribers.
+     * Creates a new actor with the name automatically injected from the property accessor,
+     * and returns a stateless handle to it with the actor ID resolved.
      *
-     * @param eventName - The name of the event to check
-     * @returns True if the event has at least one subscriber
+     * @template AD The actor class that this handle is for.
+     * @param {string | string[]} key - The key to identify the actor. Can be a single string or an array of strings.
+     * @param {CreateOptions} [opts] - Options for creating the actor (excluding name and key).
+     * @returns {Promise<ActorHandle<AD>>} - A promise that resolves to a handle to the actor.
      */
-    hasSubscribers(eventName: string): boolean;
+    create(key?: string | string[], opts?: CreateOptions): Promise<ActorHandle<AD>>;
 }
-
 /**
- * Persisted data structures for actors.
- *
- * Keep this file in sync with the Connection section of rivetkit-typescript/packages/rivetkit/schemas/actor-persist/
+ * Options for querying actors.
+ * @typedef {Object} QueryOptions
+ * @property {unknown} [parameters] - Parameters to pass to the connection.
  */
-
-type Cbor = ArrayBuffer;
-/** Scheduled event to be executed at a specific timestamp */
-interface PersistedScheduleEvent {
-    eventId: string;
-    timestamp: number;
-    action: string;
-    args?: Cbor;
+interface QueryOptions {
+    /** Parameters to pass to the connection. */
+    params?: unknown;
+    /** Signal to abort the request. */
+    signal?: AbortSignal;
 }
-/** State object that gets automatically persisted to storage */
-interface PersistedActor<S, I> {
-    /** Input data passed to the actor on initialization */
-    input?: I;
-    hasInitialized: boolean;
-    state: S;
-    scheduledEvents: PersistedScheduleEvent[];
+/**
+ * Options for getting a actor by ID.
+ * @typedef {QueryOptions} GetWithIdOptions
+ */
+interface GetWithIdOptions extends QueryOptions {
 }
-
-interface SaveStateOptions {
-    /**
-     * Forces the state to be saved immediately. This function will return when the state has saved successfully.
-     */
-    immediate?: boolean;
-    /** Bypass ready check for stopping. */
-    allowStoppingState?: boolean;
-    /**
-     * Maximum time in milliseconds to wait before forcing a save.
-     *
-     * If a save is already scheduled to occur later than this deadline, it will be rescheduled earlier.
-     */
-    maxWait?: number;
+/**
+ * Options for getting a actor.
+ * @typedef {QueryOptions} GetOptions
+ */
+interface GetOptions extends QueryOptions {
 }
 /**
- * Manages actor state persistence, proxying, and synchronization.
- * Handles automatic state change detection and throttled persistence to KV storage.
+ * Options for getting or creating a actor.
+ * @typedef {QueryOptions} GetOrCreateOptions
+ * @property {string} [createInRegion] - Region to create the actor in if it doesn't exist.
  */
-declare class StateManager$1<S, CP, CS, I> {
-    #private;
-    constructor(actor: ActorInstance<S, CP, CS, any, I, any>, actorDriver: ActorDriver, config: any);
-    get persist(): PersistedActor<S, I>;
-    get persistRaw(): PersistedActor<S, I>;
-    get persistChanged(): boolean;
-    get state(): S;
-    set state(value: S);
-    get stateEnabled(): boolean;
-    /**
-     * Initializes state from persisted data or creates new state.
-     */
-    initializeState(persistData: PersistedActor<S, I>): Promise<void>;
-    /**
-     * Creates proxy for persist object that handles automatic state change detection.
-     */
-    initPersistProxy(target: PersistedActor<S, I>): undefined;
-    /**
-     * Forces the state to get saved.
-     */
-    saveState(opts: SaveStateOptions): Promise<void>;
-    /**
-     * Throttled save state method. Used to write to KV at a reasonable cadence.
-     *
-     * Passing a maxWait will override the stateSaveInterval with the min
-     * between that and the maxWait.
-     */
-    savePersistThrottled(maxWait?: number): void;
-    /**
-     * Clears any pending save timeout.
-     */
-    clearPendingSaveTimeout(): void;
-    /**
-     * Waits for any pending write operations to complete.
-     */
-    waitForPendingWrites(): Promise<void>;
+interface GetOrCreateOptions extends QueryOptions {
+    /** Region to create the actor in if it doesn't exist. */
+    createInRegion?: string;
+    /** Input data to pass to the actor. */
+    createWithInput?: unknown;
 }
-
-/** 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> {
-    #private;
-    actorContext: ActorContext<S, CP, CS, V, I, DB>;
-    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>);
-    get log(): Logger;
-    get rLog(): Logger;
-    get isStopping(): boolean;
-    get id(): string;
-    get name(): string;
-    get key(): ActorKey;
-    get region(): string;
-    get inlineClient(): Client<Registry<any>>;
-    get inspector(): ActorInspector;
-    get inspectorToken(): string | undefined;
-    get conns(): Map<ConnId, Conn<S, CP, CS, V, I, DB>>;
-    get schedule(): Schedule;
-    get abortSignal(): AbortSignal;
-    get actions(): string[];
-    get config(): ActorConfig<S, CP, CS, V, I, DB>;
-    get persist(): PersistedActor<S, I>;
-    get state(): S;
-    set state(value: S);
-    get stateEnabled(): boolean;
-    get connStateEnabled(): boolean;
-    get vars(): V;
-    get db(): InferDatabaseClient<DB>;
-    start(actorDriver: ActorDriver, inlineClient: Client<Registry<any>>, actorId: string, name: string, key: ActorKey, region: string): Promise<void>;
-    isReady(): boolean;
-    assertReady(allowStoppingState?: boolean): void;
-    onStop(mode: "sleep" | "destroy"): Promise<void>;
-    startSleep(): void;
-    startDestroy(): void;
-    beginHonoHttpRequest(): void;
-    endHonoHttpRequest(): void;
-    processMessage(message: {
-        body: {
-            tag: "ActionRequest";
-            val: {
-                id: bigint;
-                name: string;
-                args: unknown;
-            };
-        } | {
-            tag: "SubscriptionRequest";
-            val: {
-                eventName: string;
-                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;
-    scheduleEvent(timestamp: number, action: string, args: unknown[]): Promise<void>;
-    onAlarm(): Promise<void>;
-    waitUntil(promise: Promise<void>): void;
-    resetSleepTimer(): void;
+/**
+ * Options for creating a actor.
+ * @typedef {QueryOptions} CreateOptions
+ * @property {string} [region] - The region to create the actor in.
+ */
+interface CreateOptions extends QueryOptions {
+    /** The region to create the actor in. */
+    region?: string;
+    /** Input data to pass to the actor. */
+    input?: unknown;
 }
-
-/** Pick a subset of persisted data used to represent ephemeral connections */
-type EphemeralConn<CP, CS> = Pick<PersistedConn<CP, CS>, "id" | "parameters" | "state">;
-type ConnDataInput<CP, CS> = {
-    ephemeral: EphemeralConn<CP, CS>;
-} | {
-    hibernatable: PersistedConn<CP, CS>;
-};
 /**
- * Manages connection state persistence, proxying, and change tracking.
- * Handles automatic state change detection for connection-specific state.
+ * Represents a region to connect to.
+ * @typedef {Object} Region
+ * @property {string} id - The region ID.
+ * @property {string} name - The region name.
+ * @see {@link https://rivet.dev/docs/edge|Edge Networking}
+ * @see {@link https://rivet.dev/docs/regions|Available Regions}
+ */
+interface Region {
+    /**
+     * The region slug.
+     */
+    id: string;
+    /**
+     * The human-friendly region name.
+     */
+    name: string;
+}
+declare const ACTOR_CONNS_SYMBOL: unique symbol;
+declare const CREATE_ACTOR_CONN_PROXY: unique symbol;
+/**
+ * Client for managing & connecting to actors.
+ *
+ * @template A The actors map type that defines the available actors.
+ * @see {@link https://rivet.dev/docs/manage|Create & Manage Actors}
  */
-declare class StateManager<CP, CS> {
+declare class ClientRaw {
     #private;
-    constructor(conn: Conn<any, CP, CS, any, any, any>, data: ConnDataInput<CP, CS>);
+    [ACTOR_CONNS_SYMBOL]: Set<ActorConnRaw>;
     /**
-     * Returns the ephemeral or persisted data for this connectioned.
+     * Creates an instance of Client.
+     */
+    constructor(driver: ManagerDriver, encoding: Encoding | undefined);
+    /**
+     * Gets a stateless handle to a actor by its ID.
      *
-     * This property is used to be able to treat both memory & persist conns
-     * identical by looking up the correct underlying data structure.
+     * @template AD The actor class that this handle is for.
+     * @param {string} name - The name of the actor.
+     * @param {string} actorId - The ID of the actor.
+     * @param {GetWithIdOptions} [opts] - Options for getting the actor.
+     * @returns {ActorHandle<AD>} - A handle to the actor.
      */
-    get ephemeralData(): EphemeralConn<CP, CS>;
-    get hibernatableData(): PersistedConn<CP, CS> | undefined;
-    hibernatableDataOrError(): PersistedConn<CP, CS>;
-    get hibernatableDataRaw(): PersistedConn<CP, CS> | undefined;
-    get stateEnabled(): boolean;
-    get state(): CS;
-    set state(value: CS);
-    addSubscription({ eventName }: {
-        eventName: string;
-    }): void;
-    removeSubscription({ eventName }: {
-        eventName: string;
-    }): boolean | undefined;
+    getForId<AD extends AnyActorDefinition>(name: string, actorId: string, opts?: GetWithIdOptions): ActorHandle<AD>;
+    /**
+     * Gets a stateless handle to a actor by its key, but does not create the actor if it doesn't exist.
+     *
+     * @template AD The actor class that this handle is for.
+     * @param {string} name - The name of the actor.
+     * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.
+     * @param {GetWithIdOptions} [opts] - Options for getting the actor.
+     * @returns {ActorHandle<AD>} - A handle to the actor.
+     */
+    get<AD extends AnyActorDefinition>(name: string, key?: string | string[], opts?: GetWithIdOptions): ActorHandle<AD>;
+    /**
+     * Gets a stateless handle to a actor by its key, creating it if necessary.
+     *
+     * @template AD The actor class that this handle is for.
+     * @param {string} name - The name of the actor.
+     * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.
+     * @param {GetOptions} [opts] - Options for getting the actor.
+     * @returns {ActorHandle<AD>} - A handle to the actor.
+     */
+    getOrCreate<AD extends AnyActorDefinition>(name: string, key?: string | string[], opts?: GetOrCreateOptions): ActorHandle<AD>;
+    /**
+     * Creates a new actor with the provided key and returns a stateless handle to it.
+     * Resolves the actor ID and returns a handle with getForId query.
+     *
+     * @template AD The actor class that this handle is for.
+     * @param {string} name - The name of the actor.
+     * @param {string | string[]} key - The key to identify the actor. Can be a single string or an array of strings.
+     * @param {CreateOptions} [opts] - Options for creating the actor (excluding name and key).
+     * @returns {Promise<ActorHandle<AD>>} - A promise that resolves to a handle to the actor.
+     */
+    create<AD extends AnyActorDefinition>(name: string, key?: string | string[], opts?: CreateOptions): Promise<ActorHandle<AD>>;
+    [CREATE_ACTOR_CONN_PROXY]<AD extends AnyActorDefinition>(conn: ActorConnRaw): ActorConn<AD>;
+    /**
+     * Disconnects from all actors.
+     *
+     * @returns {Promise<void>} A promise that resolves when all connections are closed.
+     */
+    dispose(): Promise<void>;
 }
-
-type ConnId = string;
-type AnyConn = Conn<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;
-declare const CONN_ACTOR_SYMBOL: unique symbol;
-declare const CONN_STATE_MANAGER_SYMBOL: unique symbol;
-declare const CONN_SEND_MESSAGE_SYMBOL: unique symbol;
 /**
- * Represents a client connection to a actor.
- *
- * Manages connection-specific data and controls the connection lifecycle.
+ * Client type with actor accessors.
+ * This adds property accessors for actor names to the ClientRaw base class.
  *
- * @see {@link https://rivet.dev/docs/connections|Connection Documentation}
+ * @template A The actor registry type.
  */
-declare class Conn<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
+type Client<A extends Registry<any>> = ClientRaw & {
+    [K in keyof ExtractActorsFromRegistry<A>]: ActorAccessor<ExtractActorsFromRegistry<A>[K]>;
+};
+type AnyClient = Client<Registry<any>>;
+
+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<{
+        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<{
+            error: "error";
+            trace: "trace";
+            fatal: "fatal";
+            warn: "warn";
+            info: "info";
+            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<{
+        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<{
+    runnerKey: string | undefined;
+    endpoint: string | undefined;
+    namespace: string;
+    token: string | undefined;
+    runnerName: string;
+    encoding: "json" | "cbor" | "bare";
+    headers: Record<string, string>;
+    disableMetadataLookup: boolean;
+    devtools: boolean;
+    getUpgradeWebSocket?: GetUpgradeWebSocket | undefined;
+    maxIncomingMessageSize: number;
+    maxOutgoingMessageSize: number;
+    inspector: {
+        enabled: boolean;
+        token: () => string;
+        defaultEndpoint?: string | undefined;
+    };
+    disableDefaultServer: boolean;
+    defaultServerPort: number;
+    runEngine: boolean;
+    runEngineVersion: string;
+    disableActorDriver: boolean;
+    runnerKind: "serverless" | "normal";
+    basePath: string;
+    noWelcome: boolean;
+    logging: {
+        baseLogger?: Logger | undefined;
+        level?: "error" | "trace" | "fatal" | "warn" | "info" | "debug" | "silent" | undefined;
+    };
+    totalSlots: number;
+    driver?: {
+        name: string;
+        manager: ManagerDriverBuilder;
+        actor: ActorDriverBuilder;
+    } | undefined;
+    overrideServerAddress?: string | undefined;
+    autoConfigureServerless?: boolean | {
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        maxRunners?: number | undefined;
+        minRunners?: number | undefined;
+        requestLifespan?: number | undefined;
+        runnersMargin?: number | undefined;
+        slotsPerRunner?: number | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    } | undefined;
+}, {
+    maxIncomingMessageSize: number;
+    maxOutgoingMessageSize: number;
+    inspector: {
+        enabled: boolean;
+        token: () => string;
+        defaultEndpoint?: string | undefined;
+    };
+    disableDefaultServer: boolean;
+    defaultServerPort: number;
+    runEngine: boolean;
+    runEngineVersion: string;
+    disableActorDriver: boolean;
+    runnerKind: "serverless" | "normal";
+    basePath: string;
+    noWelcome: boolean;
+    logging: {
+        baseLogger?: Logger | undefined;
+        level?: "error" | "trace" | "fatal" | "warn" | "info" | "debug" | "silent" | undefined;
+    };
+    endpoint: string;
+    token: string | undefined;
+    namespace: string | undefined;
+    runnerName: string;
+    encoding: "json" | "cbor" | "bare";
+    headers: Record<string, string>;
+    disableMetadataLookup: boolean;
+    devtools: boolean;
+    runnerKey: string | undefined;
+    totalSlots: number;
+    driver?: {
+        name: string;
+        manager: ManagerDriverBuilder;
+        actor: ActorDriverBuilder;
+    } | undefined;
+    overrideServerAddress?: string | undefined;
+    autoConfigureServerless?: boolean | {
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        maxRunners?: number | undefined;
+        minRunners?: number | undefined;
+        requestLifespan?: number | undefined;
+        runnersMargin?: number | undefined;
+        slotsPerRunner?: number | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    } | undefined;
+    getUpgradeWebSocket?: GetUpgradeWebSocket | undefined;
+}>>>;
+type LegacyRunnerConfigInput = z.input<typeof LegacyRunnerConfigSchema>;
+
+type FetchHandler = (request: Request, ...args: any) => Response | Promise<Response>;
+interface ServerlessHandler {
+    fetch: FetchHandler;
+}
+interface LegacyStartServerOutput<A extends Registry<any>> {
+    /** Client to communicate with the actors. */
+    client: Client<A>;
+    /** Fetch handler to manually route requests to the Rivet manager API. */
+    fetch: FetchHandler;
+}
+declare class Registry<A extends RegistryActors> {
     #private;
-    get [CONN_ACTOR_SYMBOL](): ActorInstance<S, CP, CS, V, I, DB>;
-    get [CONN_STATE_MANAGER_SYMBOL](): StateManager<CP, CS>;
-    /**
-     * Connections exist before being connected to an actor. If true, this
-     * connection has been connected.
-     **/
-    [CONN_CONNECTED_SYMBOL]: boolean;
-    /**
-     * If undefined, then no socket is connected to this conn
-     */
-    [CONN_DRIVER_SYMBOL]?: ConnDriver;
-    /**
-     * If this connection is speaking the RivetKit protocol. If false, this is
-     * a raw connection for WebSocket or fetch or inspector.
-     **/
-    get [CONN_SPEAKS_RIVETKIT_SYMBOL](): boolean;
-    subscriptions: Set<string>;
-    get params(): CP;
-    /**
-     * Gets the current state of the connection.
-     *
-     * Throws an error if the state is not enabled.
-     */
-    get state(): CS;
-    /**
-     * Sets the state of the connection.
-     *
-     * Throws an error if the state is not enabled.
-     */
-    set state(value: CS);
-    /**
-     * Unique identifier for the connection.
-     */
-    get id(): ConnId;
+    get config(): RegistryConfigInput<A>;
+    parseConfig(): RegistryConfig;
+    constructor(config: RegistryConfigInput<A>);
     /**
-     * @experimental
+     * Handle an incoming HTTP request for serverless deployments.
      *
-     * If the underlying connection can hibernate.
+     * @example
+     * ```ts
+     * const app = new Hono();
+     * app.all("/api/rivet/*", (c) => registry.handler(c.req.raw));
+     * export default app;
+     * ```
      */
-    get isHibernatable(): boolean;
+    handler(request: Request): Promise<Response>;
     /**
-     * Initializes a new instance of the Connection class.
-     *
-     * This should only be constructed by {@link Actor}.
+     * Returns a fetch handler for serverless deployments.
      *
-     * @protected
-     */
-    constructor(actor: ActorInstance<S, CP, CS, V, I, DB>, data: ConnDataInput<CP, CS>);
-    /**
-     * Sends a raw message to the underlying connection.
+     * @example
+     * ```ts
+     * export default registry.serve();
+     * ```
      */
-    [CONN_SEND_MESSAGE_SYMBOL](message: CachedSerializer<any, any, any>): void;
+    serve(): ServerlessHandler;
     /**
-     * Sends an event with arguments to the client.
-     *
-     * @param eventName - The name of the event.
-     * @param args - The arguments for the event.
-     * @see {@link https://rivet.dev/docs/events|Events Documentation}
+     * Starts an actor runner for standalone server deployments.
      */
-    send(eventName: string, ...args: unknown[]): void;
+    startRunner(): void;
     /**
-     * Disconnects the client with an optional reason.
+     * Runs the registry for a server.
      *
-     * @param reason - The reason for disconnection.
+     * @deprecated Use {@link Registry.startRunner} for long-running servers or {@link Registry.handler} for serverless deployments.
      */
-    disconnect(reason?: string): Promise<void>;
+    start(inputConfig?: LegacyRunnerConfigInput): LegacyStartServerOutput<this>;
 }
 
-interface ActorTypes<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> {
-    state?: TState;
-    connParams?: TConnParams;
-    connState?: TConnState;
-    vars?: TVars;
-    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> = {
-    state: TState;
-} | {
-    createState: (c: CreateContext<TState, TInput, TDatabase>, input: TInput) => TState | Promise<TState>;
-} | Record<never, never>;
-type CreateConnState<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> = {
-    connState: TConnState;
-} | {
-    createConnState: (c: CreateConnStateContext<TState, TVars, TInput, TDatabase>, params: TConnParams) => TConnState | Promise<TConnState>;
-} | Record<never, never>;
-/**
- * @experimental
- */
-type CreateVars<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> = {
-    /**
-     * @experimental
-     */
-    vars: TVars;
-} | {
-    /**
-     * @experimental
-     */
-    createVars: (c: CreateVarsContext<TState, TInput, TDatabase>, 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;
-}
 /**
- * @experimental
+ * Creates a client with the actor accessor proxy.
  */
-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>> {
-    /**
-     * 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>;
-    /**
-     * Called when the actor is destroyed.
-     */
-    onDestroy?: (c: DestroyContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>) => void | Promise<void>;
-    /**
-     * Called when the actor is started and ready to receive connections and action.
-     *
-     * Use this hook to initialize resources needed for the actor's operation
-     * (timers, external connections, etc.)
-     *
-     * @returns Void or a Promise that resolves when startup is complete
-     */
-    onWake?: (c: WakeContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>) => void | Promise<void>;
-    /**
-     * Called when the actor is stopping or sleeping.
-     *
-     * Use this hook to clean up resources, save state, or perform
-     * any shutdown operations before the actor sleeps or stops.
-     *
-     * Not supported on all platforms.
-     *
-     * @returns Void or a Promise that resolves when shutdown is complete
-     */
-    onSleep?: (c: SleepContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>) => void | Promise<void>;
-    /**
-     * Called when the actor's state changes.
-     *
-     * Use this hook to react to state changes, such as updating
-     * external systems or triggering events.
-     *
-     * State changes made within this hook will NOT trigger
-     * another onStateChange call, preventing infinite recursion.
-     *
-     * @param newState The updated state
-     */
-    onStateChange?: (c: StateChangeContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>, newState: TState) => void;
-    /**
-     * Called before a client connects to the actor.
-     *
-     * Use this hook to determine if a connection should be accepted
-     * and to initialize connection-specific state.
-     *
-     * @param opts Connection parameters including client-provided data
-     * @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>;
-    /**
-     * Called when a client successfully connects to the actor.
-     *
-     * Use this hook to perform actions when a connection is established,
-     * such as sending initial data or updating the actor's state.
-     *
-     * @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>;
-    /**
-     * Called when a client disconnects from the actor.
-     *
-     * Use this hook to clean up resources associated with the connection
-     * or update the actor's state.
-     *
-     * @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>;
-    /**
-     * Called before sending an action response to the client.
-     *
-     * Use this hook to modify or transform the output of an action before it's sent
-     * to the client. This is useful for formatting responses, adding metadata,
-     * or applying transformations to the output.
-     *
-     * @param name The name of the action that was called
-     * @param args The arguments that were passed to the action
-     * @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>;
-    /**
-     * Called when a raw HTTP request is made to the actor.
-     *
-     * This handler receives raw HTTP requests made to `/actors/{actorName}/http/*` endpoints.
-     * Use this hook to handle custom HTTP patterns, REST APIs, or other HTTP-based protocols.
-     *
-     * @param c The request context with access to the connection
-     * @param request The raw HTTP request object
-     * @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>;
-    /**
-     * Called when a raw WebSocket connection is established to the actor.
-     *
-     * This handler receives WebSocket connections made to `/actors/{actorName}/websocket/*` endpoints.
-     * Use this hook to handle custom WebSocket protocols, binary streams, or other WebSocket-based communication.
-     *
-     * @param c The WebSocket context with access to the connection
-     * @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>;
-    actions?: TActions;
-}
-type ActorDatabaseConfig<TDatabase extends AnyDatabaseProvider> = {
-    /**
-     * @experimental
-     */
-    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>> = {
-    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>;
+declare function createClient<A extends Registry<any>>(endpointOrConfig?: string | ClientConfigInput): Client<A>;
 
-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 { type ActorAccessor, type ActorActionFunction, ActorClientError, type ActorConn, ActorConnDisposed, ActorConnRaw, type ActorConnStatus, ActorDefinition, ActorError, type ActorHandle, ActorHandleRaw, type AnyActorDefinition, type Client, ClientRaw, type ConnectionStateCallback, type CreateOptions, type CreateRequest, type Encoding, type EventUnsubscribe, type ExtractActorsFromRegistry, type ExtractRegistryFromClient, type GetOptions, type GetWithIdOptions, InternalError, KEYS as KV_KEYS, MalformedResponseMessage, ManagerError, type QueryOptions, type Region, type StatusChangeCallback, createClient };