@voltro/runtime 0.62.2 → 0.63.0

package/CHANGELOG.md

@@ -39,6 +39,33 @@ _Changes staged for the next release accumulate here (rolled up from
 
 ---
 
+## [0.63.0] — 2026-09-03
+
+### ⚠ BREAKING
+
+- **@voltro/client, @voltro/runtime, @voltro/cli, @voltro/web, @voltro/react-native** — Short transport gaps now have one bounded recovery contract. Raw diagnostics remain immediate, while `useConnectionStatus` exposes `recovering` during a configurable grace window and `useOnRpcError` emits exactly one visible transport failure only if the gap remains open. Same-subject runtime swaps keep subscription bases, revisions and optimistic patches; subject changes discard them. Interrupted mutations report `outcome: unknown` and replay once with the same key only after the deployed API proves that server idempotency is active. The codemod explains the new status member and the raw versus presentation error channels.
+
+  **`voltro update` carries you across this** — codemod `0.63.0/01_recovery-presentation`. If you pin versions by hand and never run it, print the notes without changing anything: `voltro update --codemods-only --from <your current version> --dry-run` (this one ships in 0.63.0).
+
+### Fixed
+
+- **@voltro/database, @voltro/sql-turso, @voltro/sql-sqlite, @voltro/sql-mssql** — Framework-table evolution now converges under real SQLite and both local Turso transports, and has a live MSSQL fixture. The new Turso runs also fixed internal table protection, boolean/number introspection normalization, and case-insensitive SQLite-family index-name comparison. The MSSQL fixture exposed and fixes a second convergence bug: unbounded text that MSSQL auto-bounds for an index is now rendered and compared with the same indexed-column rule, so a second plan no longer tries to widen an indexed `NVARCHAR(450)` to `NVARCHAR(MAX)`.
+
+---
+
+## [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

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}`;
+    /** Whether WS mutations are durably idempotent. Exposed as a non-secret
+     * runtime capability so clients replay only when the deployed server proves
+     * the same key will be deduplicated. */
+    readonly mutationReplay?: boolean;
     /** 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. */
@@ -10242,6 +10265,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;
 }