rivetkit 0.0.0-skip-ready-wait-flatten-client-options.1cae221 → 0.0.0-sqlite-uds.4e59a38

package/dist/tsup/context-DzMRHkjC.d.cts

@@ -1,92 +0,0 @@
-import { A as AnyActorDefinition, B as BaseActorDefinition, E as EventSchemaConfig, Q as QueueSchemaConfig, h as RunContext, ae as QueueFilterName, aj as QueueNextOptions, ak as QueueResultMessageForName, ai as QueueNextBatchOptions, bk as InferSchemaMap, ap as Registry, V as Client, u as ActorLogger, bl as InferEventArgs } from './config-CRdGwwbr.cjs';
-import { A as AnyDatabaseProvider, I as InferDatabaseClient } from './config-kxXbtrJU.cjs';
-import { WorkflowContextInterface, TryStepResult, TryBlockResult, LoopResult, LoopConfig, BranchConfig, BranchOutput, EntryKindType } from '@rivetkit/workflow-engine';
-
-type WorkflowActorQueueNextOptions<TName extends string, TCompletable extends boolean> = Omit<QueueNextOptions<TName, TCompletable>, "signal">;
-type WorkflowActorQueueNextOptionsFallback<TCompletable extends boolean> = Omit<QueueNextOptions<string, TCompletable>, "signal">;
-type WorkflowActorQueueNextBatchOptions<TName extends string, TCompletable extends boolean> = Omit<QueueNextBatchOptions<TName, TCompletable>, "signal">;
-type WorkflowActorQueueNextBatchOptionsFallback<TCompletable extends boolean> = Omit<QueueNextBatchOptions<string, TCompletable>, "signal">;
-type ActorWorkflowLoopConfig<S, T, TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig, TQueues extends QueueSchemaConfig> = Omit<LoopConfig<S, T>, "run"> & {
-    run: (ctx: ActorWorkflowContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>, state: S) => Promise<LoopResult<S, T> | (S extends undefined ? void : never)>;
-};
-type ActorWorkflowBranchConfig<TOutput, TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig, TQueues extends QueueSchemaConfig> = {
-    run: (ctx: ActorWorkflowContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => Promise<TOutput>;
-};
-declare class ActorWorkflowContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> implements WorkflowContextInterface {
-    #private;
-    constructor(inner: WorkflowContextInterface, runCtx: RunContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>);
-    get workflowId(): string;
-    get abortSignal(): AbortSignal;
-    get queue(): {
-        next: {
-            <const TName extends QueueFilterName<TQueues>, const TCompletable extends boolean = false>(name: string, opts?: WorkflowActorQueueNextOptions<TName, TCompletable>): Promise<QueueResultMessageForName<TQueues, TName, TCompletable>>;
-            <const TCompletable extends boolean = false>(name: string, opts?: WorkflowActorQueueNextOptionsFallback<TCompletable>): Promise<QueueResultMessageForName<TQueues, QueueFilterName<TQueues>, TCompletable>>;
-        };
-        nextBatch: {
-            <const TName extends QueueFilterName<TQueues>, const TCompletable extends boolean = false>(name: string, opts?: WorkflowActorQueueNextBatchOptions<TName, TCompletable>): Promise<Array<QueueResultMessageForName<TQueues, TName, TCompletable>>>;
-            <const TCompletable extends boolean = false>(name: string, opts?: WorkflowActorQueueNextBatchOptionsFallback<TCompletable>): Promise<Array<QueueResultMessageForName<TQueues, QueueFilterName<TQueues>, TCompletable>>>;
-        };
-        send: {
-            <K extends keyof TQueues & string>(name: K, body: InferSchemaMap<TQueues>[K]): Promise<void>;
-            (name: keyof TQueues extends never ? string : never, body: unknown): Promise<void>;
-        };
-    };
-    step<T>(nameOrConfig: string | Parameters<WorkflowContextInterface["step"]>[0], run?: () => Promise<T>): Promise<T>;
-    tryStep<T>(nameOrConfig: string | Parameters<WorkflowContextInterface["tryStep"]>[0], run?: () => Promise<T>): Promise<TryStepResult<T>>;
-    try<T>(nameOrConfig: string | Parameters<WorkflowContextInterface["try"]>[0], run?: (ctx: ActorWorkflowContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => Promise<T>): Promise<TryBlockResult<T>>;
-    loop<T>(name: string, run: (ctx: ActorWorkflowContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => Promise<LoopResult<undefined, T> | void>): Promise<T>;
-    loop<T>(name: string, run: (ctx: WorkflowContextInterface) => Promise<LoopResult<undefined, T> | void>): Promise<T>;
-    loop<S, T>(config: ActorWorkflowLoopConfig<S, T, TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>): Promise<T>;
-    loop<S, T>(config: LoopConfig<S, T>): Promise<T>;
-    sleep(name: string, durationMs: number): Promise<void>;
-    sleepUntil(name: string, timestampMs: number): Promise<void>;
-    destroy(): void;
-    rollbackCheckpoint(name: string): Promise<void>;
-    join<T extends Record<string, ActorWorkflowBranchConfig<unknown, TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>>>(name: string, branches: T): Promise<{
-        [K in keyof T]: Awaited<ReturnType<T[K]["run"]>>;
-    }>;
-    join<T extends Record<string, BranchConfig<unknown>>>(name: string, branches: T): Promise<{
-        [K in keyof T]: BranchOutput<T[K]>;
-    }>;
-    race<T>(name: string, branches: Array<{
-        name: string;
-        run: (ctx: ActorWorkflowContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => Promise<T>;
-    }>): Promise<{
-        winner: string;
-        value: T;
-    }>;
-    removed(name: string, originalType: EntryKindType): Promise<void>;
-    isEvicted(): boolean;
-    get state(): TState extends never ? never : TState;
-    get vars(): TVars extends never ? never : TVars;
-    client<R extends Registry<any> = Registry<any>>(): Client<R>;
-    get db(): TDatabase extends never ? never : InferDatabaseClient<TDatabase>;
-    get log(): ActorLogger;
-    /** @deprecated No-op. Use `keepAwake(promise)` or `waitUntil(promise)` instead. */
-    setPreventSleep(_prevent: boolean): void;
-    /** @deprecated No-op. Always returns `false`. */
-    get preventSleep(): boolean;
-    /**
-     * Holds the actor awake for the duration of the provided promise. The
-     * actor cannot idle-sleep or finalize the sleep grace period until the
-     * promise settles.
-     */
-    keepAwake<T>(promise: Promise<T>): Promise<T>;
-    /**
-     * Registers a promise that the sleep grace period will wait on. Use this
-     * for best-effort flush/cleanup work that may complete inside the grace
-     * window. For work the actor must stay running through, prefer
-     * `c.keepAwake(promise)` which also blocks idle sleep.
-     */
-    waitUntil(promise: Promise<void>): void;
-    get actorId(): string;
-    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;
-    consumeGuardViolation(): boolean;
-}
-type WorkflowContextOf<AD extends AnyActorDefinition> = AD extends BaseActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB extends AnyDatabaseProvider, infer E extends EventSchemaConfig, infer Q extends QueueSchemaConfig, any> ? ActorWorkflowContext<S, CP, CS, V, I, DB, E, Q> : never;
-type WorkflowLoopContextOf<AD extends AnyActorDefinition> = WorkflowContextOf<AD>;
-type WorkflowBranchContextOf<AD extends AnyActorDefinition> = WorkflowContextOf<AD>;
-type WorkflowStepContextOf<AD extends AnyActorDefinition> = WorkflowContextOf<AD>;
-
-export { ActorWorkflowContext as A, type WorkflowBranchContextOf as W, type WorkflowContextOf as a, type WorkflowLoopContextOf as b, type WorkflowStepContextOf as c };

package/dist/tsup/utils-fwx3o3K9.d.cts

@@ -1,18 +0,0 @@
-import { Next } from 'hono';
-import { ContentfulStatusCode } from 'hono/utils/http-status';
-
-declare function assertUnreachable(x: never): never;
-interface DeconstructedError {
-    __type: "ActorError";
-    statusCode: ContentfulStatusCode;
-    public: boolean;
-    group: string;
-    code: string;
-    message: string;
-    metadata?: unknown;
-}
-declare function stringifyError(error: unknown): string;
-/** Generates a `Next` handler to pass to middleware in order to be able to call arbitrary middleware. */
-declare function noopNext(): Next;
-
-export { type DeconstructedError as D, assertUnreachable as a, noopNext as n, stringifyError as s };

package/dist/tsup/utils-fwx3o3K9.d.ts

@@ -1,18 +0,0 @@
-import { Next } from 'hono';
-import { ContentfulStatusCode } from 'hono/utils/http-status';
-
-declare function assertUnreachable(x: never): never;
-interface DeconstructedError {
-    __type: "ActorError";
-    statusCode: ContentfulStatusCode;
-    public: boolean;
-    group: string;
-    code: string;
-    message: string;
-    metadata?: unknown;
-}
-declare function stringifyError(error: unknown): string;
-/** Generates a `Next` handler to pass to middleware in order to be able to call arbitrary middleware. */
-declare function noopNext(): Next;
-
-export { type DeconstructedError as D, assertUnreachable as a, noopNext as n, stringifyError as s };

package/src/utils/serve.ts

@@ -1,217 +0,0 @@
-import type { Hono } from "hono";
-import { detectRuntime, stringifyError, type Runtime } from "../utils";
-import { RegistryConfig } from "@/registry/config";
-import { logger } from "@/registry/log";
-
-// TODO: Go back to dynamic import for this
-import getPort from "get-port";
-
-const DEFAULT_PORT = 6421;
-export type ServeStatic =
-	typeof import("@hono/node-server/serve-static").serveStatic;
-const serveStaticLoaderPromises: Partial<
-	Record<Runtime, Promise<ServeStatic>>
-> = {};
-
-/**
- * Finds a free port starting from the given port.
- *
- * Tries ports incrementally until a free one is found.
- */
-export async function findFreePort(
-	startPort: number = DEFAULT_PORT,
-): Promise<number> {
-	// TODO: Fix this
-	// const getPortModule = "get-port";
-	// const { default: getPort } = await import(/* webpackIgnore: true */ getPortModule);
-
-	// Create an iterable of ports starting from startPort
-	function* portRange(start: number, count: number = 100): Iterable<number> {
-		for (let i = 0; i < count; i++) {
-			yield start + i;
-		}
-	}
-
-	return getPort({ port: portRange(startPort) });
-}
-
-export async function crossPlatformServe(
-	config: RegistryConfig,
-	httpPort: number,
-	app: Hono<any>,
-	runtime: Runtime = detectRuntime(),
-): Promise<{ upgradeWebSocket: any; closeServer?: () => void }> {
-	logger().debug({ msg: "detected runtime for serve", runtime });
-
-	switch (runtime) {
-		case "deno":
-			return serveDeno(config, httpPort, app);
-		case "bun":
-			return serveBun(config, httpPort, app);
-		case "node":
-			return serveNode(config, httpPort, app);
-		default:
-			return serveNode(config, httpPort, app);
-	}
-}
-
-export async function loadRuntimeServeStatic(
-	runtime: Runtime,
-): Promise<ServeStatic> {
-	if (!serveStaticLoaderPromises[runtime]) {
-		if (runtime === "node") {
-			const nodeServeStaticModule = "@hono/node-server/serve-static";
-			serveStaticLoaderPromises[runtime] = import(
-				/* webpackIgnore: true */
-				nodeServeStaticModule
-			).then((x) => x.serveStatic);
-		} else if (runtime === "bun") {
-			const bunModule = "hono/bun";
-			serveStaticLoaderPromises[runtime] = import(
-				/* webpackIgnore: true */
-				bunModule
-			).then((x) => x.serveStatic as ServeStatic);
-		} else if (runtime === "deno") {
-			const denoModule = "hono/deno";
-			serveStaticLoaderPromises[runtime] = import(
-				/* webpackIgnore: true */
-				denoModule
-			).then((x) => x.serveStatic as ServeStatic);
-		} else {
-			throw new Error(`unsupported runtime: ${runtime}`);
-		}
-	}
-
-	return await serveStaticLoaderPromises[runtime]!;
-}
-
-async function serveNode(
-	config: RegistryConfig,
-	httpPort: number,
-	app: Hono<any>,
-): Promise<{ upgradeWebSocket: any; closeServer: () => void }> {
-	// Import @hono/node-server using string variable to prevent static analysis
-	const nodeServerModule = "@hono/node-server";
-	let serve: any;
-	try {
-		const dep = await import(
-			/* webpackIgnore: true */
-			nodeServerModule
-		);
-		serve = dep.serve;
-	} catch (err) {
-		logger().error({
-			msg: "failed to import @hono/node-server. please run 'npm install @hono/node-server @hono/node-ws'",
-			error: stringifyError(err),
-		});
-		process.exit(1);
-	}
-
-	// Import @hono/node-ws using string variable to prevent static analysis
-	const nodeWsModule = "@hono/node-ws";
-	let createNodeWebSocket: any;
-	try {
-		const dep = await import(
-			/* webpackIgnore: true */
-			nodeWsModule
-		);
-		createNodeWebSocket = dep.createNodeWebSocket;
-	} catch (err) {
-		logger().error({
-			msg: "failed to import @hono/node-ws. please run 'npm install @hono/node-server @hono/node-ws'",
-			error: stringifyError(err),
-		});
-		process.exit(1);
-	}
-
-	// Inject WS
-	const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({
-		app: app,
-	});
-
-	// Start server
-	const port = httpPort;
-	const hostname = config.httpHost;
-	const server = serve({ fetch: app.fetch, port, hostname }, () =>
-		logger().info({ msg: "server listening", port, hostname }),
-	);
-	injectWebSocket(server);
-
-	const closeServer = () => {
-		server.close();
-	};
-
-	return { upgradeWebSocket, closeServer };
-}
-
-async function serveDeno(
-	config: RegistryConfig,
-	httpPort: number,
-	app: Hono<any>,
-): Promise<{ upgradeWebSocket: any }> {
-	// Import hono/deno using string variable to prevent static analysis
-	const honoDenoModule = "hono/deno";
-	let upgradeWebSocket: any;
-	try {
-		const dep = await import(
-			/* webpackIgnore: true */
-			honoDenoModule
-		);
-		upgradeWebSocket = dep.upgradeWebSocket;
-	} catch (err) {
-		logger().error({
-			msg: "failed to import hono/deno",
-			error: stringifyError(err),
-		});
-		process.exit(1);
-	}
-
-	const port = httpPort;
-	const hostname = config.httpHost;
-
-	// Use Deno.serve
-	Deno.serve({ port, hostname }, app.fetch);
-	logger().info({ msg: "server listening", port, hostname });
-
-	return { upgradeWebSocket };
-}
-
-async function serveBun(
-	config: RegistryConfig,
-	httpPort: number,
-	app: Hono<any>,
-): Promise<{ upgradeWebSocket: any }> {
-	// Import hono/bun using string variable to prevent static analysis
-	const honoBunModule = "hono/bun";
-	let createBunWebSocket: any;
-	try {
-		const dep = await import(
-			/* webpackIgnore: true */
-			honoBunModule
-		);
-		createBunWebSocket = dep.createBunWebSocket;
-	} catch (err) {
-		logger().error({
-			msg: "failed to import hono/bun",
-			error: stringifyError(err),
-		});
-		process.exit(1);
-	}
-
-	const { websocket, upgradeWebSocket } = createBunWebSocket();
-
-	const port = httpPort;
-	const hostname = config.httpHost;
-
-	// Use Bun.serve
-	// @ts-expect-error - Bun global
-	Bun.serve({
-		fetch: app.fetch,
-		port,
-		hostname,
-		websocket,
-	});
-	logger().info({ msg: "server listening", port, hostname });
-
-	return { upgradeWebSocket };
-}