@voltro/runtime 0.62.1 → 0.62.3

package/CHANGELOG.md

@@ -39,6 +39,35 @@ _Changes staged for the next release accumulate here (rolled up from
 
 ---
 
+## [0.62.3] — 2026-09-03
+
+### Added
+
+- **@voltro/runtime** — `EffectStore` now exposes the complete Promise-store mutation surface plus transactions that roll back while preserving an inner Effect Cause. `defineSubscriber` accepts `eachReplica: true` so local per-replica work can state its topology explicitly; it cannot be combined with `once`.
+
+### Fixed
+
+- **@voltro/cli** — `voltro build` no longer starts Vite's HMR WebSocket while pre-rendering. A `RedirectError` from a static loader is now emitted as redirect metadata and served by `voltro start` with its exact status and `Location`; unrelated loader errors still fail the build.
+- **@voltro/cli, @voltro/database, @voltro/plugin-storage** — `voltro doctor` now resolves grouped event bindings and narrows its hand-roll, junction, ownership, nullable-write, singleton-read, and UI reachability checks to evidence they can actually prove. Ids owned by external systems can be declared with `.externalId()`; plugin references and non-FK asset references carry that metadata automatically.
+
+---
+
+## [0.62.2] — 2026-09-03
+
+### Added
+
+- **@voltro/client, @voltro/web, @voltro/runtime, @voltro/cli, @voltro/devtools, @voltro/workflow** — Reconnect incidents now have one bounded, payload-free evidence path: browser diagnostics retain runtime/socket/protocol/subscription transitions across a reload, the subscriptions panel exposes recovery progress and stuck re-issues, and `voltro support collect` joins that export to inspect snapshots and exact browser-to-replica socket ids. The opt-in browser fault harness can reproduce a bounded transport cut without a proxy; logs and traces remain excluded from the support bundle unless explicitly requested.
+
+  Workflow admission rows now retain queue-time app/schema provenance. `voltro workflows flow validate` checks queued payloads against the current release without returning them, while `flow retry <intentId>` re-arms one retained dead letter after its fix. Support bundles also inventory project `conflictColumns` callsites, and `voltro support sentry <eventId>` delegates source-map resolution diagnosis to Sentry's own CLI.
+- **@voltro/runtime** — Successful rpc WebSocket upgrades now emit structured open and close records carrying the serving `replicaId` and a stable per-socket `connectionId`, so connection cuts can be correlated to an api replica without debug traffic.
+
+### Fixed
+
+- **@voltro/client, @voltro/web, @voltro/react-native** — Subscription recovery now re-issues transport-failed active subscriptions only after the rpc protocol has cleared the previous socket error. A longer outage could previously reopen the WebSocket, immediately reject every re-issued subscription against the stale error, and leave the screen degraded until a reload.
+- **@voltro/workflow, @voltro/cli, @voltro/devtools-ui** — Queued workflow starts whose stored payload no longer decodes now signal `onFailure` once and remain visible as dead-letter intents instead of retrying forever. Inspect or remove them with `voltro workflows flow` and `voltro workflows flow discard <intentId>`; a valid later debounce arrival for the same key replaces the obsolete payload and resumes normal draining.
+
+---
+
 ## [0.62.1] — 2026-09-02
 
 ### Fixed
@@ -46,6 +75,11 @@ _Changes staged for the next release accumulate here (rolled up from
 - **@voltro/client, @voltro/web, @voltro/react-native** — `useSubscriptionHealth` now clears failures when replacement subscriptions succeed after a reconnect; each api keeps one error bus across transport, auth-refresh, and subject-reconnect generations.
 - **@voltro/client, @voltro/web, @voltro/react-native** — Active subscriptions whose fibers ended in a transport failure are now re-issued when the rpc socket opens again, preserving their last rows and resume revision; `useConnectionStatus` stays degraded until every affected subscription delivers a later snapshot or delta.
 
+  **Correction:** In 0.62.1 that reissue runs on the raw WebSocket `open`, before
+  the rpc protocol clears the previous socket error. After a longer outage the
+  reissued fibers can therefore fail immediately and remain terminal. The next
+  patch moves recovery behind the protocol-ready `onOpen` effect.
+
 ### Internal (no consumer-facing effect)
 
 - **@voltro/local-first** — Release dependency floors now exclude the vulnerable `fast-uri` and `@xmldom/xmldom` ranges, and the local-first test toolchain uses the patched Tiptap release.

package/dist/index.d.ts

@@ -3605,10 +3605,29 @@ export declare interface EffectStoreOps {
      *  hand-built descriptor. */
     readonly query: <R = Row>(descriptor: QueryDescriptor<R>) => Effect.Effect<ReadonlyArray<R>, StoreError>;
     readonly insert: (table: string, row: Row) => Effect.Effect<Row, StoreError>;
+    readonly insertMany: (table: string, rows: ReadonlyArray<Row>) => Effect.Effect<ReadonlyArray<Row>, StoreError>;
+    readonly patchJson: (table: string, primaryKey: string, path: string, value: unknown) => Effect.Effect<Row | null, StoreError>;
     readonly update: (table: string, primaryKey: string, patch: Readonly<Record<string, unknown>>) => Effect.Effect<Row | null, StoreError>;
+    readonly updateMany: (table: string, patch: Readonly<Record<string, unknown>>, options: {
+        readonly where: Predicate;
+    }) => Effect.Effect<number, StoreError>;
     readonly delete: (table: string, primaryKey: string) => Effect.Effect<boolean, StoreError>;
+    readonly deleteMany: (table: string, options: {
+        readonly where: Predicate;
+    }) => Effect.Effect<number, StoreError>;
+    readonly upsert: (table: string, row: Row, options: {
+        readonly conflictColumns: ReadonlyArray<string>;
+        readonly update?: ReadonlyArray<string> | ((existing: Row) => Readonly<Record<string, unknown>>);
+    }) => Effect.Effect<Row, StoreError>;
+    readonly insertIgnore: (table: string, row: Row, options: {
+        readonly conflictColumns: ReadonlyArray<string>;
+    }) => Effect.Effect<Row, StoreError>;
     /** Bypass soft-delete. See `MutationStore.hardDelete`. */
     readonly hardDelete: (table: string, primaryKey: string) => Effect.Effect<boolean, StoreError>;
+    /** Run one Effect program atomically against the transaction-scoped store.
+     *  The inner Effect's typed failures and defects are preserved; database /
+     *  store failures join the error channel as `StoreError`. */
+    readonly transactional: <A, E, R>(work: (transaction: EffectStoreOps) => Effect.Effect<A, E, R>) => Effect.Effect<A, E | StoreError, R>;
 }
 
 /** Empty registry — handy for tests + the rare bootstrap path with no
@@ -8779,6 +8798,10 @@ export declare interface RpcServerOptions<Rpcs extends Rpc.Any> {
      */
     readonly host?: string;
     readonly path?: `/${string}`;
+    /** Non-sensitive fleet identity written on the rpc WebSocket open/close
+     *  records. Defaults to the process identity resolver (POD_NAME/HOSTNAME).
+     *  Embedders may state it explicitly when they own process identity. */
+    readonly replicaId?: string;
     /** Optional tracer layer (`buildTracingLayer().layer`). Merged into the
      *  server's layer scope so every `Effect.withSpan` on the handler path
      *  — query/mutation/action/stream/workflow handlers — emits real OTel spans
@@ -10238,6 +10261,15 @@ export declare interface SubscriberDefinition {
      * from a `*.reaction.tsx`, where the durability is the primitive's job.
      */
     readonly once?: true | ((event: SubscribeEvent) => string);
+    /**
+     * State explicitly that this handler must run on every replica.
+     *
+     * This is the executable counterpart to omitting `once`: it documents that
+     * multiplication is intentional and lets `voltro doctor` distinguish an
+     * unmade fleet decision from a cache/index refresh that genuinely belongs on
+     * every process.
+     */
+    readonly eachReplica?: true;
     readonly handler: SubscribeHandler;
 }