@krak-stack/registry 0.1.41 → 0.1.43

package/README.md

@@ -6,41 +6,19 @@ Tree-shakable runtime components and Effect services from the KrakStack shadcn r
 bun add @krak-stack/registry
 ```
 
-## Temporary Effect form patches
+## Effect forms
 
-This interim release supports stable Effect 4, but the published form betas still
-use removed Effect import paths. Applications using Effect forms must apply both
-compatibility patches at their package-manager root; installing Registry alone
-does not apply them automatically.
-
-After installing Registry, copy its bundled patches into your application:
+Applications using Effect forms need `@lucas-barake/effect-form@1.1.0` and
+`@lucas-barake/effect-form-react@1.1.0`, which support stable Effect 4 without
+compatibility patches:
 
 ```sh
-mkdir -p patches
-cp node_modules/@krak-stack/registry/patches/*.patch patches/
-```
-
-Merge these fields into the application's root `package.json`, preserving any
-existing overrides and patches:
-
-```json
-{
-  "overrides": {
-    "@lucas-barake/effect-form": "0.25.0-beta.6",
-    "@lucas-barake/effect-form-react": "0.26.0-beta.5"
-  },
-  "patchedDependencies": {
-    "@lucas-barake/effect-form@0.25.0-beta.6": "patches/@lucas-barake%2Feffect-form@0.25.0-beta.6.patch",
-    "@lucas-barake/effect-form-react@0.26.0-beta.5": "patches/@lucas-barake%2Feffect-form-react@0.26.0-beta.5.patch"
-  }
-}
+bun add @lucas-barake/effect-form@1.1.0 @lucas-barake/effect-form-react@1.1.0
 ```
 
-Run `bun install` and commit the patches, manifest, and lockfile. Other package
-managers require equivalent patch configuration. See the bundled
-`patches/README.md` for provenance and removal instructions after
-[upstream release PR #111](https://github.com/lucas-barake/effect-form/pull/111)
-is published.
+When upgrading from the patched betas, remove their `patchedDependencies`
+entries and patch files, update any form version overrides to `1.1.0`, and run
+`bun install`. Preserve unrelated dependency patches.
 
 ## Usage
 
@@ -79,182 +57,191 @@ import {
 import { NotificationService } from "@krak-stack/registry/service-notification";
 ```
 
-Inject API telemetry and browser proxy routes into the application HTTP layer:
+## OpenTelemetry
+
+| Export                                                    | Purpose                                                                                 |
+| --------------------------------------------------------- | --------------------------------------------------------------------------------------- |
+| `HttpApiOtlp.layer` from `opentelemetry/api`              | Server exporters and same-origin browser ingestion routes. Includes `ServerOtlp.layer`. |
+| `ServerOtlp.layer` from `opentelemetry/server`            | Exporters for workers, workflows, and CLIs without an HTTP server.                      |
+| `BrowserOtlp.layer(options)` from `opentelemetry/browser` | Browser tracing and optional events, logs, and metrics.                                 |
+
+### Setup
+
+Provide the HTTP layer once at the application composition root:
 
 ```ts
+import { Layer } from "effect";
+import { HttpApiOtlp } from "@krak-stack/registry/opentelemetry/api";
+
 const appLayer = appRoutes.pipe(Layer.provideMerge(HttpApiOtlp.layer));
 ```
 
-Install browser telemetry globally on the Atom runtime used by the API client:
+Configure an OTLP/HTTP collector on the server:
+
+```dotenv
+OTEL_SERVICE_NAME=my-app-api
+OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318
+OTEL_TRACES_EXPORTER=otlp
+OTEL_METRICS_EXPORTER=otlp
+OTEL_LOGS_EXPORTER=otlp
+```
+
+Browser events require the logs signal. The proxy forwards enabled signals from
+`/api/otel/v1/{traces,metrics,logs}` to the collector. Keep collector credentials
+server-side. Server log endpoint/header overrides use
+`OTEL_EXPORTER_OTLP_LOGS_ENDPOINT` / `OTEL_EXPORTER_OTLP_LOGS_HEADERS`, falling
+back to the shared endpoint/headers; these overrides do not change proxy routing.
+`OTEL_SDK_DISABLED=true` disables server export, not browser collection.
+
+Install one browser layer on the Atom context passed to `AtomHttpApi.Service`:
 
 ```ts
 import { Atom } from "effect/reactivity";
 import { BrowserOtlp } from "@krak-stack/registry/opentelemetry/browser";
 
 const apiRuntime = Atom.context();
-
 if (!import.meta.env.SSR) {
-  apiRuntime.addGlobalLayer(BrowserOtlp.layer({ serviceName: "my-app-web" }));
+  apiRuntime.addGlobalLayer(
+    BrowserOtlp.layer({ serviceName: "my-app-web", events: {} }),
+  );
 }
 ```
 
-### Named events and page views
+Mount/read `ApiClient.runtime` in the root layout to start it. Browser methods
+target the active layer even when run from another Effect runtime. Calls before
+startup or after disposal are no-ops, not buffered. Dispose long-lived server and
+browser runtimes on shutdown to flush pending data.
 
-For workers, workflows, or CLIs without an HTTP server, provide `ServerOtlp.layer`
-from `@krak-stack/registry/opentelemetry/server`. `HttpApiOtlp.layer` already
-includes this layer alongside the browser proxy routes.
+### Browser API
 
-```ts
+All methods return Effects. Use `yield*` inside Effect code or
+`Effect.runPromise(...)` / `Effect.runFork(...)` from application callbacks.
+
+| Method                                   | Behavior                                                                                                                   |
+| ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
+| `identify({ userId?, organizationId? })` | Replace identity for future events; omitted fields clear old values. Emits no event.                                       |
+| `identify(null)`                         | Clear identity, for example on logout.                                                                                     |
+| `track(name, properties?, options?)`     | Record a named event.                                                                                                      |
+| `page(options?)`                         | Record `browser.page_view`. Accepts `path`, `name`, `category`, `properties`, and event `options`. `pageView` is an alias. |
+
+`identify` has no typed failure: invalid input warns without including supplied
+values and leaves identity unchanged. `track` and `page` fail with an Effect
+schema error on invalid input. Identity is in memory only, applies to events
+rather than automatic traces/logs, and never rewrites queued events.
+
+### Auth example
+
+Mount this once under the application's Atom registry. `ApiClient` and
+`authSessionAtom` are application-owned; the telemetry package has no auth
+dependency. The session atom in this example exposes KrakStack Auth session data.
+
+```tsx
+import { useAtomSubscribe, useAtomValue } from "@effect/atom-react";
+import { BrowserOtlp } from "@krak-stack/registry/opentelemetry/browser";
 import { Effect } from "effect";
-import { ServerOtlp } from "@krak-stack/registry/opentelemetry/server";
+import { AsyncResult } from "effect/reactivity";
+import { ApiClient } from "@/lib/api-client";
+import { authSessionAtom } from "@/services/auth/client";
+
+export const AuthTelemetry = () => {
+  const runtime = useAtomValue(ApiClient.runtime);
+
+  useAtomSubscribe(
+    authSessionAtom,
+    (session) => {
+      if (!AsyncResult.isSuccess(runtime)) return;
+
+      Effect.runFork(
+        BrowserOtlp.identify(
+          AsyncResult.isSuccess(session) && !session.waiting && session.value
+            ? {
+                userId: session.value.user.id,
+                organizationId:
+                  session.value.session.activeOrganizationId ?? undefined,
+              }
+            : null,
+        ),
+      );
+    },
+    { immediate: true },
+  );
 
-const program = ServerOtlp.track("app.order.completed", {
-  "order.id": "order-123",
-}).pipe(Effect.provide(ServerOtlp.layer));
+  return null;
+};
 ```
 
-Enable server events with `OTEL_LOGS_EXPORTER=otlp`, `OTEL_SERVICE_NAME`, and
-`OTEL_EXPORTER_OTLP_ENDPOINT` (the exporter appends `/v1/logs`), or an explicit
-`OTEL_EXPORTER_OTLP_LOGS_ENDPOINT`. Signal-specific headers override
-`OTEL_EXPORTER_OTLP_HEADERS`; `OTEL_SDK_DISABLED=true` disables export. Use a
-long-lived application runtime to retain batching; dispose it on shutdown to
-flush pending events.
+This identifies after startup and clears identity during auth loading, failure,
+and logout. The first page view may be anonymous. For other auth libraries, pass
+the same two IDs or `null` when auth state changes. Apply your own consent policy;
+do not send names, emails, or session tokens as identity.
 
-Browser events are separately opt-in and do not enable application log export:
+### Page views and browser options
 
-```ts
-BrowserOtlp.layer({ serviceName: "my-app-web", events: {} });
-
-// Effects use the active BrowserOtlp.layer, even from a different calling runtime.
-const telemetry = Effect.gen(function* () {
-  yield* BrowserOtlp.track("app.checkout.started", {
-    "checkout.source": "cart",
-  });
-  yield* BrowserOtlp.page({
-    name: "Documentation",
-    category: "Docs",
-    path: "/docs",
-  });
-});
-```
+`events: {}` enables custom events and one page view on startup, then on pathname
+changes through `pushState`, `replaceState`, and back/forward navigation.
+Same-path and query/hash-only changes are ignored. Tracking follows URL changes,
+not loader completion. Paths exclude query strings/fragments but may still
+contain personal IDs.
 
-With `events: {}`, page views are automatic: one when the layer starts, then one
-for each pathname change through `pushState`, `replaceState`, or `popstate`
-(back/forward). Repeated same-path changes and query/hash-only changes are ignored.
-History hooks and listeners are scoped and restored on disposal. Tracking follows
-URL changes, not framework loader completion. The first page may be anonymous if
-identity has not been set yet; identify does not retroactively change it.
+For sanitized route templates or custom timing, use
+`events: { pageViews: false }` and call `page({ path: "/orders/:id" })` manually.
+Do not combine automatic and manual tracking for the same view.
 
-Set `events: { pageViews: false }` to disable automatic tracking while retaining custom events.
-Then call `page` (`pageView` alias) manually for route templates or application-specific
-navigation timing. Do not also manually emit the same automatic page view.
-Without `path`, it reads `location.pathname` when executed. It emits the
-application-defined event `browser.page_view` with required attribute `url.path`,
-stripping query strings and fragments. Supply sanitized paths or route templates
-when paths contain personal information. No cookies or visitor/session IDs are
-created. Only the pathname is captured; paths may still contain personal IDs.
+| Layer option                              | Default                                                         |
+| ----------------------------------------- | --------------------------------------------------------------- |
+| `serviceName`                             | Required                                                        |
+| `traces`                                  | `{}`; includes global exception capture. `false` disables both. |
+| `events`, `logs`, `metrics`               | `false`; enable each independently with `{}`.                   |
+| `baseUrl`                                 | `/api/otel`                                                     |
+| `serviceVersion`, `attributes`, `headers` | Optional resource/transport metadata.                           |
 
-### Browser identity
+Browser events batch every 30 seconds, up to 100 records by default. Override
+`exportInterval`, `maxBatchSize`, and `shutdownTimeout` under `events`.
 
-Call `BrowserOtlp.identify` when auth state becomes available or changes, and
-`BrowserOtlp.identify(null)` on logout. These remain Effects, but the caller does not need
-the browser exporter's services in its own runtime:
+### Server events and shared options
+
+Define server events as Effects and run them inside the runtime with
+`ServerOtlp.layer` (or the HTTP layer):
 
 ```ts
-const telemetry = Effect.gen(function* () {
-  yield* BrowserOtlp.identify({
-    userId: "user-123",
-    organizationId: "org-123",
-  });
-  yield* BrowserOtlp.track("app.checkout.started");
-  yield* BrowserOtlp.page({ path: "/checkout" });
-  yield* BrowserOtlp.identify(null);
+import { Effect } from "effect";
+import { ServerOtlp } from "@krak-stack/registry/opentelemetry/server";
+
+const orderCompleted = Effect.gen(function* () {
+  yield* ServerOtlp.track("app.order.completed", { "order.total": 49 });
 });
 ```
 
-Identity is in memory per telemetry runtime, not cookies or local storage.
-`identify` is best-effort and has no typed failure: invalid identity leaves the
-previous identity unchanged and logs a warning without including supplied values.
-`identify` replaces the complete identity; omitting an organization clears the
-previous organization. It emits no event. Identity is copied into each future
-event when recorded; changes and resets do not rewrite queued events. Identified
-user/org attributes override per-call properties/options, while scoped log
-annotations take precedence over identified identity. This applies only to event
-telemetry, not automatic trace/log exporters, API request headers, or authorization.
-Browser identity is client-supplied and untrusted; use trusted server events for
-billing, authorization, audit trails, or tenant-isolated reporting. Re-identify
-after a reload and update identity before recording events after an auth or
-organization change. The OTLP proxy remains passthrough and never enriches identity.
-
-Initialize the browser layer once on the application's long-lived runtime. After
-it starts, `Effect.runPromise(BrowserOtlp.identify(...))` and
-`Effect.runPromise(BrowserOtlp.track(...))` work from ordinary application code.
-Event methods retain typed validation errors and the calling fiber's trace/log
-context; `identify` handles validation failures internally.
-Calls executed before startup or after disposal are no-ops; nothing is buffered.
-If several browser layers are active, calls target the most recently started one;
-use a single browser layer in normal applications. There is no analytics bridge,
-React hook, or automatic identification.
-
-### Event options
-
-Both environments accept
-`track(name, properties?, options?)`. Common options are explicit and per-call,
-so server requests never share mutable visitor state:
+Authenticated handlers inherit `user.id` and `organization.id` from
+`AuthMiddleware` log annotations. Server identity is fiber-scoped; there is no
+server `identify` method. Background jobs can supply identity per event.
 
-```ts
-const telemetry = Effect.gen(function* () {
-  yield* ServerOtlp.track(
-    "app.order.completed",
-    { "order.total": 49 },
-    {
-      sessionId: "session-123",
-      messageId: "order-123-completed",
-      context: { "organization.id": "org-123", "app.locale": "en" },
-    },
-  );
-});
-```
+Both `track` methods accept `options`:
+
+| Option                                            | OTLP attribute / meaning                                            |
+| ------------------------------------------------- | ------------------------------------------------------------------- |
+| `userId`, `anonymousId`, `sessionId`, `messageId` | `user.id`, `analytics.anonymous_id`, `session.id`, `log.record.uid` |
+| `context`                                         | Additional flat attributes                                          |
+| `timestamp`                                       | Effect `DateTime.Utc` occurrence time; otherwise recorded now       |
+
+Attribute precedence, lowest to highest: context, properties, explicit identity
+options, browser identified identity, scoped log annotations. Values support
+strings, finite numbers, booleans, and homogeneous arrays, not nested objects.
+Use stable event names and put dynamic values in attributes. Message IDs support
+correlation, not guaranteed deduplication.
+
+Events are OTLP log records with `eventName`, INFO severity, and active trace/span
+IDs when available; they do not create spans. `browser.page_view`, `url.path`,
+`analytics.page.name`, and `analytics.page.category` describe page events; the
+analytics names are project conventions, not standardized OTel semantics.
+
+Configure collector/storage separately. Browser identity is untrusted analytics
+metadata, not authorization or an audit trail. No visitor/session IDs or cookies
+are generated. Browser flushing on hidden/pagehide is best-effort. Apply payload
+and rate limits at ingestion, and keep sensitive data out of events and
+high-cardinality fields out of Loki labels.
 
-`context` and event properties become flat OTLP attributes; properties override
-context on collision. Options `userId`, `anonymousId`, `sessionId`, and `messageId`
-map to `user.id`, `analytics.anonymous_id`, `session.id`, and `log.record.uid`,
-overriding properties with the same keys. Scoped `Effect.annotateLogs` annotations
-are inherited automatically and take precedence over all per-call attributes.
-In authenticated server handlers, `AuthMiddleware` already supplies `user.id` and
-`organization.id`, so do not repeat them in `.track()` calls. Background jobs and
-browser code can provide identity explicitly when needed. Annotations remain
-fiber-scoped; no identity state is persisted by the event service.
-Identifiers are optional; callers own
-consent and identity lifecycle. Message IDs aid correlation, not guaranteed
-deduplication. Optional `timestamp` accepts an Effect `DateTime.Utc` for delayed
-events; the SDK still sets observed time to the time of recording. There is no
-clock-skew correction. `page` accepts `properties` and these same `options`, plus
-optional `name` and `category` mapped to application-defined
-`analytics.page.name` and `analytics.page.category` attributes. It always owns
-the sanitized `url.path`. The `analytics.*` fields and `browser.page_view` name
-are project conventions, not standardized OpenTelemetry analytics semantics.
-Group, Alias, profile storage, destination routing, and automatic
-collection of IPs, user agents, page titles, referrers, and full URLs are not
-implemented.
-
-Both `.track(name, attributes?)` methods follow the
-[OpenTelemetry event conventions](https://opentelemetry.io/docs/specs/semconv/general/events/):
-records have the native `eventName` field, an occurrence timestamp, INFO severity
-number (9), flat structured attributes, and no body. The SDK sets observed time
-when it records the occurrence. Events inherit active trace/span IDs without
-creating spans. Use stable domain-qualified names with no dynamic identifiers;
-put changing values in attributes. Document each custom event's trigger and
-required/optional attributes; include `error.type` for failures. These conventions
-are still in development. Attribute values support strings, finite numbers,
-booleans, and homogeneous arrays of those values. Invalid inputs fail with an
-Effect schema error.
-
-The logs proxy must be enabled with `OTEL_LOGS_EXPORTER=otlp` for browser events.
-OTLP transports events; configure a collector and a logs backend such as Loki for
-storage and Grafana dashboards. Browser flushing on hidden/pagehide is best
-effort. Apply payload limits and rate limits at your public ingestion boundary,
-avoid sensitive attributes, and keep high-cardinality fields out of Loki labels.
+## Other services
 
 `@krak-stack/registry/service-notification` is the source-compatible direct
 dispatcher. Use the separate `@krak-stack/notifications` package for a durable

package/dist/components/ui/data-table.js

@@ -1339,9 +1339,7 @@ var uiFromState = (state) => ({
 var sameUiState = (left, right) => left.columnVisibility === right.columnVisibility && left.columnSizing === right.columnSizing && left.rowSelection === right.rowSelection && left.grouping === right.grouping && left.collapsedGroups === right.collapsedGroups && left.view === right.view;
 var sameQueryState = (left, right) => left.page === right.page && left.pageSize === right.pageSize && left.globalFilter === right.globalFilter && left.sort === right.sort;
 var initialPublicState = (props, uiState) => ({
-  ...DEFAULT_QUERY,
-  ...props.initialState,
-  ...props.state,
+  ...queryFromState(props.state ?? { ...DEFAULT_QUERY, ...props.initialState }),
   ...uiState
 });
 var buildDataTableModel = (store) => {
@@ -1378,7 +1376,7 @@ var changeState = (setStore, update) => {
     if (!sameUiState(uiState, store.state)) {
       store.config.onUiStateChange(uiState);
     }
-    const state = store.controlledState ? { ...proposed, ...store.controlledState } : proposed;
+    const state = store.controlledState ? { ...proposed, ...queryFromState(store.controlledState) } : proposed;
     if (sameDataTableState(state, store.state))
       return store;
     const next = { ...store, state };
@@ -1700,7 +1698,7 @@ var DataTableToolbar = ({
           }),
           store.state.globalFilter ? /* @__PURE__ */ jsx14(Button, {
             "aria-label": labels.filter,
-            className: "absolute top-1/2 right-1 size-7 -translate-y-1/2",
+            className: "absolute top-1/2 right-1 size-7 -translate-y-1/2 active:not-aria-[haspopup]:-translate-y-1/2",
             onClick: () => update((state) => ({
               ...state,
               globalFilter: undefined,
@@ -2887,7 +2885,11 @@ var HydratedDataTable = ({
         labels: dataTableMessages(props.locale, props.messages),
         locale: props.locale ?? "en"
       };
-      const state = { ...store.state, ...uiState, ...props.state };
+      const state = {
+        ...store.state,
+        ...uiState,
+        ...queryFromState(props.state ?? store.state)
+      };
       const modelChanged = store.rowData !== props.rowData || store.columnDefs !== props.columnDefs || !sameDataTableState(store.state, state) || store.config.getRowId !== config.getRowId || store.config.features.pagination !== config.features.pagination;
       const next = {
         ...store,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krak-stack/registry",
-  "version": "0.1.41",
+  "version": "0.1.43",
   "description": "Tree-shakable KrakStack components and Effect services.",
   "license": "MIT",
   "repository": {
@@ -11,7 +11,6 @@
   "files": [
     "dist",
     "README.md",
-    "patches",
     "tailwind.css"
   ],
   "type": "module",
@@ -241,8 +240,8 @@
     "@effect/platform-browser": "^4.0.0",
     "@iconify/react": "^6.0.2",
     "@inlang/paraglide-js": "^2.19.0",
-    "@lucas-barake/effect-form": "0.25.0-beta.6",
-    "@lucas-barake/effect-form-react": "0.26.0-beta.5",
+    "@lucas-barake/effect-form": "1.1.0",
+    "@lucas-barake/effect-form-react": "1.1.0",
     "@tanstack/highlight": "^0.0.10",
     "@tanstack/react-form": "^1.33.0",
     "@tanstack/react-router": "^1.170.15",

package/patches/@lucas-barake%2Feffect-form-react@0.26.0-beta.5.patch

@@ -1,66 +0,0 @@
-diff --git a/dist/FormReact.d.ts b/dist/FormReact.d.ts
-index 61b65ad3ef858a3d9994d4cfde7e47216d44b549..0431a57a4a27eefa43180fc19f04f887a25ebf24 100644
---- a/dist/FormReact.d.ts
-+++ b/dist/FormReact.d.ts
-@@ -4,8 +4,8 @@ import type * as FormBuilder from "@lucas-barake/effect-form/FormBuilder";
- import type * as Effect from "effect/Effect";
- import * as Option from "effect/Option";
- import type * as Schema from "effect/Schema";
--import * as Atom from "effect/unstable/reactivity/Atom";
--import type * as AtomRegistry from "effect/unstable/reactivity/AtomRegistry";
-+import * as Atom from "effect/reactivity/Atom";
-+import type * as AtomRegistry from "effect/reactivity/AtomRegistry";
- import * as React from "react";
- export type FieldValue<T> = FieldStateModule.FieldValue<T>;
- export type FieldState<E> = FieldStateModule.FieldState<E>;
-diff --git a/dist/FormReact.js b/dist/FormReact.js
-index 03e34ec60b833b4dd220ac6faffe70b9138703cd..f313c18c5e6cdb7138e19180aeb0acd4281857fa 100644
---- a/dist/FormReact.js
-+++ b/dist/FormReact.js
-@@ -4,7 +4,7 @@ import { Field, FormAtoms } from "@lucas-barake/effect-form";
- import { getNestedValue } from "@lucas-barake/effect-form/Path";
- import * as Layer from "effect/Layer";
- import * as Option from "effect/Option";
--import * as Atom from "effect/unstable/reactivity/Atom";
-+import * as Atom from "effect/reactivity/Atom";
- import * as React from "react";
- import { createContext, useContext } from "react";
- const ArrayItemContext = /*#__PURE__*/createContext(null);
-diff --git a/package.json b/package.json
-index 416aed4983dfb7dfc1528b3cca636b860ab0986e..048e49b01201623854c1c8f042044d3f5bd64703 100644
---- a/package.json
-+++ b/package.json
-@@ -41,14 +41,14 @@
-     "@lucas-barake/effect-form": "^0.25.0-beta.6"
-   },
-   "devDependencies": {
--    "@effect/atom-react": "4.0.0-beta.52",
-+    "@effect/atom-react": "4.0.0",
-     "@vitejs/plugin-react": "^5.1.1",
--    "effect": "4.0.0-beta.52",
-+    "effect": "4.0.0",
-     "react": "^19.0.0"
-   },
-   "peerDependencies": {
--    "@effect/atom-react": ">=4.0.0-beta.52 <4.0.1",
--    "effect": ">=4.0.0-beta.52 <4.0.1",
-+    "@effect/atom-react": "^4.0.0",
-+    "effect": "^4.0.0",
-     "react": "^19.0.0"
-   },
-   "scripts": {
-diff --git a/src/FormReact.tsx b/src/FormReact.tsx
-index 49c358e92fe04a62a9ef97dbae6665ce53e905a5..dfb2792d4b824d448bf3e8f4b469c0861422bd6f 100644
---- a/src/FormReact.tsx
-+++ b/src/FormReact.tsx
-@@ -7,8 +7,8 @@ import type * as Effect from "effect/Effect"
- import * as Layer from "effect/Layer"
- import * as Option from "effect/Option"
- import type * as Schema from "effect/Schema"
--import * as Atom from "effect/unstable/reactivity/Atom"
--import type * as AtomRegistry from "effect/unstable/reactivity/AtomRegistry"
-+import * as Atom from "effect/reactivity/Atom"
-+import type * as AtomRegistry from "effect/reactivity/AtomRegistry"
- import * as React from "react"
- import { createContext, useContext } from "react"
- 

package/patches/@lucas-barake%2Feffect-form@0.25.0-beta.6.patch

@@ -1,86 +0,0 @@
-diff --git a/dist/FormAtoms.d.ts b/dist/FormAtoms.d.ts
-index 08d1e4e2e8edf08cecb5b550099c3293cbd10cd7..f7b1fa4a5a7d65e8b8b3785dc9eb5397d24718b4 100644
---- a/dist/FormAtoms.d.ts
-+++ b/dist/FormAtoms.d.ts
-@@ -1,7 +1,7 @@
- import * as Effect from "effect/Effect";
- import * as Option from "effect/Option";
- import * as Schema from "effect/Schema";
--import * as Atom from "effect/unstable/reactivity/Atom";
-+import * as Atom from "effect/reactivity/Atom";
- import * as Field from "./Field.ts";
- import * as FormBuilder from "./FormBuilder.ts";
- import * as Mode from "./Mode.ts";
-diff --git a/dist/FormAtoms.js b/dist/FormAtoms.js
-index 663c4478a08eb17bfb7a11df952ced8f7812cbf8..ebaa1be93c33af0390857e945a9d414094f215ab 100644
---- a/dist/FormAtoms.js
-+++ b/dist/FormAtoms.js
-@@ -3,8 +3,8 @@ import * as Effect from "effect/Effect";
- import { pipe } from "effect/Function";
- import * as Option from "effect/Option";
- import * as Schema from "effect/Schema";
--import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
--import * as Atom from "effect/unstable/reactivity/Atom";
-+import * as AsyncResult from "effect/reactivity/AsyncResult";
-+import * as Atom from "effect/reactivity/Atom";
- import * as Field from "./Field.js";
- import * as FormBuilder from "./FormBuilder.js";
- import { recalculateDirtyFieldsForArray, recalculateDirtySubtree } from "./internal/dirty.js";
-diff --git a/dist/FormBuilder.d.ts b/dist/FormBuilder.d.ts
-index d42cf00d24b9efea5168831549b85468a64dfcef..16dfc1af6443555454ec7e6219c94eeabce3d724 100644
---- a/dist/FormBuilder.d.ts
-+++ b/dist/FormBuilder.d.ts
-@@ -1,7 +1,7 @@
- import type * as Effect from "effect/Effect";
- import type * as Option from "effect/Option";
- import * as Schema from "effect/Schema";
--import type * as AtomRegistry from "effect/unstable/reactivity/AtomRegistry";
-+import type * as AtomRegistry from "effect/reactivity/AtomRegistry";
- import type { ArrayFieldDef, DecodedFromFields, EncodedFromFields, FieldDef, FieldsRecord } from "./Field.ts";
- /**
-  * Flattens an intersection of field records into a single object type so that
-diff --git a/package.json b/package.json
-index 96ad0aa1729c64e8378a8cb2ad29f13b5347e568..06ae5ac6312779be749ff867b846c8f3c4ccf5b1 100644
---- a/package.json
-+++ b/package.json
-@@ -36,10 +36,10 @@
-   "license": "MIT",
-   "sideEffects": [],
-   "peerDependencies": {
--    "effect": ">=4.0.0-beta.52 <4.0.1"
-+    "effect": "^4.0.0"
-   },
-   "devDependencies": {
--    "effect": "4.0.0-beta.52"
-+    "effect": "4.0.0"
-   },
-   "scripts": {
-     "build": "tsc -b tsconfig.json && pnpm babel",
-diff --git a/src/FormAtoms.ts b/src/FormAtoms.ts
-index bc60a7f7b676edf4d1e99f6eb4162335b3247022..60d3dadfe2ef14c0a1b66b5e16886e8870c82681 100644
---- a/src/FormAtoms.ts
-+++ b/src/FormAtoms.ts
-@@ -3,8 +3,8 @@ import * as Effect from "effect/Effect"
- import { pipe } from "effect/Function"
- import * as Option from "effect/Option"
- import * as Schema from "effect/Schema"
--import * as AsyncResult from "effect/unstable/reactivity/AsyncResult"
--import * as Atom from "effect/unstable/reactivity/Atom"
-+import * as AsyncResult from "effect/reactivity/AsyncResult"
-+import * as Atom from "effect/reactivity/Atom"
- import * as Field from "./Field.ts"
- import * as FormBuilder from "./FormBuilder.ts"
- import { recalculateDirtyFieldsForArray, recalculateDirtySubtree } from "./internal/dirty.ts"
-diff --git a/src/FormBuilder.ts b/src/FormBuilder.ts
-index 764de854be6b072967d1140c707ba9565eda9516..6a2d0fe285ae3b2d1afc4bf928897e5b7bfb0a4b 100644
---- a/src/FormBuilder.ts
-+++ b/src/FormBuilder.ts
-@@ -3,7 +3,7 @@ import type * as Option from "effect/Option"
- import * as Predicate from "effect/Predicate"
- import * as Schema from "effect/Schema"
- import * as SchemaGetter from "effect/SchemaGetter"
--import type * as AtomRegistry from "effect/unstable/reactivity/AtomRegistry"
-+import type * as AtomRegistry from "effect/reactivity/AtomRegistry"
- 
- import type {
-   AnyFieldDef,

package/patches/README.md

@@ -1,31 +0,0 @@
-# Temporary Effect form compatibility patches
-
-These patches backport the stable Effect 4 changes from upstream commit
-[`c10a53e041c9b0b338b26b2af66be5eb24f07d47`](https://github.com/lucas-barake/effect-form/commit/c10a53e041c9b0b338b26b2af66be5eb24f07d47).
-The fixed npm packages are awaiting [release PR #111](https://github.com/lucas-barake/effect-form/pull/111).
-
-The patches update reactivity imports in shipped JavaScript, TypeScript
-declarations, and source, and change Effect peer ranges to `^4.0.0`.
-They do not change form behavior or package versions.
-
-## Installation
-
-The workspace-root `package.json` configures `patchedDependencies` and exact
-version overrides for both packages. Run `bun install` to apply them; commit
-these patch files, `package.json`, and `bun.lock` together. In a monorepo, configure
-the patches at the workspace root, not inside individual packages.
-
-Patches do **not** propagate from a published KrakStack package to a consuming
-application. Every application using the affected form packages must configure
-both patches itself. The interim Auth and Registry packages also ship copies
-under `patches/` for consumers to copy into their application roots.
-
-## Removing the workaround
-
-After upstream publishes `@lucas-barake/effect-form@0.25.0-beta.7` and
-`@lucas-barake/effect-form-react@0.26.0-beta.6` (or newer compatible releases):
-
-1. Update direct dependencies and KrakStack peer requirements to the fixed versions.
-2. Remove the two form overrides and `patchedDependencies` entries.
-3. Remove these two patch files and any copies shipped with KrakStack packages.
-4. Run `bun install`, then the project's type, test, and release checks.