@effect-app/vue 4.0.0-beta.99 → 4.0.0

package/docs/atom-query-api-redesign.md

@@ -0,0 +1,207 @@
+# Atom query API redesign
+
+This branch can stop treating Effect atoms as an implementation detail hidden behind a TanStack-shaped API. The useful durable primitive is the atom; Vue refs, suspense promises, refetch helpers, and future hydration should all be adapters around it.
+
+## Source findings
+
+Relevant upstream Effect v4 atom APIs checked locally:
+
+- `repos/effect/packages/effect/src/unstable/reactivity/Atom.ts`
+  - `AtomRuntime.atom` turns an `Effect` into `Atom<AsyncResult<A, E>>`.
+  - `Atom.family` gives structural cache identity by input.
+  - `Atom.swr`, `Atom.withRefresh`, `Atom.setIdleTTL`, and `Atom.keepAlive` already model stale reads, polling, idle lifetime, and keep-alive.
+  - `Atom.mapResult` and `Atom.transform` are the right composition layer for `select` and derived queries.
+  - `Atom.optimistic` / `Atom.optimisticFn` can replace our current no-op optimistic `useUpdateQuery` facade.
+  - `Atom.toStreamResult`, `Atom.getResult`, `Atom.refresh`, and `Atom.mount` provide Effect-native conversion points.
+- `repos/effect/packages/effect/src/unstable/reactivity/AtomRegistry.ts`
+  - `getResult(registry, atom, { suspendOnWaiting: true })` is the precise operation we need for awaitable refetch and Vue suspense.
+  - Registries are independent; relying on the module-global `defaultRegistry` leaks a policy decision into the query engine.
+- `repos/effect/packages/effect/src/unstable/reactivity/AtomRpc.ts`
+  - Upstream RPC integration exposes `query(tag, payload)` as an atom and `mutation(tag)` as an atom result function. This is the shape we should mirror for effect-app clients.
+- `repos/effect/packages/effect/src/unstable/reactivity/Hydration.ts`
+  - Serializable atoms support `dehydrate` / `hydrate`; Nuxt SSR can use that later without inventing query-specific prefetch state.
+- `repos/effect/packages/atom/vue/src/index.ts`
+  - Vue integration is intentionally thin: `useAtomValue`, `useAtom`, `injectRegistry`, `registryKey`.
+  - There is no special query abstraction upstream; the app layer should own the ergonomic client API.
+
+## Current problems
+
+- `query.ts` still exposes TanStack vocabulary and types: `UseQueryReturnType`, `QueryObserverResult`, `RefetchOptions`, `initialData`, `placeholderData`, `gcTime`, `refetchInterval`, and tuple returns.
+- The raw query atom is hidden in the fourth tuple slot. That makes composition awkward and encourages helper APIs to tunnel through private handles.
+- Query family identity must be stable by query key plus projection hash, while observer options stay outside the family. Otherwise projected and unprojected clients can accidentally share a base atom.
+- `useUpdateQuery` accepts an updater but cannot apply it because query atoms are read-only derived atoms there; it currently refreshes and ignores the updater.
+- Legacy stream query `.query()` is still collapsed into `Stream.runCollect`, so the compatibility API behaves like a slow normal query. Stream query clients now also expose atom-native `.atom()`, `.family()`, and `.queryNew()` helpers backed by `Atom.pull`, so new call sites can observe incremental pull state without waiting for stream completion.
+- The default atom registry is used in invalidation-await logic. That works for today but blocks scoped registries, SSR hydration, and tests that provide a custom registry.
+
+## Compatibility boundary
+
+Keep the existing public APIs intact while the internals move to atom-native composition:
+
+- `client.X.query(...)` keeps its current tuple return shape.
+- `client.X.suspense(...)` keeps returning a Promise of that tuple shape.
+- Existing options remain accepted on old APIs, but their behavior should be fixed internally. In particular, handler-global base atoms should be shared, while observer-specific behavior such as `select`, polling, SWR/focus policy, and structural sharing is layered on top.
+
+Only expose breaking or meaningfully different APIs under new names:
+
+- `client.X.atom(input, options?)`
+- `client.X.queryNew(input, options?)`
+- `client.X.suspenseNew(input, options?)`
+
+This lets the app test the new shape in real call sites without forcing a broad migration, and lets old API users benefit from the internal option-sharing fix.
+
+## Target client shape
+
+Keep query helpers on the typed clients, like mutations:
+
+```ts
+const atom = client.Carts.List.atom(input, options)
+const query = client.Carts.List.queryNew(input, options)
+const suspense = await client.Carts.List.suspenseNew(input, options)
+```
+
+`suspenseNew` stays a `Promise`, because Vue setup / Suspense wants a Promise boundary.
+
+The proposed breaking return shape is an object:
+
+```ts
+interface QueryView<A, E> {
+  readonly result: ComputedRef<AsyncResult.AsyncResult<A, E>>
+  readonly data: ComputedRef<A | undefined>
+  readonly atom: ComputedRef<Atom.Atom<AsyncResult.AsyncResult<A, E>>>
+  readonly awaitResult: () => Effect.Effect<A, E, never>
+  readonly refetch: () => Effect.Effect<A, E, never>
+  readonly refresh: () => void
+}
+
+interface SuspenseQueryView<A, E> extends Omit<QueryView<A, E>, "data"> {
+  readonly data: ComputedRef<A>
+}
+```
+
+`queryNew()` returns `QueryView<A, E>`. `suspenseNew()` returns `Promise<SuspenseQueryView<A, E>>`.
+
+This removes tuple slot meaning, makes `refetch` obviously awaitable, and exposes the atom for composition.
+
+## Atom-first internals
+
+Split the implementation into two layers:
+
+- `atomQuery.ts`: build and compose atoms.
+  - `queryAtom(handler, input, options)` returns `Atom<AsyncResult<A, E>>`.
+  - `queryFamily(handler)` is stable by query key plus projection hash and does not capture observer options.
+  - `awaitQueryAtom(registry, atom)` delegates to `AtomRegistry.getResult`.
+  - `refreshQueryAtom(registry, atom)` delegates to `registry.refresh`.
+- `query.ts`: Vue adapter only.
+  - Resolve refs/getters/options.
+  - Call `useAtomValue`.
+  - Return `QueryView` / `SuspenseQueryView`.
+  - Convert to Promise only inside `useSuspenseQuery`.
+
+Options that affect a single observer should wrap the shared raw atom rather than mutate handler-family identity:
+
+```ts
+const raw = family(input)
+const selected = select ? Atom.mapResult(raw, select) : raw
+const refreshed = refreshEvery
+  ? Atom.withRefresh(refreshEvery)(selected)
+  : selected
+const viewed = Atom.swr({ staleTime, revalidateOnFocus, focusSignal })(
+  refreshed
+)
+```
+
+TTL is the awkward option. If TTL is part of the base atom, it should be a client/default policy, not the first observer's option. For old APIs, keep accepting `gcTime`, but normalize it into a base-atom policy that cannot be captured accidentally by the first observer. For new APIs, prefer an atom-native `idleTTL` or `timeToLive` name.
+
+## TanStack parity: observers, TTL, and cancellation
+
+Observer cleanup and cache lifetime are separate concerns:
+
+- Vue observers are registered through `@effect/atom-vue`'s `useAtomValue`, which uses a Vue `watchEffect` cleanup around `registry.subscribe`. Non-suspense component unmounts therefore remove observer subscriptions through normal Vue scope disposal.
+- Suspense helpers still load through native query atoms. The `Promise` returned by `.suspense()` / `.suspenseNew()` is only the Vue Suspense boundary that waits for `AtomRegistry.getResult`. Suspense setup runs in an explicit child `effectScope`; unmount stops that scope, removes the observer subscription, and aborts the waiting Effect so the Suspense Promise does not remain pending after the component is gone.
+- Observer-specific wrappers (`select`, SWR, focus revalidation, polling, structural sharing) must not get their own idle TTL. Otherwise a wrapper can keep source atoms observed after the component unmounts. TTL belongs to the canonical handler+input query atom.
+- The canonical query atom keeps its configured idle TTL after the last observer is gone. This preserves cached data and lets invalidation still reach cached-but-unmounted queries during the idle window.
+
+Current difference from TanStack Query:
+
+- TanStack creates an `AbortSignal` for each fetch. When the last observer is removed, it cancels the active retryer only if the query function consumed the signal; otherwise it cancels retries and lets the in-flight request finish so the result can populate cache.
+- Atom query currently does not cancel the canonical query atom's in-flight Effect merely because the last observer unmounted, because the canonical atom node can remain alive for `idleTTL`.
+- If canonical fetch cancellation is added later, it must match TanStack's observable state semantics: cancellation is control flow, not query data. Interrupting an in-flight fetch must not store an interrupt cause as the final `AsyncResult`; it should revert to the previous settled state, or to initial/idle when there is no previous result.
+- The desired parity target is: last observer gone -> remove observer subscriptions immediately; if no observers remain, interrupt the active fetch without recording an interrupt failure; keep the previous cached result until `idleTTL` expires.
+
+## Option names
+
+Use atom-native names on the new APIs. Keep old option names on old APIs:
+
+- `gcTime` -> `idleTTL` or `timeToLive`
+- `refetchInterval` -> `refreshEvery`
+- `refetchOnWindowFocus` -> `revalidateOnFocus`
+- `select` can stay; it is a familiar projection name and maps cleanly to `Atom.mapResult`.
+- Drop `initialData` and `placeholderData` from the new core API. Keep them accepted by old APIs if compatibility requires it, but implement them as wrappers/fallbacks over atoms rather than query-engine state.
+
+## Composition API
+
+Expose enough atoms that app code can compose before Vue refs:
+
+```ts
+const cartsAtom = client.Carts.List.atom(undefined)
+const spotsAtom = client.Spots.List.atom(undefined)
+
+const pageAtom = Atom.make((get) => ({
+  carts: get.result(cartsAtom, { suspendOnWaiting: true }),
+  spots: get.result(spotsAtom, { suspendOnWaiting: true })
+}))
+```
+
+For plain result composition, add an atom-native replacement for `composeQueries`:
+
+```ts
+const combined = composeQueryAtoms({
+  carts: client.Carts.List.atom(undefined),
+  spots: client.Spots.List.atom(undefined)
+})
+```
+
+The existing `composeQueries` can remain as a Vue-ref convenience wrapper during migration.
+
+## Optimistic updates
+
+Replace `useUpdateQuery(query, input, updater)` with atom-level helpers:
+
+```ts
+const carts = client.Carts.List.optimistic(input)
+const updateCart = client.Carts.Update.optimistic(carts, reducer)
+```
+
+Internally this should use `Atom.optimistic` / `Atom.optimisticFn`, not a manual cache patch. The mutation can still invalidate reactivity keys after success; optimistic atoms handle temporary UI state and rollback.
+
+## Registry and full-stack notes
+
+- The frontend plugin should provide an app-level `AtomRegistry` via `registryKey` instead of relying on `@effect/atom-vue`'s fallback `defaultRegistry`.
+- `invalidateAndAwait` should await against the active registry, not a module global. A registry-aware mutation layer is cleaner than hidden global state.
+- Serializable query atoms can unlock Nuxt SSR hydration later:
+  - mark query atoms with `Atom.serializable` using request schema + stable input key,
+  - dehydrate after server setup,
+  - hydrate the client registry before mounting.
+- Stream query clients expose pull atoms for real progress:
+  - `client.Progress.Stream.atom(input)` returns `Atom.Writable<Atom.PullResult<A, E>, void>`,
+  - `client.Progress.Stream.family()` returns the reusable atom family,
+  - `client.Progress.Stream.queryNew(input)` returns a Vue view with `result`, `items`, `latest`, `done`, `pull`, and `pullAndAwait`.
+  - Legacy `.query()` remains collect-to-array compatibility until call sites migrate.
+
+## Migration plan
+
+1. Refactor internals so a base query atom is shared per handler+input, then old and new APIs layer observer options on top. This fixes old API behavior without changing old API shape.
+2. Add `client.X.atom(input, options?)`, `client.X.queryNew(input, options?)`, and `client.X.suspenseNew(input, options?)`. Update type tests to assert atom exposure and object-return typing.
+3. Keep `.query()` and `.suspense()` as compatibility APIs. They can delegate to the new internal engine and adapt the result back to tuple shape.
+4. Add one or two real frontend example conversions to `queryNew` / `suspenseNew`, preferably places that exercise:
+   - a suspense read with `data` and `result`,
+   - an awaitable `refetch`,
+   - optionally `atom` composition if a small call site exists.
+5. Keep most frontend call sites on the old tuple APIs so both surfaces are exercised during the transition.
+6. Replace `useUpdateQuery` call sites with atom refresh or optimistic helpers after the new query surface proves out.
+7. Convert legacy stream query call sites from collect-to-array `.query()` to pull/accumulating `.queryNew()` / `.atom()` APIs.
+8. Add registry provider + hydration experiments after the client API is stable.
+
+## Recommendation
+
+Do direct atom exposure and the breaking object API together, but under additive names first. Keep `suspense()` as the compatibility Promise tuple and add `suspenseNew()` as the Promise object API. The Promise should remain a framework boundary over `AtomRegistry.getResult`, not the internal shape. The API should make the atom visible, because that is where Effect v4 gives us composition, refresh, hydration, streams, and optimistic state.

package/docs/mutation-command-atoms.md

@@ -0,0 +1,40 @@
+# Mutation and command atoms
+
+Keep query and cache state atom-native. Keep ordinary mutations Effect-based and wrap them in `Command` when they need UI state. Use an atom-backed mutation only when its state is itself shared application state.
+
+## Why
+
+Query state is durable, keyed by handler and input, shared across components, and refreshed by invalidation. Command state usually belongs to one invocation: `waiting`, `blocked`, progress, errors, toasts, and follow-up Effects.
+
+`makeMutation` already records invalidation keys and data-dependency writes, then awaits affected atom queries. A mutation does not need to be an atom for cache coherence.
+
+`Command.fn` and mutation `.wrap()` add action identity, local reactive state, error handling, confirmation, toasts, and stream progress around an Effect.
+
+## Prefer `Command`
+
+Use the existing Effect-based mutation path when:
+
+- The mutation returns `void` or a small value.
+- Its shared effect is query invalidation.
+- Only the initiating surface needs `waiting`, `blocked`, progress, or errors.
+- The result is immediately composed with validation, navigation, emitted events, or other Effects.
+- Nothing must observe the invocation after that surface unmounts.
+
+## Prefer an atom
+
+Use atom-backed mutation state when:
+
+- Distant components observe the same invocation.
+- State is keyed per entity and instances must be tracked independently.
+- Other atoms derive from the mutation state.
+- Long-running progress must survive component remounts.
+- Optimistic state belongs in the same graph as the canonical entity state.
+
+Effect provides `Atom.fn`, `AtomRuntime.fn`, and mutation helpers in `AtomRpc` and `AtomHttpApi`. These expose one `AsyncResult` state cell. Before using one as an application command, define its keying, lifetime, reset behavior, concurrency, and how individual callers receive results.
+
+## Recommended split
+
+1. Queries, entities, caches, and live projections: atoms.
+2. Cache invalidation: the existing atom-query invalidation path.
+3. Ordinary user actions: Effect-based mutations wrapped with `Command` as needed.
+4. Shared, keyed, or long-lived action state: an atom-backed command abstraction with explicit concurrency semantics.

package/docs/query-key-invalidation.md

@@ -0,0 +1,107 @@
+# Query-key invalidation semantics
+
+How the Atom query engine reproduces TanStack Query's **hierarchical (namespace) invalidation**, and where it intentionally differs.
+
+## The behavior we must match
+
+TanStack `queryClient.invalidateQueries({ queryKey: K })` defaults to `exact: false`:
+**K matches every query whose key has K as a prefix.**
+
+```
+invalidate ["A","B"]  ->  matches ["A","B"], ["A","B","C"], ["A","B",input], ...
+invalidate ["A","B","C"]  ->  does NOT match ["A","B"]   (K longer than the key)
+```
+
+Two requirements: don't invalidate **more** than TanStack would, and don't invalidate **less**.
+
+## How the Atom engine does it
+
+TanStack stores each full key and runs a prefix compare at invalidation time. The Atom
+engine inverts that: each query **pre-registers all prefixes of its full key**, and
+invalidation does an exact structural-hash lookup.
+
+- Full key: `fullKey = [...baseKey, input]` where `baseKey = makeQueryKey(self)` is the
+  hierarchical, input-independent namespace (e.g. `["$Project","$Configuration","get"]`).
+- On mount, the query atom registers `prefixesOf(fullKey)` — every non-empty prefix:
+
+  ```
+  ["$Project","$Configuration","get", input]
+    registers:
+      ["$Project"]
+      ["$Project","$Configuration"]
+      ["$Project","$Configuration","get"]
+      ["$Project","$Configuration","get", input]
+  ```
+
+  See `buildQueryFamily` → `prefixesOf` → `factory.withReactivity` in
+  [`src/atomQuery.ts`](../src/atomQuery.ts) (registration around L416-424).
+- Invalidation hashes K and fires the handlers registered under that exact hash
+  (`Reactivity.invalidate` → `keysToHashes` in
+  `repos/effect/packages/effect/src/unstable/reactivity/Reactivity.ts`).
+
+### Why this equals TanStack's match set
+
+```
+K matches a query
+  <=> K equals one of that query's registered prefixes
+  <=> K is a prefix of the query's full key
+```
+
+That is exactly TanStack's `exact:false` rule.
+
+- **Not too much** — `invalidate ["A","B"]` hits only queries whose full key starts with
+  `["A","B"]`. An over-specific K (longer than a query's key) matches nothing in both
+  systems, because a query never registers a prefix longer than itself.
+- **Not too little** — a short namespace `["A"]` reaches every query under it, because
+  each registered the `["A"]` prefix. The mutation default `getQueryKey`
+  (e.g. `["$Project"]`, `defaultGetQueryKey` in [`src/mutate.ts`](../src/mutate.ts)) is
+  always a leading prefix of `baseKey`, so default namespace invalidation reaches all
+  inputs and sub-resources.
+
+## Why multiple keys must be registered
+
+This is the crux. A single exact-key registration would only fire when invalidation used
+that exact key — losing TanStack's "parent namespace invalidates all children" behavior.
+Registering **every prefix** is what restores hierarchical reach under an exact-lookup
+mechanism. Drop a prefix and that namespace level stops invalidating its children
+(invalidates too little); register a key that isn't a prefix and it invalidates unrelated
+queries (too much).
+
+## Hashing consistency (register ↔ invalidate)
+
+Both sides route through `keysToHashes`, which hashes **each element** of the keys array:
+
+- Registration: `withReactivity(reactivityKeys)` → `registerUnsafe` — `reactivityKeys` is a
+  list of prefix-arrays, each hashed via `Hash.hash`.
+- Invalidation: mutations pass `ReadonlyArray<ReadonlyArray<unknown>>` — a _list of
+  key-arrays_ (`buildInvalidateCache` in [`src/mutate.ts`](../src/mutate.ts)) — so each
+  element is a full namespaced array, matching the registration shape.
+
+The await-tracking map (`keyAtoms` in `atomQuery.ts`) keys on the same `Hash.hash(key)`, so
+`invalidateAndAwait` resolves once exactly the matched live queries have settled.
+
+## Intentional differences / caveats
+
+1. **Hash-only matching, no equality fallback.** TanStack compares keys with
+   `partialDeepEqual`. The Atom path keys its handler map purely on `Hash.hash` with no
+   tiebreak. A hash collision between two distinct keys would cross-invalidate
+   (over-invalidate). Probability is low (array hashes combine element hashes) but it is
+   the one real semantic divergence from TanStack's exact compare. Same applies to
+   `keyAtoms` and `uniqueKeys`.
+2. **Input is one opaque trailing element** (`[...baseKey, input]`). You can invalidate at
+   any namespace granularity but not _within_ an input (no "all inputs where
+   status=active"). TanStack with the same key shape behaves identically — parity, just a
+   granularity ceiling.
+3. **O(depth) registrations per live query** (depth+1 prefixes, in both the reactivity
+   handler map and `keyAtoms`). Negligible at typical depths of 2-4.
+4. **Reaches only "alive" atoms** (mounted, or cached within `idleTTL`). `setIdleTTL` is
+   applied last in the atom chain so cached-but-unmounted queries stay registered.
+   Invalidation **marks** those idle entries stale (TanStack `refetchType: "active"`) and
+   **awaits** the refetch of any atom that still has observers. A query GC'd past idle TTL
+   is gone and refetches fresh on next mount — matching TanStack `gcTime` semantics.
+
+## Verdict
+
+Sound. The prefix-registration faithfully reproduces TanStack's hierarchical invalidation
+in both directions (not too much, not too little). The only behavioral gap is the
+theoretical hash-collision case in caveat 1.

package/examples/streamMutation.ts

@@ -0,0 +1,72 @@
+/**
+ * Example: stream-based mutation for a long-running operation.
+ *
+ * The server streams a tagged union of progress updates and a final result.
+ * The Vue ref is updated for every emitted value; `AsyncResult` stays in the
+ * `waiting` state until the stream ends.
+ *
+ * When using `makeClient` / `clientFor`, stream-type requests are exposed as
+ * `mutate` on the client object. Use `client.exportData.mutate` with `streamFn`
+ * combinators, or use `client.exportData.fn` to define a full command.
+ *
+ * The example below shows the low-level `asStreamResult` API.
+ */
+import * as Effect from "effect-app/Effect"
+import * as S from "effect-app/Schema"
+import * as Stream from "effect/Stream"
+import { asStreamResult } from "../src/mutate.js"
+
+// ---------------------------------------------------------------------------
+// Domain model
+// ---------------------------------------------------------------------------
+
+/** Intermediate progress report, e.g. "5 of 400 items processed". */
+export class OperationProgress extends S.TaggedClass<OperationProgress>()("OperationProgress", {
+  completed: S.NonNegativeInt,
+  total: S.NonNegativeInt
+}) {}
+
+/** The final result produced once the operation is complete. */
+export class ExportComplete extends S.TaggedClass<ExportComplete>()("ExportComplete", {
+  fileUrl: S.NonEmptyString
+}) {}
+
+/** Tagged union emitted by the stream. */
+export type ExportEvent = OperationProgress | ExportComplete
+
+// ---------------------------------------------------------------------------
+// Simulated stream (replace with a real RPC / SSE stream in production)
+// ---------------------------------------------------------------------------
+
+/**
+ * Produces `total` progress updates followed by a single `ExportComplete`.
+ * Each step is separated by a 50 ms delay to simulate real async work.
+ */
+const makeExportStream = (total: S.NonNegativeInt): Stream.Stream<ExportEvent> =>
+  Stream.concat(
+    Stream.range(1, total).pipe(
+      Stream.map((completed) => new OperationProgress({ completed: S.NonNegativeInt(completed), total })),
+      Stream.tap(() => Effect.sleep("50 millis"))
+    ),
+    Stream.make(new ExportComplete({ fileUrl: S.NonEmptyString("https://example.com/export.csv") }))
+  )
+
+// ---------------------------------------------------------------------------
+// Option A: low-level `asStreamResult` (call inside a `setup()` function)
+// ---------------------------------------------------------------------------
+
+export const useExportMutation = () => {
+  /**
+   * `result`   - reactive ref, always reflects the latest stream event.
+   *              `AsyncResult` tag:
+   *                - Initial (waiting=true)  - operation in progress
+   *                - Success (waiting=true)  - progress update received, still running
+   *                - Success (waiting=false) - final result, operation complete
+   *                - Failure                 - operation failed
+   *
+   * `execute`  - call with the desired `total` to kick off the stream.
+   */
+  const [result, execute] = asStreamResult((total: S.NonNegativeInt) => makeExportStream(total))
+
+  return { result, execute }
+}

package/package.json

@@ -1,36 +1,38 @@
 {
   "name": "@effect-app/vue",
-  "version": "4.0.0-beta.99",
+  "version": "4.0.0",
   "license": "MIT",
   "type": "module",
-  "homepage": "https://github.com/effect-ts-app/libs/tree/main/packages/vue",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/effect-app/libs.git",
+    "directory": "packages/vue"
+  },
+  "homepage": "https://github.com/effect-app/libs/tree/main/packages/vue",
   "dependencies": {
-    "@formatjs/intl": "^4.1.5",
-    "@tanstack/query-core": "5.96.2",
+    "@formatjs/intl": "^4.1.12",
     "@tanstack/vue-query": "5.96.2",
-    "@vueuse/core": "^14.2.1",
+    "@vueuse/core": "^14.3.0",
     "change-case": "^5.4.4",
-    "query-string": "^9.3.1",
-    "effect-app": "4.0.0-beta.99"
+    "query-string": "^9.4.0",
+    "effect-app": "4.0.0"
   },
   "peerDependencies": {
-    "@effect/atom-vue": "^4.0.0-beta.47",
-    "@effect/platform-browser": "^4.0.0-beta.47",
-    "@sentry/browser": "^10.47.0",
-    "effect": "^4.0.0-beta.47",
-    "vue": "^3.5.32"
+    "@effect/atom-vue": "^4.0.1",
+    "@effect/platform-browser": "^4.0.1",
+    "@sentry/browser": "^10.55.0",
+    "effect": "^4.0.1",
+    "vue": "^3.5.35"
   },
   "devDependencies": {
-    "@effect/vitest": "^4.0.0-beta.47",
-    "@formatjs/icu-messageformat-parser": "^3.5.3",
-    "@types/node": "25.5.2",
-    "@vitejs/plugin-vue": "^6.0.5",
-    "intl-messageformat": "^11.2.0",
-    "json5": "^2.2.3",
-    "typescript": "~6.0.2",
-    "vite": "^8.0.6",
-    "vitest": "^4.1.3",
-    "@effect-app/eslint-shared-config": "0.5.7-beta.9"
+    "@effect/vitest": "4.0.1",
+    "@formatjs/icu-messageformat-parser": "^3.5.10",
+    "@types/node": "25.9.1",
+    "@vitejs/plugin-vue": "^6.0.7",
+    "intl-messageformat": "^11.2.7",
+    "typescript": "~6.0.3",
+    "vite": "^8.0.15",
+    "vitest": "^4.1.7"
   },
   "typesVersions": {
     "*": {
@@ -44,69 +46,10 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
-    "./commander": {
-      "types": "./dist/commander.d.ts",
-      "default": "./dist/commander.js"
-    },
-    "./confirm": {
-      "types": "./dist/confirm.d.ts",
-      "default": "./dist/confirm.js"
-    },
-    "./errorReporter": {
-      "types": "./dist/errorReporter.d.ts",
-      "default": "./dist/errorReporter.js"
-    },
-    "./form": {
-      "types": "./dist/form.d.ts",
-      "default": "./dist/form.js"
-    },
-    "./intl": {
-      "types": "./dist/intl.d.ts",
-      "default": "./dist/intl.js"
-    },
-    "./lib": {
-      "types": "./dist/lib.d.ts",
-      "default": "./dist/lib.js"
-    },
-    "./makeClient": {
-      "types": "./dist/makeClient.d.ts",
-      "default": "./dist/makeClient.js"
-    },
-    "./makeContext": {
-      "types": "./dist/makeContext.d.ts",
-      "default": "./dist/makeContext.js"
-    },
-    "./makeIntl": {
-      "types": "./dist/makeIntl.d.ts",
-      "default": "./dist/makeIntl.js"
-    },
-    "./makeUseCommand": {
-      "types": "./dist/makeUseCommand.d.ts",
-      "default": "./dist/makeUseCommand.js"
-    },
-    "./mutate": {
-      "types": "./dist/mutate.d.ts",
-      "default": "./dist/mutate.js"
-    },
-    "./query": {
-      "types": "./dist/query.d.ts",
-      "default": "./dist/query.js"
-    },
-    "./routeParams": {
-      "types": "./dist/routeParams.d.ts",
-      "default": "./dist/routeParams.js"
-    },
-    "./runtime": {
-      "types": "./dist/runtime.d.ts",
-      "default": "./dist/runtime.js"
-    },
-    "./toast": {
-      "types": "./dist/toast.d.ts",
-      "default": "./dist/toast.js"
-    },
-    "./withToast": {
-      "types": "./dist/withToast.d.ts",
-      "default": "./dist/withToast.js"
+    "./internal/*": null,
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
     }
   },
   "gitHead": "bd8e27eea3eff97db8739d577d67e7336c078d28",
@@ -120,24 +63,22 @@
   ],
   "scripts": {
     "watch": "pnpm build:tsc -w",
-    "build:tsc": "pnpm clean-dist && effect-app-cli packagejson pnpm check",
-    "check": "tsc --build",
+    "build:tsc": "pnpm clean-dist && pnpm check && node ../../scripts/rewrite-dist-declaration-imports.mjs dist",
+    "check": "tsgo --build",
     "build": "pnpm build:tsc",
-    "watch2": "pnpm clean-dist && NODE_OPTIONS=--max-old-space-size=6144 tsc -w",
+    "watch2": "pnpm clean-dist && NODE_OPTIONS=--max-old-space-size=6144 tsgo -w",
     "clean": "rm -rf dist",
     "clean-dist": "sh ../../scripts/clean-dist.sh",
     "circular": "pnpm circular:src && pnpm circular:dist",
     "circular:src": "madge --circular --ts-config ./tsconfig.json --extensions ts ./src",
     "circular:dist": "madge --circular --extensions js ./dist",
-    "compile": "NODE_OPTIONS=--max-old-space-size=6144 tsc --noEmit",
-    "lint": "NODE_OPTIONS=--max-old-space-size=6144 ESLINT_TS=1 eslint ./src",
-    "lint:watch": "ESLINT_TS=1 esw -w --changed --clear --ext ts,tsx .",
-    "lint-fix": "pnpm lint --fix",
+    "compile": "NODE_OPTIONS=--max-old-space-size=6144 tsgo --noEmit",
+    "lint": "oxlint --quiet --type-aware ./src && pnpm exec dprint check --config ../../dprint.jsonc .",
+    "lint-fix": "oxlint --quiet --type-aware --fix ./src && pnpm exec dprint fmt --config ../../dprint.jsonc .",
     "test": "vitest",
     "test:run": "pnpm run test run --passWithNoTests",
     "testsuite": "pnpm lint && pnpm circular && pnpm run test:run",
     "ncu": "ncu",
-    "pub": "pnpm prepublish && npm publish --access public",
-    "prepublish": "cp -f ./tsconfig.json ./tsconfig.json.bak && node ../../scripts/mergeTsConfig.mjs ./tsconfig.json"
+    "pub": "npm publish --access public"
   }
 }