rivetkit 2.0.2 → 2.0.4

package/dist/tsup/inspector/mod.d.ts

@@ -0,0 +1,408 @@
+import { A as ActorFeature } from '../common-CXCe7s6i.js';
+export { d as Actor, a as ActorId, b as ActorLogEntry, c as ActorSchema, v as Build, B as BuildSchema, x as Builds, w as BuildsSchema, p as Column, o as ColumnSchema, r as Columns, q as ColumnsSchema, g as Connection, C as ConnectionSchema, z as CreateActor, y as CreateActorSchema, k as DatabaseQuery, D as DatabaseQuerySchema, s as ForeignKey, F as ForeignKeySchema, u as ForeignKeys, t as ForeignKeysSchema, e as Operation, O as OperationSchema, f as Patch, P as PatchSchema, h as RealtimeEvent, R as RealtimeEventSchema, j as RecordedRealtimeEvent, i as RecordedRealtimeEventSchema, l as Table, T as TableSchema, n as Tables, m as TablesSchema } from '../common-CXCe7s6i.js';
+import * as hono_utils_http_status from 'hono/utils/http-status';
+import * as hono_client from 'hono/client';
+import { hc } from 'hono/client';
+import * as z from 'zod/v4';
+
+declare const client$1: {
+    ping: hono_client.ClientRequest<{
+        $get: {
+            input: {};
+            output: {
+                message: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    }>;
+} & {
+    state: hono_client.ClientRequest<{
+        $get: {
+            input: {};
+            output: {
+                enabled: boolean;
+                state: null;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    } & {
+        $patch: {
+            input: {
+                json: {
+                    patch: ({
+                        op: "remove";
+                        path: string;
+                    } | {
+                        op: "add";
+                        path: string;
+                        value: unknown;
+                    } | {
+                        op: "replace";
+                        path: string;
+                        value: unknown;
+                    } | {
+                        op: "move";
+                        path: string;
+                        from: string;
+                    } | {
+                        op: "copy";
+                        path: string;
+                        from: string;
+                    } | {
+                        op: "test";
+                        path: string;
+                        value: unknown;
+                    })[];
+                } | {
+                    replace: any;
+                };
+            };
+            output: {
+                enabled: boolean;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    }>;
+} & {
+    state: {
+        stream: hono_client.ClientRequest<{
+            $get: {
+                input: {};
+                output: {};
+                outputFormat: string;
+                status: hono_utils_http_status.StatusCode;
+            };
+        }>;
+    };
+} & {
+    connections: hono_client.ClientRequest<{
+        $get: {
+            input: {};
+            output: {
+                connections: {
+                    id: string;
+                    params?: {
+                        [x: string]: any;
+                    } | undefined;
+                    stateEnabled?: boolean | undefined;
+                    state?: any;
+                    auth?: {
+                        [x: string]: any;
+                    } | undefined;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    }>;
+} & {
+    connections: {
+        stream: hono_client.ClientRequest<{
+            $get: {
+                input: {};
+                output: {};
+                outputFormat: string;
+                status: hono_utils_http_status.StatusCode;
+            };
+        }>;
+    };
+} & {
+    events: hono_client.ClientRequest<{
+        $get: {
+            input: {};
+            output: {
+                events: ({
+                    type: "action";
+                    name: string;
+                    args: any[];
+                    connId: string;
+                    id: string;
+                    timestamp: number;
+                } | {
+                    type: "broadcast";
+                    eventName: string;
+                    args: any[];
+                    id: string;
+                    timestamp: number;
+                } | {
+                    type: "subscribe";
+                    eventName: string;
+                    connId: string;
+                    id: string;
+                    timestamp: number;
+                } | {
+                    type: "unsubscribe";
+                    eventName: string;
+                    connId: string;
+                    id: string;
+                    timestamp: number;
+                } | {
+                    type: "event";
+                    eventName: string;
+                    args: any[];
+                    connId: string;
+                    id: string;
+                    timestamp: number;
+                })[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    }>;
+} & {
+    events: {
+        clear: hono_client.ClientRequest<{
+            $post: {
+                input: {};
+                output: {
+                    message: string;
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+        }>;
+    };
+} & {
+    events: {
+        stream: hono_client.ClientRequest<{
+            $get: {
+                input: {};
+                output: {};
+                outputFormat: string;
+                status: hono_utils_http_status.StatusCode;
+            };
+        }>;
+    };
+} & {
+    rpcs: hono_client.ClientRequest<{
+        $get: {
+            input: {};
+            output: {
+                rpcs: string[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    }>;
+} & {
+    db: hono_client.ClientRequest<{
+        $get: {
+            input: {};
+            output: {
+                enabled: boolean;
+                db: null;
+            };
+            outputFormat: "json";
+            status: 200;
+        } | {
+            input: {};
+            output: {
+                enabled: boolean;
+                db: {
+                    table: {
+                        schema: string;
+                        name: string;
+                        type: "table" | "view";
+                    };
+                    columns: {
+                        cid: number;
+                        name: string;
+                        type: "integer" | "blob" | "text" | "real" | "numeric" | "serial";
+                        notnull: boolean;
+                        dflt_value: string | null;
+                        pk: boolean | null;
+                    }[];
+                    foreignKeys: {
+                        id: number;
+                        table: string;
+                        from: string;
+                        to: string;
+                    }[];
+                    records: any;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    } & {
+        $post: {
+            input: {
+                json: {
+                    query: string;
+                    params?: any[] | undefined;
+                };
+            };
+            output: {
+                enabled: boolean;
+            };
+            outputFormat: "json";
+            status: 200;
+        } | {
+            input: {
+                json: {
+                    query: string;
+                    params?: any[] | undefined;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 500;
+        };
+    }>;
+};
+type ActorInspectorClient = typeof client$1;
+declare const createActorInspectorClient: (...args: Parameters<typeof hc>) => ActorInspectorClient;
+
+declare const client: {
+    ping: hono_client.ClientRequest<{
+        $get: {
+            input: {};
+            output: {
+                message: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    }>;
+} & {
+    actors: hono_client.ClientRequest<{
+        $get: {
+            input: {};
+            output: "Invalid limit";
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {};
+            output: {
+                id: string & z.$brand<"ActorId">;
+                name: string;
+                key: string[];
+                tags?: {
+                    [x: string]: string;
+                } | undefined;
+                region?: string | undefined;
+                createdAt?: string | undefined;
+                startedAt?: string | undefined;
+                destroyedAt?: string | undefined;
+                features?: ActorFeature[] | undefined;
+            }[];
+            outputFormat: "json";
+            status: 200;
+        } | {
+            input: {};
+            output: "Failed to fetch actors";
+            outputFormat: "json";
+            status: 500;
+        };
+    } & {
+        $post: {
+            input: {
+                json: {
+                    name: string;
+                    key: string[];
+                    input: any;
+                };
+            };
+            output: {
+                id: string & z.$brand<"ActorId">;
+                name: string;
+                key: string[];
+                tags?: {
+                    [x: string]: string;
+                } | undefined;
+                region?: string | undefined;
+                createdAt?: string | undefined;
+                startedAt?: string | undefined;
+                destroyedAt?: string | undefined;
+                features?: ActorFeature[] | undefined;
+            } | null;
+            outputFormat: "json";
+            status: 201;
+        };
+    }>;
+} & {
+    builds: hono_client.ClientRequest<{
+        $get: {
+            input: {};
+            output: {
+                name: string;
+                createdAt?: string | undefined;
+                tags?: {
+                    [x: string]: string;
+                } | undefined;
+            }[];
+            outputFormat: "json";
+            status: 200;
+        };
+    }>;
+} & {
+    actor: {
+        ":id": hono_client.ClientRequest<{
+            $get: {
+                input: {
+                    param: {
+                        id: string;
+                    };
+                };
+                output: {
+                    error: string;
+                };
+                outputFormat: "json";
+                status: 404;
+            } | {
+                input: {
+                    param: {
+                        id: string;
+                    };
+                };
+                output: {
+                    id: string & z.$brand<"ActorId">;
+                    name: string;
+                    key: string[];
+                    tags?: {
+                        [x: string]: string;
+                    } | undefined;
+                    region?: string | undefined;
+                    createdAt?: string | undefined;
+                    startedAt?: string | undefined;
+                    destroyedAt?: string | undefined;
+                    features?: ActorFeature[] | undefined;
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+        }>;
+    };
+} & {
+    bootstrap: hono_client.ClientRequest<{
+        $get: {
+            input: {};
+            output: {
+                actors: {
+                    id: string & z.$brand<"ActorId">;
+                    name: string;
+                    key: string[];
+                    tags?: {
+                        [x: string]: string;
+                    } | undefined;
+                    region?: string | undefined;
+                    createdAt?: string | undefined;
+                    startedAt?: string | undefined;
+                    destroyedAt?: string | undefined;
+                    features?: ActorFeature[] | undefined;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    }>;
+};
+type ManagerInspectorClient = typeof client;
+declare const createManagerInspectorClient: (...args: Parameters<typeof hc>) => ManagerInspectorClient;
+
+export { ActorFeature, type ActorInspectorClient, type ManagerInspectorClient, createActorInspectorClient, createManagerInspectorClient };

package/dist/tsup/inspector/mod.js

@@ -0,0 +1,51 @@
+import {
+  ActorFeature,
+  ActorId,
+  ActorLogEntry,
+  ActorSchema,
+  BuildSchema,
+  BuildsSchema,
+  ColumnSchema,
+  ColumnsSchema,
+  ConnectionSchema,
+  CreateActorSchema,
+  DatabaseQuerySchema,
+  ForeignKeySchema,
+  ForeignKeysSchema,
+  OperationSchema,
+  PatchSchema,
+  RealtimeEventSchema,
+  RecordedRealtimeEventSchema,
+  TableSchema,
+  TablesSchema,
+  createActorInspectorClient,
+  createManagerInspectorClient
+} from "../chunk-H26RP6GD.js";
+import "../chunk-HLLF4B4Q.js";
+import "../chunk-LV2S3OU3.js";
+import "../chunk-PQY7KKTL.js";
+import "../chunk-NFU2BBT5.js";
+export {
+  ActorFeature,
+  ActorId,
+  ActorLogEntry,
+  ActorSchema,
+  BuildSchema,
+  BuildsSchema,
+  ColumnSchema,
+  ColumnsSchema,
+  ConnectionSchema,
+  CreateActorSchema,
+  DatabaseQuerySchema,
+  ForeignKeySchema,
+  ForeignKeysSchema,
+  OperationSchema,
+  PatchSchema,
+  RealtimeEventSchema,
+  RecordedRealtimeEventSchema,
+  TableSchema,
+  TablesSchema,
+  createActorInspectorClient,
+  createManagerInspectorClient
+};
+//# sourceMappingURL=mod.js.map

package/dist/tsup/inspector/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/tsup/mod.cjs

@@ -0,0 +1,67 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkVO7ZRVVDcjs = require('./chunk-VO7ZRVVD.cjs');
+require('./chunk-LWNKVZG5.cjs');
+require('./chunk-QNNXFOQV.cjs');
+require('./chunk-WHBPJNGW.cjs');
+
+
+
+
+
+
+
+
+
+var _chunkGICQ3YCUcjs = require('./chunk-GICQ3YCU.cjs');
+require('./chunk-4CXBCT26.cjs');
+
+
+
+var _chunk6LJT3QRLcjs = require('./chunk-6LJT3QRL.cjs');
+
+
+var _chunkSBHHJ6QScjs = require('./chunk-SBHHJ6QS.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.ALLOWED_PUBLIC_HEADERS = _chunkGICQ3YCUcjs.ALLOWED_PUBLIC_HEADERS; exports.CONNECTION_DRIVER_HTTP = _chunkGICQ3YCUcjs.CONNECTION_DRIVER_HTTP; exports.CONNECTION_DRIVER_SSE = _chunkGICQ3YCUcjs.CONNECTION_DRIVER_SSE; exports.CONNECTION_DRIVER_WEBSOCKET = _chunkGICQ3YCUcjs.CONNECTION_DRIVER_WEBSOCKET; exports.GenericConnGlobalState = _chunkVO7ZRVVDcjs.GenericConnGlobalState; exports.InlineWebSocketAdapter2 = _chunkVO7ZRVVDcjs.InlineWebSocketAdapter2; exports.PATH_CONNECT_WEBSOCKET = _chunkVO7ZRVVDcjs.PATH_CONNECT_WEBSOCKET; exports.PATH_RAW_WEBSOCKET_PREFIX = _chunkVO7ZRVVDcjs.PATH_RAW_WEBSOCKET_PREFIX; exports.Registry = _chunkVO7ZRVVDcjs.Registry; exports.RegistryConfigSchema = _chunkVO7ZRVVDcjs.RegistryConfigSchema; exports.UserError = _chunkSBHHJ6QScjs.UserError; exports.actor = _chunkVO7ZRVVDcjs.actor; exports.createActorRouter = _chunkVO7ZRVVDcjs.createActorRouter; exports.createClientWithDriver = _chunkVO7ZRVVDcjs.createClientWithDriver; exports.createEngineDriver = _chunkVO7ZRVVDcjs.createEngineDriver; exports.createFileSystemDriver = _chunkVO7ZRVVDcjs.createFileSystemDriver; exports.createGenericConnDrivers = _chunkVO7ZRVVDcjs.createGenericConnDrivers; exports.createMemoryDriver = _chunkVO7ZRVVDcjs.createMemoryDriver; exports.generateConnId = _chunkGICQ3YCUcjs.generateConnId; exports.generateConnToken = _chunkGICQ3YCUcjs.generateConnToken; exports.handleRawWebSocketHandler = _chunkGICQ3YCUcjs.handleRawWebSocketHandler; exports.handleWebSocketConnect = _chunkGICQ3YCUcjs.handleWebSocketConnect; exports.lookupInRegistry = _chunkVO7ZRVVDcjs.lookupInRegistry; exports.noopNext = _chunk6LJT3QRLcjs.noopNext; exports.setup = _chunkVO7ZRVVDcjs.setup; exports.toUint8Array = _chunk6LJT3QRLcjs.toUint8Array;
+//# sourceMappingURL=mod.cjs.map

package/dist/tsup/mod.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/nathan/rivetkit/packages/rivetkit/dist/tsup/mod.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B,gCAA6B;AAC7B,gCAA6B;AAC7B,gCAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B,gCAA6B;AAC7B;AACE;AACA;AACF,wDAA6B;AAC7B;AACE;AACF,wDAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,ysDAAC","file":"/Users/nathan/rivetkit/packages/rivetkit/dist/tsup/mod.cjs"}

package/dist/tsup/mod.d.cts

@@ -0,0 +1,105 @@
+import { R as RunConfig, A as ActorDriver, a as AnyDatabaseProvider, b as Actions, c as ActorConfigInput, d as ActorDefinition, D as DriverConfig } from './connection-Dyd4NLGW.cjs';
+export { n as ActionContext, v as ActionContextOf, K as ActorConfig, H as ActorConfigSchema, u as ActorContext, w as ActorContextOf, m as ActorKey, i as ActorQuery, F as ActorTypes, x as AnyActorDefinition, B as AnyActorInstance, f as AnyClient, J as AuthIntent, r as CONNECTION_DRIVER_HTTP, s as CONNECTION_DRIVER_SSE, t as CONNECTION_DRIVER_WEBSOCKET, C as Client, o as Conn, p as ConnectionDriver, q as ConnectionStatus, E as Encoding, G as GenericConnGlobalState, I as InitContext, O as OnConnectOptions, Q as Registry, N as RegistryActors, M as RegistryConfig, P as RegistryConfigSchema, j as RivetCloseEvent, k as RivetEvent, l as RivetMessageEvent, U as UniversalWebSocket, h as createClientWithDriver, z as createGenericConnDrivers, g as generateConnId, e as generateConnToken, y as lookupInRegistry, S as setup, L as test } from './connection-Dyd4NLGW.cjs';
+export { A as ALLOWED_PUBLIC_HEADERS, I as InlineWebSocketAdapter2, U as UpgradeWebSocketArgs, h as handleRawWebSocketHandler, a as handleWebSocketConnect } from './router-endpoints-BTe_Rsdn.cjs';
+export { n as noopNext } from './utils-fwx3o3K9.cjs';
+import * as hono_types from 'hono/types';
+import { Hono } from 'hono';
+import { z } from 'zod';
+export { toUint8Array } from './utils.cjs';
+export { UserError, UserErrorOptions } from './actor/errors.cjs';
+import 'pino';
+import 'nanoevents';
+import './common-CXCe7s6i.cjs';
+import 'zod/v4';
+import 'hono/streaming';
+import 'hono/ws';
+import 'hono/utils/http-status';
+
+interface UniversalEvent {
+    type: string;
+    target?: any;
+    currentTarget?: any;
+}
+interface UniversalMessageEvent extends UniversalEvent {
+    data: string;
+    lastEventId: string;
+    origin: string;
+}
+interface UniversalErrorEvent extends UniversalEvent {
+    message: string;
+    filename?: string;
+    lineno?: number;
+    colno?: number;
+    error?: any;
+}
+/**
+ * Common EventSource interface that can be implemented by different EventSource-like classes
+ * This is compatible with the standard EventSource API but allows for custom implementations
+ */
+interface UniversalEventSource {
+    readonly CONNECTING: 0;
+    readonly OPEN: 1;
+    readonly CLOSED: 2;
+    readonly readyState: 0 | 1 | 2;
+    readonly url: string;
+    readonly withCredentials: boolean;
+    close(): void;
+    addEventListener(type: string, listener: (event: any) => void): void;
+    removeEventListener(type: string, listener: (event: any) => void): void;
+    dispatchEvent(event: UniversalEvent): boolean;
+    onopen?: ((event: UniversalEvent) => void) | null;
+    onmessage?: ((event: UniversalMessageEvent) => void) | null;
+    onerror?: ((event: UniversalErrorEvent) => void) | null;
+}
+
+declare const PATH_CONNECT_WEBSOCKET = "/connect/websocket";
+declare const PATH_RAW_WEBSOCKET_PREFIX = "/raw/websocket/";
+
+interface ActorRouterBindings {
+    actorId: string;
+}
+type ActorRouter = Hono<{
+    Bindings: ActorRouterBindings;
+}>;
+/**
+ * Creates a router that runs on the partitioned instance.
+ */
+declare function createActorRouter(runConfig: RunConfig, actorDriver: ActorDriver): ActorRouter;
+
+declare function actor<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>): ActorDefinition<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TActions>;
+
+declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
+    app: z.ZodOptional<z.ZodType<Hono<hono_types.BlankEnv, hono_types.BlankSchema, "/">, z.ZodTypeDef, Hono<hono_types.BlankEnv, hono_types.BlankSchema, "/">>>;
+    endpoint: z.ZodDefault<z.ZodString>;
+    pegboardEndpoint: z.ZodOptional<z.ZodString>;
+    namespace: z.ZodDefault<z.ZodString>;
+    runnerName: z.ZodDefault<z.ZodString>;
+    runnerKey: z.ZodDefault<z.ZodString>;
+    totalSlots: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    endpoint: string;
+    namespace: string;
+    runnerName: string;
+    runnerKey: string;
+    totalSlots: number;
+    app?: Hono<hono_types.BlankEnv, hono_types.BlankSchema, "/"> | undefined;
+    pegboardEndpoint?: string | undefined;
+}, {
+    endpoint?: string | undefined;
+    namespace?: string | undefined;
+    runnerName?: string | undefined;
+    app?: Hono<hono_types.BlankEnv, hono_types.BlankSchema, "/"> | undefined;
+    pegboardEndpoint?: string | undefined;
+    runnerKey?: string | undefined;
+    totalSlots?: number | undefined;
+}>>;
+type InputConfig = z.input<typeof ConfigSchema>;
+
+declare function createEngineDriver(inputConfig?: InputConfig): DriverConfig;
+
+declare function createFileSystemDriver(opts?: {
+    path?: string;
+}): DriverConfig;
+declare function createMemoryDriver(): DriverConfig;
+
+export { Actions, ActorConfigInput, ActorDefinition, type ActorRouter, DriverConfig, PATH_CONNECT_WEBSOCKET, PATH_RAW_WEBSOCKET_PREFIX, RunConfig, type UniversalErrorEvent, type UniversalEvent, type UniversalEventSource, type UniversalMessageEvent, actor, createActorRouter, createEngineDriver, createFileSystemDriver, createMemoryDriver };