@rikalabs/effect-react 0.0.1

package/dist/index.cjs

@@ -0,0 +1,2512 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FormValidationError: () => FormValidationError,
+  Link: () => Link,
+  NavigationCancelledError: () => NavigationCancelledError,
+  NavigationRuntimeError: () => NavigationRuntimeError,
+  Outlet: () => Outlet,
+  QueryRuntimeError: () => QueryRuntimeError,
+  cachePolicy: () => cachePolicy,
+  calculateOffsetForIndex: () => calculateOffsetForIndex,
+  calculateOffsets: () => calculateOffsets,
+  calculateTotalSize: () => calculateTotalSize,
+  calculateVisibleRange: () => calculateVisibleRange,
+  changes: () => changes,
+  createApp: () => createApp,
+  createChannel: () => createChannel,
+  createDevtoolsEventStream: () => createDevtoolsEventStream,
+  createDevtoolsEventStreamFromTelemetry: () => createDevtoolsEventStreamFromTelemetry,
+  createPresence: () => createPresence,
+  createRequestHandler: () => createRequestHandler,
+  createRuntimeEventSource: () => createRuntimeEventSource,
+  createStore: () => createStore,
+  createStoreFromEffect: () => createStoreFromEffect,
+  createStoreTag: () => createStoreTag,
+  createTestApp: () => createTestApp,
+  defaultHydrationGlobalName: () => defaultHydrationGlobalName,
+  defineAction: () => defineAction,
+  defineColumns: () => defineColumns,
+  defineConfig: () => defineConfig,
+  defineForm: () => defineForm,
+  defineLayout: () => defineLayout,
+  defineLoader: () => defineLoader,
+  defineManifest: () => defineManifest,
+  defineMiddleware: () => defineMiddleware,
+  definePage: () => definePage,
+  defineQuery: () => defineQuery,
+  defineRoute: () => defineRoute,
+  derive: () => derive,
+  fetchQuery: () => fetchQuery2,
+  filterRows: () => filterRows,
+  get: () => get,
+  getOffsetForIndex: () => getOffsetForIndex,
+  getTotalSize: () => getTotalSize,
+  getVisibleRange: () => getVisibleRange,
+  hydrateApp: () => hydrateApp,
+  invalidate: () => invalidate,
+  invalidateQuery: () => invalidateQuery,
+  loadersFromManifest: () => loadersFromManifest,
+  makeForm: () => makeForm,
+  makeStoreLayer: () => makeStoreLayer,
+  makeStoreLayerFromEffect: () => makeStoreLayerFromEffect,
+  mapRows: () => mapRows,
+  measureVirtualItems: () => measureVirtualItems,
+  modify: () => modify,
+  navigate: () => navigate,
+  noStore: () => noStore,
+  paginateRows: () => paginateRows,
+  prefetch: () => prefetch,
+  prefetchQuery: () => prefetchQuery,
+  projectRow: () => projectRow,
+  projectRows: () => projectRows,
+  publish: () => publish,
+  publishAll: () => publishAll,
+  resolveConfig: () => resolveConfig,
+  revalidateNavigation: () => revalidateNavigation,
+  routeHref: () => routeHref,
+  routePath: () => routePath,
+  routeSearchText: () => routeSearchText,
+  routeUrl: () => routeUrl,
+  routesFromManifest: () => routesFromManifest,
+  select: () => select,
+  selectChanges: () => selectChanges,
+  set: () => set,
+  sortRows: () => sortRows,
+  subscribe: () => subscribe,
+  update: () => update,
+  useDevtoolsEvents: () => useDevtoolsEvents,
+  useEventStream: () => useEventStream,
+  useForm: () => useForm,
+  useInfiniteQuery: () => useInfiniteQuery,
+  useNavigate: () => useNavigate2,
+  useNavigationSnapshot: () => useNavigationSnapshot2,
+  useQuery: () => useQuery2,
+  useRouteMatch: () => useRouteMatch,
+  useStore: () => useStore,
+  useStoreSelector: () => useStoreSelector,
+  useSuspenseQuery: () => useSuspenseQuery2
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/actions/types.ts
+var defineAction = (definition) => definition;
+
+// src/actions/service.ts
+var import_effect3 = require("effect");
+
+// src/boundary/codecs.ts
+var import_effect = require("effect");
+
+// src/boundary/errors.ts
+var BoundaryDecodeError = class extends Error {
+  constructor(source, messageText, causeValue) {
+    super(`Boundary decode failed at ${source}: ${messageText}`);
+    this.source = source;
+    this.messageText = messageText;
+    this.causeValue = causeValue;
+    this.name = "BoundaryDecodeError";
+  }
+  _tag = "BoundaryDecodeError";
+};
+var BoundaryTransportError = class extends Error {
+  constructor(source, messageText, causeValue) {
+    super(`Boundary transport failed at ${source}: ${messageText}`);
+    this.source = source;
+    this.messageText = messageText;
+    this.causeValue = causeValue;
+    this.name = "BoundaryTransportError";
+  }
+  _tag = "BoundaryTransportError";
+};
+var BoundaryProtocolError = class extends Error {
+  constructor(source, messageText) {
+    super(`Boundary protocol violation at ${source}: ${messageText}`);
+    this.source = source;
+    this.messageText = messageText;
+    this.name = "BoundaryProtocolError";
+  }
+  _tag = "BoundaryProtocolError";
+};
+
+// src/boundary/codecs.ts
+var Boundary = class extends import_effect.Context.Tag("EffectReact/Boundary")() {
+};
+var parseErrorMessage = (error) => import_effect.Cause.pretty(import_effect.Cause.fail(error)).trim();
+var makeBoundaryService = () => ({
+  decodeUnknown: ({ source, schema, value }) => import_effect.Schema.decodeUnknown(schema)(value).pipe(
+    import_effect.Effect.mapError(
+      (error) => new BoundaryDecodeError(source, parseErrorMessage(error), error)
+    )
+  ),
+  decodeTextJson: ({ source, schema, text }) => import_effect.Effect.gen(function* () {
+    const payload = yield* import_effect.Effect.try({
+      try: () => JSON.parse(text),
+      catch: (cause) => new BoundaryTransportError(source, "failed to parse JSON payload", cause)
+    });
+    return yield* import_effect.Schema.decodeUnknown(schema)(payload).pipe(
+      import_effect.Effect.mapError(
+        (error) => new BoundaryDecodeError(source, parseErrorMessage(error), error)
+      )
+    );
+  }),
+  encode: ({ source, schema, value }) => import_effect.Schema.encode(schema)(value).pipe(
+    import_effect.Effect.mapError((error) => new BoundaryProtocolError(source, parseErrorMessage(error)))
+  )
+});
+var BoundaryLive = import_effect.Layer.succeed(Boundary, makeBoundaryService());
+
+// src/kernel/telemetry.ts
+var import_effect2 = require("effect");
+var Telemetry = class extends import_effect2.Context.Tag("EffectReact/Telemetry")() {
+};
+var TelemetryLive = import_effect2.Layer.effect(
+  Telemetry,
+  import_effect2.Effect.map(import_effect2.PubSub.unbounded(), (pubsub) => ({
+    emit: (event) => import_effect2.PubSub.publish(pubsub, event).pipe(import_effect2.Effect.asVoid),
+    stream: import_effect2.Stream.fromPubSub(pubsub)
+  }))
+);
+
+// src/actions/service.ts
+var toFailureDetail = (error) => {
+  if (error instanceof Error) {
+    return `${error.name}: ${error.message}`;
+  }
+  return String(error);
+};
+var Actions = class extends import_effect3.Context.Tag("EffectReact/Actions")() {
+};
+var makeActionsLayer = (options) => import_effect3.Layer.effect(
+  Actions,
+  import_effect3.Effect.gen(function* () {
+    const boundary = yield* Boundary;
+    const telemetry = yield* Telemetry;
+    const actionMap = new Map(
+      options.actions.map((action) => [action.name, action])
+    );
+    const run = (definition, input) => import_effect3.Effect.gen(function* () {
+      yield* telemetry.emit({
+        _tag: "action",
+        phase: "start",
+        name: definition.name,
+        timestamp: Date.now()
+      });
+      const decodedInput = yield* boundary.decodeUnknown({
+        source: `action:${definition.name}:input`,
+        schema: definition.input,
+        value: input
+      });
+      const value = yield* definition.handler(decodedInput);
+      const decodedOutput = yield* boundary.decodeUnknown({
+        source: `action:${definition.name}:output`,
+        schema: definition.output,
+        value
+      });
+      yield* telemetry.emit({
+        _tag: "action",
+        phase: "success",
+        name: definition.name,
+        timestamp: Date.now()
+      });
+      return decodedOutput;
+    }).pipe(
+      import_effect3.Effect.tapError(
+        (error) => telemetry.emit({
+          _tag: "action",
+          phase: "failure",
+          name: definition.name,
+          timestamp: Date.now(),
+          detail: error
+        })
+      )
+    );
+    const dispatch = (name, input) => import_effect3.Effect.gen(function* () {
+      const definition = actionMap.get(name);
+      if (definition === void 0) {
+        return {
+          _tag: "defect",
+          message: `Unknown action: ${name}`
+        };
+      }
+      const decodedInput = yield* boundary.decodeUnknown({
+        source: `action:${name}:dispatch-input`,
+        schema: definition.input,
+        value: input
+      });
+      const handler = definition.handler;
+      const result = yield* import_effect3.Effect.exit(handler(decodedInput));
+      if (result._tag === "Success") {
+        const encoded = yield* boundary.encode({
+          source: `action:${name}:wire-success`,
+          schema: definition.output,
+          value: result.value
+        });
+        return {
+          _tag: "success",
+          value: encoded
+        };
+      }
+      const failure = import_effect3.Cause.failureOption(result.cause);
+      if (failure._tag === "Some") {
+        const value = failure.value;
+        if (value instanceof BoundaryDecodeError || value instanceof BoundaryProtocolError) {
+          return {
+            _tag: "defect",
+            message: toFailureDetail(value)
+          };
+        }
+        const encodedError = yield* boundary.encode({
+          source: `action:${name}:wire-failure`,
+          schema: definition.error,
+          value
+        }).pipe(
+          import_effect3.Effect.catchAll(() => import_effect3.Effect.succeed(value))
+        );
+        return {
+          _tag: "failure",
+          error: encodedError
+        };
+      }
+      return {
+        _tag: "defect",
+        message: import_effect3.Cause.pretty(result.cause)
+      };
+    }).pipe(
+      import_effect3.Effect.catchAll(
+        (error) => import_effect3.Effect.succeed({
+          _tag: "defect",
+          message: toFailureDetail(error)
+        })
+      )
+    );
+    return {
+      run,
+      dispatch
+    };
+  })
+);
+
+// src/actions/http.ts
+var import_effect4 = require("effect");
+var ActionRequestSchema = import_effect4.Schema.Struct({
+  name: import_effect4.Schema.String,
+  input: import_effect4.Schema.Unknown
+});
+var ActionWireResultSchema = import_effect4.Schema.Union(
+  import_effect4.Schema.Struct({ _tag: import_effect4.Schema.Literal("success"), value: import_effect4.Schema.Unknown }),
+  import_effect4.Schema.Struct({ _tag: import_effect4.Schema.Literal("failure"), error: import_effect4.Schema.Unknown }),
+  import_effect4.Schema.Struct({ _tag: import_effect4.Schema.Literal("defect"), message: import_effect4.Schema.String })
+);
+var ActionTransportError = class extends Error {
+  constructor(messageText, causeValue) {
+    super(messageText);
+    this.messageText = messageText;
+    this.causeValue = causeValue;
+    this.name = "ActionTransportError";
+  }
+  _tag = "ActionTransportError";
+};
+var jsonResponse = (status, body) => new Response(JSON.stringify(body), {
+  status,
+  headers: {
+    "content-type": "application/json"
+  }
+});
+var createActionHttpHandlerEffect = () => (request) => import_effect4.Effect.gen(function* () {
+  if (request.method.toUpperCase() !== "POST") {
+    return jsonResponse(405, { error: "Method Not Allowed" });
+  }
+  const rawBody = yield* import_effect4.Effect.tryPromise({
+    try: () => request.text(),
+    catch: (cause) => new ActionTransportError("Failed to read request body", cause)
+  });
+  const boundary = yield* Boundary;
+  const payload = yield* boundary.decodeTextJson({
+    source: "action:http:request",
+    schema: ActionRequestSchema,
+    text: rawBody
+  });
+  const actions = yield* Actions;
+  const result = yield* actions.dispatch(payload.name, payload.input);
+  return jsonResponse(200, result);
+}).pipe(
+  import_effect4.Effect.catchAll(
+    (error) => import_effect4.Effect.succeed(
+      jsonResponse(500, {
+        error: error instanceof Error ? error.message : String(error)
+      })
+    )
+  )
+);
+var createActionHttpHandler = () => {
+  const handleEffect = createActionHttpHandlerEffect();
+  return (runtimeRun) => (request) => runtimeRun(handleEffect(request));
+};
+
+// src/react/provider.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var RuntimeContext = (0, import_react.createContext)(null);
+var useEffectRuntime = () => {
+  const runtime = (0, import_react.useContext)(RuntimeContext);
+  if (runtime === null) {
+    throw new Error("Effect runtime is not available. Wrap your app with <EffectProvider>.");
+  }
+  return runtime;
+};
+
+// src/kernel/app.ts
+var import_effect10 = require("effect");
+
+// src/data/types.ts
+var defineQuery = (definition) => definition;
+var QueryRuntimeError = class extends Error {
+  constructor(messageText) {
+    super(messageText);
+    this.messageText = messageText;
+    this.name = "QueryRuntimeError";
+  }
+  _tag = "QueryRuntimeError";
+};
+
+// src/data/service.ts
+var import_effect5 = require("effect");
+var defaultRuntimeOptions = {
+  capacity: 2048,
+  timeToLive: "5 minutes"
+};
+var stableStringify = (value) => {
+  if (value === null || value === void 0) {
+    return String(value);
+  }
+  if (typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  const entries = Object.entries(value).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  return `{${entries.map(([key, nested]) => `${JSON.stringify(key)}:${stableStringify(nested)}`).join(",")}}`;
+};
+var initialSnapshot = (key) => ({
+  key,
+  phase: "initial",
+  data: void 0,
+  error: void 0,
+  updatedAt: null
+});
+var Data = class extends import_effect5.Context.Tag("EffectReact/Data")() {
+};
+var makeDataLayer = (options = {}) => {
+  const merged = {
+    ...defaultRuntimeOptions,
+    ...options
+  };
+  return import_effect5.Layer.effect(
+    Data,
+    import_effect5.Effect.gen(function* () {
+      const boundary = yield* Boundary;
+      const telemetry = yield* Telemetry;
+      const lookups = /* @__PURE__ */ new Map();
+      const snapshots = yield* import_effect5.SubscriptionRef.make(
+        /* @__PURE__ */ new Map()
+      );
+      const cache = yield* import_effect5.Cache.make({
+        capacity: merged.capacity,
+        timeToLive: merged.timeToLive,
+        lookup: (key) => import_effect5.Effect.suspend(() => {
+          const lookup = lookups.get(key);
+          if (lookup === void 0) {
+            return import_effect5.Effect.fail(new QueryRuntimeError(`No query executor registered for ${key}`));
+          }
+          return lookup;
+        })
+      });
+      const setSnapshot = (key, update2) => import_effect5.SubscriptionRef.update(snapshots, (current) => {
+        const next = new Map(current);
+        const previous = next.get(key) ?? initialSnapshot(key);
+        next.set(key, update2(previous));
+        return next;
+      }).pipe(import_effect5.Effect.asVoid);
+      const buildKey = (definition, input) => {
+        const base = definition.key ? definition.key(input) : input;
+        return `${definition.name}:${stableStringify(base)}`;
+      };
+      const fetch2 = (definition, input, runOptions) => import_effect5.Effect.gen(function* () {
+        const decodedInput = yield* boundary.decodeUnknown({
+          source: `query:${definition.name}:input`,
+          schema: definition.input,
+          value: input
+        });
+        const key = buildKey(definition, decodedInput);
+        yield* telemetry.emit({
+          _tag: "query",
+          phase: "start",
+          key,
+          timestamp: Date.now()
+        });
+        yield* setSnapshot(key, (previous) => ({
+          ...previous,
+          phase: "loading",
+          error: void 0
+        }));
+        lookups.set(
+          key,
+          definition.run(decodedInput).pipe(
+            import_effect5.Effect.flatMap(
+              (output) => boundary.decodeUnknown({
+                source: `query:${definition.name}:output`,
+                schema: definition.output,
+                value: output
+              })
+            )
+          )
+        );
+        if (runOptions?.forceRefresh === true) {
+          yield* cache.refresh(key).pipe(import_effect5.Effect.ignore);
+        }
+        const value = yield* cache.get(key).pipe(
+          import_effect5.Effect.mapError(
+            (error) => error
+          )
+        );
+        yield* setSnapshot(key, () => ({
+          key,
+          phase: "success",
+          data: value,
+          error: void 0,
+          updatedAt: Date.now()
+        }));
+        yield* telemetry.emit({
+          _tag: "query",
+          phase: "success",
+          key,
+          timestamp: Date.now()
+        });
+        return value;
+      }).pipe(
+        import_effect5.Effect.tapError(
+          (error) => import_effect5.Effect.gen(function* () {
+            const decodedInput = yield* boundary.decodeUnknown({
+              source: `query:${definition.name}:input`,
+              schema: definition.input,
+              value: input
+            });
+            const key = buildKey(definition, decodedInput);
+            yield* setSnapshot(key, (previous) => ({
+              ...previous,
+              phase: "failure",
+              error,
+              updatedAt: previous.updatedAt
+            }));
+            yield* telemetry.emit({
+              _tag: "query",
+              phase: "failure",
+              key,
+              timestamp: Date.now(),
+              detail: error
+            });
+          })
+        )
+      );
+      const prefetch2 = (definition, input) => fetch2(definition, input).pipe(import_effect5.Effect.asVoid);
+      const invalidate2 = (definition, input) => import_effect5.Effect.gen(function* () {
+        const key = `${definition.name}:${stableStringify(input)}`;
+        yield* cache.invalidate(key);
+        yield* import_effect5.SubscriptionRef.update(snapshots, (current) => {
+          const next = new Map(current);
+          next.delete(key);
+          return next;
+        }).pipe(import_effect5.Effect.asVoid);
+        yield* telemetry.emit({
+          _tag: "query",
+          phase: "invalidate",
+          key,
+          timestamp: Date.now()
+        });
+      });
+      const getSnapshot = (definition, input) => import_effect5.Effect.gen(function* () {
+        const key = `${definition.name}:${stableStringify(input)}`;
+        const current = yield* import_effect5.SubscriptionRef.get(snapshots);
+        const snapshot = current.get(key);
+        if (snapshot === void 0) {
+          return initialSnapshot(key);
+        }
+        return snapshot;
+      });
+      return {
+        fetch: fetch2,
+        prefetch: prefetch2,
+        invalidate: invalidate2,
+        getSnapshot,
+        getAllSnapshots: import_effect5.SubscriptionRef.get(snapshots),
+        hydrateSnapshots: (nextSnapshots) => import_effect5.SubscriptionRef.set(snapshots, new Map(nextSnapshots)),
+        snapshots: snapshots.changes
+      };
+    })
+  );
+};
+var fetchQuery = (definition, input, options) => import_effect5.Effect.flatMap(Data, (service) => service.fetch(definition, input, options));
+
+// src/data/react.tsx
+var import_effect6 = require("effect");
+var import_react2 = require("react");
+var useDataService = () => {
+  const runtime = useEffectRuntime();
+  return (0, import_react2.useMemo)(() => runtime.runSync(Data), [runtime]);
+};
+var useQuery = (definition, input, options = {}) => {
+  const runtime = useEffectRuntime();
+  const data = useDataService();
+  const subscribe2 = (0, import_react2.useCallback)(
+    (listener) => {
+      const fiber = runtime.runFork(
+        import_effect6.Stream.runForEach(data.snapshots, () => import_effect6.Effect.sync(listener))
+      );
+      return () => {
+        runtime.runFork(import_effect6.Fiber.interrupt(fiber));
+      };
+    },
+    [data, runtime]
+  );
+  const getSnapshot = (0, import_react2.useCallback)(
+    () => runtime.runSync(data.getSnapshot(definition, input)),
+    [data, definition, input, runtime]
+  );
+  const snapshot = (0, import_react2.useSyncExternalStore)(subscribe2, getSnapshot, getSnapshot);
+  (0, import_react2.useEffect)(() => {
+    if (options.enabled === false) {
+      return;
+    }
+    runtime.runFork(data.prefetch(definition, input));
+  }, [data, definition, input, options.enabled, runtime]);
+  const refetch = (0, import_react2.useCallback)(
+    () => runtime.runPromise(data.fetch(definition, input, { ...options.run, forceRefresh: true })),
+    [data, definition, input, options.run, runtime]
+  );
+  const invalidate2 = (0, import_react2.useCallback)(
+    () => runtime.runPromise(data.invalidate(definition, input)),
+    [data, definition, input, runtime]
+  );
+  return {
+    ...snapshot,
+    refetch,
+    invalidate: invalidate2
+  };
+};
+var useSuspenseQuery = (definition, input) => {
+  const result = useQuery(definition, input);
+  if (result.phase === "failure") {
+    throw result.error;
+  }
+  if (result.phase === "success") {
+    return result.data;
+  }
+  throw result.refetch();
+};
+
+// src/navigation/types.ts
+var defineRoute = (route) => route;
+var defineLoader = (loader) => loader;
+var NavigationRuntimeError = class extends Error {
+  constructor(messageText) {
+    super(messageText);
+    this.messageText = messageText;
+    this.name = "NavigationRuntimeError";
+  }
+  _tag = "NavigationRuntimeError";
+};
+var NavigationCancelledError = class extends Error {
+  constructor(pathname) {
+    super(`Navigation cancelled for ${pathname}`);
+    this.pathname = pathname;
+    this.name = "NavigationCancelledError";
+  }
+  _tag = "NavigationCancelledError";
+};
+
+// src/navigation/matcher.ts
+var normalizePathname = (pathname) => {
+  if (pathname.length === 0) {
+    return "/";
+  }
+  const withSlash = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  if (withSlash.length > 1 && withSlash.endsWith("/")) {
+    return withSlash.slice(0, -1);
+  }
+  return withSlash;
+};
+var scoreRoute = (path) => {
+  if (path === "/") {
+    return 10;
+  }
+  return path.split("/").filter((segment) => segment.length > 0).reduce((score, segment) => {
+    if (segment === "*") {
+      return score;
+    }
+    if (segment.startsWith(":")) {
+      return score + 2;
+    }
+    return score + 5;
+  }, 0);
+};
+var splitSegments = (path) => normalizePathname(path).split("/").filter((segment) => segment.length > 0);
+var matchRoutePath = (routePath2, pathname) => {
+  const routeSegments = splitSegments(routePath2);
+  const pathSegments = splitSegments(pathname);
+  const params = {};
+  let i = 0;
+  let j = 0;
+  while (i < routeSegments.length && j < pathSegments.length) {
+    const routeSegment = routeSegments[i];
+    const pathSegment = pathSegments[j];
+    if (routeSegment === "*") {
+      return params;
+    }
+    if (routeSegment.startsWith(":")) {
+      params[routeSegment.slice(1)] = decodeURIComponent(pathSegment);
+      i += 1;
+      j += 1;
+      continue;
+    }
+    if (routeSegment !== pathSegment) {
+      return null;
+    }
+    i += 1;
+    j += 1;
+  }
+  if (i < routeSegments.length && routeSegments[i] === "*") {
+    return params;
+  }
+  if (i !== routeSegments.length || j !== pathSegments.length) {
+    return null;
+  }
+  return params;
+};
+var matchRoute = ({ routes, pathname, search }) => {
+  const normalized = normalizePathname(pathname);
+  const sorted = [...routes].sort((a, b) => scoreRoute(b.path) - scoreRoute(a.path));
+  for (const route of sorted) {
+    const params = matchRoutePath(route.path, normalized);
+    if (params !== null) {
+      return {
+        route,
+        pathname: normalized,
+        params,
+        search
+      };
+    }
+  }
+  return null;
+};
+var buildHref = (pathname, searchText) => searchText.length > 0 ? `${normalizePathname(pathname)}${searchText}` : normalizePathname(pathname);
+var normalizeSearchText = (searchText) => {
+  if (searchText.length === 0 || searchText === "?") {
+    return "";
+  }
+  return searchText.startsWith("?") ? searchText : `?${searchText}`;
+};
+var parseHref = (href) => {
+  const [pathPart, ...searchParts] = href.split("?");
+  return {
+    pathname: normalizePathname(pathPart ?? "/"),
+    searchText: normalizeSearchText(searchParts.length === 0 ? "" : searchParts.join("?"))
+  };
+};
+
+// src/navigation/service.ts
+var import_effect7 = require("effect");
+var describeUnknown = (value) => {
+  if (value instanceof Error) {
+    return `${value.name}: ${value.message}`;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+var initialSnapshot2 = {
+  pathname: "/",
+  searchText: "",
+  href: "/",
+  status: "idle",
+  match: null,
+  loaders: {},
+  error: void 0
+};
+var toLoadersByName = (loaders) => new Map(loaders.map((loader) => [loader.name, loader]));
+var planLoaderBatches = (loaders) => {
+  const byName = toLoadersByName(loaders);
+  const depthByName = /* @__PURE__ */ new Map();
+  const visiting = /* @__PURE__ */ new Set();
+  const resolveDepth = (name) => {
+    const cached = depthByName.get(name);
+    if (cached !== void 0) {
+      return import_effect7.Effect.succeed(cached);
+    }
+    if (visiting.has(name)) {
+      return import_effect7.Effect.fail(new NavigationRuntimeError(`Cyclic loader dependency detected at ${name}`));
+    }
+    const loader = byName.get(name);
+    if (loader === void 0) {
+      return import_effect7.Effect.fail(new NavigationRuntimeError(`Loader dependency '${name}' is not registered`));
+    }
+    visiting.add(name);
+    const dependencies = loader.dependsOn ?? [];
+    return import_effect7.Effect.forEach(dependencies, resolveDepth).pipe(
+      import_effect7.Effect.map((depths) => {
+        const depth = depths.length === 0 ? 0 : Math.max(...depths) + 1;
+        depthByName.set(name, depth);
+        visiting.delete(name);
+        return depth;
+      }),
+      import_effect7.Effect.catchAll((error) => {
+        visiting.delete(name);
+        return import_effect7.Effect.fail(error);
+      })
+    );
+  };
+  return import_effect7.Effect.gen(function* () {
+    const entries = yield* import_effect7.Effect.forEach(
+      loaders,
+      (loader) => import_effect7.Effect.map(resolveDepth(loader.name), (depth) => [depth, loader])
+    );
+    const grouped = /* @__PURE__ */ new Map();
+    for (const [depth, loader] of entries) {
+      const existing = grouped.get(depth);
+      if (existing === void 0) {
+        grouped.set(depth, [loader]);
+      } else {
+        existing.push(loader);
+      }
+    }
+    const depths = Array.from(grouped.keys()).sort((a, b) => a - b);
+    return depths.map((depth) => grouped.get(depth) ?? []);
+  });
+};
+var Navigation = class extends import_effect7.Context.Tag("EffectReact/Navigation")() {
+};
+var makeNavigationLayer = (options) => {
+  const loaders = options.loaders ?? [];
+  const initial = parseHref(options.initialHref ?? "/");
+  return import_effect7.Layer.effect(
+    Navigation,
+    import_effect7.Effect.gen(function* () {
+      const boundary = yield* Boundary;
+      const telemetry = yield* Telemetry;
+      const snapshotsRef = yield* import_effect7.SubscriptionRef.make({
+        ...initialSnapshot2,
+        pathname: initial.pathname,
+        searchText: initial.searchText,
+        href: buildHref(initial.pathname, initial.searchText)
+      });
+      const activeFiberRef = yield* import_effect7.Ref.make(import_effect7.Option.none());
+      const runLoaders = (snapshot) => import_effect7.Effect.gen(function* () {
+        if (snapshot.match === null) {
+          return {};
+        }
+        const routeLoaders = loaders.filter((loader) => loader.routeId === snapshot.match.route.id);
+        if (routeLoaders.length === 0) {
+          return {};
+        }
+        const batches = yield* planLoaderBatches(routeLoaders);
+        const results = {};
+        const states = {};
+        for (const loader of routeLoaders) {
+          states[loader.name] = { _tag: "pending" };
+        }
+        yield* import_effect7.SubscriptionRef.update(snapshotsRef, (current) => ({
+          ...current,
+          loaders: {
+            ...current.loaders,
+            ...states
+          }
+        }));
+        for (const batch of batches) {
+          const exits = yield* import_effect7.Effect.all(
+            batch.map((loader) => {
+              const base = loader.run({
+                route: snapshot.match.route,
+                pathname: snapshot.pathname,
+                searchText: snapshot.searchText,
+                params: snapshot.match.params,
+                search: snapshot.match.search,
+                dependencyResults: results
+              });
+              const withRetry = loader.retry ? import_effect7.Effect.retry(base, loader.retry) : base;
+              return import_effect7.Effect.exit(withRetry).pipe(import_effect7.Effect.map((exit) => [loader, exit]));
+            }),
+            {
+              concurrency: "unbounded"
+            }
+          );
+          for (const [loader, exit] of exits) {
+            if (exit._tag === "Success") {
+              results[loader.name] = exit.value;
+              states[loader.name] = {
+                _tag: "success",
+                value: exit.value
+              };
+              continue;
+            }
+            const failure = import_effect7.Cause.failureOption(exit.cause);
+            states[loader.name] = {
+              _tag: "failure",
+              error: failure._tag === "Some" ? failure.value : import_effect7.Cause.pretty(exit.cause)
+            };
+            yield* import_effect7.SubscriptionRef.update(snapshotsRef, (current) => ({
+              ...current,
+              status: "failure",
+              loaders: {
+                ...current.loaders,
+                ...states
+              },
+              error: states[loader.name]
+            }));
+            return yield* import_effect7.Effect.fail(
+              new NavigationRuntimeError(`Loader '${loader.name}' failed for route '${snapshot.match.route.id}'`)
+            );
+          }
+          yield* import_effect7.SubscriptionRef.update(snapshotsRef, (current) => ({
+            ...current,
+            loaders: {
+              ...current.loaders,
+              ...states
+            }
+          }));
+        }
+        return states;
+      });
+      const performNavigation = (href) => import_effect7.Effect.gen(function* () {
+        const { pathname, searchText } = parseHref(href);
+        const searchParams = new URLSearchParams(searchText);
+        const candidate = options.routes.find((route) => matchRoute({
+          routes: [route],
+          pathname,
+          search: {}
+        }) !== null);
+        const decodedSearch = candidate?.search === void 0 ? import_effect7.Effect.succeed({}) : boundary.decodeUnknown({
+          source: `route:${candidate.id}:search`,
+          schema: candidate.search,
+          value: Object.fromEntries(searchParams.entries())
+        });
+        const search = yield* decodedSearch;
+        const matched = matchRoute({
+          routes: options.routes,
+          pathname,
+          search
+        });
+        if (matched === null) {
+          return yield* import_effect7.Effect.fail(
+            new NavigationRuntimeError(`No route matched pathname '${pathname}'`)
+          );
+        }
+        yield* telemetry.emit({
+          _tag: "navigation",
+          phase: "start",
+          pathname,
+          routeId: matched.route.id,
+          timestamp: Date.now()
+        });
+        const loadingSnapshot = {
+          pathname,
+          searchText: normalizeSearchText(searchText),
+          href: buildHref(pathname, normalizeSearchText(searchText)),
+          status: "loading",
+          match: matched,
+          loaders: {},
+          error: void 0
+        };
+        yield* import_effect7.SubscriptionRef.set(snapshotsRef, loadingSnapshot);
+        const loaderStates = yield* runLoaders(loadingSnapshot);
+        const completed = {
+          ...loadingSnapshot,
+          status: "success",
+          loaders: loaderStates,
+          error: void 0
+        };
+        yield* import_effect7.SubscriptionRef.set(snapshotsRef, completed);
+        yield* telemetry.emit({
+          _tag: "navigation",
+          phase: "success",
+          pathname,
+          routeId: matched.route.id,
+          timestamp: Date.now()
+        });
+        return completed;
+      });
+      const navigate2 = (href) => import_effect7.Effect.gen(function* () {
+        const previous = yield* import_effect7.Ref.getAndSet(activeFiberRef, import_effect7.Option.none());
+        if (import_effect7.Option.isSome(previous)) {
+          yield* import_effect7.Fiber.interrupt(previous.value);
+          yield* telemetry.emit({
+            _tag: "navigation",
+            phase: "cancel",
+            pathname: href,
+            timestamp: Date.now()
+          });
+        }
+        const fiber = yield* import_effect7.Effect.fork(performNavigation(href));
+        yield* import_effect7.Ref.set(activeFiberRef, import_effect7.Option.some(fiber));
+        const exit = yield* import_effect7.Effect.exit(import_effect7.Fiber.join(fiber));
+        const current = yield* import_effect7.Ref.get(activeFiberRef);
+        if (import_effect7.Option.isSome(current) && current.value === fiber) {
+          yield* import_effect7.Ref.set(activeFiberRef, import_effect7.Option.none());
+        }
+        if (exit._tag === "Success") {
+          return exit.value;
+        }
+        if (import_effect7.Cause.isInterruptedOnly(exit.cause)) {
+          return yield* import_effect7.Effect.fail(new NavigationCancelledError(href));
+        }
+        const failure = import_effect7.Cause.failureOption(exit.cause);
+        if (failure._tag === "Some") {
+          return yield* import_effect7.Effect.fail(
+            failure.value instanceof NavigationRuntimeError ? failure.value : new NavigationRuntimeError(describeUnknown(failure.value))
+          );
+        }
+        return yield* import_effect7.Effect.fail(new NavigationRuntimeError(import_effect7.Cause.pretty(exit.cause)));
+      }).pipe(
+        import_effect7.Effect.tapError(
+          (error) => telemetry.emit({
+            _tag: "navigation",
+            phase: "failure",
+            pathname: href,
+            timestamp: Date.now(),
+            detail: error
+          })
+        )
+      );
+      const revalidate = () => import_effect7.Effect.gen(function* () {
+        const snapshot = yield* import_effect7.SubscriptionRef.get(snapshotsRef);
+        return yield* navigate2(snapshot.href);
+      });
+      return {
+        navigate: navigate2,
+        revalidate,
+        getSnapshot: import_effect7.SubscriptionRef.get(snapshotsRef),
+        hydrateSnapshot: (snapshot) => import_effect7.SubscriptionRef.set(snapshotsRef, snapshot),
+        snapshots: snapshotsRef.changes
+      };
+    })
+  );
+};
+var navigateTo = (href) => import_effect7.Effect.flatMap(Navigation, (service) => service.navigate(href));
+
+// src/navigation/react.tsx
+var import_effect8 = require("effect");
+var import_react3 = require("react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var useNavigationService = () => {
+  const runtime = useEffectRuntime();
+  return (0, import_react3.useMemo)(() => runtime.runSync(Navigation), [runtime]);
+};
+var useNavigationSnapshot = () => {
+  const runtime = useEffectRuntime();
+  const navigation = useNavigationService();
+  const subscribe2 = (0, import_react3.useCallback)(
+    (listener) => {
+      const fiber = runtime.runFork(
+        import_effect8.Stream.runForEach(navigation.snapshots, () => import_effect8.Effect.sync(listener))
+      );
+      return () => {
+        runtime.runFork(import_effect8.Fiber.interrupt(fiber));
+      };
+    },
+    [navigation, runtime]
+  );
+  const getSnapshot = (0, import_react3.useCallback)(
+    () => runtime.runSync(navigation.getSnapshot),
+    [navigation, runtime]
+  );
+  return (0, import_react3.useSyncExternalStore)(subscribe2, getSnapshot, getSnapshot);
+};
+var useNavigate = () => {
+  const runtime = useEffectRuntime();
+  const navigation = useNavigationService();
+  return (0, import_react3.useCallback)(
+    (href) => runtime.runPromise(navigation.navigate(href)),
+    [navigation, runtime]
+  );
+};
+var Link = ({ to, onClick, children, ...rest }) => {
+  const navigate2 = useNavigate();
+  const handleClick = (0, import_react3.useCallback)(
+    (event) => {
+      onClick?.(event);
+      if (event.defaultPrevented) {
+        return;
+      }
+      if (event.button !== 0 || event.metaKey || event.altKey || event.ctrlKey || event.shiftKey) {
+        return;
+      }
+      event.preventDefault();
+      void navigate2(to);
+    },
+    [navigate2, onClick, to]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("a", { ...rest, href: to, onClick: handleClick, children });
+};
+var Outlet = ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, { children });
+
+// src/kernel/runtime.ts
+var import_effect9 = require("effect");
+var createManagedRuntime = (layer) => import_effect9.ManagedRuntime.make(layer);
+
+// src/kernel/app.ts
+var createAppLayer = (options) => {
+  const boundaryLayer = BoundaryLive;
+  const telemetryLayer = TelemetryLive;
+  const dataLayer = makeDataLayer(options.data).pipe(
+    import_effect10.Layer.provide([boundaryLayer, telemetryLayer])
+  );
+  const actionsLayer = makeActionsLayer({
+    actions: options.actions ?? []
+  }).pipe(import_effect10.Layer.provide([boundaryLayer, telemetryLayer]));
+  const navigationLayer = makeNavigationLayer({
+    routes: options.routes,
+    ...options.loaders !== void 0 ? { loaders: options.loaders } : {},
+    ...options.initialHref !== void 0 ? { initialHref: options.initialHref } : {}
+  }).pipe(import_effect10.Layer.provide([boundaryLayer, telemetryLayer]));
+  return import_effect10.Layer.mergeAll(boundaryLayer, telemetryLayer, dataLayer, actionsLayer, navigationLayer);
+};
+var createAppRuntime = (options) => createManagedRuntime(createAppLayer(options));
+
+// src/framework/manifest.ts
+var defineManifest = (manifest) => manifest;
+var routesFromManifest = (manifest) => manifest.pages.map((page) => page.route);
+var loadersFromManifest = (manifest) => {
+  const pageLoaders = manifest.pages.map((page) => page.loader).filter((loader) => loader !== void 0);
+  const layoutLoaders = (manifest.layouts ?? []).map((layout) => layout.loader).filter((loader) => loader !== void 0);
+  return [...pageLoaders, ...layoutLoaders];
+};
+
+// src/config/index.ts
+var defaultConfig = {
+  appDir: "app",
+  adapters: ["node", "bun"],
+  ssr: {
+    streaming: true
+  },
+  cache: {
+    defaultPolicy: "no-store",
+    routeSegmentDefaults: "explicit"
+  },
+  strict: {
+    boundarySchemas: true,
+    typedErrors: true
+  }
+};
+var defineConfig = (config) => config;
+var resolveConfig = (config = {}) => ({
+  appDir: config.appDir ?? defaultConfig.appDir,
+  adapters: config.adapters ?? defaultConfig.adapters,
+  ssr: {
+    streaming: config.ssr?.streaming ?? defaultConfig.ssr.streaming
+  },
+  cache: {
+    defaultPolicy: config.cache?.defaultPolicy ?? defaultConfig.cache.defaultPolicy,
+    routeSegmentDefaults: config.cache?.routeSegmentDefaults ?? defaultConfig.cache.routeSegmentDefaults
+  },
+  strict: {
+    boundarySchemas: config.strict?.boundarySchemas ?? defaultConfig.strict.boundarySchemas,
+    typedErrors: config.strict?.typedErrors ?? defaultConfig.strict.typedErrors
+  }
+});
+
+// src/framework/app.ts
+var createPageMatcher = (pages) => {
+  const routes = pages.map((page) => page.route);
+  return (href) => {
+    const parsed = parseHref(href);
+    const matched = matchRoute({
+      routes,
+      pathname: parsed.pathname,
+      search: {}
+    });
+    if (matched === null) {
+      return void 0;
+    }
+    return pages.find((page) => page.route.id === matched.route.id);
+  };
+};
+var createApp = (options) => {
+  const manifest = options.manifest;
+  const routes = routesFromManifest(manifest);
+  const loaders = loadersFromManifest(manifest);
+  const actions = manifest.actions ?? [];
+  const runtime = createAppRuntime({
+    routes,
+    actions,
+    loaders,
+    ...options.initialHref !== void 0 ? { initialHref: options.initialHref } : {}
+  });
+  const actionHandlerFactory = createActionHttpHandler();
+  const handleActionRequest = actionHandlerFactory((effect) => runtime.runPromise(effect));
+  return {
+    manifest,
+    config: resolveConfig(options.config),
+    runtime,
+    actions,
+    matchPage: createPageMatcher(manifest.pages),
+    handleActionRequest,
+    dispose: () => runtime.dispose()
+  };
+};
+
+// src/framework/cache.ts
+var cachePolicy = (policy) => policy;
+var noStore = () => ({
+  mode: "no-store"
+});
+
+// src/framework/contracts.ts
+var definePage = (page) => page;
+var defineLayout = (layout) => layout;
+var defineMiddleware = (middleware) => middleware;
+
+// src/server/index.ts
+var import_effect13 = require("effect");
+var import_react4 = require("react");
+
+// src/render/hydration.ts
+var import_effect11 = require("effect");
+var QuerySnapshotSchema = import_effect11.Schema.Struct({
+  key: import_effect11.Schema.String,
+  phase: import_effect11.Schema.Union(
+    import_effect11.Schema.Literal("initial"),
+    import_effect11.Schema.Literal("loading"),
+    import_effect11.Schema.Literal("success"),
+    import_effect11.Schema.Literal("failure")
+  ),
+  data: import_effect11.Schema.NullishOr(import_effect11.Schema.Unknown),
+  error: import_effect11.Schema.NullishOr(import_effect11.Schema.Unknown),
+  updatedAt: import_effect11.Schema.NullishOr(import_effect11.Schema.Number)
+});
+var HydrationStateSchema = import_effect11.Schema.Struct({
+  version: import_effect11.Schema.Literal(1),
+  data: import_effect11.Schema.Array(import_effect11.Schema.Tuple(import_effect11.Schema.String, QuerySnapshotSchema)),
+  navigationHref: import_effect11.Schema.String
+});
+var escapeForScript = (value) => value.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+var dehydrateAppState = () => import_effect11.Effect.gen(function* () {
+  const data = yield* Data;
+  const navigation = yield* Navigation;
+  const snapshots = yield* data.getAllSnapshots;
+  const navigationSnapshot = yield* navigation.getSnapshot;
+  return {
+    version: 1,
+    data: Array.from(snapshots.entries()),
+    navigationHref: navigationSnapshot.href
+  };
+});
+var createHydrationScript = (state, globalName = "__effectReactHydration") => {
+  const serialized = JSON.stringify(state);
+  return `window[${JSON.stringify(globalName)}]=JSON.parse(${JSON.stringify(escapeForScript(serialized))});`;
+};
+var hydrateAppState = (payload) => import_effect11.Effect.gen(function* () {
+  const boundary = yield* Boundary;
+  const data = yield* Data;
+  const navigation = yield* Navigation;
+  const decoded = yield* boundary.decodeUnknown({
+    source: "hydration:payload",
+    schema: HydrationStateSchema,
+    value: payload
+  });
+  const mapped = new Map(decoded.data);
+  yield* data.hydrateSnapshots(mapped);
+  const current = yield* navigation.getSnapshot;
+  const parsed = parseHref(decoded.navigationHref);
+  yield* navigation.hydrateSnapshot({
+    ...current,
+    pathname: parsed.pathname,
+    searchText: parsed.searchText,
+    href: decoded.navigationHref,
+    status: "success",
+    match: null,
+    loaders: {},
+    error: void 0
+  });
+});
+
+// src/render/ssr.ts
+var import_effect12 = require("effect");
+var ReactDOMServer = __toESM(require("react-dom/server"), 1);
+var htmlResponse = (options) => {
+  const headers = new Headers(options.headers);
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "text/html; charset=utf-8");
+  }
+  return new Response(options.html, {
+    status: options.status,
+    headers
+  });
+};
+var injectScript = (html, script) => {
+  const tag = `<script>${script}</script>`;
+  const bodyClose = html.lastIndexOf("</body>");
+  if (bodyClose === -1) {
+    return `${html}${tag}`;
+  }
+  return `${html.slice(0, bodyClose)}${tag}${html.slice(bodyClose)}`;
+};
+var toError = (cause) => cause instanceof Error ? cause : new Error(String(cause));
+var createSsrHandler = (options) => (request) => {
+  const program = import_effect12.Effect.gen(function* () {
+    const element = yield* options.render(request);
+    const html = ReactDOMServer.renderToString(element);
+    const state = yield* dehydrateAppState();
+    const script = createHydrationScript(state, options.hydrationGlobalName);
+    return htmlResponse({
+      html: injectScript(html, script),
+      status: options.status ?? 200,
+      ...options.headers !== void 0 ? { headers: options.headers } : {}
+    });
+  });
+  return options.runtime.runPromise(program).catch((cause) => {
+    const squashed = toError(cause);
+    if (options.onError !== void 0) {
+      return options.onError(squashed);
+    }
+    return new Response(`SSR render failed: ${squashed.message}`, {
+      status: 500,
+      headers: {
+        "content-type": "text/plain; charset=utf-8"
+      }
+    });
+  });
+};
+
+// src/server/index.ts
+var defaultNotFoundElement = () => (0, import_react4.createElement)("main", void 0, "Not Found");
+var createRequestHandler = (options) => {
+  const actionPath = options.actionPath ?? "/_actions";
+  const ssrHandler = createSsrHandler({
+    runtime: options.app.runtime,
+    ...options.hydrationGlobalName !== void 0 ? { hydrationGlobalName: options.hydrationGlobalName } : {},
+    ...options.onError !== void 0 ? { onError: options.onError } : {},
+    render: (request) => import_effect13.Effect.gen(function* () {
+      const url = new URL(request.url);
+      const href = `${url.pathname}${url.search}`;
+      const page = options.app.matchPage(href);
+      if (page === void 0) {
+        return defaultNotFoundElement();
+      }
+      yield* navigateTo(href);
+      if (options.render !== void 0) {
+        return yield* options.render({ request, page });
+      }
+      return (0, import_react4.createElement)(page.component);
+    }).pipe(
+      import_effect13.Effect.mapError(
+        (error) => error instanceof Error ? error : new Error(String(error))
+      )
+    )
+  });
+  return (request) => {
+    const url = new URL(request.url);
+    if (request.method.toUpperCase() === "POST" && url.pathname === actionPath) {
+      return options.app.handleActionRequest(request);
+    }
+    return ssrHandler(request);
+  };
+};
+
+// src/client/index.ts
+var import_effect14 = require("effect");
+var defaultHydrationGlobalName = "__effectReactHydration";
+var readGlobalHydrationPayload = (globalName) => {
+  const globalScope = globalThis;
+  return globalScope[globalName];
+};
+var hydrateApp = (options) => {
+  const payload = options.payload ?? readGlobalHydrationPayload(options.globalName ?? defaultHydrationGlobalName);
+  if (payload === void 0) {
+    return options.app.runtime.runPromise(import_effect14.Effect.void);
+  }
+  return options.app.runtime.runPromise(hydrateAppState(payload));
+};
+
+// src/testing/index.ts
+var createTestApp = (options) => createApp(options);
+
+// src/state/service.ts
+var import_effect15 = require("effect");
+var defaultEquality = (left, right) => Object.is(left, right);
+var createStore = (initial) => import_effect15.Effect.map(import_effect15.SubscriptionRef.make(initial), (ref) => ({ ref }));
+var createStoreFromEffect = (initial) => import_effect15.Effect.flatMap(initial, createStore);
+var createStoreTag = (key) => import_effect15.Context.GenericTag(key);
+var makeStoreLayer = (tag, initial) => import_effect15.Layer.effect(tag, createStore(initial));
+var makeStoreLayerFromEffect = (tag, initial) => import_effect15.Layer.effect(tag, createStoreFromEffect(initial));
+var get = (store) => import_effect15.SubscriptionRef.get(store.ref);
+var set = (store, value) => import_effect15.SubscriptionRef.set(store.ref, value);
+var update = (store, mutate) => import_effect15.SubscriptionRef.update(store.ref, mutate);
+var modify = (store, mutate) => import_effect15.SubscriptionRef.modify(store.ref, mutate);
+var select = (store, selector) => import_effect15.Effect.map(get(store), selector);
+var changes = (store) => store.ref.changes;
+var selectChanges = (store, selector, options = {}) => {
+  const selected = changes(store).pipe(import_effect15.Stream.map(selector));
+  if (options.distinct === false) {
+    return selected;
+  }
+  return selected.pipe(import_effect15.Stream.changesWith(options.equals ?? defaultEquality));
+};
+var derive = (store, selector, options = {}) => ({
+  get: select(store, selector),
+  changes: selectChanges(store, selector, options)
+});
+
+// src/state/react.tsx
+var import_effect16 = require("effect");
+var import_react5 = require("react");
+var defaultEquality2 = (left, right) => Object.is(left, right);
+var useStore = (store) => useStoreSelector(store, (state) => state);
+var useStoreSelector = (store, selector, equals = defaultEquality2) => {
+  const runtime = useEffectRuntime();
+  const subscribe2 = (0, import_react5.useCallback)(
+    (listener) => {
+      const fiber = runtime.runFork(
+        import_effect16.Stream.runForEach(
+          selectChanges(store, selector, {
+            equals
+          }),
+          () => import_effect16.Effect.sync(listener)
+        )
+      );
+      return () => {
+        runtime.runFork(import_effect16.Fiber.interrupt(fiber));
+      };
+    },
+    [equals, runtime, selector, store]
+  );
+  const getSnapshot = (0, import_react5.useCallback)(
+    () => runtime.runSync(select(store, selector)),
+    [runtime, selector, store]
+  );
+  return (0, import_react5.useSyncExternalStore)(subscribe2, getSnapshot, getSnapshot);
+};
+
+// src/query/service.ts
+var import_effect17 = require("effect");
+var fetchQuery2 = fetchQuery;
+var prefetchQuery = (definition, input) => import_effect17.Effect.flatMap(Data, (service) => service.prefetch(definition, input));
+var invalidateQuery = (definition, input) => import_effect17.Effect.flatMap(Data, (service) => service.invalidate(definition, input));
+var prefetch = prefetchQuery;
+var invalidate = invalidateQuery;
+
+// src/query/react.tsx
+var import_effect18 = require("effect");
+var import_react6 = require("react");
+var upsertInfiniteEntry = (entries, nextEntry) => {
+  const index = entries.findIndex((entry) => entry.key === nextEntry.key);
+  if (index < 0) {
+    return [...entries, nextEntry];
+  }
+  const next = [...entries];
+  next[index] = nextEntry;
+  return next;
+};
+var useDataService2 = () => {
+  const runtime = useEffectRuntime();
+  return (0, import_react6.useMemo)(() => runtime.runSync(Data), [runtime]);
+};
+var useQuery2 = (definition, input, options = {}) => useQuery(definition, input, options);
+var useSuspenseQuery2 = (definition, input) => useSuspenseQuery(definition, input);
+var useInfiniteQuery = (definition, options) => {
+  const optionsRef = (0, import_react6.useRef)(options);
+  optionsRef.current = options;
+  const initialPageParam = options.initialPageParam;
+  const enabled = options.enabled;
+  const run = options.run;
+  const getInput = (0, import_react6.useCallback)(
+    (pageParam) => optionsRef.current.getInput(pageParam),
+    []
+  );
+  const getNextPageParam = (0, import_react6.useCallback)(
+    (lastPage, allPages, lastPageParam, allPageParams) => optionsRef.current.getNextPageParam(lastPage, allPages, lastPageParam, allPageParams),
+    []
+  );
+  const runtime = useEffectRuntime();
+  const data = useDataService2();
+  const [initialInput, setInitialInput] = (0, import_react6.useState)(
+    () => getInput(initialPageParam)
+  );
+  const [entries, setEntries] = (0, import_react6.useState)([]);
+  const [error, setError] = (0, import_react6.useState)(void 0);
+  const [isFetchingNextPage, setIsFetchingNextPage] = (0, import_react6.useState)(false);
+  const initialQuery = useQuery2(
+    definition,
+    initialInput,
+    {
+      ...enabled !== void 0 ? { enabled } : {},
+      ...run !== void 0 ? { run } : {}
+    }
+  );
+  (0, import_react6.useEffect)(() => {
+    setInitialInput(getInput(initialPageParam));
+    setEntries([]);
+    setError(void 0);
+    setIsFetchingNextPage(false);
+  }, [definition, getInput, initialPageParam]);
+  (0, import_react6.useEffect)(() => {
+    if (initialQuery.phase === "success") {
+      setEntries(
+        (current) => upsertInfiniteEntry(current, {
+          key: initialQuery.key,
+          pageParam: initialPageParam,
+          data: initialQuery.data
+        })
+      );
+      setError(void 0);
+      return;
+    }
+    if (initialQuery.phase === "failure") {
+      setError(initialQuery.error);
+    }
+  }, [
+    initialQuery.data,
+    initialQuery.error,
+    initialQuery.key,
+    initialQuery.phase,
+    initialPageParam
+  ]);
+  const pages = (0, import_react6.useMemo)(() => entries.map((entry) => entry.data), [entries]);
+  const pageParams = (0, import_react6.useMemo)(() => entries.map((entry) => entry.pageParam), [entries]);
+  const resolveNextPageParam = (0, import_react6.useCallback)(() => {
+    const lastEntry = entries[entries.length - 1];
+    if (lastEntry !== void 0) {
+      return getNextPageParam(lastEntry.data, pages, lastEntry.pageParam, pageParams);
+    }
+    if (initialQuery.phase !== "success") {
+      return void 0;
+    }
+    const initialPage = initialQuery.data;
+    return getNextPageParam(
+      initialPage,
+      [initialPage],
+      initialPageParam,
+      [initialPageParam]
+    );
+  }, [
+    entries,
+    getNextPageParam,
+    initialPageParam,
+    initialQuery.data,
+    initialQuery.phase,
+    pageParams,
+    pages
+  ]);
+  const fetchNextPage = (0, import_react6.useCallback)(() => {
+    const nextPageParam = resolveNextPageParam();
+    if (nextPageParam === void 0) {
+      return runtime.runPromise(import_effect18.Effect.succeed(void 0));
+    }
+    setIsFetchingNextPage(true);
+    setError(void 0);
+    const input = getInput(nextPageParam);
+    const program = import_effect18.Effect.gen(function* () {
+      const value = yield* data.fetch(definition, input, run);
+      const snapshot = yield* data.getSnapshot(definition, input);
+      return {
+        key: snapshot.key,
+        pageParam: nextPageParam,
+        value
+      };
+    });
+    return runtime.runPromise(program).then(
+      ({ key, pageParam, value }) => {
+        setEntries(
+          (current) => upsertInfiniteEntry(current, {
+            key,
+            pageParam,
+            data: value
+          })
+        );
+        setIsFetchingNextPage(false);
+        return value;
+      },
+      (cause) => {
+        setIsFetchingNextPage(false);
+        const resolved = cause;
+        setError(resolved);
+        return runtime.runPromise(import_effect18.Effect.fail(resolved));
+      }
+    );
+  }, [data, definition, getInput, resolveNextPageParam, run, runtime]);
+  const refetch = (0, import_react6.useCallback)(() => {
+    const targets = pageParams.length === 0 ? [initialPageParam] : pageParams;
+    setError(void 0);
+    const program = import_effect18.Effect.forEach(
+      targets,
+      (pageParam) => {
+        const input = getInput(pageParam);
+        return import_effect18.Effect.gen(function* () {
+          const value = yield* data.fetch(definition, input, {
+            ...run,
+            forceRefresh: true
+          });
+          const snapshot = yield* data.getSnapshot(definition, input);
+          return {
+            key: snapshot.key,
+            pageParam,
+            data: value
+          };
+        });
+      },
+      {
+        concurrency: 1,
+        discard: false
+      }
+    );
+    return runtime.runPromise(program).then(
+      (fetchedEntries) => {
+        setEntries(fetchedEntries);
+        return fetchedEntries.map((entry) => entry.data);
+      },
+      (cause) => {
+        const resolved = cause;
+        setError(resolved);
+        return runtime.runPromise(import_effect18.Effect.fail(resolved));
+      }
+    );
+  }, [data, definition, getInput, initialPageParam, pageParams, run, runtime]);
+  const invalidate2 = (0, import_react6.useCallback)(() => {
+    const targets = pageParams.length === 0 ? [initialPageParam] : pageParams;
+    const program = import_effect18.Effect.forEach(
+      targets,
+      (pageParam) => data.invalidate(definition, getInput(pageParam)),
+      {
+        concurrency: 1,
+        discard: true
+      }
+    );
+    return runtime.runPromise(program).then(
+      () => {
+        setEntries([]);
+        setError(void 0);
+        setIsFetchingNextPage(false);
+        return void 0;
+      },
+      (cause) => {
+        const resolved = cause;
+        setError(resolved);
+        return runtime.runPromise(import_effect18.Effect.fail(resolved));
+      }
+    );
+  }, [data, definition, getInput, initialPageParam, pageParams, runtime]);
+  const resolvedError = error ?? (initialQuery.phase === "failure" ? initialQuery.error : void 0);
+  const phase = resolvedError !== void 0 ? "failure" : entries.length > 0 ? "success" : initialQuery.phase;
+  return {
+    phase,
+    pages,
+    pageParams,
+    error: resolvedError,
+    hasNextPage: resolveNextPageParam() !== void 0,
+    isFetchingNextPage,
+    fetchNextPage,
+    refetch,
+    invalidate: invalidate2
+  };
+};
+
+// src/router/helpers.ts
+var PARAM_PATTERN = /:([A-Za-z0-9_]+)/g;
+var appendSearchValue = (params, key, value) => {
+  if (value === null || value === void 0) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const nestedValue of value) {
+      appendSearchValue(params, key, nestedValue);
+    }
+    return;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    params.append(key, String(value));
+  }
+};
+var defaultBase = () => {
+  if (typeof window === "undefined") {
+    return "http://localhost";
+  }
+  return window.location.origin;
+};
+var routeSearchText = (search) => {
+  if (search === void 0) {
+    return "";
+  }
+  const params = new URLSearchParams();
+  const keys = Object.keys(search).sort((a, b) => a.localeCompare(b));
+  for (const key of keys) {
+    appendSearchValue(params, key, search[key]);
+  }
+  const text = params.toString();
+  return text.length > 0 ? `?${text}` : "";
+};
+var routePath = (route, params) => route.path.replace(PARAM_PATTERN, (_match, name) => {
+  const value = params?.[name];
+  if (value === void 0) {
+    throw new Error(`Missing route param '${name}' for route '${route.id}'`);
+  }
+  return encodeURIComponent(String(value));
+});
+var routeHref = (route, options = {}) => buildHref(
+  routePath(route, options.params),
+  routeSearchText(options.search)
+);
+var routeUrl = (route, options = {}) => new URL(
+  routeHref(route, options),
+  options.base ?? defaultBase()
+);
+
+// src/router/service.ts
+var import_effect19 = require("effect");
+var navigate = (href) => navigateTo(href);
+var revalidateNavigation = () => import_effect19.Effect.flatMap(Navigation, (service) => service.revalidate());
+
+// src/router/react.tsx
+var useNavigate2 = () => useNavigate();
+var useNavigationSnapshot2 = () => useNavigationSnapshot();
+var useRouteMatch = (route) => {
+  const snapshot = useNavigationSnapshot2();
+  const match = snapshot.match;
+  if (match === null || match.route.id !== route.id) {
+    return null;
+  }
+  return match;
+};
+
+// src/form/types.ts
+var defineForm = (contract) => contract;
+var FormValidationError = class extends Error {
+  constructor(errors) {
+    super("Form validation failed");
+    this.errors = errors;
+    this.name = "FormValidationError";
+  }
+  _tag = "FormValidationError";
+};
+
+// src/form/service.ts
+var import_effect20 = require("effect");
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var cloneUnknown = (value) => {
+  if (Array.isArray(value)) {
+    return value.map((entry) => cloneUnknown(entry));
+  }
+  if (isRecord(value)) {
+    const clone = {};
+    for (const [key, entry] of Object.entries(value)) {
+      clone[key] = cloneUnknown(entry);
+    }
+    return clone;
+  }
+  return value;
+};
+var cloneValue = (value) => {
+  return cloneUnknown(value);
+};
+var deepEqual = (left, right) => {
+  if (Object.is(left, right)) {
+    return true;
+  }
+  if (Array.isArray(left) && Array.isArray(right)) {
+    if (left.length !== right.length) {
+      return false;
+    }
+    for (let index = 0; index < left.length; index += 1) {
+      if (!deepEqual(left[index], right[index])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (isRecord(left) && isRecord(right)) {
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    if (leftKeys.length !== rightKeys.length) {
+      return false;
+    }
+    for (const key of leftKeys) {
+      if (!(key in right)) {
+        return false;
+      }
+      if (!deepEqual(left[key], right[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+};
+var toFormErrors = (error, fieldNames) => {
+  const formatted = import_effect20.ParseResult.ArrayFormatter.formatErrorSync(error);
+  const errors = {};
+  for (const entry of formatted) {
+    const root = entry.path[0];
+    if (typeof root === "string" && fieldNames.has(root)) {
+      const key = root;
+      errors[key] ??= entry.message;
+      continue;
+    }
+    errors._form ??= entry.message;
+  }
+  if (formatted.length === 0 && errors._form === void 0) {
+    errors._form = "Invalid form values.";
+  }
+  return errors;
+};
+var createInitialState = (defaults) => ({
+  values: cloneValue(defaults),
+  errors: {},
+  touched: {},
+  dirty: false,
+  submitting: false,
+  submitted: false
+});
+var makeForm = (contract) => import_effect20.Effect.gen(function* () {
+  const decode = import_effect20.Schema.decodeUnknown(contract.schema, { errors: "all" });
+  const defaults = cloneValue(contract.defaults);
+  const fieldNames = new Set(Object.keys(defaults));
+  const snapshots = yield* import_effect20.SubscriptionRef.make(createInitialState(defaults));
+  const validateCurrent = (current) => decode(current.values).pipe(
+    import_effect20.Effect.match({
+      onFailure: (issue) => ({
+        _tag: "invalid",
+        errors: toFormErrors(issue, fieldNames),
+        issue
+      }),
+      onSuccess: (values) => ({
+        _tag: "valid",
+        values: cloneValue(values)
+      })
+    })
+  );
+  const setField = (field, value) => import_effect20.SubscriptionRef.update(snapshots, (current) => {
+    const nextValues = {
+      ...current.values,
+      [field]: value
+    };
+    const nextErrors = {
+      ...current.errors
+    };
+    delete nextErrors[field];
+    return {
+      ...current,
+      values: nextValues,
+      errors: nextErrors,
+      touched: {
+        ...current.touched,
+        [field]: true
+      },
+      dirty: !deepEqual(nextValues, defaults),
+      submitted: false
+    };
+  }).pipe(import_effect20.Effect.asVoid);
+  const reset = import_effect20.SubscriptionRef.set(
+    snapshots,
+    createInitialState(defaults)
+  ).pipe(import_effect20.Effect.asVoid);
+  const validate = import_effect20.Effect.gen(function* () {
+    const current = yield* import_effect20.SubscriptionRef.get(snapshots);
+    const result = yield* validateCurrent(current);
+    if (result._tag === "valid") {
+      yield* import_effect20.SubscriptionRef.update(snapshots, (snapshot) => ({
+        ...snapshot,
+        values: result.values,
+        errors: {},
+        dirty: !deepEqual(result.values, defaults)
+      }));
+    } else {
+      yield* import_effect20.SubscriptionRef.update(snapshots, (snapshot) => ({
+        ...snapshot,
+        errors: result.errors
+      }));
+    }
+    return result;
+  });
+  const submit = (handler) => import_effect20.Effect.gen(function* () {
+    yield* import_effect20.SubscriptionRef.update(snapshots, (current2) => ({
+      ...current2,
+      submitting: true,
+      submitted: false
+    }));
+    const current = yield* import_effect20.SubscriptionRef.get(snapshots);
+    const validation = yield* validateCurrent(current);
+    if (validation._tag === "invalid") {
+      yield* import_effect20.SubscriptionRef.update(snapshots, (snapshot) => ({
+        ...snapshot,
+        submitting: false,
+        submitted: false,
+        errors: validation.errors
+      }));
+      return yield* import_effect20.Effect.fail(new FormValidationError(validation.errors));
+    }
+    yield* import_effect20.SubscriptionRef.update(snapshots, (snapshot) => ({
+      ...snapshot,
+      values: validation.values,
+      errors: {},
+      dirty: !deepEqual(validation.values, defaults)
+    }));
+    return yield* handler(validation.values).pipe(
+      import_effect20.Effect.tap(
+        () => import_effect20.SubscriptionRef.update(snapshots, (snapshot) => ({
+          ...snapshot,
+          submitting: false,
+          submitted: true
+        })).pipe(import_effect20.Effect.asVoid)
+      ),
+      import_effect20.Effect.tapError(
+        () => import_effect20.SubscriptionRef.update(snapshots, (snapshot) => ({
+          ...snapshot,
+          submitting: false,
+          submitted: false
+        })).pipe(import_effect20.Effect.asVoid)
+      )
+    );
+  });
+  return {
+    getSnapshot: import_effect20.SubscriptionRef.get(snapshots),
+    snapshots: snapshots.changes,
+    setField,
+    reset,
+    validate,
+    submit
+  };
+});
+
+// src/form/react.tsx
+var import_effect21 = require("effect");
+var import_react9 = require("react");
+var useFormStore = (contract) => {
+  const runtime = useEffectRuntime();
+  return (0, import_react9.useMemo)(() => runtime.runSync(makeForm(contract)), [contract, runtime]);
+};
+var useForm = (contract) => {
+  const runtime = useEffectRuntime();
+  const form = useFormStore(contract);
+  const subscribe2 = (0, import_react9.useCallback)(
+    (listener) => {
+      const fiber = runtime.runFork(import_effect21.Stream.runForEach(form.snapshots, () => import_effect21.Effect.sync(listener)));
+      return () => {
+        runtime.runFork(import_effect21.Fiber.interrupt(fiber));
+      };
+    },
+    [form, runtime]
+  );
+  const getSnapshot = (0, import_react9.useCallback)(() => runtime.runSync(form.getSnapshot), [form, runtime]);
+  const snapshot = (0, import_react9.useSyncExternalStore)(subscribe2, getSnapshot, getSnapshot);
+  const setField = (0, import_react9.useCallback)(
+    (field, value) => runtime.runPromise(form.setField(field, value)),
+    [form, runtime]
+  );
+  const reset = (0, import_react9.useCallback)(
+    () => runtime.runPromise(form.reset),
+    [form, runtime]
+  );
+  const validate = (0, import_react9.useCallback)(
+    () => runtime.runPromise(form.validate),
+    [form, runtime]
+  );
+  const submit = (0, import_react9.useCallback)(
+    (handler) => runtime.runPromise(form.submit(handler)),
+    [form, runtime]
+  );
+  return {
+    ...snapshot,
+    commands: {
+      setField: form.setField,
+      reset: form.reset,
+      validate: form.validate,
+      submit: form.submit
+    },
+    setField,
+    reset,
+    validate,
+    submit
+  };
+};
+
+// src/grid/grid.ts
+var import_effect22 = require("effect");
+var normalizeInteger = (value, minimum) => {
+  if (!Number.isFinite(value)) {
+    return minimum;
+  }
+  return Math.max(minimum, Math.floor(value));
+};
+var toComparable = (value) => {
+  if (value === null || value === void 0 || value instanceof Date) {
+    return value;
+  }
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "bigint":
+    case "boolean":
+      return value;
+    case "symbol":
+      return value.description ?? "symbol";
+    case "function":
+      return value.name.length > 0 ? `[function ${value.name}]` : "[function]";
+    default:
+      try {
+        const encoded = JSON.stringify(value);
+        return encoded ?? "";
+      } catch {
+        return "";
+      }
+  }
+};
+var compareComparable = (left, right) => {
+  if (left === right) {
+    return 0;
+  }
+  if (left === null || left === void 0) {
+    return right === null || right === void 0 ? 0 : -1;
+  }
+  if (right === null || right === void 0) {
+    return 1;
+  }
+  if (left instanceof Date && right instanceof Date) {
+    return import_effect22.Order.Date(left, right);
+  }
+  if (typeof left === "number" && typeof right === "number") {
+    return import_effect22.Order.number(left, right);
+  }
+  if (typeof left === "bigint" && typeof right === "bigint") {
+    return import_effect22.Order.bigint(left, right);
+  }
+  if (typeof left === "boolean" && typeof right === "boolean") {
+    return import_effect22.Order.boolean(left, right);
+  }
+  return import_effect22.Order.string(toSearchText(left), toSearchText(right));
+};
+var comparableOrder = import_effect22.Order.make(compareComparable);
+var toSearchText = (value) => {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  switch (typeof value) {
+    case "string":
+      return value;
+    case "number":
+    case "bigint":
+    case "boolean":
+      return value.toString();
+    case "symbol":
+      return value.description ?? "symbol";
+    case "function":
+      return value.name.length > 0 ? value.name : "function";
+    default:
+      try {
+        const encoded = JSON.stringify(value);
+        return encoded ?? "";
+      } catch {
+        return "";
+      }
+  }
+};
+var defaultFilterMatch = (value, filterValue) => {
+  if (filterValue === null || filterValue === void 0) {
+    return true;
+  }
+  if (typeof filterValue === "string") {
+    const normalizedFilter = filterValue.trim().toLowerCase();
+    if (normalizedFilter.length === 0) {
+      return true;
+    }
+    return toSearchText(value).toLowerCase().includes(normalizedFilter);
+  }
+  if (Array.isArray(filterValue)) {
+    return filterValue.some((candidate) => Object.is(candidate, value));
+  }
+  if (filterValue instanceof Date && value instanceof Date) {
+    return filterValue.getTime() === value.getTime();
+  }
+  return Object.is(value, filterValue);
+};
+var toSortDirection = (direction) => direction === "desc" ? "desc" : "asc";
+var defineColumns = (columns) => columns;
+var projectRow = (row, columns) => {
+  const projection = {};
+  for (const column of columns) {
+    projection[column.id] = column.accessor(row);
+  }
+  return projection;
+};
+var projectRows = (rows, columns) => (0, import_effect22.pipe)(
+  rows,
+  import_effect22.Array.fromIterable,
+  import_effect22.Array.map((row) => projectRow(row, columns))
+);
+var mapRows = projectRows;
+var sortRows = (rows, columns, sorts) => {
+  const input = import_effect22.Array.fromIterable(rows);
+  if (input.length < 2 || sorts.length === 0) {
+    return input;
+  }
+  const columnLookup = /* @__PURE__ */ new Map();
+  for (const column of columns) {
+    columnLookup.set(column.id, column);
+  }
+  const orders = [];
+  for (const sort of sorts) {
+    const column = columnLookup.get(sort.id);
+    if (column === void 0) {
+      continue;
+    }
+    const orderForColumn = import_effect22.Order.mapInput(
+      comparableOrder,
+      (row) => toComparable(column.accessor(row))
+    );
+    orders.push(toSortDirection(sort.direction) === "desc" ? import_effect22.Order.reverse(orderForColumn) : orderForColumn);
+  }
+  if (orders.length === 0) {
+    return input;
+  }
+  const combinedOrder = import_effect22.Order.combineAll(orders);
+  const indexedOrder = import_effect22.Order.combine(
+    import_effect22.Order.mapInput(combinedOrder, (entry) => entry.row),
+    import_effect22.Order.mapInput(import_effect22.Order.number, (entry) => entry.index)
+  );
+  return (0, import_effect22.pipe)(
+    input,
+    import_effect22.Array.map((row, index) => ({ row, index })),
+    import_effect22.Array.sort(indexedOrder),
+    import_effect22.Array.map((entry) => entry.row)
+  );
+};
+var filterRows = (rows, columns, filters) => {
+  const input = import_effect22.Array.fromIterable(rows);
+  if (filters.length === 0) {
+    return input;
+  }
+  const columnLookup = /* @__PURE__ */ new Map();
+  for (const column of columns) {
+    columnLookup.set(column.id, column);
+  }
+  return (0, import_effect22.pipe)(
+    input,
+    import_effect22.Array.filter(
+      (row) => filters.every((filter) => {
+        const column = columnLookup.get(filter.id);
+        if (column === void 0) {
+          return true;
+        }
+        return defaultFilterMatch(column.accessor(row), filter.value);
+      })
+    )
+  );
+};
+var paginateRows = (rows, pagination) => {
+  const input = import_effect22.Array.fromIterable(rows);
+  const pageSize = normalizeInteger(pagination.pageSize, 1);
+  const pageCount = input.length === 0 ? 0 : Math.ceil(input.length / pageSize);
+  const requestedPageIndex = normalizeInteger(pagination.pageIndex, 0);
+  const pageIndex = pageCount === 0 ? 0 : Math.min(requestedPageIndex, pageCount - 1);
+  const pageOffset = pageIndex * pageSize;
+  const pageRows = (0, import_effect22.pipe)(
+    input,
+    import_effect22.Array.drop(pageOffset),
+    import_effect22.Array.take(pageSize)
+  );
+  return {
+    rows: pageRows,
+    pageIndex,
+    pageSize,
+    pageCount,
+    totalRows: input.length
+  };
+};
+
+// src/virtual/virtual.ts
+var import_effect23 = require("effect");
+var normalizeNonNegativeInteger = (value) => {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.max(0, Math.floor(value));
+};
+var normalizeNonNegativeNumber = (value) => {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.max(0, value);
+};
+var normalizePositiveNumber = (value, fallback) => {
+  if (!Number.isFinite(value) || value <= 0) {
+    return fallback;
+  }
+  return value;
+};
+var normalizeCount = (count) => normalizeNonNegativeInteger(count);
+var normalizeEstimateSize = (estimateSize) => normalizePositiveNumber(estimateSize, 1);
+var resolveItemSize = (sizes, index, estimateSize) => normalizePositiveNumber(sizes?.[index] ?? estimateSize, estimateSize);
+var measureVirtualItems = (input) => {
+  const count = normalizeCount(input.count);
+  const estimateSize = normalizeEstimateSize(input.estimateSize);
+  const items = [];
+  let offset = 0;
+  for (let index = 0; index < count; index += 1) {
+    const size = resolveItemSize(input.sizes, index, estimateSize);
+    const start = offset;
+    const end = start + size;
+    items[index] = {
+      index,
+      size,
+      start,
+      end
+    };
+    offset = end;
+  }
+  return items;
+};
+var calculateOffsets = (input) => (0, import_effect23.pipe)(
+  measureVirtualItems(input),
+  import_effect23.Array.map((item) => item.start)
+);
+var calculateTotalSize = (input) => {
+  const items = measureVirtualItems(input);
+  if (items.length === 0) {
+    return 0;
+  }
+  return items[items.length - 1].end;
+};
+var calculateOffsetForIndex = (input) => {
+  const count = normalizeCount(input.count);
+  const index = normalizeNonNegativeInteger(input.index);
+  if (count === 0 || index === 0) {
+    return 0;
+  }
+  if (index >= count) {
+    return calculateTotalSize(input);
+  }
+  const estimateSize = normalizeEstimateSize(input.estimateSize);
+  let offset = 0;
+  for (let currentIndex = 0; currentIndex < index; currentIndex += 1) {
+    offset += resolveItemSize(input.sizes, currentIndex, estimateSize);
+  }
+  return offset;
+};
+var calculateVisibleRange = (input) => {
+  const count = normalizeCount(input.count);
+  if (count === 0) {
+    return {
+      startIndex: 0,
+      endIndex: -1,
+      overscanStartIndex: 0,
+      overscanEndIndex: -1
+    };
+  }
+  const viewportSize = normalizeNonNegativeNumber(input.viewportSize);
+  const scrollOffset = normalizeNonNegativeNumber(input.scrollOffset);
+  const overscan = normalizeNonNegativeInteger(input.overscan ?? 0);
+  const viewportEnd = scrollOffset + viewportSize;
+  const measurements = measureVirtualItems(input);
+  let startIndex = count - 1;
+  let endIndex = count - 1;
+  let foundStart = false;
+  for (const item of measurements) {
+    if (!foundStart && item.end > scrollOffset) {
+      startIndex = item.index;
+      foundStart = true;
+    }
+    if (item.start < viewportEnd) {
+      endIndex = item.index;
+    }
+    if (foundStart && item.start >= viewportEnd) {
+      break;
+    }
+  }
+  if (!foundStart) {
+    startIndex = count - 1;
+    endIndex = count - 1;
+  } else if (viewportSize <= 0) {
+    endIndex = startIndex;
+  }
+  return {
+    startIndex,
+    endIndex,
+    overscanStartIndex: Math.max(0, startIndex - overscan),
+    overscanEndIndex: Math.min(count - 1, endIndex + overscan)
+  };
+};
+var getOffsetForIndex = calculateOffsetForIndex;
+var getTotalSize = calculateTotalSize;
+var getVisibleRange = calculateVisibleRange;
+
+// src/realtime/channel.ts
+var import_effect24 = require("effect");
+var createChannel = (options = {}) => import_effect24.Effect.map(import_effect24.PubSub.unbounded(options), (pubsub) => {
+  const subscribe2 = () => import_effect24.Stream.fromPubSub(pubsub);
+  return {
+    publish: (message) => import_effect24.PubSub.publish(pubsub, message).pipe(import_effect24.Effect.asVoid),
+    publishAll: (messages) => import_effect24.PubSub.publishAll(pubsub, messages).pipe(import_effect24.Effect.asVoid),
+    subscribe: subscribe2,
+    stream: subscribe2(),
+    shutdown: import_effect24.PubSub.shutdown(pubsub)
+  };
+});
+var publish = (channel, message) => channel.publish(message);
+var publishAll = (channel, messages) => channel.publishAll(messages);
+var subscribe = (channel) => channel.subscribe();
+
+// src/realtime/presence.ts
+var import_effect25 = require("effect");
+var cloneMembers = (members) => new Map(members);
+var applyPresenceEvent = (members, event) => {
+  const next = new Map(members);
+  if (event._tag === "join") {
+    next.set(event.memberId, event.member);
+  } else {
+    next.delete(event.memberId);
+  }
+  return next;
+};
+var createPresence = (options) => import_effect25.Effect.gen(function* () {
+  const channel = yield* createChannel();
+  const membersRef = yield* import_effect25.Ref.make(/* @__PURE__ */ new Map());
+  const getMembers = import_effect25.Ref.get(membersRef).pipe(
+    import_effect25.Effect.map((members2) => cloneMembers(members2))
+  );
+  const events = subscribe(channel);
+  const members = import_effect25.Stream.flatMap(
+    import_effect25.Stream.fromEffect(getMembers),
+    (initialMembers) => events.pipe(
+      import_effect25.Stream.scan(
+        initialMembers,
+        (current, event) => applyPresenceEvent(current, event)
+      )
+    )
+  );
+  const join = (member) => {
+    const memberId = options.identify(member);
+    const event = {
+      _tag: "join",
+      memberId,
+      member,
+      timestamp: Date.now()
+    };
+    return import_effect25.Ref.update(membersRef, (current) => {
+      const next = new Map(current);
+      next.set(memberId, member);
+      return next;
+    }).pipe(import_effect25.Effect.zipRight(publish(channel, event)));
+  };
+  const leave = (memberId) => {
+    const event = {
+      _tag: "leave",
+      memberId,
+      timestamp: Date.now()
+    };
+    return import_effect25.Ref.update(membersRef, (current) => {
+      const next = new Map(current);
+      next.delete(memberId);
+      return next;
+    }).pipe(import_effect25.Effect.zipRight(publish(channel, event)));
+  };
+  return {
+    events,
+    members,
+    getMembers,
+    join,
+    leave
+  };
+});
+
+// src/devtools/events.ts
+var import_effect26 = require("effect");
+var emptyRuntimeStream = () => import_effect26.Stream.fromIterable([]);
+var wrapTelemetryEvent = (event) => ({
+  _tag: "telemetry",
+  timestamp: event.timestamp,
+  event
+});
+var wrapRuntimeEvent = (event) => ({
+  _tag: "runtime",
+  timestamp: event.timestamp,
+  event
+});
+var createRuntimeEventSource = () => import_effect26.Effect.map(createChannel(), (channel) => ({
+  emit: (event) => publish(channel, event),
+  stream: subscribe(channel)
+}));
+var createDevtoolsEventStream = (options) => {
+  const telemetry = options.telemetry.pipe(import_effect26.Stream.map(wrapTelemetryEvent));
+  const runtime = (options.runtime ?? emptyRuntimeStream()).pipe(import_effect26.Stream.map(wrapRuntimeEvent));
+  return {
+    stream: import_effect26.Stream.merge(telemetry, runtime)
+  };
+};
+var createDevtoolsEventStreamFromTelemetry = (options = {}) => import_effect26.Effect.map(
+  Telemetry,
+  (telemetry) => createDevtoolsEventStream({
+    telemetry: telemetry.stream,
+    ...options.runtime !== void 0 ? { runtime: options.runtime } : {}
+  })
+);
+
+// src/devtools/react.tsx
+var import_effect27 = require("effect");
+var import_react10 = require("react");
+var appendEvent = (current, event, limit) => {
+  if (limit <= 0) {
+    return current;
+  }
+  if (current.length < limit) {
+    return [...current, event];
+  }
+  return [...current.slice(current.length - limit + 1), event];
+};
+var useEventStream = (stream, options = {}) => {
+  const runtime = useEffectRuntime();
+  const limit = options.limit ?? 128;
+  const [events, setEvents] = (0, import_react10.useState)([]);
+  (0, import_react10.useEffect)(() => {
+    if (options.enabled === false || limit <= 0) {
+      return;
+    }
+    const fiber = runtime.runFork(
+      import_effect27.Stream.runForEach(
+        stream,
+        (event) => import_effect27.Effect.sync(() => {
+          setEvents((current) => appendEvent(current, event, limit));
+        })
+      )
+    );
+    return () => {
+      runtime.runFork(import_effect27.Fiber.interrupt(fiber));
+    };
+  }, [runtime, stream, options.enabled, limit]);
+  return events;
+};
+var useDevtoolsEvents = (source, options = {}) => useEventStream(source.stream, options);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FormValidationError,
+  Link,
+  NavigationCancelledError,
+  NavigationRuntimeError,
+  Outlet,
+  QueryRuntimeError,
+  cachePolicy,
+  calculateOffsetForIndex,
+  calculateOffsets,
+  calculateTotalSize,
+  calculateVisibleRange,
+  changes,
+  createApp,
+  createChannel,
+  createDevtoolsEventStream,
+  createDevtoolsEventStreamFromTelemetry,
+  createPresence,
+  createRequestHandler,
+  createRuntimeEventSource,
+  createStore,
+  createStoreFromEffect,
+  createStoreTag,
+  createTestApp,
+  defaultHydrationGlobalName,
+  defineAction,
+  defineColumns,
+  defineConfig,
+  defineForm,
+  defineLayout,
+  defineLoader,
+  defineManifest,
+  defineMiddleware,
+  definePage,
+  defineQuery,
+  defineRoute,
+  derive,
+  fetchQuery,
+  filterRows,
+  get,
+  getOffsetForIndex,
+  getTotalSize,
+  getVisibleRange,
+  hydrateApp,
+  invalidate,
+  invalidateQuery,
+  loadersFromManifest,
+  makeForm,
+  makeStoreLayer,
+  makeStoreLayerFromEffect,
+  mapRows,
+  measureVirtualItems,
+  modify,
+  navigate,
+  noStore,
+  paginateRows,
+  prefetch,
+  prefetchQuery,
+  projectRow,
+  projectRows,
+  publish,
+  publishAll,
+  resolveConfig,
+  revalidateNavigation,
+  routeHref,
+  routePath,
+  routeSearchText,
+  routeUrl,
+  routesFromManifest,
+  select,
+  selectChanges,
+  set,
+  sortRows,
+  subscribe,
+  update,
+  useDevtoolsEvents,
+  useEventStream,
+  useForm,
+  useInfiniteQuery,
+  useNavigate,
+  useNavigationSnapshot,
+  useQuery,
+  useRouteMatch,
+  useStore,
+  useStoreSelector,
+  useSuspenseQuery
+});
+//# sourceMappingURL=index.cjs.map