@rikalabs/effect-react 0.0.1

package/dist/config/index.cjs

@@ -0,0 +1,63 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config/index.ts
+var config_exports = {};
+__export(config_exports, {
+  defineConfig: () => defineConfig,
+  resolveConfig: () => resolveConfig
+});
+module.exports = __toCommonJS(config_exports);
+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
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineConfig,
+  resolveConfig
+});
+//# sourceMappingURL=index.cjs.map

package/dist/config/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/config/index.ts"],"sourcesContent":["export interface EffectReactConfig {\n  readonly appDir?: string;\n  readonly adapters?: readonly (\"node\" | \"bun\")[];\n  readonly ssr?: {\n    readonly streaming?: boolean;\n  };\n  readonly cache?: {\n    readonly defaultPolicy?: \"no-store\" | \"force-cache\";\n    readonly routeSegmentDefaults?: \"explicit\";\n  };\n  readonly strict?: {\n    readonly boundarySchemas?: boolean;\n    readonly typedErrors?: boolean;\n  };\n}\n\nexport interface EffectReactResolvedConfig {\n  readonly appDir: string;\n  readonly adapters: readonly (\"node\" | \"bun\")[];\n  readonly ssr: {\n    readonly streaming: boolean;\n  };\n  readonly cache: {\n    readonly defaultPolicy: \"no-store\" | \"force-cache\";\n    readonly routeSegmentDefaults: \"explicit\";\n  };\n  readonly strict: {\n    readonly boundarySchemas: boolean;\n    readonly typedErrors: boolean;\n  };\n}\n\nconst defaultConfig: EffectReactResolvedConfig = {\n  appDir: \"app\",\n  adapters: [\"node\", \"bun\"],\n  ssr: {\n    streaming: true,\n  },\n  cache: {\n    defaultPolicy: \"no-store\",\n    routeSegmentDefaults: \"explicit\",\n  },\n  strict: {\n    boundarySchemas: true,\n    typedErrors: true,\n  },\n};\n\nexport const defineConfig = (config: EffectReactConfig): EffectReactConfig => config;\n\nexport const resolveConfig = (\n  config: EffectReactConfig = {},\n): EffectReactResolvedConfig => ({\n  appDir: config.appDir ?? defaultConfig.appDir,\n  adapters: config.adapters ?? defaultConfig.adapters,\n  ssr: {\n    streaming: config.ssr?.streaming ?? defaultConfig.ssr.streaming,\n  },\n  cache: {\n    defaultPolicy: config.cache?.defaultPolicy ?? defaultConfig.cache.defaultPolicy,\n    routeSegmentDefaults:\n      config.cache?.routeSegmentDefaults ?? defaultConfig.cache.routeSegmentDefaults,\n  },\n  strict: {\n    boundarySchemas:\n      config.strict?.boundarySchemas ?? defaultConfig.strict.boundarySchemas,\n    typedErrors: config.strict?.typedErrors ?? defaultConfig.strict.typedErrors,\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgCA,IAAM,gBAA2C;AAAA,EAC/C,QAAQ;AAAA,EACR,UAAU,CAAC,QAAQ,KAAK;AAAA,EACxB,KAAK;AAAA,IACH,WAAW;AAAA,EACb;AAAA,EACA,OAAO;AAAA,IACL,eAAe;AAAA,IACf,sBAAsB;AAAA,EACxB;AAAA,EACA,QAAQ;AAAA,IACN,iBAAiB;AAAA,IACjB,aAAa;AAAA,EACf;AACF;AAEO,IAAM,eAAe,CAAC,WAAiD;AAEvE,IAAM,gBAAgB,CAC3B,SAA4B,CAAC,OACE;AAAA,EAC/B,QAAQ,OAAO,UAAU,cAAc;AAAA,EACvC,UAAU,OAAO,YAAY,cAAc;AAAA,EAC3C,KAAK;AAAA,IACH,WAAW,OAAO,KAAK,aAAa,cAAc,IAAI;AAAA,EACxD;AAAA,EACA,OAAO;AAAA,IACL,eAAe,OAAO,OAAO,iBAAiB,cAAc,MAAM;AAAA,IAClE,sBACE,OAAO,OAAO,wBAAwB,cAAc,MAAM;AAAA,EAC9D;AAAA,EACA,QAAQ;AAAA,IACN,iBACE,OAAO,QAAQ,mBAAmB,cAAc,OAAO;AAAA,IACzD,aAAa,OAAO,QAAQ,eAAe,cAAc,OAAO;AAAA,EAClE;AACF;","names":[]}

package/dist/config/index.d.ts

@@ -0,0 +1,32 @@
+export interface EffectReactConfig {
+    readonly appDir?: string;
+    readonly adapters?: readonly ("node" | "bun")[];
+    readonly ssr?: {
+        readonly streaming?: boolean;
+    };
+    readonly cache?: {
+        readonly defaultPolicy?: "no-store" | "force-cache";
+        readonly routeSegmentDefaults?: "explicit";
+    };
+    readonly strict?: {
+        readonly boundarySchemas?: boolean;
+        readonly typedErrors?: boolean;
+    };
+}
+export interface EffectReactResolvedConfig {
+    readonly appDir: string;
+    readonly adapters: readonly ("node" | "bun")[];
+    readonly ssr: {
+        readonly streaming: boolean;
+    };
+    readonly cache: {
+        readonly defaultPolicy: "no-store" | "force-cache";
+        readonly routeSegmentDefaults: "explicit";
+    };
+    readonly strict: {
+        readonly boundarySchemas: boolean;
+        readonly typedErrors: boolean;
+    };
+}
+export declare const defineConfig: (config: EffectReactConfig) => EffectReactConfig;
+export declare const resolveConfig: (config?: EffectReactConfig) => EffectReactResolvedConfig;

package/dist/config/index.js

@@ -0,0 +1,9 @@
+import {
+  defineConfig,
+  resolveConfig
+} from "../chunk-WPV3WFMS.js";
+export {
+  defineConfig,
+  resolveConfig
+};
+//# sourceMappingURL=index.js.map

package/dist/config/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/data/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./service";
+export * from "./react";

package/dist/data/react.d.ts

@@ -0,0 +1,10 @@
+import type { QueryDefinition, QueryRunOptions, QuerySnapshot } from "./types";
+export interface UseQueryOptions {
+    readonly enabled?: boolean;
+    readonly run?: QueryRunOptions;
+}
+export declare const useQuery: <Name extends string, Input, Output, E>(definition: QueryDefinition<Name, Input, Output, E>, input: unknown, options?: UseQueryOptions) => QuerySnapshot<Output, E> & {
+    readonly refetch: () => Promise<Output>;
+    readonly invalidate: () => Promise<void>;
+};
+export declare const useSuspenseQuery: <Name extends string, Input, Output, E>(definition: QueryDefinition<Name, Input, Output, E>, input: unknown) => Output;

package/dist/data/service.d.ts

@@ -0,0 +1,20 @@
+import { Context, Effect, Layer, type Stream } from "effect";
+import { Boundary, type BoundaryDecodeError } from "../boundary";
+import type { BoundaryProtocolError } from "../boundary/errors";
+import { Telemetry } from "../kernel/telemetry";
+import { type QueryDefinition, type QueryRunOptions, type QueryRuntimeOptions, type QuerySnapshot, QueryRuntimeError } from "./types";
+export interface DataService {
+    readonly fetch: <Name extends string, Input, Output, E>(definition: QueryDefinition<Name, Input, Output, E>, input: unknown, options?: QueryRunOptions) => Effect.Effect<Output, E | BoundaryDecodeError | BoundaryProtocolError | QueryRuntimeError, never>;
+    readonly prefetch: <Name extends string, Input, Output, E>(definition: QueryDefinition<Name, Input, Output, E>, input: unknown) => Effect.Effect<void, E | BoundaryDecodeError | BoundaryProtocolError | QueryRuntimeError, never>;
+    readonly invalidate: <Name extends string, Input, Output, E>(definition: QueryDefinition<Name, Input, Output, E>, input: unknown) => Effect.Effect<void, QueryRuntimeError, never>;
+    readonly getSnapshot: <Name extends string, Input, Output, E>(definition: QueryDefinition<Name, Input, Output, E>, input: unknown) => Effect.Effect<QuerySnapshot<Output, E>, never, never>;
+    readonly getAllSnapshots: Effect.Effect<ReadonlyMap<string, QuerySnapshot<unknown, unknown>>, never, never>;
+    readonly hydrateSnapshots: (snapshots: ReadonlyMap<string, QuerySnapshot<unknown, unknown>>) => Effect.Effect<void, never, never>;
+    readonly snapshots: Stream.Stream<ReadonlyMap<string, QuerySnapshot<unknown, unknown>>>;
+}
+declare const Data_base: Context.TagClass<Data, "EffectReact/Data", DataService>;
+export declare class Data extends Data_base {
+}
+export declare const makeDataLayer: (options?: QueryRuntimeOptions) => Layer.Layer<Data, never, Boundary | Telemetry>;
+export declare const fetchQuery: <Name extends string, Input, Output, E>(definition: QueryDefinition<Name, Input, Output, E>, input: unknown, options?: QueryRunOptions) => Effect.Effect<Output, E | BoundaryDecodeError | BoundaryProtocolError | QueryRuntimeError, Data>;
+export {};

package/dist/data/types.d.ts

@@ -0,0 +1,31 @@
+import type { Duration, Effect, Schema } from "effect";
+import type { BoundaryDecodeError } from "../boundary";
+import type { BoundaryProtocolError } from "../boundary/errors";
+export interface QueryDefinition<Name extends string, Input, Output, E, InputEncoded = Input, OutputEncoded = Output> {
+    readonly name: Name;
+    readonly input: Schema.Schema<Input, InputEncoded, never>;
+    readonly output: Schema.Schema<Output, OutputEncoded, never>;
+    readonly run: (input: Input) => Effect.Effect<Output, E, never>;
+    readonly key?: (input: Input) => unknown;
+}
+export declare const defineQuery: <Name extends string, Input, Output, E, InputEncoded = Input, OutputEncoded = Output>(definition: QueryDefinition<Name, Input, Output, E, InputEncoded, OutputEncoded>) => QueryDefinition<Name, Input, Output, E, InputEncoded, OutputEncoded>;
+export type QueryPhase = "initial" | "loading" | "success" | "failure";
+export interface QuerySnapshot<Output, E> {
+    readonly key: string;
+    readonly phase: QueryPhase;
+    readonly data: Output | undefined;
+    readonly error: E | BoundaryDecodeError | BoundaryProtocolError | QueryRuntimeError | undefined;
+    readonly updatedAt: number | null | undefined;
+}
+export interface QueryRunOptions {
+    readonly forceRefresh?: boolean;
+}
+export interface QueryRuntimeOptions {
+    readonly capacity?: number;
+    readonly timeToLive?: Duration.DurationInput;
+}
+export declare class QueryRuntimeError extends Error {
+    readonly messageText: string;
+    readonly _tag: "QueryRuntimeError";
+    constructor(messageText: string);
+}

package/dist/devtools/events.d.ts

@@ -0,0 +1,37 @@
+import { Effect, Stream } from "effect";
+import { Telemetry, type TelemetryEvent } from "../kernel/telemetry";
+export type RuntimeEvent = {
+    readonly phase: "runtime-created" | "runtime-disposed";
+    readonly timestamp: number;
+    readonly detail?: unknown;
+} | {
+    readonly phase: "run-fork" | "run-sync" | "run-promise";
+    readonly timestamp: number;
+    readonly detail?: unknown;
+};
+export interface RuntimeEventSource {
+    readonly emit: (event: RuntimeEvent) => Effect.Effect<void>;
+    readonly stream: Stream.Stream<RuntimeEvent>;
+}
+export type DevtoolsEvent = {
+    readonly _tag: "telemetry";
+    readonly timestamp: number;
+    readonly event: TelemetryEvent;
+} | {
+    readonly _tag: "runtime";
+    readonly timestamp: number;
+    readonly event: RuntimeEvent;
+};
+export interface DevtoolsEventStream {
+    readonly stream: Stream.Stream<DevtoolsEvent>;
+}
+export interface CreateDevtoolsEventStreamOptions {
+    readonly telemetry: Stream.Stream<TelemetryEvent>;
+    readonly runtime?: Stream.Stream<RuntimeEvent>;
+}
+export interface CreateDevtoolsEventStreamFromTelemetryOptions {
+    readonly runtime?: Stream.Stream<RuntimeEvent>;
+}
+export declare const createRuntimeEventSource: () => Effect.Effect<RuntimeEventSource>;
+export declare const createDevtoolsEventStream: (options: CreateDevtoolsEventStreamOptions) => DevtoolsEventStream;
+export declare const createDevtoolsEventStreamFromTelemetry: (options?: CreateDevtoolsEventStreamFromTelemetryOptions) => Effect.Effect<DevtoolsEventStream, never, Telemetry>;

package/dist/devtools/index.cjs

@@ -0,0 +1,149 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/devtools/index.ts
+var devtools_exports = {};
+__export(devtools_exports, {
+  createDevtoolsEventStream: () => createDevtoolsEventStream,
+  createDevtoolsEventStreamFromTelemetry: () => createDevtoolsEventStreamFromTelemetry,
+  createRuntimeEventSource: () => createRuntimeEventSource,
+  useDevtoolsEvents: () => useDevtoolsEvents,
+  useEventStream: () => useEventStream
+});
+module.exports = __toCommonJS(devtools_exports);
+
+// src/devtools/events.ts
+var import_effect3 = require("effect");
+
+// src/kernel/telemetry.ts
+var import_effect = require("effect");
+var Telemetry = class extends import_effect.Context.Tag("EffectReact/Telemetry")() {
+};
+var TelemetryLive = import_effect.Layer.effect(
+  Telemetry,
+  import_effect.Effect.map(import_effect.PubSub.unbounded(), (pubsub) => ({
+    emit: (event) => import_effect.PubSub.publish(pubsub, event).pipe(import_effect.Effect.asVoid),
+    stream: import_effect.Stream.fromPubSub(pubsub)
+  }))
+);
+
+// src/realtime/channel.ts
+var import_effect2 = require("effect");
+var createChannel = (options = {}) => import_effect2.Effect.map(import_effect2.PubSub.unbounded(options), (pubsub) => {
+  const subscribe2 = () => import_effect2.Stream.fromPubSub(pubsub);
+  return {
+    publish: (message) => import_effect2.PubSub.publish(pubsub, message).pipe(import_effect2.Effect.asVoid),
+    publishAll: (messages) => import_effect2.PubSub.publishAll(pubsub, messages).pipe(import_effect2.Effect.asVoid),
+    subscribe: subscribe2,
+    stream: subscribe2(),
+    shutdown: import_effect2.PubSub.shutdown(pubsub)
+  };
+});
+var publish = (channel, message) => channel.publish(message);
+var subscribe = (channel) => channel.subscribe();
+
+// src/devtools/events.ts
+var emptyRuntimeStream = () => import_effect3.Stream.fromIterable([]);
+var wrapTelemetryEvent = (event) => ({
+  _tag: "telemetry",
+  timestamp: event.timestamp,
+  event
+});
+var wrapRuntimeEvent = (event) => ({
+  _tag: "runtime",
+  timestamp: event.timestamp,
+  event
+});
+var createRuntimeEventSource = () => import_effect3.Effect.map(createChannel(), (channel) => ({
+  emit: (event) => publish(channel, event),
+  stream: subscribe(channel)
+}));
+var createDevtoolsEventStream = (options) => {
+  const telemetry = options.telemetry.pipe(import_effect3.Stream.map(wrapTelemetryEvent));
+  const runtime = (options.runtime ?? emptyRuntimeStream()).pipe(import_effect3.Stream.map(wrapRuntimeEvent));
+  return {
+    stream: import_effect3.Stream.merge(telemetry, runtime)
+  };
+};
+var createDevtoolsEventStreamFromTelemetry = (options = {}) => import_effect3.Effect.map(
+  Telemetry,
+  (telemetry) => createDevtoolsEventStream({
+    telemetry: telemetry.stream,
+    ...options.runtime !== void 0 ? { runtime: options.runtime } : {}
+  })
+);
+
+// src/devtools/react.tsx
+var import_effect4 = require("effect");
+var import_react2 = require("react");
+
+// 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/devtools/react.tsx
+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_react2.useState)([]);
+  (0, import_react2.useEffect)(() => {
+    if (options.enabled === false || limit <= 0) {
+      return;
+    }
+    const fiber = runtime.runFork(
+      import_effect4.Stream.runForEach(
+        stream,
+        (event) => import_effect4.Effect.sync(() => {
+          setEvents((current) => appendEvent(current, event, limit));
+        })
+      )
+    );
+    return () => {
+      runtime.runFork(import_effect4.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 = {
+  createDevtoolsEventStream,
+  createDevtoolsEventStreamFromTelemetry,
+  createRuntimeEventSource,
+  useDevtoolsEvents,
+  useEventStream
+});
+//# sourceMappingURL=index.cjs.map

package/dist/devtools/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/devtools/index.ts","../../src/devtools/events.ts","../../src/kernel/telemetry.ts","../../src/realtime/channel.ts","../../src/devtools/react.tsx","../../src/react/provider.tsx"],"sourcesContent":["export * from \"./events\";\nexport * from \"./react\";\n","import { Effect, Stream } from \"effect\";\nimport { Telemetry, type TelemetryEvent } from \"../kernel/telemetry\";\nimport { createChannel, publish, subscribe } from \"../realtime\";\n\nexport type RuntimeEvent =\n  | {\n      readonly phase: \"runtime-created\" | \"runtime-disposed\";\n      readonly timestamp: number;\n      readonly detail?: unknown;\n    }\n  | {\n      readonly phase: \"run-fork\" | \"run-sync\" | \"run-promise\";\n      readonly timestamp: number;\n      readonly detail?: unknown;\n    };\n\nexport interface RuntimeEventSource {\n  readonly emit: (event: RuntimeEvent) => Effect.Effect<void>;\n  readonly stream: Stream.Stream<RuntimeEvent>;\n}\n\nexport type DevtoolsEvent =\n  | {\n      readonly _tag: \"telemetry\";\n      readonly timestamp: number;\n      readonly event: TelemetryEvent;\n    }\n  | {\n      readonly _tag: \"runtime\";\n      readonly timestamp: number;\n      readonly event: RuntimeEvent;\n    };\n\nexport interface DevtoolsEventStream {\n  readonly stream: Stream.Stream<DevtoolsEvent>;\n}\n\nexport interface CreateDevtoolsEventStreamOptions {\n  readonly telemetry: Stream.Stream<TelemetryEvent>;\n  readonly runtime?: Stream.Stream<RuntimeEvent>;\n}\n\nexport interface CreateDevtoolsEventStreamFromTelemetryOptions {\n  readonly runtime?: Stream.Stream<RuntimeEvent>;\n}\n\nconst emptyRuntimeStream = (): Stream.Stream<RuntimeEvent> =>\n  Stream.fromIterable<RuntimeEvent>([]);\n\nconst wrapTelemetryEvent = (event: TelemetryEvent): DevtoolsEvent => ({\n  _tag: \"telemetry\",\n  timestamp: event.timestamp,\n  event,\n});\n\nconst wrapRuntimeEvent = (event: RuntimeEvent): DevtoolsEvent => ({\n  _tag: \"runtime\",\n  timestamp: event.timestamp,\n  event,\n});\n\nexport const createRuntimeEventSource = (): Effect.Effect<RuntimeEventSource> =>\n  Effect.map(createChannel<RuntimeEvent>(), (channel) => ({\n    emit: (event) => publish(channel, event),\n    stream: subscribe(channel),\n  }));\n\nexport const createDevtoolsEventStream = (\n  options: CreateDevtoolsEventStreamOptions,\n): DevtoolsEventStream => {\n  const telemetry = options.telemetry.pipe(Stream.map(wrapTelemetryEvent));\n  const runtime = (options.runtime ?? emptyRuntimeStream()).pipe(Stream.map(wrapRuntimeEvent));\n\n  return {\n    stream: Stream.merge(telemetry, runtime),\n  };\n};\n\nexport const createDevtoolsEventStreamFromTelemetry = (\n  options: CreateDevtoolsEventStreamFromTelemetryOptions = {},\n): Effect.Effect<DevtoolsEventStream, never, Telemetry> =>\n  Effect.map(Telemetry, (telemetry) =>\n    createDevtoolsEventStream({\n      telemetry: telemetry.stream,\n      ...(options.runtime !== undefined ? { runtime: options.runtime } : {}),\n    }),\n  );\n","import { Context, Effect, Layer, PubSub, Stream } from \"effect\";\n\nexport type TelemetryEvent =\n  | {\n      readonly _tag: \"query\";\n      readonly phase: \"start\" | \"success\" | \"failure\" | \"invalidate\";\n      readonly key: string;\n      readonly timestamp: number;\n      readonly detail?: unknown;\n    }\n  | {\n      readonly _tag: \"navigation\";\n      readonly phase: \"start\" | \"success\" | \"failure\" | \"cancel\";\n      readonly pathname: string;\n      readonly routeId?: string;\n      readonly timestamp: number;\n      readonly detail?: unknown;\n    }\n  | {\n      readonly _tag: \"action\";\n      readonly phase: \"start\" | \"success\" | \"failure\" | \"transport\";\n      readonly name: string;\n      readonly timestamp: number;\n      readonly detail?: unknown;\n    }\n  | {\n      readonly _tag: \"boundary\";\n      readonly phase: \"decode-failure\" | \"protocol-failure\" | \"transport-failure\";\n      readonly source: string;\n      readonly timestamp: number;\n      readonly detail?: unknown;\n    };\n\nexport interface TelemetryService {\n  readonly emit: (event: TelemetryEvent) => Effect.Effect<void>;\n  readonly stream: Stream.Stream<TelemetryEvent>;\n}\n\nexport class Telemetry extends Context.Tag(\"EffectReact/Telemetry\")<\n  Telemetry,\n  TelemetryService\n>() {}\n\nexport const TelemetryLive = Layer.effect(\n  Telemetry,\n  Effect.map(PubSub.unbounded<TelemetryEvent>(), (pubsub) => ({\n    emit: (event) => PubSub.publish(pubsub, event).pipe(Effect.asVoid),\n    stream: Stream.fromPubSub(pubsub),\n  })),\n);\n\nexport const emitTelemetry = (event: TelemetryEvent): Effect.Effect<void, never, Telemetry> =>\n  Effect.flatMap(Telemetry, (service) => service.emit(event));\n","import { Effect, PubSub, Stream } from \"effect\";\n\nexport interface CreateChannelOptions {\n  readonly replay?: number;\n}\n\nexport interface RealtimeChannel<Message> {\n  readonly publish: (message: Message) => Effect.Effect<void>;\n  readonly publishAll: (messages: Iterable<Message>) => Effect.Effect<void>;\n  readonly subscribe: () => Stream.Stream<Message>;\n  readonly stream: Stream.Stream<Message>;\n  readonly shutdown: Effect.Effect<void>;\n}\n\nexport const createChannel = <Message>(\n  options: CreateChannelOptions = {},\n): Effect.Effect<RealtimeChannel<Message>> =>\n  Effect.map(PubSub.unbounded<Message>(options), (pubsub) => {\n    const subscribe = (): Stream.Stream<Message> => Stream.fromPubSub(pubsub);\n\n    return {\n      publish: (message) => PubSub.publish(pubsub, message).pipe(Effect.asVoid),\n      publishAll: (messages) => PubSub.publishAll(pubsub, messages).pipe(Effect.asVoid),\n      subscribe,\n      stream: subscribe(),\n      shutdown: PubSub.shutdown(pubsub),\n    };\n  });\n\nexport const publish = <Message>(\n  channel: RealtimeChannel<Message>,\n  message: Message,\n): Effect.Effect<void> => channel.publish(message);\n\nexport const publishAll = <Message>(\n  channel: RealtimeChannel<Message>,\n  messages: Iterable<Message>,\n): Effect.Effect<void> => channel.publishAll(messages);\n\nexport const subscribe = <Message>(channel: RealtimeChannel<Message>): Stream.Stream<Message> =>\n  channel.subscribe();\n","import { Effect, Fiber, Stream } from \"effect\";\nimport { useEffect, useState } from \"react\";\nimport { useEffectRuntime } from \"../react/provider\";\nimport type { DevtoolsEvent, DevtoolsEventStream } from \"./events\";\n\nexport interface UseEventStreamOptions {\n  readonly enabled?: boolean;\n  readonly limit?: number;\n}\n\nconst appendEvent = <Event,>(\n  current: readonly Event[],\n  event: Event,\n  limit: number,\n): readonly Event[] => {\n  if (limit <= 0) {\n    return current;\n  }\n  if (current.length < limit) {\n    return [...current, event];\n  }\n  return [...current.slice(current.length - limit + 1), event];\n};\n\nexport const useEventStream = <Event,>(\n  stream: Stream.Stream<Event>,\n  options: UseEventStreamOptions = {},\n): readonly Event[] => {\n  const runtime = useEffectRuntime();\n  const limit = options.limit ?? 128;\n  const [events, setEvents] = useState<readonly Event[]>([]);\n\n  useEffect(() => {\n    if (options.enabled === false || limit <= 0) {\n      return;\n    }\n\n    const fiber = runtime.runFork(\n      Stream.runForEach(stream, (event) =>\n        Effect.sync(() => {\n          setEvents((current) => appendEvent(current, event, limit));\n        }),\n      ),\n    );\n\n    return () => {\n      runtime.runFork(Fiber.interrupt(fiber));\n    };\n  }, [runtime, stream, options.enabled, limit]);\n\n  return events;\n};\n\nexport const useDevtoolsEvents = (\n  source: DevtoolsEventStream,\n  options: UseEventStreamOptions = {},\n): readonly DevtoolsEvent[] => useEventStream(source.stream, options);\n","import type { ManagedRuntime } from \"effect\";\nimport { createContext, useContext, useEffect, type ReactNode } from \"react\";\nimport type { AppServices } from \"../kernel/app\";\n\nexport type EffectReactManagedRuntime<R = AppServices> = ManagedRuntime.ManagedRuntime<R, never>;\n\nconst RuntimeContext = createContext<EffectReactManagedRuntime | null>(null);\n\nexport interface EffectProviderProps {\n  readonly runtime: EffectReactManagedRuntime;\n  readonly children?: ReactNode;\n}\n\nexport const EffectProvider = ({ runtime, children }: EffectProviderProps) => {\n  useEffect(\n    () => () => {\n      void runtime.dispose();\n    },\n    [runtime],\n  );\n\n  return <RuntimeContext.Provider value={runtime}>{children}</RuntimeContext.Provider>;\n};\n\nexport const useEffectRuntime = (): EffectReactManagedRuntime => {\n  const runtime = useContext(RuntimeContext);\n  if (runtime === null) {\n    throw new Error(\"Effect runtime is not available. Wrap your app with <EffectProvider>.\");\n  }\n  return runtime;\n};\n"],"mappings":"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","names":["import_effect","import_effect","subscribe","import_effect","import_react"]}

package/dist/devtools/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./events";
+export * from "./react";

package/dist/devtools/index.js

@@ -0,0 +1,18 @@
+import {
+  createDevtoolsEventStream,
+  createDevtoolsEventStreamFromTelemetry,
+  createRuntimeEventSource,
+  useDevtoolsEvents,
+  useEventStream
+} from "../chunk-S67FHWAR.js";
+import "../chunk-JKN75OYC.js";
+import "../chunk-2GIUCKL2.js";
+import "../chunk-SKC3HMF3.js";
+export {
+  createDevtoolsEventStream,
+  createDevtoolsEventStreamFromTelemetry,
+  createRuntimeEventSource,
+  useDevtoolsEvents,
+  useEventStream
+};
+//# sourceMappingURL=index.js.map

package/dist/devtools/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/devtools/react.d.ts

@@ -0,0 +1,8 @@
+import { Stream } from "effect";
+import type { DevtoolsEvent, DevtoolsEventStream } from "./events";
+export interface UseEventStreamOptions {
+    readonly enabled?: boolean;
+    readonly limit?: number;
+}
+export declare const useEventStream: <Event>(stream: Stream.Stream<Event>, options?: UseEventStreamOptions) => readonly Event[];
+export declare const useDevtoolsEvents: (source: DevtoolsEventStream, options?: UseEventStreamOptions) => readonly DevtoolsEvent[];