@voltro/workflow 0.1.4 → 0.1.5

package/CHANGELOG.md

@@ -39,6 +39,26 @@ _Changes staged for the next release accumulate here (rolled up from
 
 ---
 
+## [0.1.5] — 2026-07-16
+
+### Added
+
+- **@voltro/cli** — `voltro build` now precompiles an API app (previously it only handled web apps). It bundles the whole handler closure — every procedure/executor, workflow, subscriber, reaction, aggregate, agent, tool, webhook, cron, startup, `app.config`, and their shared `database`/`lib` deps — into a single `.framework/dist-api/apiEntry.js` (framework/npm kept external), via a two-pass esbuild build (pass 1 discovers the full module closure so shared side-effectful modules like the schema are covered; pass 2 emits the bundle + a module map). `voltro serve` loads that one bundle at boot and resolves every app module from it — no `node --import tsx` runtime transpilation, and a SINGLE instance of each module (so side-effectful modules like the table registry aren't evaluated twice). Without a build — `voltro dev`, or `voltro serve` on an unbuilt app — every module still loads from source exactly as before, and a per-module miss falls back to source too, so a stale/partial bundle degrades safely. Note: an API's boot is dominated by the framework/Effect module-graph evaluation, not app-module transpilation, so the bundle is primarily a correctness/hygiene win (no source transpilation in production) rather than a large cold-start reduction.
+- **@voltro/i18n** — Two message accessors that react-intl parity was missing. `useMessages()` returns the active locale's RAW (unformatted ICU) catalog — `useMessages()['some.id']` gives the template, not the formatted output — for when you need the raw string. `pickCatalog(catalogs, locale, defaultLocale)` resolves a catalog for an ARBITRARY locale OUTSIDE React (for `meta({ locale })` and other non-hook call sites where `useT` can't run); it returns the concrete catalog type, so a known-key lookup is `string` (not `string | undefined`) — the exact shape `PageMeta.title` needs, replacing the hand-rolled `getCatalog(locale)` helper apps kept copying.
+- **@voltro/cli, @voltro/workflow** — `VOLTRO_WORKFLOW_RUNNER_STORAGE` (`memory` | `sql`) forces the workflow-engine runner storage instead of always deriving it from the store dialect. The load-bearing case is `memory` on a real SQL dialect (postgres / mysql / mariadb / mssql): it runs the single-process durable engine — workflow run state stays SQL-backed via `@effect/cluster`'s `SqlMessageStorage` — but SKIPS `SqlRunnerStorage` entirely, so there is no `cluster_runners` / `cluster_locks` table and none of its `GET_LOCK` advisory-lock acquisition. That unblocks a managed MySQL / MariaDB reached through a connection-load-balancing Service or a non-session-pinned pooler, where the advisory-lock connection can't be pinned to one backend and the runner-storage bootstrap wedges before it ever creates its table (the pod stays un-Ready while a shard-lock refresher errors forever). The tradeoff is no cross-pod shard handoff. An invalid value — or `sql` on sqlite / turso — fails boot loudly rather than silently selecting a broken engine. The `voltro cluster status` snapshot and the boot log both report the resolved storage.
+- **@voltro/cli, @voltro/workflow** — Durable-workflow clustering now keeps **cross-pod handoff on Galera / Percona XtraDB (multi-primary) clusters**. `@effect/cluster`'s default shard-ownership coordination uses session advisory locks (`GET_LOCK` / `pg_advisory_lock`), which are node-local and can't coordinate a fleet whose connections span cluster nodes — so on a Galera cluster behind a load-balancing Service, pods split-brain shard ownership and the runner-storage bootstrap can wedge (pod never becomes Ready). The new **`VOLTRO_WORKFLOW_SHARD_LOCK`** (`auto` | `row` | `advisory`, default `auto`) fixes this: `auto` probes the live connection (`@@wsrep_on`) and, on a wsrep cluster, switches `SqlRunnerStorage` to a certified row-lease on the `cluster_locks` table (`INSERT … ON DUPLICATE KEY UPDATE … WHERE acquired_at < expiry`) instead of advisory locks — Galera certifies that write across all nodes, so shard ownership and dead-pod handoff stay correct without a single-writer proxy. A single-primary server keeps the faster advisory path. The resolved mode is reported in the boot log and in `voltro cluster status` (`shard-lock=row`). Non-wsrep multi-primary topologies (e.g. MySQL Group Replication) can force it with `VOLTRO_WORKFLOW_SHARD_LOCK=row`; an unrecognized value fails boot loudly.
+
+### Fixed
+
+- **@voltro/cli** — `voltro start` no longer loads every page module at boot, so a large mostly-static site (e.g. a docs site with hundreds of prerendered routes) boots with memory proportional to its ssr/isr routes instead of its total routes — it used to OOM a modest container even though only a handful of routes ever need a runtime module. The SSR bundle (`voltro build`) now emits page/layout modules as lazy `() => import()` loaders plus a build-time `pageMeta` manifest; `voltro start` reads render mode / tenant-awareness / revalidate from the manifest and imports a page's module (and its content chunk) only when that ssr/isr route is actually rendered. A 500+ route docs site that OOMed a 512 MB container now boots at ~190 MB. Bundles without a `pageMeta` manifest (older builds) fall back to the previous load-every-module behaviour, and `voltro dev` (Vite middleware mode) is unchanged.
+- **@voltro/web** — Static prerendering (`voltro build`) no longer crashes with "Router hooks must be used inside <Router>" on pages whose layout reads router/i18n context (e.g. URL-prefix locale). The framework's React contexts are now process-wide singletons pinned on the global symbol registry, so the SSG renderer (loaded via Vite's `ssrLoadModule('@voltro/web/ssr')`) and the app's page modules (with `@voltro/web` externalised to Node) always resolve the SAME context instance even though the prerender loads the package through two module instances. This only bit consumers building against the published npm package; the framework's own workspace build resolves `@voltro/web`'s source and masked it.
+
+### Internal (no consumer-facing effect)
+
+- **@voltro/voltro** — Package READMEs no longer carry a relative `[Changelog](./CHANGELOG.md)` link — npm resolved it to a 404 (`npmjs.com/package/@voltro/CHANGELOG.md`) because relative README links don't resolve for scoped packages, and there is no public changelog URL (the repo is private). The `CHANGELOG.md` is still bundled in each package tarball. The README link row is now Documentation · voltro.dev · Voltro Cloud.
+
+---
+
 ## [0.1.1] — 2026-07-15
 
 ### Fixed

package/README.md

@@ -4,7 +4,7 @@
 
 **Durable workflows for Voltro — the workflow() descriptor + step() / awaitSignal primitives over @effect/cluster, with a browser-safe define subpath.**
 
-[📖 Documentation](https://docs.voltro.dev/docs/workflows/overview) · [Changelog](./CHANGELOG.md) · [voltro.dev](https://voltro.dev) · [Voltro Cloud](https://voltro.cloud)
+[📖 Documentation](https://docs.voltro.dev/docs/workflows/overview) · [voltro.dev](https://voltro.dev) · [Voltro Cloud](https://voltro.cloud)
 
 </div>
 

package/dist/cluster-DuFweKq0.js

@@ -0,0 +1,58 @@
+import { Duration as e, Effect as t, Layer as n, Option as r } from "effect";
+import { ClusterCron as i, ClusterWorkflowEngine as a, RunnerAddress as o, SingleRunner as s } from "@effect/cluster";
+import { SqlClient as c } from "@effect/sql";
+//#region src/clusterLayer.ts
+var l = 34e3, u = (e) => {
+	let t = e.runnerListenHost ?? process.env.POD_IP ?? process.env.VOLTRO_WORKFLOW_RUNNER_HOST ?? "localhost";
+	return {
+		host: t,
+		port: e.runnerListenPort ?? 34e3,
+		localhostRisk: e.runnerStorage === "sql" && (t === "localhost" || t === "127.0.0.1")
+	};
+}, d = (e) => {
+	let t = e.sqliteFamily ? "memory" : "sql", n = e.override ?? process.env.VOLTRO_WORKFLOW_RUNNER_STORAGE;
+	if (n === void 0 || n.trim() === "") return t;
+	let r = n.trim().toLowerCase();
+	if (r !== "memory" && r !== "sql") throw Error(`VOLTRO_WORKFLOW_RUNNER_STORAGE must be 'memory' or 'sql', got '${n}'.`);
+	if (r === "sql" && e.sqliteFamily) throw Error("VOLTRO_WORKFLOW_RUNNER_STORAGE='sql' is unsupported on sqlite / turso — @effect/cluster has no sqlite advisory-lock branch. Use 'memory'.");
+	return r;
+}, f = (e = process.env.VOLTRO_WORKFLOW_SHARD_LOCK) => {
+	if (e === void 0 || e.trim() === "") return "auto";
+	let t = e.trim().toLowerCase();
+	if (t === "auto" || t === "row" || t === "advisory") return t;
+	throw Error(`VOLTRO_WORKFLOW_SHARD_LOCK must be 'auto', 'row', or 'advisory', got '${e}'.`);
+}, p = t.gen(function* () {
+	let e = yield* (yield* c.SqlClient)`SELECT @@wsrep_on AS wsrep`.pipe(t.catchAll(() => t.succeed([])));
+	if (e.length === 0) return !1;
+	let n = e[0].wsrep;
+	return n === 1 || n === "1" || n === !0 || n === "ON" || n === "on";
+}), m = (e) => t.gen(function* () {
+	return e.runnerStorage === "memory" ? !1 : e.mode === "row" ? !0 : e.mode === "advisory" || e.dialectId !== "mysql" && e.dialectId !== "mariadb" ? !1 : yield* p;
+}), h = (e) => {
+	let i = u({
+		runnerStorage: e.runnerStorage,
+		runnerListenHost: e.runnerListenHost,
+		runnerListenPort: e.runnerListenPort
+	}), c = i.host, l = i.port;
+	i.localhostRisk && process.stderr.write(`[voltro:workflow] runner host is '${c}' with SQL cluster storage — other pods cannot reach this runner, so a workflow cannot resume on another pod after a reschedule. Inject POD_IP via the K8s downward API (fieldRef: status.podIP) or set runnerListenHost / VOLTRO_WORKFLOW_RUNNER_HOST.
+`);
+	let d = e.shardLockMode ?? f(), p = n.unwrapEffect(m({
+		dialectId: e.dialectId,
+		runnerStorage: e.runnerStorage,
+		mode: d
+	}).pipe(t.map((t) => (e.runnerStorage === "sql" && process.stderr.write(`[voltro:workflow] shard-lock coordination: ${t ? "row-based" : "advisory"} (dialect=${e.dialectId ?? "unknown"}, mode=${d}` + (t && d === "auto" ? ", wsrep/Galera cluster detected" : "") + ")\n"), s.layer({
+		runnerStorage: e.runnerStorage,
+		shardingConfig: {
+			runnerListenAddress: r.some(o.make(c, l)),
+			...t ? { shardLockDisableAdvisory: !0 } : {}
+		}
+	}))))).pipe(n.provide(e.sqlClientLayer)), h = e.extraShardingLayers ?? [];
+	return (h.length === 0 ? a.layer : n.mergeAll(a.layer, ...h)).pipe(n.provide(p));
+}, g = (n) => i.make({
+	name: n.name,
+	cron: n.cron,
+	execute: t.promise(() => n.execute()),
+	skipIfOlderThan: n.skipIfOlderThan ?? e.days(1)
+});
+//#endregion
+export { u as a, h as c, f as i, l as n, d as o, p as r, m as s, g as t };

package/dist/cluster.d.ts

@@ -1,6 +1,7 @@
 import { ConfigError } from 'effect';
 import { Cron } from 'effect';
 import { Duration } from 'effect';
+import { Effect } from 'effect';
 import { Layer } from 'effect';
 import { Sharding } from '@effect/cluster';
 import { SqlClient } from '@effect/sql';
@@ -25,6 +26,14 @@ export declare interface ClusterCronSpec {
 /** Default port for the cluster's single-runner listener. Override per deploy. */
 export declare const DEFAULT_RUNNER_LISTEN_PORT: 34000;
 
+/** Probe the live connection for an active wsrep (Galera / Percona XtraDB)
+ *  cluster. `@@wsrep_on = 1` iff Galera replication is active; the variable is
+ *  absent on stock MySQL (→ query errors → not a wsrep cluster) and `0` on a
+ *  non-clustered MariaDB. Any probe failure resolves to `false` (advisory) —
+ *  the safe default for the common single-primary case; wsrep deployments that
+ *  somehow can't be probed can still force `VOLTRO_WORKFLOW_SHARD_LOCK=row`. */
+export declare const detectWsrepCluster: Effect.Effect<boolean, never, SqlClient.SqlClient>;
+
 /**
  * Build the cluster-cron layer for one schedule. Returns a
  * `Layer<never, never, Sharding>` — the framework provides `Sharding`
@@ -33,6 +42,11 @@ export declare const DEFAULT_RUNNER_LISTEN_PORT: 34000;
  */
 export declare const makeClusterCronLayer: (spec: ClusterCronSpec) => Layer.Layer<never, never, Sharding.Sharding>;
 
+/** Parse `VOLTRO_WORKFLOW_SHARD_LOCK` (default `'auto'`). Throws on an
+ *  unrecognized value so a typo fails boot loudly instead of silently keeping
+ *  the advisory path that breaks cross-pod handoff on Galera. */
+export declare const parseShardLockMode: (raw?: string | undefined) => ShardLockMode;
+
 /** Resolve the runner host/port the SAME way `workflowEngineLayer` does:
  *  explicit option → `POD_IP` → `VOLTRO_WORKFLOW_RUNNER_HOST` → loopback;
  *  port from option → `VOLTRO_WORKFLOW_RUNNER_PORT` → default. */
@@ -42,6 +56,51 @@ export declare const resolveRunnerIdentity: (opts: {
     readonly runnerListenPort?: number | undefined;
 }) => RunnerIdentity;
 
+/**
+ * Resolve the runner-storage backend for `SingleRunner`.
+ *
+ * Default by dialect: sqlite / turso → `'memory'` (`@effect/cluster` has no
+ * sqlite advisory-lock branch); every other SQL dialect → `'sql'` (durable +
+ * multi-runner shard coordination via `cluster_runners` / `cluster_locks`).
+ *
+ * `VOLTRO_WORKFLOW_RUNNER_STORAGE` (or an explicit `override`) forces the
+ * choice. The load-bearing case is `'memory'` on a real SQL dialect: it keeps
+ * the single-process durable engine (workflow run state stays SQL-backed via
+ * `@effect/cluster`'s `SqlMessageStorage`) but SKIPS `SqlRunnerStorage`
+ * entirely — no `cluster_runners` / `cluster_locks` table, and none of its
+ * `GET_LOCK` advisory-lock acquisition. That unblocks a managed MySQL /
+ * MariaDB reached through a connection-load-balancing Service or a
+ * non-session-pinned pooler, where the advisory-lock connection can't be
+ * pinned to one backend and the runner-storage bootstrap wedges before it ever
+ * creates its table (pod stays un-Ready, shard-lock refresher errors forever).
+ * The tradeoff: no cross-pod shard handoff — a workflow started on a now-dead
+ * pod won't resume elsewhere.
+ *
+ * Throws on an unrecognized value, or on `'sql'` for sqlite / turso (no
+ * advisory-lock branch) — a misconfiguration fails boot loudly rather than
+ * silently selecting a broken engine.
+ */
+export declare const resolveRunnerStorage: (opts: {
+    readonly sqliteFamily: boolean;
+    readonly override?: string | undefined;
+}) => RunnerStorage;
+
+/**
+ * Resolve whether `SqlRunnerStorage` should disable advisory locks and use the
+ * certified row-lease path instead — the load-bearing decision for correct
+ * cross-pod workflow handoff on a Galera / Percona XtraDB cluster.
+ *
+ * `'memory'` runner storage never builds `SqlRunnerStorage`, so the choice is
+ * moot there (returns `false`, no probe). For `'sql'` storage it honors the
+ * mode: `'row'`/`'advisory'` are explicit; `'auto'` probes the live connection
+ * for wsrep on MySQL/MariaDB and stays advisory on every other dialect.
+ */
+export declare const resolveShardLockDisableAdvisory: (opts: {
+    readonly dialectId: string | undefined;
+    readonly runnerStorage: RunnerStorage;
+    readonly mode: ShardLockMode;
+}) => Effect.Effect<boolean, never, SqlClient.SqlClient>;
+
 /** Resolved cluster-runner address + the silent-resume-breaker flag.
  *  Single source of truth for both the engine layer and the
  *  `/_voltro/inspect/cluster` snapshot, so the CLI never reports an
@@ -67,6 +126,35 @@ export declare interface RunnerIdentity {
  */
 export declare type RunnerStorage = 'sql' | 'memory';
 
+/**
+ * How `@effect/cluster`'s `SqlRunnerStorage` coordinates shard ownership across
+ * a fleet of runners:
+ *
+ *   - `'advisory'` — session-scoped DB advisory locks (`GET_LOCK` on
+ *                    MySQL/MariaDB, `pg_advisory_lock` on Postgres). Fast, and
+ *                    self-releasing the instant a connection drops (so a dead
+ *                    pod's shards are reclaimed immediately). Correct ONLY when
+ *                    every runner's connection reaches ONE coherent server —
+ *                    advisory locks are node-local and do NOT span the nodes of
+ *                    a Galera / Percona XtraDB cluster or a load-balanced pool.
+ *   - `'row'`      — a certified conditional upsert on the `cluster_locks`
+ *                    TABLE (`INSERT … ON DUPLICATE KEY UPDATE … WHERE
+ *                    acquired_at < <expiry>`). Works across a multi-primary
+ *                    cluster because the write is globally certified — the same
+ *                    reason Voltro's own cron `advisoryLock` uses a claims row,
+ *                    not a session lock. Failover is expiry-based (a dead pod's
+ *                    shards are reclaimed once the lease ages out), not instant.
+ *   - `'auto'`     — the default: probe the live connection for a wsrep
+ *                    (Galera / PXC) cluster and pick `'row'` there, `'advisory'`
+ *                    everywhere else. Gives correct multi-replica handoff on
+ *                    Galera out of the box while keeping the faster advisory
+ *                    path on a single-primary server.
+ *
+ * MySQL Group Replication and other multi-primary topologies that aren't wsrep
+ * are NOT auto-detected — pin `VOLTRO_WORKFLOW_SHARD_LOCK=row` for those.
+ */
+export declare type ShardLockMode = 'auto' | 'row' | 'advisory';
+
 /**
  * Compose the dialect's SqlClient → SingleRunner → ClusterWorkflowEngine
  * into a single layer that user code provides to its program to get
@@ -92,6 +180,20 @@ export declare interface WorkflowEngineLayerOptions {
     readonly sqlClientLayer: Layer.Layer<SqlClient.SqlClient, ConfigError.ConfigError | SqlError.SqlError, never>;
     /** `'sql'` for postgres / mysql / mariadb / mssql, `'memory'` for sqlite. */
     readonly runnerStorage: RunnerStorage;
+    /**
+     * The resolved dialect id (`postgres` / `mysql` / `mariadb` / `mssql` /
+     * `sqlite`). Used by the `'auto'` shard-lock mode to decide whether to probe
+     * for a wsrep (Galera) cluster. Omitted → the auto probe is skipped and
+     * advisory locking is kept.
+     */
+    readonly dialectId?: string;
+    /**
+     * Shard-ownership coordination mode (see {@link ShardLockMode}). Defaults to
+     * `VOLTRO_WORKFLOW_SHARD_LOCK` (→ `'auto'`). `'auto'` uses the certified
+     * row-lease path on a Galera / PXC cluster and advisory locks elsewhere, so
+     * cross-pod workflow handoff is correct on Galera without operator config.
+     */
+    readonly shardLockMode?: ShardLockMode;
     readonly runnerListenHost?: string;
     readonly runnerListenPort?: number;
     /**

package/dist/cluster.js

@@ -1,2 +1,2 @@
-import { i as e, n as t, r as n, t as r } from "./cluster-Cl6mB2rW.js";
-export { t as DEFAULT_RUNNER_LISTEN_PORT, r as makeClusterCronLayer, n as resolveRunnerIdentity, e as workflowEngineLayer };
+import { a as e, c as t, i as n, n as r, o as i, r as a, s as o, t as s } from "./cluster-DuFweKq0.js";
+export { r as DEFAULT_RUNNER_LISTEN_PORT, a as detectWsrepCluster, s as makeClusterCronLayer, n as parseShardLockMode, e as resolveRunnerIdentity, i as resolveRunnerStorage, o as resolveShardLockDisableAdvisory, t as workflowEngineLayer };

package/dist/clusterTestSuite.d.ts

@@ -17,6 +17,13 @@ export declare interface ClusterEngineFixture {
     readonly sqlClientLayer: WorkflowEngineLayerOptions['sqlClientLayer'];
     /** `'sql'` for server dialects, `'memory'` for sqlite. */
     readonly runnerStorage: 'sql' | 'memory';
+    /** Force the shard-lock coordination mode (see `ShardLockMode`). Omit → the
+     *  engine default (`auto`). The `mariadb-row` fixture sets `'row'` to exercise
+     *  the certified `cluster_locks` lease path that backs cross-pod handoff on a
+     *  Galera / PXC cluster (where node-local `GET_LOCK` can't coordinate). */
+    readonly shardLockMode?: WorkflowEngineLayerOptions['shardLockMode'];
+    /** Resolved dialect id, for the `auto` shard-lock wsrep probe. */
+    readonly dialectId?: string;
     /** Base cluster-runner listen port (distinct per dialect so suites can
      *  run side by side). The suite uses `port`, `port+1`, `port+2`. */
     readonly runnerPort: number;
@@ -48,6 +55,35 @@ export declare const runClusterEngineSuite: (fixture: ClusterEngineFixture) => v
  */
 declare type RunnerStorage = 'sql' | 'memory';
 
+/**
+ * How `@effect/cluster`'s `SqlRunnerStorage` coordinates shard ownership across
+ * a fleet of runners:
+ *
+ *   - `'advisory'` — session-scoped DB advisory locks (`GET_LOCK` on
+ *                    MySQL/MariaDB, `pg_advisory_lock` on Postgres). Fast, and
+ *                    self-releasing the instant a connection drops (so a dead
+ *                    pod's shards are reclaimed immediately). Correct ONLY when
+ *                    every runner's connection reaches ONE coherent server —
+ *                    advisory locks are node-local and do NOT span the nodes of
+ *                    a Galera / Percona XtraDB cluster or a load-balanced pool.
+ *   - `'row'`      — a certified conditional upsert on the `cluster_locks`
+ *                    TABLE (`INSERT … ON DUPLICATE KEY UPDATE … WHERE
+ *                    acquired_at < <expiry>`). Works across a multi-primary
+ *                    cluster because the write is globally certified — the same
+ *                    reason Voltro's own cron `advisoryLock` uses a claims row,
+ *                    not a session lock. Failover is expiry-based (a dead pod's
+ *                    shards are reclaimed once the lease ages out), not instant.
+ *   - `'auto'`     — the default: probe the live connection for a wsrep
+ *                    (Galera / PXC) cluster and pick `'row'` there, `'advisory'`
+ *                    everywhere else. Gives correct multi-replica handoff on
+ *                    Galera out of the box while keeping the faster advisory
+ *                    path on a single-primary server.
+ *
+ * MySQL Group Replication and other multi-primary topologies that aren't wsrep
+ * are NOT auto-detected — pin `VOLTRO_WORKFLOW_SHARD_LOCK=row` for those.
+ */
+declare type ShardLockMode = 'auto' | 'row' | 'advisory';
+
 /** Lightweight TCP reachability probe for a dialect's database — the
  *  soft-skip a fixture's `reachable()` uses (cheaper than a full connect).
  *  SQLite fixtures just return `true` directly. */
@@ -64,6 +100,20 @@ declare interface WorkflowEngineLayerOptions {
     readonly sqlClientLayer: Layer.Layer<SqlClient.SqlClient, ConfigError.ConfigError | SqlError.SqlError, never>;
     /** `'sql'` for postgres / mysql / mariadb / mssql, `'memory'` for sqlite. */
     readonly runnerStorage: RunnerStorage;
+    /**
+     * The resolved dialect id (`postgres` / `mysql` / `mariadb` / `mssql` /
+     * `sqlite`). Used by the `'auto'` shard-lock mode to decide whether to probe
+     * for a wsrep (Galera) cluster. Omitted → the auto probe is skipped and
+     * advisory locking is kept.
+     */
+    readonly dialectId?: string;
+    /**
+     * Shard-ownership coordination mode (see {@link ShardLockMode}). Defaults to
+     * `VOLTRO_WORKFLOW_SHARD_LOCK` (→ `'auto'`). `'auto'` uses the certified
+     * row-lease path on a Galera / PXC cluster and advisory locks elsewhere, so
+     * cross-pod workflow handoff is correct on Galera without operator config.
+     */
+    readonly shardLockMode?: ShardLockMode;
     readonly runnerListenHost?: string;
     readonly runnerListenPort?: number;
     /**

package/dist/clusterTestSuite.js

@@ -1,6 +1,6 @@
 import { C as e, m as t, p as n, v as r, x as i } from "./primitives-CWy1iu5w.js";
 import { i as a } from "./src-CNeLb-4L.js";
-import { i as o, t as s } from "./cluster-Cl6mB2rW.js";
+import { c as o, t as s } from "./cluster-DuFweKq0.js";
 import { Cron as c, Deferred as l, Effect as u, Fiber as d, Layer as f, Schema as p } from "effect";
 import { beforeAll as m, describe as h, expect as g, test as _ } from "vitest";
 //#region src/clusterTestSuite.ts
@@ -32,6 +32,8 @@ var v = async (e, t, n = 750) => {
 		sqlClientLayer: v.sqlClientLayer,
 		runnerStorage: v.runnerStorage,
 		runnerListenPort: e,
+		...v.dialectId ? { dialectId: v.dialectId } : {},
+		...v.shardLockMode ? { shardLockMode: v.shardLockMode } : {},
 		...t && t.length > 0 ? { extraShardingLayers: t } : {}
 	});
 	h(`cluster workflow engine — ${v.name}`, () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/workflow",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Durable workflows for Voltro — the workflow() descriptor + step() / awaitSignal primitives over @effect/cluster, with a browser-safe define subpath.",
   "keywords": [
     "voltro",
@@ -50,8 +50,8 @@
     "@effect/cluster": "^0.59.0",
     "@effect/sql": "^0.51.1",
     "@effect/workflow": "^0.18.2",
-    "@voltro/database": "0.1.4",
-    "@voltro/protocol": "0.1.4"
+    "@voltro/database": "0.1.5",
+    "@voltro/protocol": "0.1.5"
   },
   "peerDependencies": {
     "effect": "^3.21.4",

package/dist/cluster-Cl6mB2rW.js

@@ -1,31 +0,0 @@
-import { Duration as e, Effect as t, Layer as n, Option as r } from "effect";
-import { ClusterCron as i, ClusterWorkflowEngine as a, RunnerAddress as o, SingleRunner as s } from "@effect/cluster";
-//#region src/clusterLayer.ts
-var c = 34e3, l = (e) => {
-	let t = e.runnerListenHost ?? process.env.POD_IP ?? process.env.VOLTRO_WORKFLOW_RUNNER_HOST ?? "localhost";
-	return {
-		host: t,
-		port: e.runnerListenPort ?? 34e3,
-		localhostRisk: e.runnerStorage === "sql" && (t === "localhost" || t === "127.0.0.1")
-	};
-}, u = (e) => {
-	let t = l({
-		runnerStorage: e.runnerStorage,
-		runnerListenHost: e.runnerListenHost,
-		runnerListenPort: e.runnerListenPort
-	}), i = t.host, c = t.port;
-	t.localhostRisk && process.stderr.write(`[voltro:workflow] runner host is '${i}' with SQL cluster storage — other pods cannot reach this runner, so a workflow cannot resume on another pod after a reschedule. Inject POD_IP via the K8s downward API (fieldRef: status.podIP) or set runnerListenHost / VOLTRO_WORKFLOW_RUNNER_HOST.
-`);
-	let u = s.layer({
-		runnerStorage: e.runnerStorage,
-		shardingConfig: { runnerListenAddress: r.some(o.make(i, c)) }
-	}).pipe(n.provide(e.sqlClientLayer)), d = e.extraShardingLayers ?? [];
-	return (d.length === 0 ? a.layer : n.mergeAll(a.layer, ...d)).pipe(n.provide(u));
-}, d = (n) => i.make({
-	name: n.name,
-	cron: n.cron,
-	execute: t.promise(() => n.execute()),
-	skipIfOlderThan: n.skipIfOlderThan ?? e.days(1)
-});
-//#endregion
-export { u as i, c as n, l as r, d as t };