@voltro/sql-mssql 0.87.0 → 0.88.0

package/CHANGELOG.md

@@ -41,6 +41,166 @@ _Changes staged for the next release accumulate here (rolled up from
 
 ---
 
+## [0.88.0] — 2026-11-02
+
+### ⚠ BREAKING
+
+- **Direct computed-cache key callers handle unencodable subjects** — `@voltro/runtime`, `@voltro/voltro`
+
+  `computedCacheKey()` can return `bypass: 'subject-not-encodable'` for claims that cannot safely identify a cache entry. Direct consumers with exhaustive bypass switches must handle this case by running without caching. `voltro update` identifies the direct imports to review. Queries using the native `cache:` declaration and `invoke()` tests need no manual key or code change.
+- **The framework runs on effect 4.1.0** — `@voltro/cli`, `@voltro/devtools`, `@voltro/runtime`, `@voltro/database`, `@voltro/voltro`, `@voltro/sql-sqlite`, `@voltro/sql-mysql`, `@voltro/sql-mssql`, `@voltro/sql-postgres`
+
+  Every `@voltro/*` package now pins `effect` and its `@effect/*` companions to 4.1.0. Apps pin the same version and run `voltro add patches`: it writes the 4.1.0 patch files, retires the `patchedDependencies` entries an earlier CLI shipped for 4.0.1 (pnpm refuses an install over an unused patch) and moves the lockstep overrides. Two former patch fixes ship upstream in 4.1.0 (SQL Server request cancellation, the SQL Server message-storage MERGE). On SQL Server the shared transaction key now applies to every client in the process, not only the first one built.
+
+  `chunkRowsForInsert` from `@voltro/database` returns non-empty chunks (`NonEmptyReadonlyArray`), the shape effect 4.1's `sql.insert` requires; an empty input yields no chunk instead of one empty chunk.
+
+  SQL statement spans are named after their database, following the OpenTelemetry database conventions: the database name, else the server address, else the system name (`postgresql`, `mysql`, `microsoft.sql_server`, `sqlite`). Before, every statement span was `sql.execute`. Trace queries and dashboards that match that name should match the `db.query.text` attribute instead; the devtools trace panel and durable-trace sampling already do.
+
+  **`voltro update` carries you across this** — codemod `0.88.0/01_effect-4-1`. 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.88.0).
+- **Runtime patch pins preserve third-party Effect majors** — `@voltro/cli`
+
+  `voltro add patches` scopes Effect pins to their current major instead of replacing unrelated libraries' Effect 3 dependencies. It migrates exact pins previously shipped by the framework, preserves unrelated policies, and refuses conflicting custom policies before writing files. In pnpm workspaces it names competing nonempty root `resolutions` or `pnpm.overrides` and explains their explicit reconciliation. Peer repair refuses cross-major global policy changes. Bun workspaces require Bun >=1.4.4 and a supported `packageManager` pin or `engines.bun` floor; upgrade the actual tool and older declarations before retrying, because Bun 1.2.0 ignored the scoped companion pin. `voltro update` carries the review as `0.88.0/06_effect-override-scope`.
+- **Keep test runners out of production KV and workflow dependency closures** — `@voltro/kv`, `@voltro/workflow`
+
+  The test-only HotStore and workflow conformance suites now require their caller to supply runner operations. Pass `{ describe, it, expect }` as the third argument to `hotStoreConformance`, and `{ describe, test, expect, beforeAll, afterEach }` as the second argument to `runClusterEngineSuite` and `runJournalEncryptionSuite`. The exported structural runner interfaces have no dependency on Vitest. Both production packages remove their optional Vitest peer; an application's development runner can no longer enter a production deployment through those peer links. Keep Vitest in the test application's own devDependencies. Runtime KV/workflow calls and `runHotStoreSqlParity` are unchanged. `voltro update` identifies direct suite imports for review.
+- **REST test handlers publish events under the request tenant** — `@voltro/testing`, `@voltro/cli`
+
+  When crossing 0.87.0, custom `makeTestApp({ restRoutes })` handlers receive a request-scoped `ctx.app` instead of the root fixture context. Event assertions must subscribe to that request tenant: the default anonymous request uses `acme` or `x-tenant`; an explicit `anonymous: 'no-tenant'` uses `''`, distinct from the event bus subscriber's default `null`. Pass the app's anonymous policy, select the subscriber tenant explicitly and assert delivered payloads even when HTTP success and `notified` already pass. Direct `invoke` retains its supplied context identity, and projected `publicApi` handlers already use request-scoped invocation. Plugin HTTP routes are not mounted by this request harness. `voltro update` locates raw request harness calls and prints the review steps.
+
+### Added
+
+- **voltro add patches --ai accepts ai 7.0.156** — `@voltro/cli`, `@voltro/ai`
+
+  `voltro add patches --ai 7.0.156` wires the AI SDK declaration correction for `@ai-sdk/provider-utils` 5.0.70, regenerated with the original build from the release commit; JavaScript stays byte-identical to the published package. 7.0.105 and 7.0.132 remain selectable. `@voltro/ai` is built and tested against ai 7.0.156.
+- **The retained invoice observations table is exported from the billing package** — `@voltro/plugin-billing`
+
+  `billingRetainedInvoiceObservationsTable` is exported from `@voltro/plugin-billing` beside the other billing tables, so an app can reference it.
+- **plugin-billing accepts stripe 23** — `@voltro/plugin-billing`
+
+  The `stripe` peer range is `^22.6.1 || ^23.0.1`. stripe 23 pins Stripe API version `2026-09-30.endive`; the plugin still sends no `apiVersion` of its own, so the SDK's pinned version applies.
+
+### Changed
+
+- **A booting server holds requests until the app is ready instead of answering 503** — `@voltro/runtime`, `@voltro/voltro`
+
+  `voltro serve`, `voltro start` and `voltro dev` used to answer every request that arrived before the boot finished with a plain-text `503 starting`. On a platform that scales to zero, that request is the visitor who woke the instance, and a browser does not act on `Retry-After` for a navigation. Requests and WebSocket upgrades that arrive while the app boots now wait and are handed to the app in arrival order once it is ready. The wait is bounded by `VOLTRO_BOOT_HOLD_MS` (default `30000`, at most five minutes, `0` restores the immediate `503`) and by 512 waiting requests. A request the wait cannot cover still gets `503` with `Retry-After: 1`, and a browser navigation gets a minimal page that reloads itself. `/internal/startup` reports waiting requests as `held`, and `bindBootListener` accepts `holdMs` and `maxHeld`. Probes are unchanged, so nothing changes under Kubernetes.
+- **DocsLayout navigation nests collapsible groups with page counts** — `@voltro/ui-shadcn`
+
+  `DocsLayout` renders its sidebar as one tree: headerless groups are flat start links, other groups and sub-groups are collapsible rows with page counts, `DocsNavSubGroup` accepts nested `subgroups` and `trailingEntries`, the current page's link carries `aria-current="page"` (forwarded through `ShellLinkProps`), and the rail scrolls the active link into view after navigation.
+- **Native Redis connections use ioredis 6 and keep the RESP2 protocol** — `@voltro/kv`, `@voltro/runtime`, `@voltro/cli`
+
+  The native Redis transport moved to ioredis 6, which defaults to RESP3. Registry connections set `protocol: 2`, so command replies, Pub/Sub and Lua results keep their shapes.
+- **Connection drivers install only with the server runtime** — `@voltro/kv`, `@voltro/runtime`
+
+  `ioredis`, `@upstash/redis` and `@nats-io/transport-node` are optional peers of `@voltro/kv` and dependencies of `@voltro/runtime`. API apps keep all three without a step; web apps and SDKs that reach `@voltro/kv` only through types no longer download server drivers. Code that opens a connection without `@voltro/runtime` adds its driver, and a missing driver now fails naming the package.
+- **The mobile template targets Expo SDK 58** — `@voltro/cli`
+
+  New mobile apps scaffold on Expo SDK 58 with React Native 0.88.1 and React 19.3.0, using the versions SDK 58 bundles for its native modules.
+- **plugin-sentry runs on Sentry 11 and exports server spans over OTLP** — `@voltro/plugin-sentry`
+
+  Sentry 11 removed `SentrySpanProcessor`. The plugin now exports the framework's spans to the OTLP endpoint Sentry derives from the DSN and links errors and logs to the active span with `openTelemetryIntegration()`; the Sentry SDK records no spans of its own. `tracesSampleRate` keeps its meaning and is applied per trace id at the export. Server traces need the optional `@opentelemetry/sdk-trace-base` and `@opentelemetry/exporter-trace-otlp-http` packages (they replace `@sentry/opentelemetry`); without them the plugin warns and reports errors and breadcrumbs only. `init.tracesSampleRate` and `init.enableOpenTelemetrySetup` are ignored, and `init.skipOpenTelemetrySetup` no longer exists in Sentry 11.
+
+### Fixed
+
+- **Deferred workflow starts retain their original caller receipt** — `@voltro/workflow`, `@voltro/cli`
+
+  A controlled workflow start now returns its existing queued receipt when another replica exhausts submission retries, or shared capacity moves, before its acceptance callback dispatches. It no longer reports an ordinary start failure while the committed submission remains unresolved. Execution identity, caller input, capacity ownership and retry limits stay unchanged; definite rejection and invalid ownership still fail explicitly.
+
+- **Aggregate counters are non-negative safe integers on every dialect** — `@voltro/database`
+
+  A `count()` / `countDistinct()` / ranking counter now decodes to a number only when it is a non-negative safe integer; a fractional, negative, non-numeric or larger value is refused instead of passed through or rounded. SQLite and Turso decode counters too when the queried table has decimal columns, where they used to stay strings.
+- **Cache clear honors connection namespace prefixes** — `@voltro/kv`, `@voltro/cache`
+
+  Clearing a cache through a named, namespaced Redis connection now binds logical cache keys to that connection's physical namespace. Redis-family engines and the local transport preserve neighboring caches and invalidation fences, while refusing foreign prefixes and forged key sets. The existing atomic cache command format remains unchanged.
+- **Cache commands use the selected app's configuration and connections** — `@voltro/cli`
+
+  `voltro cache status`, `flush` and `invalidate` resolve `app.config.ts`, environment overrides and named Redis connections exactly like Dev and Serve, including an optional target app directory. Invalid configuration fails instead of silently reporting memory, in-process transports refuse CLI mutation, and diagnostics omit endpoint URLs and credentials.
+- **Generated cache examples boot and upgrade reviews name affected lines** — `@voltro/cli`
+
+  The seeded core API example now uses an object cache declaration. Forced guide refresh discovers both flat and project-grouped app layouts, replacing stale nested examples without executing configs or crossing an app boundary. The shared cache/KV migration review lists authored code locations, including asserted backend literals, and a new review reaches applications that already crossed the original migration. It also identifies stale core guides for refresh; protected hand-maintained guides stay under their owner's control.
+- **Subject query caches follow current authority** — `@voltro/runtime`, `@voltro/testing`
+
+  Subject-scoped computed queries key the complete subject claims and raw and resolved permission sets. Removing an admin grant, changing roles or switching tenant or credential type cannot reuse a result admitted under earlier authority. Authentication refreshes before lookup, and a change while a read is pending refuses retention and delivery. Connection-local state is never covered by subject scope; handlers that read it do not retain their results. The same decisions apply to `invoke` tests, memory caches and Redis caches.
+- **Preserve connection declaration errors across module boundaries** — `@voltro/kv`
+
+  Redis, NATS, Storage, Analytics and SQL registries retain typed configuration diagnostics across module and VM boundaries instead of mislabeling them as dynamic credential failures. Errors returned by credential resolvers remain redacted.
+- **Bind demo API tenants consistently in browser and server renders** — `@voltro/cli`
+
+  The fullstack, admin, SSR API and public status templates now send their explicit demo tenant to header-based anonymous APIs. SSR API and status pages use the same binding for server-side RPC reads, so a fresh scaffold renders successfully and its browser subscriptions select the same data. API refusals for missing tenants and access checks remain enforced. These demo bindings select rows and do not authenticate users; private production data requires verified authentication. Fresh-consumer diagnostics retain uppercase error log lines.
+- **Two voltro dev processes starting together mint one set of secrets, not two** — `@voltro/cli`
+
+  `voltro dev` mints missing project secrets into `.env.local`. Two processes on one project starting at the same time (two local replicas, a dev server beside a test boot) each minted their own values; with field encryption the database recorded one key and refused the second process at boot. Minting now runs under a lock and adopts a value another process wrote meanwhile; a lock left by a crashed mint is taken over.
+- **Event warnings follow workspace package exports** — `@voltro/cli`
+
+  Development event wiring warnings now recognise sibling `useEvent` consumers imported through package exports, TypeScript path aliases, named and namespace re-exports, and static local aliases. Each subscription is matched to its descriptor so an unused import or another API's same-named module does not hide a missing consumer. Workspace discovery supports declared pnpm, npm, Yarn and Bun members and excludes nested projects and build output.
+- **Index audit preserves partial row coverage and uniqueness** — `@voltro/database`
+
+  The index audit recommends dropping an index only when another B-tree index preserves its row coverage and uniqueness. Partial unique indexes no longer make full indexes appear redundant; specialized index methods and unproved predicate relationships are excluded, and recommendations name only the safe replacement direction.
+- **Migration logs identify which operations their count includes** — `@voltro/database`
+
+  Development auto-migration logs now identify their applied-operation count as the planner pass, excluding framework bootstrap and file-based migrations. A schema plan taken before boot can include work completed by those earlier stages; run a new plan after boot to verify that no operations remain.
+- **Filter completed workflow pool owners before recovery transport** — `@voltro/cli`, `@voltro/voltro`, `@voltro/workflow`
+
+  Pool release recovery now persists its terminal settlement on submission and restart owners and filters those markers through indexed SQL predicates. Finished owner history no longer crosses the wire on every idle pass or after process restart. Lost release acknowledgements, held owners and missing evidence remain recoverable and reported; immutable owners and permit tombstones remain for receipt and replay safety. Normal framework schema migration adds two nullable settlement markers and their indexes; existing history is checked once in bounded pages. Settlement indexes use explicit short names within SQL identifier limits. Reconciliation cadence is unchanged.
+- **Presence transport warnings follow actual subscription readiness** — `@voltro/plugin-presence`
+
+  Presence reports pending binding or subscription acquisition without a false missing-provider warning after five seconds. It reports cross-instance readiness only after acquiring the broadcast subscription, while local-only bindings and failed subscriptions still warn. Closing or replacing a binding prevents stale callbacks and releases subscriptions acquired afterward.
+- **Self-updates finish after the old CLI installation is removed** — `@voltro/cli`, `@voltro/runtime`
+
+  `voltro update` loads its completion helpers before installing the target version, so removing the running CLI package no longer turns a successful upgrade into a missing-module failure. Error reporting uses the shared lightweight `@voltro/runtime/boot-refusal` entry loaded before dispatch; genuine failures keep their original message and exit code without loading the server dependency graph for help or version commands.
+- **Compiled API servers start without a source-analysis dependency** — `@voltro/cli`
+
+  The development event-consumer audit loads its source compiler only when scanning. A compiled API server can start after relocation without app sources or a direct `ts-morph` dependency. Package-export consumer discovery keeps its existing scope and does not execute application modules.
+- **SignalHeader centers its brand in the masthead** — `@voltro/ui-shadcn`
+
+  The `SignalHeader` brand slot is a centered flex row, so a brand link no longer sits on the text baseline and renders a few pixels above the masthead's center.
+- **Update reports changed runtime patch assets before boot** — `@voltro/cli`
+
+  `voltro update` compares configured pnpm Effect and SQL-driver patches with the target CLI's assets during its codemod step, including `--codemods-only`. Changed bytes produce refresh and install instructions even without workflows. Same-version checks also report drift. Custom patch paths are named and files remain untouched.
+- **Upgrade reviews omit locator counts and unchanged REST type plumbing** — `@voltro/cli`
+
+  The aggregate review excludes locator chains and local locator aliases while retaining uncertain query receivers. The idempotency review lists REST context constructions, context factories and guard definitions instead of every context or guard parameter annotation. Aliased imported calls in JavaScript custom hosts remain visible.
+
+### Internal (no consumer-facing effect)
+
+- **Effect audits distinguish regression data from executable legacy APIs**
+
+  Effect migration audits allow test data to describe a foreign dependency's retained major. Removed package imports and obsolete bound API calls remain findings in tests and application code, while production migration-residue checks remain unchanged.
+- **The doctor's table nullability manifest covers the billing history tables** — `@voltro/cli`
+
+  The generated nullability manifest `voltro doctor` reads was missing the invoice-history and customer-account tables the billing plugin added; it is regenerated from the declarations.
+- **Installation checks refuse ambient workspaces and source overrides**
+
+  Installation checks require standalone directories before creating projects. Artifact consumers use shipped template and documentation assets without inheriting maintainer source overrides or Node module loaders. Registry, package-manager and explicit application settings remain available.
+- **Installation checks require healthy applications and usable modules**
+
+  Installation checks require API readiness, successful web responses and transformed JavaScript modules while the development process remains running. HTTP errors and HTML fallbacks cannot satisfy those checks. Diagnostics distinguish application startup from shutdown.
+- **Keep CLI fixture temporary roots and child outcomes explicit**
+
+  Automatic sidecar tests inspect the actual operating-system temporary directory and release their bound owner even when an assertion fails. Schema-boot fixtures retain the child's exit signal and assert the real exit tuple alongside readiness and migration counts, so a signal cannot become a false successful process result. Production security and signal guards remain unchanged.
+
+  Workflow recovery tests distinguish the recorded failure budget from concurrent dispatches already in flight. They retain the same prepared execution identity, require one body execution, and verify that stopped or accepted submissions cannot dispatch again.
+- **Native SQL checks isolate schema ownership across fixtures**
+
+  Wallet and shop checks own separate server databases so concurrent schema creation cannot contend with another fixture's live writes. Independent pools within a fixture still share the real database. Cleanup closes all acquired pools before dropping only the owned namespace, and a native regression verifies isolation with identical wallet identities.
+- **Native reload checks retain manifests published during SQL observation**
+
+  Native geometry checks establish the expected-version receiver before reload activation. A real transport regression holds the consumer until the new manifest arrives, so asynchronous SQL observation cannot hide a missed publication. Frame deadlines retain their original call sites.
+- **Native snapshot probes join their scheduled driver**
+
+  Held-source stream probes quiesce and join the actual Host driver before directly pumping its captured graph. This prevents a scheduled turn from concurrently entering that graph and closing the fixture's native Session. Listener, SQL, controller, wire delivery, rights withdrawal and final cleanup assertions remain active; ordinary stream cases retain the running driver.
+- **Bound the reviewed Sentry tool exception and retain every dependency instance**
+
+  The owner-reviewed exception accepts only sentry 0.45.0 under FSL-1.1-Apache-2.0 as unmodified external tooling for the Sentry integration. This does not classify FSL as permissive or remove its competing-use restriction. The runtime license walk checks every resolved instance, so an accepted version cannot hide a second version or license. Generated notices and the SBOM use actual package identities. Containment checks cover framework, workspace and scaffold patch files plus declared patches with arbitrary filenames; the API bundler leaves the tool external.
+- **Stack scaffold checks require major-scoped runtime alignment**
+
+  The normal stack scaffold regression parses its generated workspace policy and verifies both Effect 4 selectors while refusing unqualified Effect and companion pins. Patch declaration and actual patch-byte checks remain, so the regression follows the preserved foreign-major contract instead of demanding its earlier unsafe global override. Its synthetic workspace declares its own pnpm version, making Compose baseline coverage independent of the test runner's package-manager environment.
+- **Dependency security checks verify installed source remediations**
+
+  Dependency security checks accept a reviewed source remediation only after verifying exact patch and implementation hashes, patched references in every lockfile document, actual caller resolution and runtime behavior. Deepmerge's returned-object prototype protection preserves ordinary configuration merging. Unaffected dependency graphs receive no exception, and a local source remediation is never reported as an upstream fixed version.
+
+---
+
 ## [0.87.0] — 2026-10-31
 
 ### ⚠ BREAKING
@@ -3231,6 +3391,15 @@ _Changes staged for the next release accumulate here (rolled up from
 - **Prepare the exact XYFlow type correction before normal installation** — `@voltro/cli`
 
   `voltro add patches --xyflow 12.12.0` prepares the original XYFlow declaration correction and its complete license/notice before a normal package-manager or UI installation. Existing conflicting project patch assets are preserved and rejected before writes.
+- **Dispatchers drain accepted reads before store disposal** — `@voltro/runtime`, `@voltro/cli`
+
+  Runtime adds `Dispatcher.closeAndDrain()` to join accepted reads and deliveries before store disposal. Normal Dev and Serve API shutdown await it; synchronous `close()` remains available.
+- **Workflow cluster hosts declare shard groups and ClusterCron routing groups** — `@voltro/workflow`, `@voltro/cli`
+
+  Workflow cluster hosts can explicitly declare available/assigned shard groups and ClusterCron routing groups. Omitted settings retain existing routing; persistent journal migration is a separate prerequisite for changing groups.
+- **PostgreSQL workflow hosts can persist routing-generation admission** — `@voltro/workflow`, `@voltro/cli`
+
+  PostgreSQL workflow engine hosts can opt into persisted routing-generation admission with `journalRouting`; actual durable MessageStorage operations use the ownership guard. Full API-role wiring and maintenance rollout remain separate requirements.
 
 ### Changed
 
@@ -24321,9 +24490,3 @@ public registry yet.
 
 Subsequent releases record their deltas from here under dated headings, with
 `⚠ BREAKING` first.
-
-- Runtime adds `Dispatcher.closeAndDrain()` to join accepted reads and deliveries before store disposal. Normal Dev and Serve API shutdown await it; synchronous `close()` remains available.
-
-- Workflow cluster hosts can explicitly declare available/assigned shard groups and ClusterCron routing groups. Omitted settings retain existing routing; persistent journal migration is a separate prerequisite for changing groups.
-
-- PostgreSQL workflow engine hosts can opt into persisted routing-generation admission with `journalRouting`; actual durable MessageStorage operations use the ownership guard. Full API-role wiring and maintenance rollout remain separate requirements.

package/THIRD-PARTY-NOTICES.md

@@ -1,15 +1,15 @@
 # Third-Party Notices — @voltro/sql-mssql
 
-This package uses the open-source software listed below. Each is the
+This package uses the third-party software listed below. Each is the
 property of its respective copyright holders and is used under the terms of
 its license. This file is provided for attribution; it grants no rights in
 @voltro/sql-mssql itself, which is proprietary (see LICENSE).
 
-Generated from the resolved runtime dependency closure (70 packages).
+Generated from the resolved runtime dependency closure (72 packages).
 
 ---
 
-## @azure-rest/core-client@2.6.0
+## @azure-rest/core-client@2.9.0
 
 License: MIT
 
@@ -37,14 +37,14 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
-## @azure/abort-controller@2.1.2
+## @azure/abort-controller@2.2.0
 
 License: MIT
 
 ```
-The MIT License (MIT)
+Copyright (c) Microsoft Corporation.
 
-Copyright (c) 2020 Microsoft
+MIT License
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -56,7 +56,7 @@ furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
@@ -65,7 +65,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
-## @azure/core-auth@1.10.1
+## @azure/core-auth@1.11.0
 
 License: MIT
 
@@ -93,7 +93,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
-## @azure/core-client@1.10.1
+## @azure/core-client@1.11.1
 
 License: MIT
 
@@ -149,14 +149,42 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
-## @azure/core-paging@1.6.2
+## @azure/core-paging@1.7.0
+
+License: MIT
+
+```
+Copyright (c) Microsoft Corporation.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+## @azure/core-process@1.0.0
 
 License: MIT
 
 ```
 The MIT License (MIT)
 
-Copyright (c) 2020 Microsoft
+Copyright (c) 2018 Microsoft
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -177,7 +205,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
-## @azure/core-rest-pipeline@1.24.0
+## @azure/core-rest-pipeline@1.25.0
 
 License: MIT
 
@@ -205,7 +233,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
-## @azure/core-tracing@1.3.1
+## @azure/core-tracing@1.4.0
 
 License: MIT
 
@@ -233,7 +261,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
-## @azure/core-util@1.13.1
+## @azure/core-util@1.14.0
 
 License: MIT
 
@@ -261,7 +289,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
-## @azure/identity@4.13.1
+## @azure/identity@4.14.0
 
 License: MIT
 
@@ -345,7 +373,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
-## @azure/logger@1.3.0
+## @azure/logger@1.4.0
 
 License: MIT
 
@@ -373,7 +401,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
-## @azure/msal-browser@5.11.0
+## @azure/msal-browser@5.27.0
 
 License: MIT
 
@@ -401,7 +429,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE
 ```
 
-## @azure/msal-common@16.6.2
+## @azure/msal-common@16.15.0
 
 License: MIT
 
@@ -429,7 +457,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE
 ```
 
-## @azure/msal-node@7.1.1
+## @azure/msal-node@7.1.2
 
 License: MIT
 
@@ -457,7 +485,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
-## @effect/sql-mssql@4.0.1
+## @effect/sql-mssql@4.1.0
 
 License: MIT
 
@@ -485,7 +513,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
-## @js-joda/core@6.2.0
+## @js-joda/core@6.3.0
 
 License: BSD-3-Clause
 
@@ -525,7 +553,7 @@ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ```
 
-## @types/node@26.6.1
+## @types/node@26.6.6
 
 License: MIT
 
@@ -553,7 +581,7 @@ MIT License
     SOFTWARE
 ```
 
-## @types/readable-stream@4.0.23
+## @types/readable-stream@4.0.25
 
 License: MIT
 
@@ -581,7 +609,7 @@ MIT License
     SOFTWARE
 ```
 
-## @typespec/ts-http-runtime@0.3.5
+## @typespec/ts-http-runtime@0.3.9
 
 License: MIT
 
@@ -761,7 +789,7 @@ Redistribution and use in source and binary forms, with or without modification,
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ```
 
-## bundle-name@4.1.0
+## bundle-name@4.1.1
 
 License: MIT
 
@@ -803,7 +831,7 @@ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ```
 
-## default-browser@5.5.0
+## default-browser@5.5.1
 
 License: MIT
 
@@ -1257,6 +1285,22 @@ The above copyright notice and this permission notice shall be included in all c
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ```
 
+## is-in-ssh@1.0.0
+
+License: MIT
+
+```
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+```
+
 ## is-inside-container@1.0.0
 
 License: MIT
@@ -1751,7 +1795,23 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
-## open@10.2.0
+## open@11.0.4
+
+License: MIT
+
+```
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+```
+
+## powershell-utils@0.2.1
 
 License: MIT
 
@@ -1796,7 +1856,7 @@ TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ```
 
-## readable-stream@4.7.0
+## readable-stream@4.8.0
 
 License: MIT
 
@@ -1944,37 +2004,6 @@ ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
 IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 ```
 
-## sprintf-js@1.1.3
-
-License: BSD-3-Clause
-
-```
-Copyright (c) 2007-present, Alexandru Mărășteanu <hello@alexei.ro>
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-* Redistributions of source code must retain the above copyright
-  notice, this list of conditions and the following disclaimer.
-* Redistributions in binary form must reproduce the above copyright
-  notice, this list of conditions and the following disclaimer in the
-  documentation and/or other materials provided with the distribution.
-* Neither the name of this software nor the names of its contributors may be
-  used to endorse or promote products derived from this software without
-  specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-```
-
 ## string_decoder@1.3.0
 
 License: MIT
@@ -2029,14 +2058,14 @@ IN THE SOFTWARE.
 """
 ```
 
-## tedious@20.3.3
+## tedious@20.3.8
 
 License: MIT
 
 ```
 The MIT License
 
-Copyright (c) 2010-2018 Mike D Pilsbury
+Copyright (c) 2010-2026 Mike D Pilsbury
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -2132,7 +2161,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
-## wsl-utils@0.1.0
+## wsl-utils@1.0.1
 
 License: MIT
 

package/dist/binaryParameter.js

@@ -1,9 +1,8 @@
 import { TYPES as e } from "tedious";
-//#region src/binaryParameter.ts
+// src/binaryParameter.ts
 var t = {
 	...e.VarBinary,
 	resolveLength: (t) => Math.max(1, e.VarBinary.resolveLength(t)),
 	validate: (t, n, r) => e.VarBinary.validate(t instanceof Uint8Array && !Buffer.isBuffer(t) ? Buffer.from(t.buffer, t.byteOffset, t.byteLength) : t, n, r)
 };
-//#endregion
 export { t as binaryParameter };

package/dist/changeTrackingCdc.js

@@ -3,7 +3,7 @@ import { Effect as n } from "effect";
 import { decodeRowsFromSchema as r } from "@voltro/database";
 import { createLogger as i } from "@voltro/logger";
 import { SqlClient as a } from "effect/sql/SqlClient";
-//#region src/changeTrackingCdc.ts
+// src/changeTrackingCdc.ts
 var o = {
 	I: "insert",
 	U: "update",
@@ -107,5 +107,4 @@ var o = {
 		currentVersion: () => g
 	};
 };
-//#endregion
 export { s as ensureChangeTracking, u as startChangeTrackingCdc };

package/dist/index.js

@@ -4,7 +4,7 @@ import { ensureChangeTracking as a, startChangeTrackingCdc as o } from "./change
 import { CDC_OFFSETS_TABLE as s, _voltroMssqlCdcOffsetsTable as c } from "./cdcOffsetsTable.js";
 import { makeMssqlStore as l } from "./store.js";
 import { mssqlReplicationAdapter as u } from "./replicationAdapter.js";
-//#region src/index.ts
+// src/index.ts
 var d = {
 	id: "mssql",
 	makeSqlLayer: (e) => r(e),
@@ -12,5 +12,4 @@ var d = {
 	compileContains: (e, t, n) => n`${e} LIKE ${`%${t.replace(/[\\%_[\]]/g, (e) => `\\${e}`)}%`} ESCAPE '\\'`,
 	retryFilter: i
 };
-//#endregion
 export { s as CDC_OFFSETS_TABLE, e as MssqlClient, c as _voltroMssqlCdcOffsetsTable, t as connectionFromConfig, a as ensureChangeTracking, n as makeMssqlSqlLayer, r as makeMssqlSqlLayerFromConfig, l as makeMssqlStore, d as mssqlDialect, u as mssqlReplicationAdapter, i as mssqlRetryFilter, o as startChangeTrackingCdc };

package/dist/numberParameter.js

@@ -1,6 +1,6 @@
 import { TYPES as e } from "tedious";
 import { resolveParameter as t } from "tedious/lib/data-type";
-//#region src/numberParameter.ts
+// src/numberParameter.ts
 var n = (t) => typeof t == "bigint" ? e.BigInt : typeof t == "number" && Number.isSafeInteger(t) ? t >= -2147483648 && t <= 2147483647 ? e.Int : e.BigInt : e.Float, r = {
 	...e.Int,
 	declaration: (e) => n(e.value).declaration(e),
@@ -15,5 +15,4 @@ var n = (t) => typeof t == "bigint" ? e.BigInt : typeof t == "number" && Number.
 		return n(e).validate(e, t, r);
 	}
 };
-//#endregion
 export { r as numberParameter };

package/dist/replicationAdapter.js

@@ -1,6 +1,6 @@
 import { Effect as e } from "effect";
 import { SqlClient as t } from "effect/sql/SqlClient";
-//#region src/replicationAdapter.ts
+// src/replicationAdapter.ts
 var n = (e) => e.__mssqlReplicationFriend ?? null, r = (e, t) => e === t ? 0 : e < t ? -1 : 1, i = () => ({
 	async capturePrimaryPosition(r) {
 		let i = n(r);
@@ -31,5 +31,4 @@ var n = (e) => e.__mssqlReplicationFriend ?? null, r = (e, t) => e === t ? 0 : e
 		return r(t, e) >= 0 ? "caught-up" : "behind";
 	}
 });
-//#endregion
 export { i as mssqlReplicationAdapter };

package/dist/retry.js

@@ -1,5 +1,5 @@
 import { MSSQL_TRANSIENT_NUMBERS as e, causeBranches as t } from "@voltro/database";
-//#region src/retry.ts
+// src/retry.ts
 var n = e, r = (e) => {
 	let t = e;
 	for (let e = 0; e < 5 && typeof t == "object" && t; e++) {
@@ -16,5 +16,4 @@ var n = e, r = (e) => {
 	let t = r(e);
 	return t !== void 0 && a.has(t);
 }), s = (e) => i(e) ? "retry" : "noRetry";
-//#endregion
 export { o as isDuplicateKeyMssqlFailure, i as isRetryableMssqlFailure, s as mssqlRetryFilter };

package/dist/rowResultProjection.js

@@ -1,6 +1,6 @@
 import { Effect as e } from "effect";
 import { sqlError as t } from "@voltro/database";
-//#region src/rowResultProjection.ts
+// src/rowResultProjection.ts
 var n = (n, r) => e.gen(function* () {
 	let e = yield* n`
     SELECT name, system_type_id FROM sys.columns
@@ -12,5 +12,4 @@ var n = (n, r) => e.gen(function* () {
 	let r = e.literal(`[${t.name.replaceAll("]", "]]")}]`), i = n ? e`${e(n)}.${r}` : r;
 	return t.system_type_id === 106 || t.system_type_id === 108 ? e`CONVERT(varchar(80), ${i}) AS ${r}` : i;
 }));
-//#endregion
 export { r as mssqlRowResultProjection, n as readMssqlPhysicalColumns };

package/dist/sqlLayer.js

@@ -4,7 +4,7 @@ import { MssqlClient as n } from "@effect/sql-mssql";
 import { TYPES as r } from "tedious";
 import { Config as i, Duration as a, Redacted as o } from "effect";
 import { DEFAULT_ACQUIRE_TIMEOUT_MS as s, SHARED_TRANSACTION_SERVICE as c } from "@voltro/database";
-//#region src/sqlLayer.ts
+// src/sqlLayer.ts
 var l = {
 	...n.defaultParameterTypes,
 	null: r.NVarChar,
@@ -74,5 +74,4 @@ var l = {
 		...t
 	};
 }, m = (e) => d(p(e));
-//#endregion
 export { n as MssqlClient, p as connectionFromConfig, d as makeMssqlSqlLayer, m as makeMssqlSqlLayerFromConfig, u as resolveAcquireTimeoutMs, f as sslFromUrlQuery };

package/dist/store.js

@@ -2,53 +2,53 @@ import { writeOutput as e } from "./writeOutput.js";
 import { isDuplicateKeyMssqlFailure as t, isRetryableMssqlFailure as n } from "./retry.js";
 import { startChangeTrackingCdc as r } from "./changeTrackingCdc.js";
 import { CDC_OFFSETS_TABLE as i } from "./cdcOffsetsTable.js";
-import { Effect as a, Layer as o, ManagedRuntime as s, Option as c } from "effect";
-import { EagerCardinalityError as l, attachEagerLoads as u, attributionFields as d, bulkInsertLimitsFor as f, chunkRowsForInsert as p, compileEagerJson as m, compileJsonPatch as h, compilePredicate as g, compileRawFragment as _, compileSelect as v, decodeRowsFromSchema as y, decodeSelectRows as b, emitCommittedChanges as x, encodeRowForSchema as S, externalChangeEvent as C, hasEagerLoads as w, isTableReactive as T, jsonPatchAssignments as E, makeEagerFallbackReporter as D, makeTransactionAbortTracker as O, observeDbOp as k, onTransaction as A, qualifyTable as j, quoteIdent as M, raiseChangeListenerCeiling as N, recordsTable as P, requireTable as F, rowKeyColumns as I, runSavepoint as L, runStoreTransaction as R, runWriteRecorders as z, stampGeneratedId as B, stampGeneratedIds as V, upsertUpdatePatch as H, upsertUpdateValues as U, withCapturedAttribution as W, writeImagesObserved as G } from "@voltro/database";
-import { EventEmitter as K } from "node:events";
-import { createLogger as q } from "@voltro/logger";
-import { SqlClient as J } from "effect/sql/SqlClient";
-//#region src/store.ts
-var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
+import { Array as a, Effect as o, Layer as s, ManagedRuntime as c, Option as l } from "effect";
+import { EagerCardinalityError as u, attachEagerLoads as d, attributionFields as f, bulkInsertLimitsFor as p, chunkRowsForInsert as m, compileEagerJson as h, compileJsonPatch as g, compilePredicate as _, compileRawFragment as v, compileSelect as y, decodeRowsFromSchema as b, decodeSelectRows as x, emitCommittedChanges as S, encodeRowForSchema as C, externalChangeEvent as w, hasEagerLoads as T, isTableReactive as E, jsonPatchAssignments as D, makeEagerFallbackReporter as O, makeTransactionAbortTracker as k, observeDbOp as A, onTransaction as j, qualifyTable as M, quoteIdent as N, raiseChangeListenerCeiling as P, recordsTable as F, requireTable as I, rowKeyColumns as L, runSavepoint as R, runStoreTransaction as z, runWriteRecorders as B, stampGeneratedId as V, stampGeneratedIds as H, upsertUpdatePatch as U, upsertUpdateValues as W, withCapturedAttribution as G, writeImagesObserved as K } from "@voltro/database";
+import { EventEmitter as q } from "node:events";
+import { createLogger as J } from "@voltro/logger";
+import { SqlClient as Y } from "effect/sql/SqlClient";
+// src/store.ts
+var X = J({ scope: "voltro:mssql" }), Z = async (e) => {
 	let t = e.changeStrategy ?? "inline", n = t;
-	t === "cdc" && !e.cdcConfig && (Y.warn("changeStrategy='cdc' requires cdcConfig (replicaId + includeTables); falling back to 'inline'."), n = "inline");
-	let r = e.tracerLayer ? o.mergeAll(e.sqlLayer, e.tracerLayer) : e.sqlLayer, i = s.make(r), a = new Z(await i.runPromise(J), i, n);
+	t === "cdc" && !e.cdcConfig && (X.warn("changeStrategy='cdc' requires cdcConfig (replicaId + includeTables); falling back to 'inline'."), n = "inline");
+	let r = e.tracerLayer ? s.mergeAll(e.sqlLayer, e.tracerLayer) : e.sqlLayer, i = c.make(r), a = new Q(await i.runPromise(Y), i, n);
 	return n === "cdc" && e.cdcConfig && await a.startCdcConsumer(e.cdcConfig), a;
-}, Z = class o {
+}, Q = class s {
 	sql;
 	runtime;
 	changeStrategy;
 	namespace;
 	emitter;
 	inflightTxns = 0;
-	reportEagerFallback = D(Y);
+	reportEagerFallback = O(X);
 	cdcHandle = null;
 	cdcCheckpointTimer = null;
 	cdcPendingVersion = null;
 	cdcReplicaId = "";
 	cdcStreamName = "default";
 	constructor(e, t, n = "inline", r = null, i) {
-		this.sql = e, this.runtime = t, this.changeStrategy = n, this.namespace = r, this.emitter = i ?? new K(), N(this.emitter);
+		this.sql = e, this.runtime = t, this.changeStrategy = n, this.namespace = r, this.emitter = i ?? new q(), P(this.emitter);
 	}
 	get inlineEmit() {
 		return this.changeStrategy === "inline";
 	}
 	withNamespace(e) {
-		return e === this.namespace ? this : new o(this.sql, this.runtime, this.changeStrategy, e, this.emitter);
+		return e === this.namespace ? this : new s(this.sql, this.runtime, this.changeStrategy, e, this.emitter);
 	}
 	nsT(e) {
-		return j(this.namespace, e);
+		return M(this.namespace, e);
 	}
 	__mssqlReplicationFriend = { runEffect: (e) => this.runtime.runPromise(e) };
 	async executeQuery(e, t) {
-		let n = v(e, this.sql, this.namespace), r = t ? a.provideService(n, this.sql.transactionService, t) : n, i = await k("mssql", "select", () => this.runtime.runPromise(r));
-		return b(i, e, "mssql");
+		let n = y(e, this.sql, this.namespace), r = t ? o.provideService(n, this.sql.transactionService, t) : n, i = await A("mssql", "select", () => this.runtime.runPromise(r));
+		return x(i, e, "mssql");
 	}
 	decodeWritten(e, t) {
-		return y([t], e, "mssql")[0] ?? t;
+		return b([t], e, "mssql")[0] ?? t;
 	}
-	async executeInsert(t, n, r, i, o) {
-		n = B(t, n);
-		let s = this.sql, c = e(s, this.nsT(t), (e) => s`INSERT INTO ${s(this.nsT(t))} ${s.insert(S(n, t)).returning(s`INSERTED.* INTO ${e}`)}`), l = r ? a.provideService(c, this.sql.transactionService, r) : c, u = (await this.runtime.runPromise(l))[0];
+	async executeInsert(t, n, r, i, a) {
+		n = V(t, n);
+		let s = this.sql, c = e(s, this.nsT(t), (e) => s`INSERT INTO ${s(this.nsT(t))} ${s.insert(C(n, t)).returning(s`INSERTED.* INTO ${e}`)}`), l = r ? o.provideService(c, this.sql.transactionService, r) : c, u = (await this.runtime.runPromise(l))[0];
 		if (!u) throw Error(`MssqlStore.insert: row not returned post-insert in '${t}'`);
 		let d = this.decodeWritten(t, u);
 		return await this.routeEvent({
@@ -56,10 +56,10 @@ var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
 			op: "insert",
 			old: null,
 			new: d
-		}, i, r, o), d;
+		}, i, r, a), d;
 	}
-	async executeUpdate(t, n, r, i, o, s) {
-		let c = this.sql, l = e(c, this.nsT(t), (e) => c`UPDATE ${c(this.nsT(t))} SET ${c.update(S(r, t)).returning(c`INSERTED.* INTO ${e}`)} WHERE ${c.and(I(n).map(([e, t]) => c`${c(e)} = ${t}`))}`), u = i ? a.provideService(l, this.sql.transactionService, i) : l, d = (await this.runtime.runPromise(u))[0];
+	async executeUpdate(t, n, r, i, a, s) {
+		let c = this.sql, l = e(c, this.nsT(t), (e) => c`UPDATE ${c(this.nsT(t))} SET ${c.update(C(r, t)).returning(c`INSERTED.* INTO ${e}`)} WHERE ${c.and(L(n).map(([e, t]) => c`${c(e)} = ${t}`))}`), u = i ? o.provideService(l, this.sql.transactionService, i) : l, d = (await this.runtime.runPromise(u))[0];
 		if (!d) return null;
 		let f = this.decodeWritten(t, d);
 		return await this.routeEvent({
@@ -67,45 +67,45 @@ var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
 			op: "update",
 			old: null,
 			new: f
-		}, o, i, s), f;
-	}
-	async executeInsertMany(t, n, r, i, o, s) {
-		if (n = V(t, n), n.length === 0) return [];
-		let c = this.sql, l = p(n, f("mssql")), u = s?.returning === "none", d = u && !G(t), m = (n) => {
-			let r = c.insert(n.map((e) => S(e, t)));
-			return d ? a.as(c`INSERT INTO ${c(this.nsT(t))} ${r}`, []) : e(c, this.nsT(t), (e) => c`INSERT INTO ${c(this.nsT(t))} ${r.returning(c`INSERTED.* INTO ${e}`)}`);
-		}, h;
-		if (l.length === 1) {
-			let e = m(l[0]), t = r ? a.provideService(e, this.sql.transactionService, r) : e;
-			h = await this.runtime.runPromise(t);
+		}, a, i, s), f;
+	}
+	async executeInsertMany(t, n, r, i, s, c) {
+		if (n = H(t, n), n.length === 0) return [];
+		let l = this.sql, u = m(n, p("mssql")), d = c?.returning === "none", f = d && !K(t), h = (n) => {
+			let r = l.insert(a.map(n, (e) => C(e, t)));
+			return f ? o.as(l`INSERT INTO ${l(this.nsT(t))} ${r}`, []) : e(l, this.nsT(t), (e) => l`INSERT INTO ${l(this.nsT(t))} ${r.returning(l`INSERTED.* INTO ${e}`)}`);
+		}, g;
+		if (u.length === 1) {
+			let e = h(u[0]), t = r ? o.provideService(e, this.sql.transactionService, r) : e;
+			g = await this.runtime.runPromise(t);
 		} else if (r) {
 			let e = [];
-			for (let t of l) e.push(...await this.runtime.runPromise(a.provideService(m(t), this.sql.transactionService, r)));
-			h = e;
-		} else h = await this.runtime.runPromise(c.withTransaction(a.map(a.forEach(l, m, { concurrency: 1 }), (e) => e.flat())));
-		if (d) return [];
-		let g = n.map((e) => e.id), _ = y(h, t, "mssql"), v = new Map(_.map((e) => [e.id, e])), b = g.map((e) => v.get(e)).filter((e) => e !== void 0), x = b.length === h.length ? b : _;
-		for (let e of x) await this.routeEvent({
+			for (let t of u) e.push(...await this.runtime.runPromise(o.provideService(h(t), this.sql.transactionService, r)));
+			g = e;
+		} else g = await this.runtime.runPromise(l.withTransaction(o.map(o.forEach(u, h, { concurrency: 1 }), (e) => e.flat())));
+		if (f) return [];
+		let _ = n.map((e) => e.id), v = b(g, t, "mssql"), y = new Map(v.map((e) => [e.id, e])), x = _.map((e) => y.get(e)).filter((e) => e !== void 0), S = x.length === g.length ? x : v;
+		for (let e of S) await this.routeEvent({
 			table: t,
 			op: "insert",
 			old: null,
 			new: e
-		}, i, r, o);
-		return u ? [] : x;
+		}, i, r, s);
+		return d ? [] : S;
 	}
-	async executePatchJson(t, n, r, i, o, s, c, l) {
-		let u = this.sql, d = S(E(n, r, l), t), f = u.csv([h(u, "mssql", r, i), ...Object.entries(d).map(([e, t]) => u`${u(e)} = ${t}`)]), p = e(u, this.nsT(t), (e) => u`UPDATE ${u(this.nsT(t))} SET ${f} OUTPUT INSERTED.* INTO ${e} WHERE ${u.and(I(n).map(([e, t]) => u`${u(e)} = ${t}`))}`), m = o ? a.provideService(p, this.sql.transactionService, o) : p, g = (await this.runtime.runPromise(m))[0];
-		if (!g) return null;
-		let _ = this.decodeWritten(t, g);
+	async executePatchJson(t, n, r, i, a, s, c, l) {
+		let u = this.sql, d = C(D(n, r, l), t), f = u.csv([g(u, "mssql", r, i), ...Object.entries(d).map(([e, t]) => u`${u(e)} = ${t}`)]), p = e(u, this.nsT(t), (e) => u`UPDATE ${u(this.nsT(t))} SET ${f} OUTPUT INSERTED.* INTO ${e} WHERE ${u.and(L(n).map(([e, t]) => u`${u(e)} = ${t}`))}`), m = a ? o.provideService(p, this.sql.transactionService, a) : p, h = (await this.runtime.runPromise(m))[0];
+		if (!h) return null;
+		let _ = this.decodeWritten(t, h);
 		return await this.routeEvent({
 			table: t,
 			op: "update",
 			old: null,
 			new: _
-		}, s, o, c), _;
+		}, s, a, c), _;
 	}
-	async executeDelete(t, n, r, i, o) {
-		let s = this.sql, c = e(s, this.nsT(t), (e) => s`DELETE FROM ${s(this.nsT(t))} OUTPUT DELETED.* INTO ${e} WHERE ${s.and(I(n).map(([e, t]) => s`${s(e)} = ${t}`))}`), l = r ? a.provideService(c, this.sql.transactionService, r) : c, u = (await this.runtime.runPromise(l))[0];
+	async executeDelete(t, n, r, i, a) {
+		let s = this.sql, c = e(s, this.nsT(t), (e) => s`DELETE FROM ${s(this.nsT(t))} OUTPUT DELETED.* INTO ${e} WHERE ${s.and(L(n).map(([e, t]) => s`${s(e)} = ${t}`))}`), l = r ? o.provideService(c, this.sql.transactionService, r) : c, u = (await this.runtime.runPromise(l))[0];
 		if (!u) return !1;
 		let d = this.decodeWritten(t, u);
 		return await this.routeEvent({
@@ -113,21 +113,21 @@ var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
 			op: "delete",
 			old: d,
 			new: null
-		}, i, r, o), !0;
+		}, i, r, a), !0;
 	}
 	async appendInTxn(e, t, n) {
-		let r = this.sql, i = r`INSERT INTO ${r(this.nsT(e))} ${r.insert(S(t, e))}`;
-		await this.runtime.runPromise(n ? a.provideService(i, this.sql.transactionService, n) : i);
+		let r = this.sql, i = r`INSERT INTO ${r(this.nsT(e))} ${r.insert(C(t, e))}`;
+		await this.runtime.runPromise(n ? o.provideService(i, this.sql.transactionService, n) : i);
 	}
 	async maxInTxn(e, t, n, r) {
-		let i = this.sql, o = Object.entries(n).map(([e, t]) => i`${i(e)} = ${t}`), s = i`SELECT MAX(${i(t)}) AS ${i("m")} FROM ${i(this.nsT(e))} WHERE ${i.and(o)}`, c = (await this.runtime.runPromise(r ? a.provideService(s, this.sql.transactionService, r) : s))[0]?.m;
+		let i = this.sql, a = Object.entries(n).map(([e, t]) => i`${i(e)} = ${t}`), s = i`SELECT MAX(${i(t)}) AS ${i("m")} FROM ${i(this.nsT(e))} WHERE ${i.and(a)}`, c = (await this.runtime.runPromise(r ? o.provideService(s, this.sql.transactionService, r) : s))[0]?.m;
 		return c == null ? null : Number(c);
 	}
 	async routeEvent(e, t, n = null, r) {
 		e = {
-			...d(r),
+			...f(r),
 			...e
-		}, P(e.table) && await z({
+		}, F(e.table) && await B({
 			append: (e, t) => this.appendInTxn(e, t, n),
 			maxOf: (e, t, r) => this.maxInTxn(e, t, r, n)
 		}, {
@@ -137,7 +137,7 @@ var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
 			prev: e.old,
 			traceId: e.traceId,
 			subjectId: e.subjectId
-		}), T(e.table) && (t === null ? this.inlineEmit && this.emitter.emit("change", e) : t.push(e));
+		}), E(e.table) && (t === null ? this.inlineEmit && this.emitter.emit("change", e) : t.push(e));
 	}
 	integrityQuery(e) {
 		return this.query(e);
@@ -149,17 +149,17 @@ var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
 		return this.rawOn(e, null);
 	}
 	rawOn(e, t) {
-		let n = _(e, this.sql), r = t ? a.provideService(n, this.sql.transactionService, t) : n;
-		return k("mssql", "raw", () => this.runtime.runPromise(r));
+		let n = v(e, this.sql), r = t ? o.provideService(n, this.sql.transactionService, t) : n;
+		return A("mssql", "raw", () => this.runtime.runPromise(r));
 	}
 	async runWithEager(e, t) {
-		if (!w(e)) return this.executeQuery(e, t);
-		let n = this.namespace === null ? m(e, this.sql, "mssql") : null;
+		if (!T(e)) return this.executeQuery(e, t);
+		let n = this.namespace === null ? h(e, this.sql, "mssql") : null;
 		if (n !== null) try {
-			let e = t ? a.provideService(n.fragment, this.sql.transactionService, t) : n.fragment, r = await k("mssql", "select", () => this.runtime.runPromise(e));
+			let e = t ? o.provideService(n.fragment, this.sql.transactionService, t) : n.fragment, r = await A("mssql", "select", () => this.runtime.runPromise(e));
 			return n.decode(r);
 		} catch (t) {
-			if (t instanceof l) throw t;
+			if (t instanceof u) throw t;
 			this.reportEagerFallback({
 				dialect: "mssql",
 				table: e.table,
@@ -173,21 +173,21 @@ var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
 			reason: "not-compilable"
 		});
 		let r = await this.executeQuery(e, t);
-		return u(r, e.eager, e.sourceTable ?? F(e.table), (e) => this.executeQuery(e, t));
+		return d(r, e.eager, e.sourceTable ?? I(e.table), (e) => this.executeQuery(e, t));
 	}
 	getInternalRunWithEager() {
 		return this.runWithEager.bind(this);
 	}
 	localWrite(e, t, n) {
-		let r = (e) => P(t) ? this.writeWithRecorders(n, e) : n(e, null, null);
-		return k("mssql", e, () => W(r));
+		let r = (e) => F(t) ? this.writeWithRecorders(n, e) : n(e, null, null);
+		return A("mssql", e, () => G(r));
 	}
 	async writeWithRecorders(e, t) {
-		let n = [], r = this.sql, i = await this.runtime.runPromise(r.withTransaction(a.flatMap(a.serviceOption(this.sql.transactionService), (r) => c.isNone(r) ? a.fail(/* @__PURE__ */ Error("MssqlStore.write: TransactionConnection missing.")) : a.tryPromise({
+		let n = [], r = this.sql, i = await this.runtime.runPromise(r.withTransaction(o.flatMap(o.serviceOption(this.sql.transactionService), (r) => l.isNone(r) ? o.fail(/* @__PURE__ */ Error("MssqlStore.write: TransactionConnection missing.")) : o.tryPromise({
 			try: () => e(t, r.value, n),
 			catch: (e) => e
 		}))));
-		return x(n, (e) => this.emitChange(e)), i;
+		return S(n, (e) => this.emitChange(e)), i;
 	}
 	insert(e, t) {
 		return this.localWrite("insert", e, (n, r, i) => this.executeInsert(e, t, r, i, n));
@@ -210,32 +210,32 @@ var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
 	deleteMany(e, t) {
 		return this.executeDeleteMany(e, t, null, null);
 	}
-	async executeUpdateMany(t, n, r, i, o, s) {
-		let c = this.sql, l = g(r.where, c, this.namespace), u = c.update(S(n, t));
-		if (!G(t)) return this.countWritten(c`UPDATE ${c(this.nsT(t))} SET ${u} WHERE ${l}`, "update", i);
-		let d = e(c, this.nsT(t), (e) => c`UPDATE ${c(this.nsT(t))} SET ${u} OUTPUT INSERTED.* INTO ${e} WHERE ${l}`), f = i ? a.provideService(d, this.sql.transactionService, i) : d, p = await k("mssql", "update", () => this.runtime.runPromise(f));
-		for (let e of y(p, t, "mssql")) await this.routeEvent({
+	async executeUpdateMany(t, n, r, i, a, s) {
+		let c = this.sql, l = _(r.where, c, this.namespace), u = c.update(C(n, t));
+		if (!K(t)) return this.countWritten(c`UPDATE ${c(this.nsT(t))} SET ${u} WHERE ${l}`, "update", i);
+		let d = e(c, this.nsT(t), (e) => c`UPDATE ${c(this.nsT(t))} SET ${u} OUTPUT INSERTED.* INTO ${e} WHERE ${l}`), f = i ? o.provideService(d, this.sql.transactionService, i) : d, p = await A("mssql", "update", () => this.runtime.runPromise(f));
+		for (let e of b(p, t, "mssql")) await this.routeEvent({
 			table: t,
 			op: "update",
 			old: null,
 			new: e
-		}, o, i, s);
+		}, a, i, s);
 		return p.length;
 	}
 	async countWritten(e, t, n) {
-		let r = this.sql`${e}; SELECT @@ROWCOUNT AS n`, i = n ? a.provideService(r, this.sql.transactionService, n) : r, [o] = await k("mssql", t, () => this.runtime.runPromise(i));
-		return Number(o?.n ?? 0);
-	}
-	async executeDeleteMany(t, n, r, i, o) {
-		let s = this.sql, c = g(n.where, s, this.namespace);
-		if (!G(t)) return this.countWritten(s`DELETE FROM ${s(this.nsT(t))} WHERE ${c}`, "delete", r);
-		let l = e(s, this.nsT(t), (e) => s`DELETE FROM ${s(this.nsT(t))} OUTPUT DELETED.* INTO ${e} WHERE ${c}`), u = r ? a.provideService(l, this.sql.transactionService, r) : l, d = await k("mssql", "delete", () => this.runtime.runPromise(u));
-		for (let e of y(d, t, "mssql")) await this.routeEvent({
+		let r = (0, this.sql)`${e}; SELECT @@ROWCOUNT AS n`, i = n ? o.provideService(r, this.sql.transactionService, n) : r, [a] = await A("mssql", t, () => this.runtime.runPromise(i));
+		return Number(a?.n ?? 0);
+	}
+	async executeDeleteMany(t, n, r, i, a) {
+		let s = this.sql, c = _(n.where, s, this.namespace);
+		if (!K(t)) return this.countWritten(s`DELETE FROM ${s(this.nsT(t))} WHERE ${c}`, "delete", r);
+		let l = e(s, this.nsT(t), (e) => s`DELETE FROM ${s(this.nsT(t))} OUTPUT DELETED.* INTO ${e} WHERE ${c}`), u = r ? o.provideService(l, this.sql.transactionService, r) : l, d = await A("mssql", "delete", () => this.runtime.runPromise(u));
+		for (let e of b(d, t, "mssql")) await this.routeEvent({
 			table: t,
 			op: "delete",
 			old: e,
 			new: null
-		}, i, r, o);
+		}, i, r, a);
 		return d.length;
 	}
 	upsert(e, t, n) {
@@ -248,24 +248,24 @@ var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
 		return this.localWrite("upsert", e, (r, i, a) => this.executeInsertIgnore(e, t, n, i, a, r));
 	}
 	async executeUpsert(e, n, r, i, a, o) {
-		if (U(r), n = B(e, n), typeof r.update != "function" && r.conflictColumns.length > 0) return this.mergeUpsert(e, n, {
+		if (W(r), n = V(e, n), typeof r.update != "function" && r.conflictColumns.length > 0) return this.mergeUpsert(e, n, {
 			conflictColumns: r.conflictColumns,
 			...r.update === void 0 ? {} : { update: r.update },
 			...r.updateValues === void 0 ? {} : { updateValues: r.updateValues }
 		}, i, a, o);
 		let s = await this.findByConflict(e, n, r.conflictColumns, i);
-		if (s) return await this.executeUpdate(e, Object.fromEntries(r.conflictColumns.map((e) => [e, s[e]])), H(n, s, r), i, a, o) ?? s;
+		if (s) return await this.executeUpdate(e, Object.fromEntries(r.conflictColumns.map((e) => [e, s[e]])), U(n, s, r), i, a, o) ?? s;
 		try {
 			return await this.executeInsert(e, n, i, a, o);
 		} catch (s) {
 			if (!t(s)) throw s;
 			let c = await this.findByConflict(e, n, r.conflictColumns, i);
 			if (!c) throw s;
-			return await this.executeUpdate(e, Object.fromEntries(r.conflictColumns.map((e) => [e, c[e]])), H(n, c, r), i, a, o) ?? c;
+			return await this.executeUpdate(e, Object.fromEntries(r.conflictColumns.map((e) => [e, c[e]])), U(n, c, r), i, a, o) ?? c;
 		}
 	}
-	async mergeUpsert(t, n, r, i, o, s) {
-		let c = this.sql, l = Object.keys(n), u = Array.isArray(r.update) ? r.update.filter((e) => l.includes(e)) : l.filter((e) => e !== "id" && !r.conflictColumns.includes(e)), d = S(n, t), f = l.map((e) => c`${d[e]}`), p = l.map((e) => c`${c(e)}`), m = r.conflictColumns.map((e) => c`tgt.${c(e)} = src.${c(e)}`), h = l.map((e) => c`${c(e)}`), g = l.map((e) => c`src.${c(e)}`), _ = U(r), v = S(_, t), y = [...u.filter((e) => !Object.hasOwn(_, e)).map((e) => c`tgt.${c(e)} = src.${c(e)}`), ...Object.entries(v).map(([e, t]) => c`tgt.${c(e)} = ${t}`)];
+	async mergeUpsert(t, n, r, i, a, s) {
+		let c = this.sql, l = Object.keys(n), u = Array.isArray(r.update) ? r.update.filter((e) => l.includes(e)) : l.filter((e) => e !== "id" && !r.conflictColumns.includes(e)), d = C(n, t), f = l.map((e) => c`${d[e]}`), p = l.map((e) => c`${c(e)}`), m = r.conflictColumns.map((e) => c`tgt.${c(e)} = src.${c(e)}`), h = l.map((e) => c`${c(e)}`), g = l.map((e) => c`src.${c(e)}`), _ = W(r), v = C(_, t), y = [...u.filter((e) => !Object.hasOwn(_, e)).map((e) => c`tgt.${c(e)} = src.${c(e)}`), ...Object.entries(v).map(([e, t]) => c`tgt.${c(e)} = ${t}`)];
 		y.length === 0 && y.push(c`tgt.${c(r.conflictColumns[0])} = src.${c(r.conflictColumns[0])}`);
 		let b = e(c, this.nsT(t), (e) => c`
       MERGE ${c(this.nsT(t))} WITH (HOLDLOCK) AS tgt
@@ -273,18 +273,18 @@ var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
       ON ${c.and(m)}
       WHEN MATCHED THEN UPDATE SET ${c.csv(y)}
       WHEN NOT MATCHED THEN INSERT (${c.csv(h)}) VALUES (${c.csv(g)})
-      OUTPUT $action AS ${c("__action")}, INSERTED.* INTO ${e};`, !0), x = i ? a.provideService(b, this.sql.transactionService, i) : b, C = (await this.runtime.runPromise(x))[0];
-		if (!C) throw Error(`MssqlStore.upsert: MERGE returned no row for '${t}'`);
-		let w = C.__action, { __action: T, ...E } = C, D = this.decodeWritten(t, E);
+      OUTPUT $action AS ${c("__action")}, INSERTED.* INTO ${e};`, !0), x = i ? o.provideService(b, this.sql.transactionService, i) : b, S = (await this.runtime.runPromise(x))[0];
+		if (!S) throw Error(`MssqlStore.upsert: MERGE returned no row for '${t}'`);
+		let w = S.__action, { __action: T, ...E } = S, D = this.decodeWritten(t, E);
 		return await this.routeEvent({
 			table: t,
 			op: w === "INSERT" ? "insert" : "update",
 			old: null,
 			new: D
-		}, o, i, s), D;
+		}, a, i, s), D;
 	}
 	async executeInsertIgnore(e, n, r, i, a, o) {
-		n = B(e, n);
+		n = V(e, n);
 		let s = await this.findByConflict(e, n, r.conflictColumns, i);
 		if (s) return {
 			row: s,
@@ -307,7 +307,7 @@ var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
 	}
 	async findByConflict(e, t, n, r) {
 		if (n.length === 0) return;
-		let i = this.sql, o = n.map((e) => i`${i(e)} = ${t[e]}`), s = i`SELECT TOP 1 * FROM ${i(this.nsT(e))} WHERE ${i.and(o)}`, c = r ? a.provideService(s, this.sql.transactionService, r) : s, l = (await this.runtime.runPromise(c))[0];
+		let i = this.sql, a = n.map((e) => i`${i(e)} = ${t[e]}`), s = i`SELECT TOP 1 * FROM ${i(this.nsT(e))} WHERE ${i.and(a)}`, c = r ? o.provideService(s, this.sql.transactionService, r) : s, l = (await this.runtime.runPromise(c))[0];
 		return l ? this.decodeWritten(e, l) : void 0;
 	}
 	emitChange(e) {
@@ -317,7 +317,7 @@ var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
 		if (this.cdcHandle) return;
 		this.cdcReplicaId = e.replicaId;
 		let t = e.includeTables ?? [];
-		t.length === 0 && Y.warn("cdc: no reactive tables to tail; Change Tracking reader idle. Set includeTables to enable.");
+		t.length === 0 && X.warn("cdc: no reactive tables to tail; Change Tracking reader idle. Set includeTables to enable.");
 		let n = await this.readCdcOffset(e.replicaId);
 		this.cdcHandle = await r({
 			run: this.__mssqlReplicationFriend.runEffect,
@@ -327,9 +327,9 @@ var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
 			onVersion: (e) => {
 				this.cdcPendingVersion = e;
 			},
-			onError: (e) => Y.warn("cdc: consumer error", {}, e),
+			onError: (e) => X.warn("cdc: consumer error", {}, e),
 			onResync: () => {
-				Y.warn("cdc: resynced to current CT version after retention gap — subscriptions self-heal on the next change");
+				X.warn("cdc: resynced to current CT version after retention gap — subscriptions self-heal on the next change");
 			}
 		}), this.cdcCheckpointTimer = setInterval(() => {
 			this.flushCdcOffset();
@@ -340,12 +340,12 @@ var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
 			let t = this.sql, n = (await this.runtime.runPromise(t`
           SELECT TOP 1 ${t("ctVersion")} FROM ${t(i)}
           WHERE ${t("id")} = ${e}`))[0]?.ctVersion;
-			return n ? (Y.info("cdc: resuming from persisted CT version", {
+			return n ? (X.info("cdc: resuming from persisted CT version", {
 				replicaId: e,
 				version: n
 			}), n) : null;
 		} catch (t) {
-			return Y.warn("cdc: no readable offset; starting at current CT version", { replicaId: e }, t), null;
+			return X.warn("cdc: no readable offset; starting at current CT version", { replicaId: e }, t), null;
 		}
 	}
 	async flushCdcOffset() {
@@ -365,7 +365,7 @@ var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
 					update: ["ctVersion", "updatedAt"]
 				}, null, null);
 			} catch (t) {
-				this.cdcPendingVersion = e, Y.warn("cdc: checkpoint write failed", {}, t);
+				this.cdcPendingVersion = e, X.warn("cdc: checkpoint write failed", {}, t);
 			}
 		}
 	}
@@ -420,16 +420,16 @@ var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
 	}
 	async emptyTablesOn(e, t) {
 		if (e.length === 0) return;
-		let n = this.sql, r = (e) => this.nsT(e), i = (e, t) => n.unsafe(`ALTER TABLE ${M(r(e), "mssql")} ${t ? "WITH CHECK CHECK" : "NOCHECK"} CONSTRAINT ALL`), o = a.acquireUseRelease(a.forEach(e, (e) => i(e, !1), { discard: !0 }), () => a.forEach(e, (e) => n`DELETE FROM ${n(r(e))}`, { discard: !0 }), () => a.orDie(a.ignore(a.forEach(e, (e) => i(e, !0), { discard: !0 })))), s = t === null ? n.withTransaction(o) : a.provideService(o, this.sql.transactionService, t);
+		let n = this.sql, r = (e) => this.nsT(e), i = (e, t) => n.unsafe(`ALTER TABLE ${N(r(e), "mssql")} ${t ? "WITH CHECK CHECK" : "NOCHECK"} CONSTRAINT ALL`), a = o.acquireUseRelease(o.forEach(e, (e) => i(e, !1), { discard: !0 }), () => o.forEach(e, (e) => n`DELETE FROM ${n(r(e))}`, { discard: !0 }), () => o.orDie(o.ignore(o.forEach(e, (e) => i(e, !0), { discard: !0 })))), s = t === null ? n.withTransaction(a) : o.provideService(a, this.sql.transactionService, t);
 		await this.runtime.runPromise(s);
 	}
 	async transactional(e) {
 		this.inflightTxns++;
 		try {
-			return await R({
+			return await z({
 				...this.txnSpec("MssqlStore.transactional"),
 				work: e,
-				makeView: (e, t) => new Q(this, e, t)
+				makeView: (e, t) => new $(this, e, t)
 			});
 		} finally {
 			this.inflightTxns--;
@@ -464,7 +464,7 @@ var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
 		return this.changeStrategy === "cdc" ? "fleet" : "local";
 	}
 	injectExternalChange(e) {
-		T(e.table) && this.emitter.emit("change", C(e));
+		E(e.table) && this.emitter.emit("change", w(e));
 	}
 	run(e) {
 		return this.runtime.runPromise(e);
@@ -477,7 +477,7 @@ var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
 		if (this.inflightTxns > 0) {
 			let t = Date.now() + e;
 			for (; this.inflightTxns > 0 && Date.now() < t;) await new Promise((e) => setTimeout(e, 25));
-			this.inflightTxns > 0 && Y.warn("close: grace period expired with in-flight transactions", {
+			this.inflightTxns > 0 && X.warn("close: grace period expired with in-flight transactions", {
 				gracePeriodMs: e,
 				inflight: this.inflightTxns
 			});
@@ -487,12 +487,12 @@ var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
 	async ping() {
 		await this.runtime.runPromise(this.sql`SELECT 1`);
 	}
-}, Q = class {
+}, $ = class {
 	parent;
 	txn;
 	attr;
 	events = [];
-	aborts = O((e) => n(e));
+	aborts = k((e) => n(e));
 	committed = !1;
 	constructor(e, t, n = void 0) {
 		this.parent = e, this.txn = t, this.attr = n;
@@ -500,11 +500,11 @@ var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
 	async savepoint(e) {
 		let t = this.events.length;
 		try {
-			return await L({
+			return await R({
 				tracker: this.aborts,
 				name: `voltro_sp_${++this.savepointCounter}`,
 				spelling: "mssql",
-				exec: (e) => this.parent.run(a.provideService(J.pipe(a.flatMap((t) => t.unsafe(e))), this.parent.transactionService, this.txn))
+				exec: (e) => this.parent.run(o.provideService(Y.pipe(o.flatMap((t) => t.unsafe(e))), this.parent.transactionService, this.txn))
 			}, e);
 		} catch (e) {
 			throw this.events.length = t, e;
@@ -512,7 +512,7 @@ var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
 	}
 	savepointCounter = 0;
 	run(e) {
-		return this.aborts.track(() => this.parent.run(A(e, this.parent.transactionService, this.txn)));
+		return this.aborts.track(() => this.parent.run(j(e, this.parent.transactionService, this.txn)));
 	}
 	abortedBy() {
 		return this.aborts.abortedBy();
@@ -569,8 +569,7 @@ var Y = q({ scope: "voltro:mssql" }), X = async (e) => {
 		throw Error("MssqlTransactionalView.injectExternalChange: not supported inside a transaction.");
 	}
 	commitEvents() {
-		this.committed || (this.committed = !0, x(this.events, (e) => this.parent.emitChange(e)), this.events.length = 0);
+		this.committed || (this.committed = !0, S(this.events, (e) => this.parent.emitChange(e)), this.events.length = 0);
 	}
 };
-//#endregion
-export { Z as MssqlStore, X as makeMssqlStore };
+export { Q as MssqlStore, Z as makeMssqlStore };

package/dist/writeOutput.js

@@ -1,6 +1,6 @@
 import { mssqlRowResultProjection as e, readMssqlPhysicalColumns as t } from "./rowResultProjection.js";
 import { Effect as n } from "effect";
-//#region src/writeOutput.ts
+// src/writeOutput.ts
 var r = (r, i, a, o = !1) => n.uninterruptible(n.gen(function* () {
 	let n = r.literal("[#voltro_write_output]"), s = yield* t(r, i), c = r.join(", ", !1)(s.map((e) => {
 		let t = r.literal(`[${e.name.replaceAll("]", "]]")}]`);
@@ -14,5 +14,4 @@ var r = (r, i, a, o = !1) => n.uninterruptible(n.gen(function* () {
     DROP TABLE ${n};
   `;
 }));
-//#endregion
 export { r as writeOutput };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/sql-mssql",
-  "version": "0.87.0",
+  "version": "0.88.0",
   "description": "SQL Server (mssql) dialect adapter for Voltro's cross-dialect DataStore (OUTPUT-clause returning, OFFSET/FETCH paging, inline reactivity).",
   "keywords": [
     "voltro",
@@ -33,13 +33,13 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@effect/sql-mssql": "4.0.1",
-    "@voltro/database": "0.87.0",
-    "@voltro/logger": "0.87.0",
-    "tedious": "20.3.3"
+    "@effect/sql-mssql": "4.1.0",
+    "@voltro/database": "0.88.0",
+    "@voltro/logger": "0.88.0",
+    "tedious": "20.3.8"
   },
   "peerDependencies": {
-    "effect": "4.0.1"
+    "effect": "4.1.0"
   },
   "publishConfig": {
     "access": "public"