@workflow/web-shared 4.1.0-beta.47 → 4.1.0-beta.49

package/dist/api/workflow-server-actions.js

@@ -1,861 +0,0 @@
-'use server';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { hydrateResourceIO } from '@workflow/core/observability';
-import { createWorld, healthCheck, resumeHook as resumeHookRuntime, start, } from '@workflow/core/runtime';
-import { getDeserializeStream, getExternalRevivers, } from '@workflow/core/serialization';
-import { WorkflowAPIError, WorkflowRunNotFoundError } from '@workflow/errors';
-import { findWorkflowDataDir } from '@workflow/utils/check-data-dir';
-import { isLegacySpecVersion, SPEC_VERSION_LEGACY, } from '@workflow/world';
-import { createVercelWorld } from '@workflow/world-vercel';
-/**
- * Map from WORKFLOW_TARGET_WORLD value to human-readable display name
- */
-function getBackendDisplayName(targetWorld) {
-    if (!targetWorld)
-        return 'Local';
-    switch (targetWorld) {
-        case 'local':
-            return 'Local';
-        case 'vercel':
-            return 'Vercel';
-        case '@workflow/world-postgres':
-        case 'postgres':
-            return 'PostgreSQL';
-        default:
-            // For custom worlds, try to make a readable name
-            if (targetWorld.startsWith('@')) {
-                // Extract package name without scope for display
-                const parts = targetWorld.split('/');
-                return parts[parts.length - 1] || targetWorld;
-            }
-            return targetWorld;
-    }
-}
-function getEffectiveBackendId() {
-    const targetWorld = process.env.WORKFLOW_TARGET_WORLD;
-    if (targetWorld) {
-        return targetWorld;
-    }
-    // Match @workflow/core/runtime defaulting: vercel if VERCEL_DEPLOYMENT_ID is set, else local.
-    return process.env.VERCEL_DEPLOYMENT_ID ? 'vercel' : 'local';
-}
-function getObservabilityCwd() {
-    const raw = process.env.WORKFLOW_OBSERVABILITY_CWD;
-    if (!raw) {
-        return process.cwd();
-    }
-    return path.isAbsolute(raw) ? raw : path.resolve(process.cwd(), raw);
-}
-/**
- * Ensure local-world env is derived consistently when running `packages/web` directly.
- *
- * Without this, the UI may *display* a dataDir detected from WORKFLOW_OBSERVABILITY_CWD,
- * while the actual World reads from `WORKFLOW_LOCAL_DATA_DIR` (defaulting to `.workflow-data`
- * under the web package cwd), resulting in "no runs" even though data exists.
- */
-async function ensureLocalWorldDataDirEnv() {
-    if (process.env.WORKFLOW_LOCAL_DATA_DIR)
-        return;
-    const cwd = getObservabilityCwd();
-    const info = await findWorkflowDataDir(cwd);
-    // Prefer a discovered workflow-data directory (e.g. `.next/workflow-data`).
-    if (info.dataDir) {
-        process.env.WORKFLOW_LOCAL_DATA_DIR = info.dataDir;
-        return;
-    }
-    // Fall back to a canonical location under the target project directory.
-    process.env.WORKFLOW_LOCAL_DATA_DIR = path.resolve(cwd, '.workflow-data');
-}
-/**
- * Extract hostname from a database URL without exposing credentials.
- */
-function extractHostnameFromUrl(url) {
-    if (!url)
-        return undefined;
-    try {
-        const parsed = new URL(url);
-        return parsed.hostname || undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Extract database name from a URL where pathname is like "/dbname".
- * (Works for postgres/mongodb-style URLs; returns undefined when not applicable.)
- */
-function extractDatabaseFromUrl(url) {
-    if (!url)
-        return undefined;
-    try {
-        const parsed = new URL(url);
-        const dbName = parsed.pathname?.slice(1);
-        return dbName || undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-// Keep this list in sync with `worlds-manifest.json` env + credentialsNote.
-const WORLD_ENV_ALLOWLIST_BY_TARGET_WORLD = {
-    // Official
-    local: [
-        'WORKFLOW_TARGET_WORLD',
-        'WORKFLOW_LOCAL_DATA_DIR',
-        'WORKFLOW_MANIFEST_PATH',
-        'WORKFLOW_OBSERVABILITY_CWD',
-        'PORT',
-    ],
-    '@workflow/world-local': [
-        'WORKFLOW_TARGET_WORLD',
-        'WORKFLOW_LOCAL_DATA_DIR',
-        'WORKFLOW_MANIFEST_PATH',
-        'WORKFLOW_OBSERVABILITY_CWD',
-        'PORT',
-    ],
-    postgres: ['WORKFLOW_TARGET_WORLD', 'WORKFLOW_POSTGRES_URL'],
-    '@workflow/world-postgres': [
-        'WORKFLOW_TARGET_WORLD',
-        'WORKFLOW_POSTGRES_URL',
-    ],
-    vercel: [
-        'WORKFLOW_TARGET_WORLD',
-        'WORKFLOW_VERCEL_ENV',
-        'WORKFLOW_VERCEL_TEAM',
-        'WORKFLOW_VERCEL_PROJECT',
-        'WORKFLOW_VERCEL_AUTH_TOKEN',
-    ],
-    '@workflow/world-vercel': [
-        'WORKFLOW_TARGET_WORLD',
-        'WORKFLOW_VERCEL_ENV',
-        'WORKFLOW_VERCEL_TEAM',
-        'WORKFLOW_VERCEL_PROJECT',
-        'WORKFLOW_VERCEL_AUTH_TOKEN',
-    ],
-    // Community (from worlds-manifest.json)
-    '@workflow-worlds/starter': ['WORKFLOW_TARGET_WORLD'],
-    '@workflow-worlds/turso': [
-        'WORKFLOW_TARGET_WORLD',
-        'WORKFLOW_TURSO_DATABASE_URL',
-    ],
-    '@workflow-worlds/mongodb': [
-        'WORKFLOW_TARGET_WORLD',
-        'WORKFLOW_MONGODB_URI',
-        'WORKFLOW_MONGODB_DATABASE_NAME',
-    ],
-    '@workflow-worlds/redis': ['WORKFLOW_TARGET_WORLD', 'WORKFLOW_REDIS_URI'],
-    'workflow-world-jazz': [
-        'WORKFLOW_TARGET_WORLD',
-        // credentialsNote:
-        'JAZZ_API_KEY',
-        'JAZZ_WORKER_ACCOUNT',
-        'JAZZ_WORKER_SECRET',
-    ],
-};
-function getAllowedEnvKeysForBackend(backendId) {
-    return (WORLD_ENV_ALLOWLIST_BY_TARGET_WORLD[backendId] ?? ['WORKFLOW_TARGET_WORLD']);
-}
-// Keep this list in sync with `worlds-manifest.json` env + credentialsNote.
-//
-// IMPORTANT: This is intentionally explicit (no heuristics). We only redact values for env
-// vars that are known + whitelisted and that we *know* contain secrets/credentials.
-const WORLD_SENSITIVE_ENV_KEYS = new Set([
-    // Official
-    'WORKFLOW_POSTGRES_URL',
-    'WORKFLOW_VERCEL_AUTH_TOKEN',
-    // Community
-    'WORKFLOW_TURSO_DATABASE_URL',
-    'WORKFLOW_MONGODB_URI',
-    'WORKFLOW_REDIS_URI',
-    'JAZZ_API_KEY',
-    'JAZZ_WORKER_SECRET',
-]);
-function isSet(value) {
-    return value !== undefined && value !== null && value !== '';
-}
-function deriveDbInfoForKey(key, value) {
-    // Only attempt for URL-like strings.
-    if (!value.includes(':'))
-        return null;
-    try {
-        const parsed = new URL(value);
-        const protocol = (parsed.protocol || '').replace(':', '');
-        // file: URIs are not useful for hostname/db display
-        if (protocol === 'file')
-            return null;
-        const hostname = extractHostnameFromUrl(value);
-        const database = extractDatabaseFromUrl(value);
-        const out = {};
-        if (hostname)
-            out[`derived.${key}.hostname`] = hostname;
-        if (database)
-            out[`derived.${key}.database`] = database;
-        if (protocol)
-            out[`derived.${key}.protocol`] = protocol;
-        return Object.keys(out).length ? out : null;
-    }
-    catch {
-        return null;
-    }
-}
-async function getLocalDisplayInfo() {
-    const cwd = getObservabilityCwd();
-    const dataDirInfo = await findWorkflowDataDir(cwd);
-    const out = {
-        'local.shortName': dataDirInfo.shortName,
-        'local.projectDir': dataDirInfo.projectDir,
-    };
-    if (dataDirInfo.dataDir) {
-        out['local.dataDirPath'] = dataDirInfo.dataDir;
-    }
-    return out;
-}
-function collectAllowedEnv(allowedKeys) {
-    const publicEnv = {};
-    const sensitiveEnvKeys = [];
-    const derivedDisplayInfo = {};
-    for (const key of allowedKeys) {
-        const value = process.env[key];
-        if (!isSet(value))
-            continue;
-        if (WORLD_SENSITIVE_ENV_KEYS.has(key)) {
-            sensitiveEnvKeys.push(key);
-            const derived = deriveDbInfoForKey(key, value);
-            if (derived)
-                Object.assign(derivedDisplayInfo, derived);
-            continue;
-        }
-        publicEnv[key] = value;
-    }
-    return {
-        publicEnv,
-        sensitiveEnvKeys: Array.from(new Set(sensitiveEnvKeys)).sort(),
-        derivedDisplayInfo,
-    };
-}
-/**
- * Get public configuration info that is safe to send to the client.
- *
- * This is the ONLY server action that intentionally exposes env-derived data,
- * and that data is strictly whitelisted per world backend.
- */
-export async function getPublicServerConfig() {
-    const backendId = getEffectiveBackendId();
-    const backendDisplayName = getBackendDisplayName(backendId);
-    const allowedKeys = getAllowedEnvKeysForBackend(backendId);
-    const { publicEnv, sensitiveEnvKeys, derivedDisplayInfo } = collectAllowedEnv(allowedKeys);
-    const displayInfo = { ...derivedDisplayInfo };
-    if (backendId === 'local' || backendId === '@workflow/world-local') {
-        Object.assign(displayInfo, await getLocalDisplayInfo());
-    }
-    const config = {
-        backendDisplayName,
-        backendId,
-        publicEnv,
-        sensitiveEnvKeys,
-        displayInfo: Object.keys(displayInfo).length ? displayInfo : undefined,
-    };
-    // Provide defaults for commonly expected keys without revealing extra secrets.
-    if ((backendId === 'vercel' || backendId === '@workflow/world-vercel') &&
-        !publicEnv.WORKFLOW_VERCEL_ENV) {
-        config.publicEnv.WORKFLOW_VERCEL_ENV = 'production';
-    }
-    return config;
-}
-/**
- * Cache for World instances.
- *
- * IMPORTANT:
- * - We only cache non-vercel worlds.
- * - Cache keys are derived from **server-side** WORKFLOW_* env vars only.
- */
-const worldCache = new Map();
-/**
- * Get or create a World instance based on configuration.
- *
- * The @workflow/web UI should always pass `{}` for envMap.
- */
-async function getWorldFromEnv(userEnvMap) {
-    const backendId = getEffectiveBackendId();
-    const isVercelWorld = ['vercel', '@workflow/world-vercel'].includes(backendId);
-    // For the vercel world specifically, we do not cache the world,
-    // and allow user-provided env, as it can be a multi-tenant environment,
-    // and we instantiate the world per-user directly to avoid having to set
-    // process.env.
-    if (isVercelWorld) {
-        return createVercelWorld({
-            token: userEnvMap.WORKFLOW_VERCEL_AUTH_TOKEN ||
-                process.env.WORKFLOW_VERCEL_AUTH_TOKEN,
-            projectConfig: {
-                environment: userEnvMap.WORKFLOW_VERCEL_ENV || process.env.WORKFLOW_VERCEL_ENV,
-                projectId: userEnvMap.WORKFLOW_VERCEL_PROJECT ||
-                    process.env.WORKFLOW_VERCEL_PROJECT,
-                teamId: userEnvMap.WORKFLOW_VERCEL_TEAM || process.env.WORKFLOW_VERCEL_TEAM,
-            },
-        });
-    }
-    // For other worlds, we intentionally do not trust or apply client-provided env,
-    // to avoid potential security risks in self-hosted scenarios.
-    // Ensure local-world reads from the same project directory the UI is inspecting.
-    if (backendId === 'local' || backendId === '@workflow/world-local') {
-        await ensureLocalWorldDataDirEnv();
-    }
-    // Cache key derived ONLY from WORKFLOW_* env vars.
-    const workflowEnvEntries = Object.entries(process.env).filter(([key]) => key.startsWith('WORKFLOW_'));
-    workflowEnvEntries.sort(([a], [b]) => a.localeCompare(b));
-    const cacheKey = JSON.stringify(Object.fromEntries(workflowEnvEntries));
-    const cachedWorld = worldCache.get(cacheKey);
-    if (cachedWorld) {
-        return cachedWorld;
-    }
-    const world = createWorld();
-    worldCache.set(cacheKey, world);
-    return world;
-}
-/**
- * Creates a structured error object from a caught error
- */
-function createServerActionError(error, operation, requestParams) {
-    const err = error instanceof Error ? error : new Error(String(error));
-    console.error(`[web-api] ${operation} error:`, err);
-    let errorResponse;
-    if (WorkflowAPIError.is(error)) {
-        // If the World threw the error on fetch/fs.read, we add that data
-        // to the error object
-        errorResponse = {
-            message: getUserFacingErrorMessage(err, error.status),
-            layer: 'API',
-            cause: err.stack || err.message,
-            request: {
-                operation,
-                params: requestParams ?? {},
-                status: error.status,
-                url: error.url,
-                code: error.code ?? undefined,
-            },
-        };
-    }
-    else if (WorkflowRunNotFoundError.is(error)) {
-        // The World might repackage the error as a WorkflowRunNotFoundError
-        errorResponse = {
-            message: getUserFacingErrorMessage(error, 404),
-            layer: 'API',
-            cause: err.stack || err.message,
-            request: { operation, status: 404, params: requestParams ?? {} },
-        };
-    }
-    else {
-        errorResponse = {
-            message: getUserFacingErrorMessage(err),
-            layer: 'server',
-            cause: err.stack || err.message,
-            request: { status: 500, operation, params: requestParams ?? {} },
-        };
-    }
-    return {
-        success: false,
-        error: errorResponse,
-    };
-}
-/**
- * Converts an error into a user-facing message
- */
-function getUserFacingErrorMessage(error, status) {
-    if (!status) {
-        return `Error creating response: ${error.message}`;
-    }
-    // Check for common error patterns
-    if (status === 403 || status === 401) {
-        return 'Access denied. Please check your credentials and permissions.';
-    }
-    if (status === 404) {
-        return 'The requested resource was not found.';
-    }
-    if (status === 500) {
-        return 'Error connecting to World backend, please try again later.';
-    }
-    if (error.message?.includes('Network') || error.message?.includes('fetch')) {
-        return 'Network error. Please check your connection and try again.';
-    }
-    // Return the original message for other errors
-    return error.message || 'An unexpected error occurred';
-}
-const toJSONCompatible = (data) => {
-    if (data && typeof data === 'object') {
-        return JSON.parse(JSON.stringify(data));
-    }
-    return data;
-};
-const hydrate = (data) => {
-    try {
-        return hydrateResourceIO(data);
-    }
-    catch (error) {
-        throw new Error('Failed to hydrate data', { cause: error });
-    }
-};
-/**
- * Helper to create successful responses
- * @param data - The data to return on success
- * @returns ServerActionResult with success=true and the data
- */
-function createResponse(data) {
-    data = toJSONCompatible(data);
-    return {
-        success: true,
-        data,
-    };
-}
-/**
- * Fetch paginated list of workflow runs
- */
-export async function fetchRuns(worldEnv, params) {
-    const { cursor, sortOrder = 'desc', limit = 10, workflowName, status, } = params;
-    try {
-        const world = await getWorldFromEnv(worldEnv);
-        const result = await world.runs.list({
-            ...(workflowName ? { workflowName } : {}),
-            ...(status ? { status: status } : {}),
-            pagination: { cursor, limit, sortOrder },
-            resolveData: 'none',
-        });
-        return createResponse({
-            data: result.data.map(hydrate),
-            cursor: result.cursor ?? undefined,
-            hasMore: result.hasMore,
-        });
-    }
-    catch (error) {
-        return createServerActionError(error, 'world.runs.list', params);
-    }
-}
-/**
- * Fetch a single workflow run with full data
- */
-export async function fetchRun(worldEnv, runId, resolveData = 'all') {
-    try {
-        const world = await getWorldFromEnv(worldEnv);
-        const run = await world.runs.get(runId, { resolveData });
-        const hydratedRun = hydrate(run);
-        return createResponse(hydratedRun);
-    }
-    catch (error) {
-        return createServerActionError(error, 'world.runs.get', {
-            runId,
-            resolveData,
-        });
-    }
-}
-/**
- * Fetch paginated list of steps for a run
- */
-export async function fetchSteps(worldEnv, runId, params) {
-    const { cursor, sortOrder = 'asc', limit = 100 } = params;
-    try {
-        const world = await getWorldFromEnv(worldEnv);
-        const result = await world.steps.list({
-            runId,
-            pagination: { cursor, limit, sortOrder },
-            resolveData: 'none',
-        });
-        return createResponse({
-            // StepWithoutData has undefined input/output, but after hydration the structure is compatible
-            data: result.data.map(hydrate),
-            cursor: result.cursor ?? undefined,
-            hasMore: result.hasMore,
-        });
-    }
-    catch (error) {
-        return createServerActionError(error, 'world.steps.list', {
-            runId,
-            ...params,
-        });
-    }
-}
-/**
- * Fetch a single step with full data
- */
-export async function fetchStep(worldEnv, runId, stepId, resolveData = 'all') {
-    try {
-        const world = await getWorldFromEnv(worldEnv);
-        const step = await world.steps.get(runId, stepId, { resolveData });
-        const hydratedStep = hydrate(step);
-        return createResponse(hydratedStep);
-    }
-    catch (error) {
-        return createServerActionError(error, 'world.steps.get', {
-            runId,
-            stepId,
-            resolveData,
-        });
-    }
-}
-/**
- * Fetch paginated list of events for a run
- */
-export async function fetchEvents(worldEnv, runId, params) {
-    const { cursor, sortOrder = 'asc', limit = 1000 } = params;
-    try {
-        const world = await getWorldFromEnv(worldEnv);
-        const result = await world.events.list({
-            runId,
-            pagination: { cursor, limit, sortOrder },
-            resolveData: 'none',
-        });
-        return createResponse({
-            data: result.data,
-            cursor: result.cursor ?? undefined,
-            hasMore: result.hasMore,
-        });
-    }
-    catch (error) {
-        return createServerActionError(error, 'world.events.list', {
-            runId,
-            ...params,
-        });
-    }
-}
-/**
- * Fetch events by correlation ID
- */
-export async function fetchEventsByCorrelationId(worldEnv, correlationId, params) {
-    const { cursor, sortOrder = 'asc', limit = 1000, withData = false } = params;
-    try {
-        const world = await getWorldFromEnv(worldEnv);
-        const result = await world.events.listByCorrelationId({
-            correlationId,
-            pagination: { cursor, limit, sortOrder },
-            resolveData: withData ? 'all' : 'none',
-        });
-        return createResponse({
-            data: result.data.map(hydrate),
-            cursor: result.cursor ?? undefined,
-            hasMore: result.hasMore,
-        });
-    }
-    catch (error) {
-        return createServerActionError(error, 'world.events.listByCorrelationId', {
-            correlationId,
-            ...params,
-        });
-    }
-}
-/**
- * Fetch paginated list of hooks
- */
-export async function fetchHooks(worldEnv, params) {
-    const { runId, cursor, sortOrder = 'desc', limit = 10 } = params;
-    try {
-        const world = await getWorldFromEnv(worldEnv);
-        const result = await world.hooks.list({
-            ...(runId ? { runId } : {}),
-            pagination: { cursor, limit, sortOrder },
-            resolveData: 'none',
-        });
-        return createResponse({
-            data: result.data.map(hydrate),
-            cursor: result.cursor ?? undefined,
-            hasMore: result.hasMore,
-        });
-    }
-    catch (error) {
-        return createServerActionError(error, 'world.hooks.list', params);
-    }
-}
-/**
- * Fetch a single hook with full data
- */
-export async function fetchHook(worldEnv, hookId, resolveData = 'all') {
-    try {
-        const world = await getWorldFromEnv(worldEnv);
-        const hook = await world.hooks.get(hookId, { resolveData });
-        return createResponse(hydrate(hook));
-    }
-    catch (error) {
-        return createServerActionError(error, 'world.hooks.get', {
-            hookId,
-            resolveData,
-        });
-    }
-}
-/**
- * Cancel a workflow run
- */
-export async function cancelRun(worldEnv, runId) {
-    try {
-        const world = await getWorldFromEnv(worldEnv);
-        const run = await world.runs.get(runId, { resolveData: 'none' });
-        const compatMode = isLegacySpecVersion(run.specVersion);
-        const eventData = {
-            eventType: 'run_cancelled',
-            specVersion: run.specVersion || 1,
-        };
-        await world.events.create(runId, eventData, { v1Compat: compatMode });
-        return createResponse(undefined);
-    }
-    catch (error) {
-        return createServerActionError(error, 'world.events.create', {
-            runId,
-        });
-    }
-}
-/**
- * Start a new workflow run.
- *
- * This requires the ID of an existing run of which to re-use the deployment ID of.
- */
-export async function recreateRun(worldEnv, runId, deploymentId) {
-    try {
-        const world = await getWorldFromEnv({ ...worldEnv });
-        const run = await world.runs.get(runId);
-        // Get original input/output
-        const hydratedRun = hydrate(run);
-        // Preserve original specVersion - if undefined (legacy v1), use SPEC_VERSION_LEGACY
-        const newRun = await start({ workflowId: run.workflowName }, hydratedRun.input, {
-            deploymentId: deploymentId ?? run.deploymentId,
-            world,
-            specVersion: run.specVersion ?? SPEC_VERSION_LEGACY,
-        });
-        return createResponse(newRun.runId);
-    }
-    catch (error) {
-        return createServerActionError(error, 'recreateRun', { runId });
-    }
-}
-/**
- * Re-enqueue a workflow run.
- *
- * This re-enqueues the workflow orchestration layer. It's a no-op unless the workflow
- * got stuck due to an implementation issue in the World. Useful for debugging custom Worlds.
- */
-export async function reenqueueRun(worldEnv, runId) {
-    try {
-        const world = await getWorldFromEnv({ ...worldEnv });
-        const run = await world.runs.get(runId);
-        const deploymentId = run.deploymentId;
-        await world.queue(`__wkf_workflow_${run.workflowName}`, {
-            runId,
-        }, {
-            deploymentId,
-        });
-        return createResponse(undefined);
-    }
-    catch (error) {
-        return createServerActionError(error, 'reenqueueRun', { runId });
-    }
-}
-/**
- * Wake up a workflow run by interrupting pending sleep() calls.
- *
- * This finds wait_created events without matching wait_completed events,
- * creates wait_completed events for them, and then re-enqueues the run.
- *
- * @param worldEnv - Environment configuration for the World
- * @param runId - The run ID to wake up
- * @param options - Optional settings to narrow down targeting (specific correlation IDs)
- */
-export async function wakeUpRun(worldEnv, runId, options) {
-    try {
-        const world = await getWorldFromEnv({ ...worldEnv });
-        const run = await world.runs.get(runId);
-        const deploymentId = run.deploymentId;
-        const compatMode = isLegacySpecVersion(run.specVersion);
-        // Fetch all events for the run
-        const eventsResult = await world.events.list({
-            runId,
-            pagination: { limit: 1000 },
-            resolveData: 'none',
-        });
-        // Find wait_created events without matching wait_completed events
-        const waitCreatedEvents = eventsResult.data.filter((e) => e.eventType === 'wait_created');
-        const waitCompletedCorrelationIds = new Set(eventsResult.data
-            .filter((e) => e.eventType === 'wait_completed')
-            .map((e) => e.correlationId));
-        let pendingWaits = waitCreatedEvents.filter((e) => !waitCompletedCorrelationIds.has(e.correlationId));
-        // If specific correlation IDs are provided, filter to only those
-        if (options?.correlationIds && options.correlationIds.length > 0) {
-            const targetCorrelationIds = new Set(options.correlationIds);
-            pendingWaits = pendingWaits.filter((e) => e.correlationId && targetCorrelationIds.has(e.correlationId));
-        }
-        // Create wait_completed events for each pending wait
-        for (const waitEvent of pendingWaits) {
-            if (waitEvent.correlationId) {
-                // For v2, include specVersion in event data; for v1Compat, it's not needed
-                const eventData = compatMode
-                    ? {
-                        eventType: 'wait_completed',
-                        correlationId: waitEvent.correlationId,
-                    }
-                    : {
-                        eventType: 'wait_completed',
-                        correlationId: waitEvent.correlationId,
-                        specVersion: run.specVersion,
-                    };
-                await world.events.create(runId, eventData, { v1Compat: compatMode });
-            }
-        }
-        // Re-enqueue the run to wake it up
-        if (pendingWaits.length > 0) {
-            await world.queue(`__wkf_workflow_${run.workflowName}`, {
-                runId,
-            }, {
-                deploymentId,
-            });
-        }
-        return createResponse({ stoppedCount: pendingWaits.length });
-    }
-    catch (error) {
-        return createServerActionError(error, 'wakeUpRun', {
-            runId,
-            correlationIds: options?.correlationIds,
-        });
-    }
-}
-/**
- * Resume a hook by sending a payload.
- *
- * This sends a payload to a hook identified by its token, which resumes
- * the associated workflow run. The payload will be available as the return
- * value of the `createHook()` call in the workflow.
- *
- * @param worldEnv - Environment configuration for the World
- * @param token - The hook token
- * @param payload - The JSON payload to send to the hook
- */
-export async function resumeHook(worldEnv, token, payload) {
-    try {
-        // Initialize the world so resumeHookRuntime can access it
-        await getWorldFromEnv({ ...worldEnv });
-        const hook = await resumeHookRuntime(token, payload);
-        return createResponse({
-            hookId: hook.hookId,
-            runId: hook.runId,
-        });
-    }
-    catch (error) {
-        return createServerActionError(error, 'resumeHook', {
-            token,
-        });
-    }
-}
-export async function readStreamServerAction(env, streamId, startIndex) {
-    try {
-        const world = await getWorldFromEnv(env);
-        // We should probably use getRun().getReadable() instead, to make the UI
-        // more consistent with runtime behavior, and also expose a "replay" and "startIndex",
-        // feature, to allow for testing World behavior.
-        const stream = await world.readFromStream(streamId, startIndex);
-        const revivers = getExternalRevivers(globalThis, [], '');
-        const transform = getDeserializeStream(revivers);
-        return stream.pipeThrough(transform);
-    }
-    catch (error) {
-        const actionError = createServerActionError(error, 'world.readFromStream', {
-            streamId,
-            startIndex,
-        });
-        if (!actionError.success) {
-            return actionError.error;
-        }
-        // Shouldn't happen, this is just a type guard
-        throw new Error();
-    }
-}
-/**
- * List all stream IDs for a run
- */
-export async function fetchStreams(env, runId) {
-    try {
-        const world = await getWorldFromEnv(env);
-        const streams = await world.listStreamsByRunId(runId);
-        return createResponse(streams);
-    }
-    catch (error) {
-        return createServerActionError(error, 'world.listStreamsByRunId', {
-            runId,
-        });
-    }
-}
-/**
- * Fetch the workflows manifest from the workflow route directory
- * The manifest is generated at build time and contains static structure info about workflows
- *
- * Configuration priority:
- * 1. WORKFLOW_MANIFEST_PATH - explicit path to the manifest file
- * 2. Standard Next.js app router locations (app/.well-known/workflow/v1/manifest.json)
- * 3. WORKFLOW_EMBEDDED_DATA_DIR - legacy data directory
- */
-export async function fetchWorkflowsManifest(_worldEnv) {
-    const cwd = getObservabilityCwd();
-    // Helper to resolve path (absolute or relative to cwd)
-    const resolvePath = (p) => path.isAbsolute(p) ? p : path.join(cwd, p);
-    // Build list of paths to try, in priority order
-    const manifestPaths = [];
-    // 1. Explicit manifest path configuration (highest priority)
-    if (process.env.WORKFLOW_MANIFEST_PATH) {
-        manifestPaths.push(resolvePath(process.env.WORKFLOW_MANIFEST_PATH));
-    }
-    // 2. Standard Next.js app router locations
-    manifestPaths.push(path.join(cwd, 'app/.well-known/workflow/v1/manifest.json'), path.join(cwd, 'src/app/.well-known/workflow/v1/manifest.json'));
-    // 3. Legacy data directory locations
-    if (process.env.WORKFLOW_EMBEDDED_DATA_DIR) {
-        manifestPaths.push(path.join(resolvePath(process.env.WORKFLOW_EMBEDDED_DATA_DIR), 'manifest.json'));
-    }
-    // Try each path until we find the manifest
-    for (const manifestPath of manifestPaths) {
-        try {
-            const content = await fs.readFile(manifestPath, 'utf-8');
-            const manifest = JSON.parse(content);
-            return createResponse(manifest);
-        }
-        catch (_err) {
-            // Continue to next path
-        }
-    }
-    // If no manifest found, return an empty manifest
-    // This allows the UI to work without workflows graph data
-    return createResponse({
-        version: '1.0.0',
-        steps: {},
-        workflows: {},
-    });
-}
-/**
- * Run a queue-based health check on a workflow endpoint.
- *
- * This sends a health check message through the Queue infrastructure,
- * bypassing Vercel Deployment Protection. The endpoint processes the
- * message and writes a response to a stream, which we then read to
- * verify the endpoint is healthy.
- *
- * @param worldEnv - Environment configuration for the World
- * @param endpoint - Which endpoint to check: 'workflow' or 'step'
- * @param options - Optional configuration (timeout in ms)
- */
-export async function runHealthCheck(worldEnv, endpoint, options) {
-    const startTime = Date.now();
-    try {
-        const world = await getWorldFromEnv(worldEnv);
-        const result = await healthCheck(world, endpoint, options);
-        const latencyMs = Date.now() - startTime;
-        return createResponse({
-            ...result,
-            latencyMs,
-        });
-    }
-    catch (error) {
-        const latencyMs = Date.now() - startTime;
-        // For health check failures, we want to return success=true with healthy=false
-        // so the UI can display the error properly, rather than propagating the server
-        // action error. This allows the health check result to be parsed by the UI
-        // even when the endpoint is down or unreachable.
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return createResponse({
-            healthy: false,
-            error: errorMessage,
-            latencyMs,
-        });
-    }
-}
-//# sourceMappingURL=workflow-server-actions.js.map