@rikalabs/effect-react 0.0.1

package/dist/chunk-C5JI7D7W.js

@@ -0,0 +1,213 @@
+import {
+  Boundary
+} from "./chunk-YG22YP5K.js";
+import {
+  Telemetry
+} from "./chunk-SKC3HMF3.js";
+
+// 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
+import {
+  Cache,
+  Context,
+  Effect,
+  Layer,
+  SubscriptionRef
+} from "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 Context.Tag("EffectReact/Data")() {
+};
+var makeDataLayer = (options = {}) => {
+  const merged = {
+    ...defaultRuntimeOptions,
+    ...options
+  };
+  return Layer.effect(
+    Data,
+    Effect.gen(function* () {
+      const boundary = yield* Boundary;
+      const telemetry = yield* Telemetry;
+      const lookups = /* @__PURE__ */ new Map();
+      const snapshots = yield* SubscriptionRef.make(
+        /* @__PURE__ */ new Map()
+      );
+      const cache = yield* Cache.make({
+        capacity: merged.capacity,
+        timeToLive: merged.timeToLive,
+        lookup: (key) => Effect.suspend(() => {
+          const lookup = lookups.get(key);
+          if (lookup === void 0) {
+            return Effect.fail(new QueryRuntimeError(`No query executor registered for ${key}`));
+          }
+          return lookup;
+        })
+      });
+      const setSnapshot = (key, update) => SubscriptionRef.update(snapshots, (current) => {
+        const next = new Map(current);
+        const previous = next.get(key) ?? initialSnapshot(key);
+        next.set(key, update(previous));
+        return next;
+      }).pipe(Effect.asVoid);
+      const buildKey = (definition, input) => {
+        const base = definition.key ? definition.key(input) : input;
+        return `${definition.name}:${stableStringify(base)}`;
+      };
+      const fetch = (definition, input, runOptions) => 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(
+            Effect.flatMap(
+              (output) => boundary.decodeUnknown({
+                source: `query:${definition.name}:output`,
+                schema: definition.output,
+                value: output
+              })
+            )
+          )
+        );
+        if (runOptions?.forceRefresh === true) {
+          yield* cache.refresh(key).pipe(Effect.ignore);
+        }
+        const value = yield* cache.get(key).pipe(
+          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(
+        Effect.tapError(
+          (error) => 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 prefetch = (definition, input) => fetch(definition, input).pipe(Effect.asVoid);
+      const invalidate = (definition, input) => Effect.gen(function* () {
+        const key = `${definition.name}:${stableStringify(input)}`;
+        yield* cache.invalidate(key);
+        yield* SubscriptionRef.update(snapshots, (current) => {
+          const next = new Map(current);
+          next.delete(key);
+          return next;
+        }).pipe(Effect.asVoid);
+        yield* telemetry.emit({
+          _tag: "query",
+          phase: "invalidate",
+          key,
+          timestamp: Date.now()
+        });
+      });
+      const getSnapshot = (definition, input) => Effect.gen(function* () {
+        const key = `${definition.name}:${stableStringify(input)}`;
+        const current = yield* SubscriptionRef.get(snapshots);
+        const snapshot = current.get(key);
+        if (snapshot === void 0) {
+          return initialSnapshot(key);
+        }
+        return snapshot;
+      });
+      return {
+        fetch,
+        prefetch,
+        invalidate,
+        getSnapshot,
+        getAllSnapshots: SubscriptionRef.get(snapshots),
+        hydrateSnapshots: (nextSnapshots) => SubscriptionRef.set(snapshots, new Map(nextSnapshots)),
+        snapshots: snapshots.changes
+      };
+    })
+  );
+};
+var fetchQuery = (definition, input, options) => Effect.flatMap(Data, (service) => service.fetch(definition, input, options));
+
+export {
+  defineQuery,
+  QueryRuntimeError,
+  Data,
+  makeDataLayer,
+  fetchQuery
+};
+//# sourceMappingURL=chunk-C5JI7D7W.js.map

package/dist/chunk-C5JI7D7W.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/data/types.ts","../src/data/service.ts"],"sourcesContent":["import type { Duration, Effect, Schema } from \"effect\";\nimport type { BoundaryDecodeError } from \"../boundary\";\nimport type { BoundaryProtocolError } from \"../boundary/errors\";\n\nexport interface QueryDefinition<\n  Name extends string,\n  Input,\n  Output,\n  E,\n  InputEncoded = Input,\n  OutputEncoded = Output,\n> {\n  readonly name: Name;\n  readonly input: Schema.Schema<Input, InputEncoded, never>;\n  readonly output: Schema.Schema<Output, OutputEncoded, never>;\n  readonly run: (input: Input) => Effect.Effect<Output, E, never>;\n  readonly key?: (input: Input) => unknown;\n}\n\nexport const defineQuery = <\n  Name extends string,\n  Input,\n  Output,\n  E,\n  InputEncoded = Input,\n  OutputEncoded = Output,\n>(\n  definition: QueryDefinition<Name, Input, Output, E, InputEncoded, OutputEncoded>,\n): QueryDefinition<Name, Input, Output, E, InputEncoded, OutputEncoded> => definition;\n\nexport type QueryPhase = \"initial\" | \"loading\" | \"success\" | \"failure\";\n\nexport interface QuerySnapshot<Output, E> {\n  readonly key: string;\n  readonly phase: QueryPhase;\n  readonly data: Output | undefined;\n  readonly error: E | BoundaryDecodeError | BoundaryProtocolError | QueryRuntimeError | undefined;\n  readonly updatedAt: number | null | undefined;\n}\n\nexport interface QueryRunOptions {\n  readonly forceRefresh?: boolean;\n}\n\nexport interface QueryRuntimeOptions {\n  readonly capacity?: number;\n  readonly timeToLive?: Duration.DurationInput;\n}\n\nexport class QueryRuntimeError extends Error {\n  readonly _tag = \"QueryRuntimeError\" as const;\n\n  constructor(readonly messageText: string) {\n    super(messageText);\n    this.name = \"QueryRuntimeError\";\n  }\n}\n","import {\n  Cache,\n  Context,\n  Effect,\n  Layer,\n  SubscriptionRef,\n  type Stream,\n} from \"effect\";\nimport { Boundary, type BoundaryDecodeError } from \"../boundary\";\nimport type { BoundaryProtocolError } from \"../boundary/errors\";\nimport { Telemetry } from \"../kernel/telemetry\";\nimport {\n  type QueryDefinition,\n  type QueryRunOptions,\n  type QueryRuntimeOptions,\n  type QuerySnapshot,\n  QueryRuntimeError,\n} from \"./types\";\n\nconst defaultRuntimeOptions: Required<QueryRuntimeOptions> = {\n  capacity: 2048,\n  timeToLive: \"5 minutes\",\n};\n\nconst stableStringify = (value: unknown): string => {\n  if (value === null || value === undefined) {\n    return String(value);\n  }\n\n  if (typeof value !== \"object\") {\n    return JSON.stringify(value);\n  }\n\n  if (Array.isArray(value)) {\n    return `[${value.map(stableStringify).join(\",\")}]`;\n  }\n\n  const entries = Object.entries(value as Record<string, unknown>).sort(([a], [b]) =>\n    a.localeCompare(b),\n  );\n  return `{${entries.map(([key, nested]) => `${JSON.stringify(key)}:${stableStringify(nested)}`).join(\",\")}}`;\n};\n\nconst initialSnapshot = <Output, E>(key: string): QuerySnapshot<Output, E> => ({\n  key,\n  phase: \"initial\",\n  data: undefined,\n  error: undefined,\n  updatedAt: null,\n});\n\nexport interface DataService {\n  readonly fetch: <Name extends string, Input, Output, E>(\n    definition: QueryDefinition<Name, Input, Output, E>,\n    input: unknown,\n    options?: QueryRunOptions,\n  ) => Effect.Effect<Output, E | BoundaryDecodeError | BoundaryProtocolError | QueryRuntimeError, never>;\n  readonly prefetch: <Name extends string, Input, Output, E>(\n    definition: QueryDefinition<Name, Input, Output, E>,\n    input: unknown,\n  ) => Effect.Effect<void, E | BoundaryDecodeError | BoundaryProtocolError | QueryRuntimeError, never>;\n  readonly invalidate: <Name extends string, Input, Output, E>(\n    definition: QueryDefinition<Name, Input, Output, E>,\n    input: unknown,\n  ) => Effect.Effect<void, QueryRuntimeError, never>;\n  readonly getSnapshot: <Name extends string, Input, Output, E>(\n    definition: QueryDefinition<Name, Input, Output, E>,\n    input: unknown,\n  ) => Effect.Effect<QuerySnapshot<Output, E>, never, never>;\n  readonly getAllSnapshots: Effect.Effect<ReadonlyMap<string, QuerySnapshot<unknown, unknown>>, never, never>;\n  readonly hydrateSnapshots: (\n    snapshots: ReadonlyMap<string, QuerySnapshot<unknown, unknown>>,\n  ) => Effect.Effect<void, never, never>;\n  readonly snapshots: Stream.Stream<ReadonlyMap<string, QuerySnapshot<unknown, unknown>>>;\n}\n\nexport class Data extends Context.Tag(\"EffectReact/Data\")<Data, DataService>() {}\n\nexport const makeDataLayer = (\n  options: QueryRuntimeOptions = {},\n): Layer.Layer<Data, never, Boundary | Telemetry> => {\n  const merged = {\n    ...defaultRuntimeOptions,\n    ...options,\n  };\n\n  return Layer.effect(\n    Data,\n    Effect.gen(function* () {\n      const boundary = yield* Boundary;\n      const telemetry = yield* Telemetry;\n      const lookups = new Map<string, Effect.Effect<unknown, unknown, never>>();\n      const snapshots = yield* SubscriptionRef.make(\n        new Map<string, QuerySnapshot<unknown, unknown>>() as ReadonlyMap<\n          string,\n          QuerySnapshot<unknown, unknown>\n        >,\n      );\n\n      const cache = yield* Cache.make<string, unknown, unknown>({\n        capacity: merged.capacity,\n        timeToLive: merged.timeToLive,\n        lookup: (key) =>\n          Effect.suspend(() => {\n            const lookup = lookups.get(key);\n            if (lookup === undefined) {\n              return Effect.fail(new QueryRuntimeError(`No query executor registered for ${key}`));\n            }\n            return lookup;\n          }),\n      });\n\n      const setSnapshot = <Output, E>(\n        key: string,\n        update: (previous: QuerySnapshot<Output, E>) => QuerySnapshot<Output, E>,\n      ): Effect.Effect<void> =>\n        SubscriptionRef.update(snapshots, (current) => {\n          const next = new Map(current);\n          const previous =\n            (next.get(key) as QuerySnapshot<Output, E> | undefined) ?? initialSnapshot<Output, E>(key);\n          next.set(key, update(previous));\n          return next;\n        }).pipe(Effect.asVoid);\n\n      const buildKey = <Name extends string, Input, Output, E>(\n        definition: QueryDefinition<Name, Input, Output, E>,\n        input: Input,\n      ): string => {\n        const base = definition.key ? definition.key(input) : input;\n        return `${definition.name}:${stableStringify(base)}`;\n      };\n\n      const fetch = <Name extends string, Input, Output, E>(\n        definition: QueryDefinition<Name, Input, Output, E>,\n        input: unknown,\n        runOptions?: QueryRunOptions,\n      ): Effect.Effect<\n        Output,\n        E | BoundaryDecodeError | BoundaryProtocolError | QueryRuntimeError,\n        never\n      > =>\n        Effect.gen(function* () {\n          const decodedInput = yield* boundary.decodeUnknown({\n            source: `query:${definition.name}:input`,\n            schema: definition.input,\n            value: input,\n          });\n\n          const key = buildKey(definition, decodedInput);\n          yield* telemetry.emit({\n            _tag: \"query\",\n            phase: \"start\",\n            key,\n            timestamp: Date.now(),\n          });\n\n          yield* setSnapshot(key, (previous) => ({\n            ...previous,\n            phase: \"loading\",\n            error: undefined,\n          }));\n\n          lookups.set(\n            key,\n            definition\n              .run(decodedInput)\n              .pipe(\n                Effect.flatMap((output) =>\n                  boundary.decodeUnknown({\n                    source: `query:${definition.name}:output`,\n                    schema: definition.output,\n                    value: output,\n                  }),\n                ),\n              ) as Effect.Effect<unknown, unknown, never>,\n          );\n\n          if (runOptions?.forceRefresh === true) {\n            yield* cache.refresh(key).pipe(Effect.ignore);\n          }\n\n          const value = yield* cache.get(key).pipe(\n            Effect.mapError(\n              (error) =>\n                error as E | BoundaryDecodeError | BoundaryProtocolError | QueryRuntimeError,\n            ),\n          );\n\n          yield* setSnapshot(key, () => ({\n            key,\n            phase: \"success\",\n            data: value,\n            error: undefined,\n            updatedAt: Date.now(),\n          }));\n\n          yield* telemetry.emit({\n            _tag: \"query\",\n            phase: \"success\",\n            key,\n            timestamp: Date.now(),\n          });\n\n          return value as Output;\n        }).pipe(\n          Effect.tapError((error) =>\n            Effect.gen(function* () {\n              const decodedInput = yield* boundary.decodeUnknown({\n                source: `query:${definition.name}:input`,\n                schema: definition.input,\n                value: input,\n              });\n              const key = buildKey(definition, decodedInput);\n              yield* setSnapshot(key, (previous) => ({\n                ...previous,\n                phase: \"failure\",\n                error,\n                updatedAt: previous.updatedAt,\n              }));\n              yield* telemetry.emit({\n                _tag: \"query\",\n                phase: \"failure\",\n                key,\n                timestamp: Date.now(),\n                detail: error,\n              });\n            }),\n          ),\n        );\n\n      const prefetch: DataService[\"prefetch\"] = (definition, input) =>\n        fetch(definition, input).pipe(Effect.asVoid);\n\n      const invalidate: DataService[\"invalidate\"] = (definition, input) =>\n        Effect.gen(function* () {\n          const key = `${definition.name}:${stableStringify(input)}`;\n          yield* cache.invalidate(key);\n          yield* SubscriptionRef.update(snapshots, (current) => {\n            const next = new Map(current);\n            next.delete(key);\n            return next;\n          }).pipe(Effect.asVoid);\n          yield* telemetry.emit({\n            _tag: \"query\",\n            phase: \"invalidate\",\n            key,\n            timestamp: Date.now(),\n          });\n        });\n\n      const getSnapshot = <Name extends string, Input, Output, E>(\n        definition: QueryDefinition<Name, Input, Output, E>,\n        input: unknown,\n      ): Effect.Effect<QuerySnapshot<Output, E>, never, never> =>\n        Effect.gen(function* () {\n          const key = `${definition.name}:${stableStringify(input)}`;\n          const current = yield* SubscriptionRef.get(snapshots);\n          const snapshot = current.get(key);\n          if (snapshot === undefined) {\n            return initialSnapshot<Output, E>(key);\n          }\n          return snapshot as QuerySnapshot<Output, E>;\n        });\n\n      return {\n        fetch,\n        prefetch,\n        invalidate,\n        getSnapshot,\n        getAllSnapshots: SubscriptionRef.get(snapshots),\n        hydrateSnapshots: (nextSnapshots) => SubscriptionRef.set(snapshots, new Map(nextSnapshots)),\n        snapshots: snapshots.changes,\n      } satisfies DataService;\n    }),\n  );\n};\n\nexport const fetchQuery = <Name extends string, Input, Output, E>(\n  definition: QueryDefinition<Name, Input, Output, E>,\n  input: unknown,\n  options?: QueryRunOptions,\n): Effect.Effect<Output, E | BoundaryDecodeError | BoundaryProtocolError | QueryRuntimeError, Data> =>\n  Effect.flatMap(Data, (service) => service.fetch(definition, input, options));\n"],"mappings":"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","names":[]}

package/dist/chunk-EEYASTXR.js

@@ -0,0 +1,99 @@
+import {
+  createHydrationScript,
+  dehydrateAppState
+} from "./chunk-IVIYY6S5.js";
+import {
+  navigateTo
+} from "./chunk-O7XTA7H3.js";
+
+// src/server/index.ts
+import { Effect as Effect2 } from "effect";
+import { createElement } from "react";
+
+// src/render/ssr.ts
+import { Effect } from "effect";
+import * as ReactDOMServer from "react-dom/server";
+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 = 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 = () => 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) => Effect2.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 createElement(page.component);
+    }).pipe(
+      Effect2.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);
+  };
+};
+
+export {
+  createRequestHandler
+};
+//# sourceMappingURL=chunk-EEYASTXR.js.map

package/dist/chunk-EEYASTXR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/server/index.ts","../src/render/ssr.ts"],"sourcesContent":["import { Effect } from \"effect\";\nimport { createElement, type ReactElement } from \"react\";\nimport type { AppServices } from \"../kernel/app\";\nimport { navigateTo } from \"../navigation\";\nimport { createSsrHandler } from \"../render\";\nimport type { AnyPageDefinition } from \"../framework/contracts\";\nimport type { EffectReactApp } from \"../framework/app\";\n\nexport interface CreateRequestHandlerOptions {\n  readonly app: EffectReactApp;\n  readonly render?: (options: {\n    readonly request: Request;\n    readonly page: AnyPageDefinition;\n  }) => Effect.Effect<ReactElement, unknown, AppServices>;\n  readonly actionPath?: string;\n  readonly hydrationGlobalName?: string;\n  readonly onError?: (error: Error) => Response;\n}\n\nconst defaultNotFoundElement = (): ReactElement =>\n  createElement(\"main\", undefined, \"Not Found\");\n\nexport const createRequestHandler = (\n  options: CreateRequestHandlerOptions,\n): ((request: Request) => Promise<Response>) => {\n  const actionPath = options.actionPath ?? \"/_actions\";\n\n  const ssrHandler = createSsrHandler({\n    runtime: options.app.runtime,\n    ...(options.hydrationGlobalName !== undefined\n      ? { hydrationGlobalName: options.hydrationGlobalName }\n      : {}),\n    ...(options.onError !== undefined ? { onError: options.onError } : {}),\n    render: (request) =>\n      Effect.gen(function* () {\n        const url = new URL(request.url);\n        const href = `${url.pathname}${url.search}`;\n        const page = options.app.matchPage(href);\n\n        if (page === undefined) {\n          return defaultNotFoundElement();\n        }\n\n        yield* navigateTo(href);\n\n        if (options.render !== undefined) {\n          return yield* options.render({ request, page });\n        }\n\n        return createElement(page.component);\n      }).pipe(\n        Effect.mapError((error) =>\n          error instanceof Error ? error : new Error(String(error)),\n        ),\n      ),\n  });\n\n  return (request) => {\n    const url = new URL(request.url);\n    if (request.method.toUpperCase() === \"POST\" && url.pathname === actionPath) {\n      return options.app.handleActionRequest(request);\n    }\n\n    return ssrHandler(request);\n  };\n};\n","import { Effect } from \"effect\";\nimport type { ReactElement } from \"react\";\nimport * as ReactDOMServer from \"react-dom/server\";\nimport type { AppServices } from \"../kernel/app\";\nimport type { AppManagedRuntime } from \"../kernel/runtime\";\nimport { createHydrationScript, dehydrateAppState, type HydrationState } from \"./hydration\";\n\nexport interface CreateSsrHandlerOptions<E> {\n  readonly runtime: AppManagedRuntime<AppServices>;\n  readonly render: (request: Request) => Effect.Effect<ReactElement, E, AppServices>;\n  readonly status?: number;\n  readonly headers?: HeadersInit;\n  readonly hydrationGlobalName?: string;\n  readonly onError?: (error: E | Error) => Response;\n}\n\nconst htmlResponse = (options: {\n  readonly html: string;\n  readonly status: number;\n  readonly headers?: HeadersInit;\n}): Response => {\n  const headers = new Headers(options.headers);\n  if (!headers.has(\"content-type\")) {\n    headers.set(\"content-type\", \"text/html; charset=utf-8\");\n  }\n  return new Response(options.html, {\n    status: options.status,\n    headers,\n  });\n};\n\nconst injectScript = (html: string, script: string): string => {\n  const tag = `<script>${script}</script>`;\n  const bodyClose = html.lastIndexOf(\"</body>\");\n  if (bodyClose === -1) {\n    return `${html}${tag}`;\n  }\n  return `${html.slice(0, bodyClose)}${tag}${html.slice(bodyClose)}`;\n};\n\nconst toError = (cause: unknown): Error =>\n  cause instanceof Error ? cause : new Error(String(cause));\n\nexport const createSsrHandler = <E>(options: CreateSsrHandlerOptions<E>) =>\n  (request: Request): Promise<Response> => {\n    const program = Effect.gen(function* () {\n      const element = yield* options.render(request);\n      const html = ReactDOMServer.renderToString(element);\n\n      const state: HydrationState = yield* dehydrateAppState();\n      const script = createHydrationScript(state, options.hydrationGlobalName);\n\n      return htmlResponse({\n        html: injectScript(html, script),\n        status: options.status ?? 200,\n        ...(options.headers !== undefined ? { headers: options.headers } : {}),\n      });\n    });\n\n    return options.runtime\n      .runPromise(program)\n      .catch((cause: unknown) => {\n        const squashed = toError(cause);\n        if (options.onError !== undefined) {\n          return options.onError(squashed as E | Error);\n        }\n        return new Response(`SSR render failed: ${squashed.message}`, {\n          status: 500,\n          headers: {\n            \"content-type\": \"text/plain; charset=utf-8\",\n          },\n        });\n      });\n  };\n"],"mappings":"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","names":["Effect","Effect"]}

package/dist/chunk-H7MOLKTU.js

@@ -0,0 +1,301 @@
+import {
+  useEffectRuntime
+} from "./chunk-2GIUCKL2.js";
+import {
+  Data,
+  fetchQuery
+} from "./chunk-C5JI7D7W.js";
+
+// src/query/service.ts
+import { Effect as Effect2 } from "effect";
+
+// src/data/react.tsx
+import { Effect, Fiber, Stream } from "effect";
+import { useCallback, useEffect, useMemo, useSyncExternalStore } from "react";
+var useDataService = () => {
+  const runtime = useEffectRuntime();
+  return useMemo(() => runtime.runSync(Data), [runtime]);
+};
+var useQuery = (definition, input, options = {}) => {
+  const runtime = useEffectRuntime();
+  const data = useDataService();
+  const subscribe = useCallback(
+    (listener) => {
+      const fiber = runtime.runFork(
+        Stream.runForEach(data.snapshots, () => Effect.sync(listener))
+      );
+      return () => {
+        runtime.runFork(Fiber.interrupt(fiber));
+      };
+    },
+    [data, runtime]
+  );
+  const getSnapshot = useCallback(
+    () => runtime.runSync(data.getSnapshot(definition, input)),
+    [data, definition, input, runtime]
+  );
+  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  useEffect(() => {
+    if (options.enabled === false) {
+      return;
+    }
+    runtime.runFork(data.prefetch(definition, input));
+  }, [data, definition, input, options.enabled, runtime]);
+  const refetch = useCallback(
+    () => runtime.runPromise(data.fetch(definition, input, { ...options.run, forceRefresh: true })),
+    [data, definition, input, options.run, runtime]
+  );
+  const invalidate2 = 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/query/service.ts
+var fetchQuery2 = fetchQuery;
+var prefetchQuery = (definition, input) => Effect2.flatMap(Data, (service) => service.prefetch(definition, input));
+var invalidateQuery = (definition, input) => Effect2.flatMap(Data, (service) => service.invalidate(definition, input));
+var prefetch = prefetchQuery;
+var invalidate = invalidateQuery;
+
+// src/query/react.tsx
+import { Effect as Effect3 } from "effect";
+import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo2, useRef, useState } from "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 useMemo2(() => 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 = useRef(options);
+  optionsRef.current = options;
+  const initialPageParam = options.initialPageParam;
+  const enabled = options.enabled;
+  const run = options.run;
+  const getInput = useCallback2(
+    (pageParam) => optionsRef.current.getInput(pageParam),
+    []
+  );
+  const getNextPageParam = useCallback2(
+    (lastPage, allPages, lastPageParam, allPageParams) => optionsRef.current.getNextPageParam(lastPage, allPages, lastPageParam, allPageParams),
+    []
+  );
+  const runtime = useEffectRuntime();
+  const data = useDataService2();
+  const [initialInput, setInitialInput] = useState(
+    () => getInput(initialPageParam)
+  );
+  const [entries, setEntries] = useState([]);
+  const [error, setError] = useState(void 0);
+  const [isFetchingNextPage, setIsFetchingNextPage] = useState(false);
+  const initialQuery = useQuery2(
+    definition,
+    initialInput,
+    {
+      ...enabled !== void 0 ? { enabled } : {},
+      ...run !== void 0 ? { run } : {}
+    }
+  );
+  useEffect2(() => {
+    setInitialInput(getInput(initialPageParam));
+    setEntries([]);
+    setError(void 0);
+    setIsFetchingNextPage(false);
+  }, [definition, getInput, initialPageParam]);
+  useEffect2(() => {
+    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 = useMemo2(() => entries.map((entry) => entry.data), [entries]);
+  const pageParams = useMemo2(() => entries.map((entry) => entry.pageParam), [entries]);
+  const resolveNextPageParam = useCallback2(() => {
+    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 = useCallback2(() => {
+    const nextPageParam = resolveNextPageParam();
+    if (nextPageParam === void 0) {
+      return runtime.runPromise(Effect3.succeed(void 0));
+    }
+    setIsFetchingNextPage(true);
+    setError(void 0);
+    const input = getInput(nextPageParam);
+    const program = Effect3.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(Effect3.fail(resolved));
+      }
+    );
+  }, [data, definition, getInput, resolveNextPageParam, run, runtime]);
+  const refetch = useCallback2(() => {
+    const targets = pageParams.length === 0 ? [initialPageParam] : pageParams;
+    setError(void 0);
+    const program = Effect3.forEach(
+      targets,
+      (pageParam) => {
+        const input = getInput(pageParam);
+        return Effect3.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(Effect3.fail(resolved));
+      }
+    );
+  }, [data, definition, getInput, initialPageParam, pageParams, run, runtime]);
+  const invalidate2 = useCallback2(() => {
+    const targets = pageParams.length === 0 ? [initialPageParam] : pageParams;
+    const program = Effect3.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(Effect3.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
+  };
+};
+
+export {
+  fetchQuery2 as fetchQuery,
+  prefetchQuery,
+  invalidateQuery,
+  prefetch,
+  invalidate,
+  useQuery2 as useQuery,
+  useSuspenseQuery2 as useSuspenseQuery,
+  useInfiniteQuery
+};
+//# sourceMappingURL=chunk-H7MOLKTU.js.map