experimental-ash 0.22.2 → 0.24.0

package/dist/src/compiled/@workflow/core/runtime/world.d.ts

@@ -0,0 +1,32 @@
+import type { World } from '../_workflow-world.js';
+/**
+ * Create a new world instance based on environment variables.
+ * WORKFLOW_TARGET_WORLD is used to determine the target world.
+ *
+ * Note: WORKFLOW_VERCEL_* env vars (PROJECT, TEAM, AUTH_TOKEN, etc.) are
+ * intentionally NOT read here. Those are for CLI/observability tooling only
+ * and should not affect runtime behavior. The Vercel runtime provides
+ * authentication via OIDC tokens and project context via system env vars
+ * (VERCEL_DEPLOYMENT_ID, VERCEL_PROJECT_ID). Tooling that needs these env
+ * vars should call createVercelWorld() directly with an explicit config and
+ * use setWorld() to inject the instance.
+ */
+export declare const createWorld: () => Promise<World>;
+export type WorldHandlers = Pick<World, 'createQueueHandler' | 'specVersion'>;
+/**
+ * Some functions from the world are needed at build time, but we do NOT want
+ * to cache the world in those instances for general use, since we don't have
+ * the correct environment variables set yet. This is a safe function to
+ * call at build time, that only gives access to non-environment-bound world
+ * functions. The only binding value should be the target world.
+ * Once we migrate to a file-based configuration (workflow.config.ts), we should
+ * be able to re-combine getWorld and getWorldHandlers into one singleton.
+ */
+export declare const getWorldHandlers: () => Promise<WorldHandlers>;
+export declare const getWorld: () => Promise<World>;
+/**
+ * Reset the cached world instance. This should be called when environment
+ * variables change and you need to reinitialize the world with new config.
+ */
+export declare const setWorld: (world: World | undefined) => void;
+//# sourceMappingURL=world.d.ts.map

package/dist/src/compiled/@workflow/core/runtime.d.ts

@@ -1,67 +1,22 @@
-export type Event = any;
-export type WorkflowRun = any;
-export type WorkflowReadableStream<T = unknown> = ReadableStream<T>;
-export interface WorkflowReadableStreamOptions {
-  [key: string]: unknown;
-}
-export interface WorkflowWritableStreamOptions {
-  namespace?: string | undefined;
-}
-export type HealthCheckEndpoint = any;
-export type HealthCheckOptions = any;
-export type HealthCheckResult = any;
-export type ReadStreamOptions = any;
-export type RecreateRunOptions = any;
-export type StartOptions = any;
-export type StartOptionsBase = any;
-export type StartOptionsWithDeploymentId = any;
-export type StartOptionsWithoutDeploymentId = any;
-export type StopSleepOptions = any;
-export type StopSleepResult = any;
-export interface WorkflowWorldCollection {
-  get(id: string, options?: Record<string, any>): Promise<any>;
-  get(params?: Record<string, any>, options?: Record<string, any>): Promise<any>;
-  list(
-    params?: Record<string, any>,
-  ): Promise<{ cursor?: string | null; data: any[]; hasMore?: boolean }>;
-}
-export interface WorkflowWorld {
-  readonly events: WorkflowWorldCollection;
-  readonly hooks: WorkflowWorldCollection;
-  readonly runs: WorkflowWorldCollection;
-  readonly steps: WorkflowWorldCollection;
-}
-export declare class Run<T = any> {
-  readonly runId: string;
-  readonly readable: ReadableStream<Uint8Array>;
-  readonly returnValue: Promise<T>;
-  readonly status: Promise<string>;
-  cancel(): Promise<void>;
-  getReadable(options?: WorkflowReadableStreamOptions): ReadableStream<Uint8Array>;
-}
-export declare class WorkflowSuspension extends Error {}
-export declare function cancelRun(...args: unknown[]): Promise<unknown>;
-export declare function createWorld(...args: unknown[]): Promise<unknown>;
-export declare function getHookByToken(...args: unknown[]): Promise<unknown>;
-export declare function getRun<T = unknown>(runId: string): Run<T>;
-export declare function getWorld(): Promise<WorkflowWorld>;
-export declare function getWorldHandlers(): Promise<any>;
-export declare function healthCheck(...args: unknown[]): Promise<HealthCheckResult>;
-export declare function listStreams(...args: unknown[]): Promise<unknown>;
-export declare function readStream<T = unknown>(
-  ...args: unknown[]
-): Promise<WorkflowReadableStream<T>>;
-export declare function recreateRunFromExisting(...args: unknown[]): Promise<unknown>;
-export declare function reenqueueRun(...args: unknown[]): Promise<unknown>;
-export declare function resumeHook<T = unknown>(token: string, value?: T): Promise<void>;
-export declare function resumeWebhook<T = unknown>(token: string, value?: T): Promise<Response>;
-export declare function setWorld(world: unknown): void;
-export declare function start<T = any>(
-  workflow: unknown,
-  args?: unknown[],
-  options?: StartOptions,
-): Promise<Run<T>>;
-export declare function wakeUpRun(...args: unknown[]): Promise<unknown>;
-export declare function workflowEntrypoint(
-  workflowCode: string,
-): (req: Request) => Promise<Response>;
+import { type Event, type WorkflowRun } from './_workflow-world.js';
+export type { Event, WorkflowRun };
+export { WorkflowSuspension } from './global.js';
+export { type HealthCheckEndpoint, type HealthCheckOptions, type HealthCheckResult, healthCheck, } from './runtime/helpers.js';
+export { getHookByToken, resumeHook, resumeWebhook, } from './runtime/resume-hook.js';
+export { getRun, Run, type WorkflowReadableStream, type WorkflowReadableStreamOptions, } from './runtime/run.js';
+export { cancelRun, listStreams, type ReadStreamOptions, type RecreateRunOptions, readStream, recreateRunFromExisting, reenqueueRun, type StopSleepOptions, type StopSleepResult, wakeUpRun, } from './runtime/runs.js';
+export { type StartOptions, type StartOptionsBase, type StartOptionsWithDeploymentId, type StartOptionsWithoutDeploymentId, start, } from './runtime/start.js';
+export { createWorld, getWorld, getWorldHandlers, setWorld, } from './runtime/world.js';
+/**
+ * Creates a single route which handles workflow execution requests,
+ * executing steps inline when possible to reduce function invocations
+ * and queue overhead.
+ *
+ * The handler loops: replay workflow → execute step inline → replay → ...
+ * until the workflow completes, times out, or encounters non-step suspensions.
+ *
+ * @param workflowCode - The workflow bundle code containing all workflow functions
+ * @returns A function that can be used as a Vercel API route
+ */
+export declare function workflowEntrypoint(workflowCode: string): (req: Request) => Promise<Response>;
+//# sourceMappingURL=runtime.d.ts.map