/** * ClientLite — v3 in-process workflow client. * * No gRPC. No network. Direct FFI calls to the embedded engine. */ import type { NativeEngine } from '@memoflowio/memoflow-engine'; import type { WorkerLite } from '../runtime/worker-lite.js'; import type { ForkWorkflowResult, StartWorkflowInput } from '../types.js'; export declare class ClientLite { private engine; private worker; constructor(engine: NativeEngine, worker: WorkerLite); /** * Start a new workflow execution. */ start(input: StartWorkflowInput): Promise<{ workflowId: string; runId: string; }>; /** * Send a signal to a running workflow. */ signal(workflowId: string, signalName: string, payload?: any): Promise; /** * Query a running workflow (read-only). */ query(workflowId: string, queryName: string): Promise; /** * Wait for a workflow to complete and return its result. */ getResult(workflowId: string, _runId?: string, timeoutMs?: number): Promise; /** * Cancel a running workflow. */ cancel(workflowId: string, reason?: string): Promise; /** * P6.5 — restart-from-step (operational time travel) has NO equivalent on * the embedded lite engine: fork is implemented server-side only * (`crates/server/src/grpc/workflow_service.rs`'s `ForkWorkflow` RPC, * backed by `Store::fork_workflow_run` on Postgres/MemoryStore). The lite * engine (`crates/engine`) has no such RPC and no plan to grow one in this * phase — rather than silently no-op or approximate it, this fails loudly * so a caller mixing lite + fork-dependent code finds out immediately, * not via a confusing missing side effect (Design Law 4 in spirit: never * swallow an unsupported operation into something that looks like * success). */ fork(_workflowId: string, _runId: string, _stepSeq: number): Promise; /** * No-op — no connection to close. */ close(): void; }