@lunora/platform-node 0.0.0 → 1.0.0-alpha.1

package/dist/index.d.mts

@@ -0,0 +1,517 @@
+import { SchemaLike } from '@lunora/shard-engine';
+import { SqlCtxDbOptions, SqlCtxExec, createSqlCtxDb } from '@lunora/sql-store';
+import Database from 'better-sqlite3';
+import { ShardKvStore, QueueBindingLike, MessageBatchLike, SchedulerHost, ShardHost, SocketHost, DirectShardDirectory, PlatformCapabilities, ShardDirectory, R2BucketLike, SocketHandle } from '@lunora/platform';
+import { WorkflowBindingLike } from '@lunora/workflow';
+import { WorkflowRuntime, WorkflowStore } from '@visulima/workflow';
+/**
+ * The Node store options — the shared store options minus the two this binding
+ * owns. `dialect` is fixed (SQLite) and `exec` is the store's own connection;
+ * letting a caller pass either would let them point the writer at a different
+ * engine or a different database than the one `migrate` just provisioned.
+ */
+type NodeGlobalContextDatabaseOptions = Omit<SqlCtxDbOptions, "dialect" | "exec">;
+/**
+ * Wrap a `better-sqlite3` connection as the async exec the store core consumes.
+ *
+ * `batch` is deliberately **not** implemented. The contract lets an exec that
+ * omits it fall back to a sequential `run()` loop, and that fallback is already
+ * optimal here: `batch` exists to collapse network round trips (D1 does it
+ * atomically in one request; the Hyperdrive adapters dispatch concurrently over
+ * a pool), and an embedded database has no round trip to collapse. Declaring it
+ * would buy nothing and would opt this exec into the "MAY reorder or
+ * parallelize" licence for no reason.
+ */
+declare const createNodeSqlExec: (database: Database.Database) => SqlCtxExec;
+/** Options for {@link createNodeGlobalStore}. */
+interface NodeGlobalStoreOptions {
+  /**
+   * SQLite file backing the `.global()` tables. Defaults to `:memory:`.
+   *
+   * Deliberately a *separate* database from any shard's: a global table is
+   * shared by every shard, so keeping it inside one shard's file would make
+   * that shard's lifecycle (and its single-writer gate) the global store's
+   * too.
+   */
+  path?: string;
+}
+/** A `.global()` store for the Node target, plus the handles to run it down. */
+interface NodeGlobalStore {
+  /** The underlying connection, for callers that need to run migrations or inspect it. */
+  database: Database.Database;
+  /** Close the connection. Safe to call more than once. */
+  dispose: () => void;
+  /** The async exec the store core (and the migration helpers) consume. */
+  exec: SqlCtxExec;
+  /**
+   * Create the schema's `.global()` tables and every companion table
+   * (aggregate, rank, search) they need, then backfill the search indexes.
+   * Idempotent — every statement is `CREATE TABLE IF NOT EXISTS`-shaped — so
+   * it is safe to run on each boot, which is what a dev server does.
+   */
+  migrate: (schema: SchemaLike, options?: {
+    cdc?: boolean;
+  }) => Promise<void>;
+  /** Build a `.global()` writer bound to this store. */
+  writer: (options: NodeGlobalContextDatabaseOptions) => ReturnType<typeof createSqlCtxDb>;
+}
+/**
+ * Stand up the `.global()` backend for a Node target.
+ *
+ * The returned `writer` is the same `createSqlCtxDb` every other backend
+ * returns, so the engine above it cannot tell which target it is running on —
+ * which is the whole point of the dialect seam.
+ */
+declare const createNodeGlobalStore: (options?: NodeGlobalStoreOptions) => NodeGlobalStore;
+/** Build a `ShardKvStore` over a `better-sqlite3` table in the shard's database. */
+declare const createNodeShardKvStore: (database: Database.Database) => ShardKvStore;
+/** Options for {@link createNodeQueueHost}. */
+interface NodeQueueHostOptions<Queues extends Record<string, {
+  isLunoraQueue: true;
+}>> {
+  /** Base env merged under the derived `QUEUE_*` bindings. */
+  env?: Record<string, unknown>;
+  /**
+   * The host's clock, in epoch ms. Producers and `poll()` share it, so a
+   * `delaySeconds` written by `send` is measured against the same reading
+   * `poll` compares it to. Defaults to `Date.now`.
+   *
+   * Injectable because otherwise the two diverge: a test that captures
+   * `Date.now()`, sends, and then polls at `captured + delay` misses by however
+   * many milliseconds elapsed in between — and the dead-letter re-enqueue,
+   * which stamps `enqueued_at` from the poll clock, mixes two clocks in one
+   * column.
+   */
+  now?: () => number;
+  /**
+   * Deliver one assembled batch. Wire this to `dispatchQueueBatch` from
+   * `@lunora/queue` — the host owns storage and batching, not routing, which is
+   * the same split the Cloudflare host has.
+   *
+   * A rejection retries every message the handler left undecided, matching
+   * workerd; a normal return acks them.
+   */
+  onBatch: (batch: MessageBatchLike) => Promise<void> | void;
+  /** The declared queues keyed by their `lunora/queues.ts` export name. */
+  queues: Queues;
+  /** How long a claimed batch stays invisible before redelivery. Defaults to 30s. */
+  visibilityTimeoutMs?: number;
+}
+/** A fully-wired Node queue host. */
+interface NodeQueueHost<Queues extends Record<string, {
+  isLunoraQueue: true;
+}>> {
+  /** Per-export-name `QueueBindingLike` — the map `ctx.queues` consumes. */
+  readonly bindings: { [K in keyof Queues]: QueueBindingLike; };
+  /**
+   * The parked messages — those that exhausted `maxRetries` with no
+   * `deadLetterQueue` declared.
+   *
+   * `list` + `requeue`, mirroring `SchedulerHost.deadLetter` rather than
+   * inspection alone: this host justifies parking with "a dropped message with
+   * no trace is the thing that makes a queue impossible to debug", and a trace
+   * you can read but not act on is only half of that.
+   */
+  deadLetters: {
+    list: (queue: string) => {
+      attempts: number;
+      body: unknown;
+      id: string;
+    }[];
+    /** Return a parked message to its queue with `attempts` reset. `false` when no such message is parked. */
+    requeue: (id: string) => boolean;
+  };
+  /** The caller's `env` plus one `QUEUE_<EXPORT>` binding per queue. */
+  readonly env: Record<string, unknown>;
+  /**
+   * Deliver every batch currently due, one per queue per call, and return how
+   * many batches were delivered. Drives the consumer — nothing here runs on a
+   * timer, because this host has no dev server to own one yet.
+   */
+  poll: (now?: number) => Promise<number>;
+}
+/**
+ * Create a Node queue host: one durable table behind every declared queue, a
+ * producer binding per queue, and `poll()` to drive the consumer.
+ */
+declare const createNodeQueueHost: <Queues extends Record<string, {
+  isLunoraQueue: true;
+}>>(database: Database.Database, options: NodeQueueHostOptions<Queues>) => NodeQueueHost<Queues>;
+/** Options for {@link createNodeSchedulerHost}. */
+interface NodeSchedulerHostOptions {
+  /**
+   * Called when a job or cron tick comes due — this host's stand-in for the
+   * Worker fetch `SchedulerDO` makes when its alarm drains the queue.
+   *
+   * A handler that **throws** marks the delivery failed, which is what drives
+   * the retry/dead-letter machinery: the job's `attempts` increments and it is
+   * either re-armed with backoff or parked. A handler that resolves marks the
+   * job delivered and removes it.
+   *
+   * Omitting it makes every delivery trivially succeed, which means a caller
+   * who forgets to pass one gets a scheduler that quietly drops work — the
+   * precise failure plan 267 caught. Supply one in anything real; the
+   * conformance host supplies one purely so the TCK can tell a delivery apart
+   * from an expired timer.
+   */
+  onDispatch?: (functionPath: string, args: Record<string, unknown>, job: {
+    attempts: number;
+    id: string;
+  }) => Promise<void> | void;
+}
+/**
+ * The scheduler half of a Node platform instance, plus the test-only hook the
+ * TCK's dead-letter legs need.
+ */
+interface NodeSchedulerHost {
+  /**
+   * Clear every armed `setTimeout` (one-shot jobs and cron ticks alike) and
+   * put the host into a terminal, closed state: afterwards `schedule()` and
+   * `cron()` throw rather than arm a fresh timer nothing would ever clear.
+   *
+   * Rows are left in place on purpose: `dispose()` is shutdown, not deletion,
+   * and the next construction over the same database re-arms exactly what was
+   * still pending. An armed timer is also a handle that keeps the event loop —
+   * and transitively the process — alive until it fires, which is what
+   * produces the "worker process failed to exit gracefully" delay if it is
+   * left uncleared.
+   */
+  dispose: () => void;
+  scheduler: SchedulerHost;
+  /**
+   * Drive a pending job straight to its dead-letter state without waiting out
+   * a real retry budget. Exactly the hook `ConformanceHost.simulateDeadLetter`
+   * describes: the observable invariants of dead-lettering are contract-level,
+   * while how many failures it takes to get there is host policy.
+   */
+  simulateDeadLetter: (id: string) => Promise<boolean>;
+}
+/** Build a durable, SQLite-backed scheduler over `database`. */
+declare const createNodeSchedulerHost: (database: Database.Database, options?: NodeSchedulerHostOptions) => NodeSchedulerHost;
+/** Options for {@link createNodeShardHost}. */
+interface NodeShardHostOptions {
+  /**
+   * Called when a durable alarm comes due — this host's stand-in for the
+   * `alarm()` method workerd invokes on a Durable Object. Fires for alarms
+   * set during this process's lifetime AND for one restored from
+   * `_lunora_alarm` when the host is constructed over an existing database,
+   * including an alarm whose time elapsed while nothing was running.
+   *
+   * A handler that throws is isolated to its own delivery; it never reaches
+   * the caller that set the alarm, because by then that call has long
+   * returned.
+   */
+  onAlarm?: () => Promise<void> | void;
+  /**
+   * SQLite database file. Defaults to `:memory:` (matching the reference
+   * host) — pass a real path to exercise cross-process persistence, the one
+   * axis the in-memory reference host cannot.
+   */
+  path?: string;
+  /**
+   * The shard key this host serves, threaded through to `ShardHost.shardKey`.
+   * Cloudflare derives this from `state.id.name`; a Node host has no
+   * equivalent addressing scheme, so the caller supplies it.
+   */
+  shardKey?: string;
+}
+/**
+ * Build a `ShardHost` over a real `better-sqlite3` database.
+ *
+ * `runSerialized` chains onto a single `tail` promise rather than the
+ * reference host's explicit job-array-plus-drain-loop: every queued closure
+ * runs once `tail` settles, and `tail` is reset to a version that always
+ * resolves (never rejects) so one job's failure cannot wedge the queue for
+ * every job after it — the same "no two closures interleave" guarantee,
+ * fewer moving parts to get wrong.
+ *
+ * `transaction` issues raw `BEGIN`/`COMMIT`/`ROLLBACK` — legal here (unlike
+ * inside a Cloudflare Durable Object, where the runtime forbids it and
+ * callers must use `storage.transaction`) because better-sqlite3 is a plain
+ * embedded database with no platform-level transaction primitive layered over
+ * it. It runs on its own private `transactionTail` chain, the same shape as
+ * `runSerialized`'s but never shared with it: two bare, overlapping
+ * `transaction()` calls on this host serialize against each other rather than
+ * corrupting each other's commits (raw `BEGIN` on a connection already inside
+ * a transaction throws, or worse, interleaves). Routing `transaction` through
+ * `runSerialized` itself would deadlock, since the engine already composes
+ * `runSerialized(() => transaction(work))` — the inner enqueue would then wait
+ * on the outer closure awaiting it.
+ *
+ * The returned `dispose()` is this host's lifecycle owner: it clears the
+ * pending alarm `setTimeout` (so it can never fire against a connection this
+ * call is about to close) and then closes the database. Call it whenever a
+ * caller is done with the host — composition roots (`createNodePlatform`,
+ * the conformance host) route their own `close()`/`cleanup()` through it
+ * rather than closing `database` directly, so the alarm timer and the
+ * connection are always retired together.
+ */
+declare const createNodeShardHost: (options?: NodeShardHostOptions) => {
+  database: Database.Database;
+  dispose: () => void;
+  drain: () => Promise<void>;
+  host: ShardHost;
+};
+/** The contracts scoped to one shard key. */
+interface NodeShard {
+  /** Durable key-value storage on this shard's database. */
+  kv: ShardKvStore;
+  /** Single-writer execution, local SQL, transactions, durable alarms. */
+  shard: ShardHost;
+  /** The key this shard serves. */
+  shardKey: string;
+  /** This shard's socket registry, with SQLite-persisted attachments. */
+  sockets: SocketHost;
+}
+/** Options for {@link createNodeShardRegistry}. */
+interface NodeShardRegistryOptions {
+  /**
+   * Directory to hold one SQLite file per shard. Omit for in-memory shards,
+   * which is right for tests and wrong for anything that must survive a
+   * restart — an in-memory registry also has no files to seed its key set
+   * from, so its fan-out set is empty until each shard is touched again.
+   */
+  directory?: string;
+  /** Called when a shard's durable alarm comes due. */
+  onAlarm?: (shard: NodeShard) => Promise<void> | void;
+  /**
+   * The app's per-shard request handler — the Node equivalent of
+   * `ShardDO.fetch`. This is what a resolved stub dispatches to, and what the
+   * query coordinator reaches on every fan-out leg.
+   *
+   * Omitted, a resolved stub answers with the shard key. That is not a
+   * placeholder for convenience: it is the exact behaviour the TCK's
+   * directory legs assert (same key ⇒ same body, and a stub is dispatchable),
+   * so the conformance run exercises this registry rather than a second
+   * implementation kept alive just for tests.
+   */
+  onFetch?: (request: Request, shard: NodeShard) => Promise<Response> | Response;
+}
+/** An in-process shard registry: placement, hosting, and the fan-out key set. */
+interface NodeShardRegistry {
+  /** Dispose every live shard. Safe to call more than once. */
+  close: () => void;
+  /** The `ShardDirectory` to hand the runtime. */
+  directory: DirectShardDirectory;
+  /**
+   * Every shard key this registry knows about — the set `@lunora/runtime`'s
+   * query coordinator fans out over.
+   *
+   * The `table` argument is accepted and ignored, which is a real
+   * approximation worth stating: Cloudflare's dynamic registry tracks which
+   * shard keys hold rows for which table, while this one knows only that a
+   * shard exists. Answering with every shard is a *superset*, so results stay
+   * correct — a shard holding no rows for the table contributes none — at the
+   * cost of visiting shards that had nothing to say.
+   */
+  listShardKeys: (table?: string) => ReadonlyArray<string>;
+  /** Materialize (or reuse) the shard serving `key`. */
+  shardFor: (key: string) => NodeShard;
+}
+/** Build the in-process shard registry. */
+declare const createNodeShardRegistry: (options?: NodeShardRegistryOptions) => NodeShardRegistry;
+/** Every contract this package provides, composed for one Node process. */
+interface NodePlatform<Queues extends Record<string, {
+  isLunoraQueue: true;
+}> = Record<string, never>> {
+  /** `using platform = createNodePlatform(...)` support — delegates to `close()`. */
+  [Symbol.dispose]: () => void;
+  /** What this target supports — see `NODE_CAPABILITIES` in `@lunora/platform`. */
+  capabilities: PlatformCapabilities;
+  /**
+   * Tear this platform instance down: clears the shard host's pending alarm
+   * timer and closes its `better-sqlite3` database (and, with it, `kv`'s
+   * table — both live on the same connection), then clears every armed
+   * scheduler job timer. Nothing in this package closes these resources on
+   * its own — a `NodePlatform` a caller stops using without calling `close()`
+   * leaks the open file handle (plus its WAL/SHM sidecar files) and keeps
+   * the process alive on outstanding timers. Safe to call more than once.
+   *
+   * **`close()` is a terminal state, not merely a cleanup step.** After it
+   * runs: `scheduler.schedule()` throws instead of arming a fresh timer
+   * nothing would ever clear; `scheduler.list()` returns `[]` and
+   * `scheduler.cancel()` answers `false` (the job map is empty, so this
+   * happens naturally, without a throw — keeping teardown-order races
+   * benign); `shard.alarms.set()`/`delete()` throw before mutating any
+   * in-memory state (checked against the connection's own open/closed state,
+   * the single source of truth); `shard.alarms.get()` keeps answering
+   * whatever it last held. A no-op instead of a throw would be
+   * indistinguishable from a working call — exactly the silent-vanishing
+   * this lifecycle exists to end.
+   */
+  close: () => void;
+  /** In-process shard directory (see `createNodeShardRegistry` for what it can and cannot do). */
+  directory: ShardDirectory;
+  /**
+   * Wait for every promise handed to `shard.waitUntil` to settle.
+   *
+   * Separate from `close()` because the two answer different questions:
+   * `close()` releases handles and stays synchronous (it backs
+   * `Symbol.dispose`), while draining is inherently awaitable. A graceful
+   * shutdown is `await platform.drain()` then `platform.close()`.
+   */
+  drain: () => Promise<void>;
+  /** Durable key-value storage backed by the same `better-sqlite3` database as `shard`. */
+  kv: ShardKvStore;
+  /**
+   * The declared queues, or `undefined` when the caller declared none.
+   *
+   * Present only when `queues` is passed: with no declarations there is
+   * nothing to bind, and handing back an empty host would suggest `ctx.queues`
+   * works when no queue exists to send to.
+   */
+  queues?: NodeQueueHost<Queues>;
+  /** Delayed jobs and crons, persisted to the same database and re-armed on construction. */
+  scheduler: SchedulerHost;
+  /** Single-writer execution, local SQL, transactions, durable alarms. */
+  shard: ShardHost;
+  /** Socket registry with mutable tags and SQLite-persisted attachments. */
+  sockets: SocketHost;
+}
+/**
+ * Options for {@link createNodePlatform} — the shard host's (`path`,
+ * `shardKey`, `onAlarm`), the scheduler's (`onDispatch`), and the shard
+ * registry's (`directory`, `onAlarm`, `onFetch`). Both delivery hooks are
+ * optional and both are what make the durable halves useful: a re-armed alarm
+ * or job with nowhere to land is bookkeeping. `directory` makes the shards the
+ * directory resolves for fan-out file-backed too, and `onAlarm` gives their
+ * durable alarms somewhere to land.
+ */
+type NodePlatformOptions<Queues extends Record<string, {
+  isLunoraQueue: true;
+}> = Record<string, never>> = {
+  /**
+   * Deliver one assembled queue batch — wire this to `dispatchQueueBatch`.
+   * Required alongside `queues`; without it the messages would be stored
+   * and never consumed.
+   */
+  onQueueBatch?: NodeQueueHostOptions<Queues>["onBatch"];
+  /** The app's `defineQueue` results, keyed by export name. Omit when the app declares no queues. */
+  queues?: Queues;
+} & NodeSchedulerHostOptions & NodeShardHostOptions & NodeShardRegistryOptions;
+/** Compose every contract this package provides over one `better-sqlite3` database. */
+declare const createNodePlatform: <Queues extends Record<string, {
+  isLunoraQueue: true;
+}> = Record<string, never>>(options?: NodePlatformOptions<Queues>) => NodePlatform<Queues>;
+/** Options for {@link createNodeR2Bucket}. */
+interface NodeR2BucketOptions {
+  /** The bucket directory — created on first write. Objects live here, one file per key. */
+  directory: string;
+}
+/**
+ * Create an `R2BucketLike` over the local filesystem. Any object shape
+ * `createStorage({ bucket })` accepts — `put`/`get`/`head`/`delete`/`list` —
+ * maps directly onto a file operation.
+ */
+declare const createNodeR2Bucket: (options: NodeR2BucketOptions) => R2BucketLike;
+/**
+ * The `DurableObjectState` subset `ShardDO` consumes.
+ *
+ * Declared here rather than imported so this package keeps no dependency on
+ * `@lunora/do` (which depends on `@lunora/platform-cloudflare`, and through it
+ * on Cloudflare's types). Structural typing does the rest: a value of this type
+ * satisfies `ShardDO`'s constructor parameter without the two ever meeting at
+ * the type level.
+ */
+interface NodeShardState {
+  acceptWebSocket: (socket: unknown, tags?: string[]) => void;
+  blockConcurrencyWhile: <T>(callback: () => Promise<T>) => Promise<T>;
+  getWebSockets: (tag?: string) => unknown[];
+  id: {
+    name?: string;
+  };
+  storage: {
+    delete: (key: string) => Promise<boolean>;
+    deleteAlarm: () => Promise<void>;
+    get: <T = unknown>(key: string) => Promise<T | undefined>;
+    getAlarm: () => Promise<number | null>;
+    list: <T = unknown>(options?: {
+      prefix?: string;
+    }) => Promise<Map<string, T>>;
+    put: (key: string, value: unknown) => Promise<void>;
+    setAlarm: (scheduledTime: Date | number) => Promise<void>;
+    sql: {
+      readonly databaseSize?: number;
+      exec: (query: string, ...bindings: unknown[]) => unknown;
+    };
+    transaction: <T>(closure: () => Promise<T>) => Promise<T>;
+  };
+  waitUntil: (promise: Promise<unknown>) => void;
+}
+/**
+ * Project a shard's platform contracts into the `DurableObjectState` shape.
+ *
+ * Deliberately **not** exposing the native-PITR members
+ * (`getBookmarkForTime` / `getCurrentBookmark` /
+ * `onNextSessionRestoreBookmark`) or `setWebSocketAutoResponse`: those are
+ * Cloudflare runtime features with no Node equivalent, and `ShardDO` probes for
+ * each before use. Omitting them takes the documented degraded path — the same
+ * one local `wrangler dev` takes — whereas supplying a stub that resolves would
+ * report a point-in-time restore that never happened.
+ */
+declare const createNodeShardState: (shard: NodeShard) => NodeShardState;
+/**
+ * The socket-host half of a Node platform instance, plus the test-only hooks
+ * `@lunora/platform/conformance`'s `ConformanceHost` needs to drive a recycle
+ * from inside a test.
+ */
+interface NodeSocketHost {
+  /** Read back the frames sent to a socket, oldest first, text frames only. */
+  readFrames: (handle: SocketHandle) => string[];
+  /**
+   * Re-create a runtime socket from durable state.
+   *
+   * `attachment` is a fallback only: this host restores what it persisted,
+   * because that is what a real wake looks like. The argument covers an id
+   * this host never durably tracked (a synthetic id a test constructs).
+   */
+  restoreSocket: (id: string, attachment: unknown) => SocketHandle;
+  /** Drop the runtime socket map while keeping durable attachments/tags. */
+  simulateRecycle: () => void;
+  /** The `SocketHost` contract implementation. */
+  socket: SocketHost;
+}
+/** Build the socket registry, persisting attachments and tags to `database`. */
+declare const createNodeSocketHost: (database: Database.Database) => NodeSocketHost;
+/** Options for {@link createNodeWorkflowHost}. */
+interface NodeWorkflowHostOptions<Workflows extends Record<string, {
+  isLunoraWorkflow: true;
+}>> {
+  /** Base env merged under the derived `WORKFLOW_*` bindings — surfaced to workflow bodies as `ctx.env` and used to resolve spawned children. */
+  env?: Record<string, unknown>;
+  /** How long (ms) the engine holds a cross-process lease while an activation runs, for stores that implement `acquire`. Defaults to 30000. */
+  leaseTtlMs?: number;
+  /** Where runs are persisted. Required — see the header for why there is no default. `createNodeWorkflowStore(database)` is the durable one. */
+  store: WorkflowStore;
+  /** The declared workflows keyed by their `lunora/workflows.ts` export name (e.g. `{ orderPipeline: orderPipeline }`). Values must be `defineWorkflow` results. */
+  workflows: Workflows;
+}
+/** A fully-wired Node workflow host. */
+interface NodeWorkflowHost<Workflows extends Record<string, {
+  isLunoraWorkflow: true;
+}>> {
+  /** Per-export-name `WorkflowBindingLike` — the map `ctx.workflows` consumes. */
+  readonly bindings: { [K in keyof Workflows]: WorkflowBindingLike; };
+  /**
+   * The caller's `env` plus one `WORKFLOW_&lt;EXPORT>` binding per workflow —
+   * merge this into a worker env so `ctx.spawn`/`ctx.parallel` resolve
+   * children through the same runtime.
+   */
+  readonly env: Record<string, unknown>;
+  /** The underlying visulima runtime — `sweep`/`signal` for a dev loop or tests. */
+  readonly runtime: WorkflowRuntime;
+}
+/**
+ * Create a Node workflow host: compile every declared Lunora workflow onto the
+ * visulima engine, derive the `WORKFLOW_*` env, and expose the per-workflow
+ * `WorkflowBindingLike` handles.
+ */
+declare const createNodeWorkflowHost: <Workflows extends Record<string, {
+  isLunoraWorkflow: true;
+}>>(options: NodeWorkflowHostOptions<Workflows>) => NodeWorkflowHost<Workflows>;
+/**
+ * Build a durable {@link WorkflowStore} over a `better-sqlite3` connection.
+ * Pass the result as `createNodeWorkflowHost({ store })`.
+ */
+declare const createNodeWorkflowStore: (database: Database.Database) => WorkflowStore;
+export { type NodeGlobalContextDatabaseOptions, type NodeGlobalStore, type NodeGlobalStoreOptions, type NodePlatform, type NodePlatformOptions, type NodeQueueHost, type NodeQueueHostOptions, type NodeR2BucketOptions, type NodeSchedulerHost, type NodeSchedulerHostOptions, type NodeShard, type NodeShardHostOptions, type NodeShardRegistry, type NodeShardRegistryOptions, type NodeShardState, type NodeSocketHost, type NodeWorkflowHost, type NodeWorkflowHostOptions, createNodeGlobalStore, createNodePlatform, createNodeQueueHost, createNodeR2Bucket, createNodeSchedulerHost, createNodeShardHost, createNodeShardKvStore, createNodeShardRegistry, createNodeShardState, createNodeSocketHost, createNodeSqlExec, createNodeWorkflowHost, createNodeWorkflowStore };