@systemfsoftware/effect-atom 0.5.3

package/dist/Atom.d.ts

@@ -0,0 +1,2 @@
+import { $ as toStreamResult, A as get, At as isAtom, B as modify, C as autoDispose, D as family, E as debounce, F as kvs, Ft as writable, G as refresh, H as optimistic, I as make, J as set, K as runtime, L as makeRead, M as initialValue, Mt as readable, N as isSerializable, Nt as setIdleTTL, O as fn, Ot as TypeId, P as keepAlive, Pt as transform, Q as toStream, R as map, S as WriteContext, T as context, U as optimisticFn, V as mount, W as pull, X as subscriptionRef, Y as setLazy, Z as swr, _ as SharedRuntimeFactory, at as withRefresh, b as WithoutSerializable, c as Interrupt, ct as getServerValue, d as RegistryRuntimeFactory, dt as makeRefreshOnSignal, et as update, f as Reset, ft as refreshOnWindowFocus, g as SerializableTypeId, h as SerializableJson, i as AtomRuntime, it as withReactivity, j as getResult, jt as isWritable, k as fnSync, kt as WritableTypeId, l as PullResult, lt as withServerValue, m as Serializable, mt as windowFocusSignal, n as AtomContext, nt as withFallback, o as Failure, ot as ServerValue, p as RuntimeFactory, pt as searchParam, q as serializable, r as AtomResultFn, rt as withLabel, s as FnContext, st as ServerValueTypeId, t as Atom, tt as withEquality, u as PullSuccess, ut as withServerValueInitial, v as Success, w as batch, x as Writable, y as Type, z as mapResult } from "./Atom-BgqgP-Qc.js";
+export { Atom, AtomContext, AtomResultFn, AtomRuntime, Failure, FnContext, Interrupt, PullResult, PullSuccess, RegistryRuntimeFactory, Reset, RuntimeFactory, Serializable, SerializableJson, SerializableTypeId, type ServerValue, ServerValueTypeId, SharedRuntimeFactory, Success, Type, TypeId, WithoutSerializable, Writable, WritableTypeId, WriteContext, autoDispose, batch, context, debounce, family, fn, fnSync, get, getResult, getServerValue, initialValue, isAtom, isSerializable, isWritable, keepAlive, kvs, make, makeRead, makeRefreshOnSignal, map, mapResult, modify, mount, optimistic, optimisticFn, pull, readable, refresh, refreshOnWindowFocus, runtime, searchParam, serializable, set, setIdleTTL, setLazy, subscriptionRef, swr, toStream, toStreamResult, transform, update, windowFocusSignal, withEquality, withFallback, withLabel, withReactivity, withRefresh, withServerValue, withServerValueInitial, writable };

package/dist/Atom.mjs

@@ -0,0 +1,2 @@
+import { $ as isWritable, A as set, B as withReactivity, C as mount, D as refresh, E as pull, F as toStreamResult, G as withServerValueInitial, H as ServerValueTypeId, I as update, J as searchParam, K as makeRefreshOnSignal, L as withEquality, M as subscriptionRef, N as swr, O as runtime, P as toStream, Q as isAtom, R as withFallback, S as modify, T as optimisticFn, U as getServerValue, V as withRefresh, W as withServerValue, X as TypeId, Y as windowFocusSignal, Z as WritableTypeId, _ as kvs, a as autoDispose, b as map, c as debounce, d as fnSync, et as readable, f as get, g as keepAlive, h as isSerializable, i as SerializableTypeId, j as setLazy, k as serializable, l as family, m as initialValue, n as Interrupt, nt as transform, o as batch, p as getResult, q as refreshOnWindowFocus, r as Reset, rt as writable, s as context, tt as setIdleTTL, u as fn, v as make, w as optimistic, x as mapResult, y as makeRead, z as withLabel } from "./Atom-DVWTGeoV.mjs";
+export { Interrupt, Reset, SerializableTypeId, ServerValueTypeId, TypeId, WritableTypeId, autoDispose, batch, context, debounce, family, fn, fnSync, get, getResult, getServerValue, initialValue, isAtom, isSerializable, isWritable, keepAlive, kvs, make, makeRead, makeRefreshOnSignal, map, mapResult, modify, mount, optimistic, optimisticFn, pull, readable, refresh, refreshOnWindowFocus, runtime, searchParam, serializable, set, setIdleTTL, setLazy, subscriptionRef, swr, toStream, toStreamResult, transform, update, windowFocusSignal, withEquality, withFallback, withLabel, withReactivity, withRefresh, withServerValue, withServerValueInitial, writable };

package/dist/AtomHttpApi.d.ts

@@ -0,0 +1,74 @@
+import { i as AtomRuntime, n as AtomContext, p as RuntimeFactory, r as AtomResultFn, t as Atom } from "./Atom-BgqgP-Qc.js";
+import { L as Result } from "./Result-BHH-qTvm.js";
+import * as Context from "effect/Context";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as HttpApiClient from "effect/unstable/httpapi/HttpApiClient";
+import * as HttpApiEndpoint from "effect/unstable/httpapi/HttpApiEndpoint";
+import { ReadonlyRecord } from "effect/Record";
+import { Simplify } from "effect/Types";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import { HttpClientResponse } from "effect/unstable/http/HttpClientResponse";
+import * as HttpApi from "effect/unstable/httpapi/HttpApi";
+import * as HttpApiGroup from "effect/unstable/httpapi/HttpApiGroup";
+import * as HttpApiMiddleware from "effect/unstable/httpapi/HttpApiMiddleware";
+declare namespace AtomHttpApi_d_exports {
+  export { AtomHttpApiClient, Service };
+}
+/**
+ * A `Context.Service` for an HTTP API client integrated with atom reactivity.
+ *
+ * **Details**
+ *
+ * It exposes the generated HTTP API client, an atom runtime, mutation helpers that
+ * return `AtomResultFn`s, and query helpers that return atoms of endpoint results.
+ *
+ * @category services
+ * @since 4.0.0
+ */
+interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpApiGroup.Constraint> extends Context.Service<Self, HttpApiClient.Client<Groups, never, never>> {
+  new (_: never): Context.ServiceClass.Shape<Id, HttpApiClient.Client<Groups, never, never>>;
+  readonly runtime: AtomRuntime<Self>;
+  readonly mutation: <GroupIdentifier extends HttpApiGroup.Identifier<Groups>, EndpointIdentifier extends HttpApiEndpoint.Identifier<HttpApiGroup.Endpoints<Group>>, Group extends HttpApiGroup.WithIdentifier<Groups, GroupIdentifier> = HttpApiGroup.WithIdentifier<Groups, GroupIdentifier>, Endpoint extends HttpApiEndpoint.WithIdentifier<HttpApiGroup.Endpoints<Group>, EndpointIdentifier> = HttpApiEndpoint.WithIdentifier<HttpApiGroup.Endpoints<Group>, EndpointIdentifier>, const ResponseMode extends HttpApiEndpoint.ClientResponseMode = HttpApiEndpoint.ClientResponseMode>(group: GroupIdentifier, endpoint: EndpointIdentifier, options?: {
+    readonly responseMode?: ResponseMode | undefined;
+  }) => [Endpoint] extends [HttpApiEndpoint.HttpApiEndpoint<infer _Identifier, infer _Method, infer _Path, infer _Params, infer _Query, infer _Payload, infer _Headers, infer _Success, infer _Error, infer _Middleware, infer _RE>] ? AtomResultFn<Simplify<HttpApiEndpoint.ClientRequest<_Params, _Query, _Payload, _Headers, 'decoded-only'> & {
+    readonly reactivityKeys?: readonly unknown[] | ReadonlyRecord<string, readonly unknown[]> | undefined;
+  }>, ResponseByMode<Extract<_Success, Schema.Top>['Type'], ResponseMode>, ErrorByMode<_Error, _Middleware, ResponseMode>> : never;
+  readonly query: <GroupIdentifier extends HttpApiGroup.Identifier<Groups>, EndpointIdentifier extends HttpApiEndpoint.Identifier<HttpApiGroup.Endpoints<Group>>, Group extends HttpApiGroup.WithIdentifier<Groups, GroupIdentifier> = HttpApiGroup.WithIdentifier<Groups, GroupIdentifier>, Endpoint extends HttpApiEndpoint.WithIdentifier<HttpApiGroup.Endpoints<Group>, EndpointIdentifier> = HttpApiEndpoint.WithIdentifier<HttpApiGroup.Endpoints<Group>, EndpointIdentifier>, const ResponseMode extends HttpApiEndpoint.ClientResponseMode = 'decoded-only'>(group: GroupIdentifier, endpoint: EndpointIdentifier, request: [Endpoint] extends [HttpApiEndpoint.HttpApiEndpoint<infer _Identifier, infer _Method, infer _Path, infer _Params, infer _Query, infer _Payload, infer _Headers, infer _Success, infer _Error, infer _R, infer _RE>] ? Simplify<HttpApiEndpoint.ClientRequest<_Params, _Query, _Payload, _Headers, ResponseMode> & {
+    readonly reactivityKeys?: readonly unknown[] | ReadonlyRecord<string, readonly unknown[]> | undefined;
+    readonly timeToLive?: Duration.Input | undefined;
+    readonly serializationKey?: string | undefined;
+  }> : never) => [Endpoint] extends [HttpApiEndpoint.HttpApiEndpoint<infer _Identifier, infer _Method, infer _Path, infer _Params, infer _Query, infer _Payload, infer _Headers, infer _Success, infer _Error, infer _Middleware, infer _RE>] ? Atom<Result<ResponseByMode<Extract<_Success, Schema.Top>['Type'], ResponseMode>, ErrorByMode<_Error, _Middleware, ResponseMode>>> : never;
+}
+declare global {
+  interface ErrorConstructor {
+    stackTraceLimit: number;
+  }
+}
+/**
+ * Creates a `Context.Service` class for an HTTP API client backed by an atom
+ * runtime.
+ *
+ * **Details**
+ *
+ * The options provide the API definition, HTTP client layer, optional client and
+ * response transforms, base URL, and runtime factory used by the query and
+ * mutation helpers.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+declare const Service: <Self>() => <const Id extends string, ApiId extends string, Groups extends HttpApiGroup.Constraint>(id: Id, options: {
+  readonly api: HttpApi.HttpApi<ApiId, Groups>;
+  readonly httpClient: Layer.Layer<HttpApiGroup.ClientServices<Groups> | HttpApiGroup.MiddlewareClient<Groups> | HttpClient.HttpClient> | ((get: AtomContext) => Layer.Layer<HttpApiGroup.ClientServices<Groups> | HttpApiGroup.MiddlewareClient<Groups> | HttpClient.HttpClient>);
+  readonly transformClient?: ((client: HttpClient.HttpClient) => HttpClient.HttpClient) | undefined;
+  readonly transformResponse?: ((effect: Effect.Effect<unknown, unknown, unknown>) => Effect.Effect<unknown, unknown, unknown>) | undefined;
+  readonly baseUrl?: URL | string | undefined;
+  readonly runtime?: RuntimeFactory | undefined;
+}) => AtomHttpApiClient<Self, Id, Groups>;
+type ResponseByMode<Success, ResponseMode extends HttpApiEndpoint.ClientResponseMode> = [ResponseMode] extends ['decoded-and-response'] ? [Success, HttpClientResponse] : [ResponseMode] extends ['response-only'] ? HttpClientResponse : Success;
+type ErrorByMode<Error extends Schema.Constraint, Middleware, ResponseMode extends HttpApiEndpoint.ClientResponseMode> = HttpApiMiddleware.Error<Middleware> | HttpApiMiddleware.ClientError<Middleware> | ([ResponseMode] extends ['response-only'] ? never : Error['Type']);
+//#endregion
+export { AtomHttpApiClient, Service, AtomHttpApi_d_exports as t };

package/dist/AtomHttpApi.mjs

@@ -0,0 +1,129 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { O as runtime, g as keepAlive, k as serializable, l as family, tt as setIdleTTL } from "./Atom-DVWTGeoV.mjs";
+import { j as schemaCodec } from "./Result-rlUvoHzK.mjs";
+import * as Context from "effect/Context";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as Reactivity from "effect/unstable/reactivity/Reactivity";
+import * as HttpClientError from "effect/unstable/http/HttpClientError";
+import * as HttpApiClient from "effect/unstable/httpapi/HttpApiClient";
+import * as HttpApiEndpoint from "effect/unstable/httpapi/HttpApiEndpoint";
+import * as HttpApiSchema from "effect/unstable/httpapi/HttpApiSchema";
+//#region src/AtomHttpApi.ts
+/**
+* Connects typed `HttpApi` clients to atoms.
+*
+* The service created here exposes the generated HTTP API client plus
+* atom-based query and mutation helpers. Query atoms call endpoints and track
+* their asynchronous result, while mutations run endpoint calls that can
+* invalidate reactivity keys after a successful request. Query atoms can also be
+* cached, serialized for hydration, and kept alive with a time-to-live.
+*
+* @since 4.0.0
+*/
+var AtomHttpApi_exports = /* @__PURE__ */ __exportAll({ Service: () => Service });
+const getSuccessSchemas = (endpoint) => {
+	const [first, ...rest] = Array.from(endpoint.success);
+	return first === void 0 ? [HttpApiSchema.NoContent] : [first, ...rest];
+};
+const getErrorSchemas = (endpoint) => Array.from(endpoint.error);
+/**
+* Creates a `Context.Service` class for an HTTP API client backed by an atom
+* runtime.
+*
+* **Details**
+*
+* The options provide the API definition, HTTP client layer, optional client and
+* response transforms, base URL, and runtime factory used by the query and
+* mutation helpers.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const Service = () => (id, options) => {
+	const service = Context.Service()(id);
+	const layer = Layer.effect(service, HttpApiClient.make(options.api, options));
+	const httpClient = options.httpClient;
+	const runtime$1 = (options.runtime ?? runtime)(typeof httpClient === "function" ? (get) => Layer.provide(layer, httpClient(get)) : Layer.provide(layer, httpClient));
+	const catchErrors = Effect.catch((e) => Schema.isSchemaError(e) || HttpClientError.isHttpClientError(e) ? Effect.die(e) : Effect.fail(e));
+	const isEndpointCall = (u) => typeof u === "function";
+	const endpointFor = (group, endpoint) => {
+		for (const candidate of Object.values(options.api.groups)) {
+			if ((typeof candidate !== "object" || candidate === null) && typeof candidate !== "function" || "identifier" in candidate === false || candidate.identifier !== group) continue;
+			if (!("endpoints" in candidate) || typeof candidate.endpoints !== "object" || candidate.endpoints === null) break;
+			for (const definition of Object.values(candidate.endpoints)) if ((typeof definition === "object" && definition !== null || typeof definition === "function") && HttpApiEndpoint.isHttpApiEndpoint(definition) && definition.identifier === endpoint) return definition;
+			break;
+		}
+		throw new Error(`Unknown endpoint: ${group}.${endpoint}`);
+	};
+	const callEndpoint = (client, group, endpoint, request) => {
+		const groupEntry = typeof client === "object" && client !== null || typeof client === "function" ? Reflect.get(client, group) : void 0;
+		if (typeof groupEntry !== "object" || groupEntry === null) throw new Error(`Unknown API group: ${group}`);
+		const call = Reflect.get(groupEntry, endpoint);
+		if (!isEndpointCall(call)) throw new Error(`Unknown endpoint: ${group}.${endpoint}`);
+		return call(request);
+	};
+	const resultSchema = schemaCodec;
+	const mutationFamily = family(({ endpoint, group, responseMode }) => {
+		const fnAtom = runtime$1.fn()(Effect.fnUntraced(function* (opts) {
+			const client = yield* service;
+			const effect = catchErrors(callEndpoint(client, group, endpoint, {
+				...opts,
+				responseMode
+			}));
+			return yield* opts.reactivityKeys ? Reactivity.mutation(effect, opts.reactivityKeys) : effect;
+		}));
+		if (responseMode === "decoded-only") {
+			const definition = endpointFor(group, endpoint);
+			return serializable(fnAtom, {
+				key: `AtomHttpApi:mutation:${group}:${endpoint}`,
+				schema: resultSchema(Schema.Union(getSuccessSchemas(definition)), Schema.Union(getErrorSchemas(definition)))
+			});
+		}
+		return fnAtom;
+	});
+	function mutation(group, endpoint, options) {
+		return mutationFamily({
+			group,
+			endpoint,
+			responseMode: options?.responseMode ?? "decoded-only"
+		});
+	}
+	const queryFamily = family((opts) => {
+		let atom = runtime$1.atom(service.use((client) => catchErrors(callEndpoint(client, opts.group, opts.endpoint, opts))));
+		if (opts.reactivityKeys) atom = runtime$1.factory.withReactivity(opts.reactivityKeys)(atom);
+		if (opts.responseMode === "decoded-only" && opts.serializationKey) {
+			const endpoint = endpointFor(opts.group, opts.endpoint);
+			atom = serializable(atom, {
+				key: `AtomHttpApi:${opts.group}:${opts.endpoint}:${opts.serializationKey}`,
+				schema: resultSchema(Schema.Union(getSuccessSchemas(endpoint)), Schema.Union(getErrorSchemas(endpoint)))
+			});
+		}
+		if (opts.timeToLive) atom = Duration.isFinite(opts.timeToLive) ? setIdleTTL(atom, opts.timeToLive) : keepAlive(atom);
+		return atom;
+	});
+	function query(group, endpoint, request) {
+		const key = {
+			group,
+			endpoint,
+			params: request.params,
+			query: request.query,
+			payload: request.payload,
+			headers: request.headers,
+			responseMode: request.responseMode ?? "decoded-only",
+			reactivityKeys: request.reactivityKeys,
+			timeToLive: request.timeToLive ? Duration.fromInputUnsafe(request.timeToLive) : void 0,
+			serializationKey: request.serializationKey
+		};
+		return queryFamily(key);
+	}
+	return Object.assign(service, {
+		runtime: runtime$1,
+		mutation,
+		query
+	});
+};
+//#endregion
+export { Service, AtomHttpApi_exports as t };

package/dist/AtomRef.d.ts

@@ -0,0 +1,91 @@
+import { Equal } from "effect/Equal";
+declare namespace AtomRef_d_exports {
+  export { AtomRef, Collection, ReadonlyRef, TypeId, collection, make };
+}
+/**
+ * The literal type used to identify `AtomRef` values.
+ *
+ * @category type IDs
+ * @since 4.0.0
+ */
+type TypeId = '~effect/reactivity/AtomRef';
+/**
+ * The runtime type id used to identify `AtomRef` values.
+ *
+ * @category type IDs
+ * @since 4.0.0
+ */
+declare const TypeId: TypeId;
+/**
+ * A read-only reactive reference.
+ *
+ * **Details**
+ *
+ * It exposes a stable key, the current value, subscriptions to value changes, and
+ * `map` for creating derived read-only references. Equality and hashing are based
+ * on the current value.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+interface ReadonlyRef<A> extends Equal {
+  readonly [TypeId]: TypeId;
+  readonly key: string;
+  readonly value: A;
+  readonly subscribe: (f: (a: A) => void) => () => void;
+  readonly map: <B>(f: (a: A) => B) => ReadonlyRef<B>;
+}
+/**
+ * A mutable reactive reference.
+ *
+ * **Details**
+ *
+ * It supports replacing the whole value, updating it from the current value, and
+ * creating mutable references to nested properties.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+interface AtomRef<A> extends ReadonlyRef<A> {
+  readonly prop: <K extends keyof A>(prop: K) => AtomRef<A[K]>;
+  readonly set: (value: A) => AtomRef<A>;
+  readonly update: (f: (value: A) => A) => AtomRef<A>;
+}
+/**
+ * A reactive collection of mutable item references.
+ *
+ * **Details**
+ *
+ * The collection can push, insert, and remove item refs, and `toArray` returns the
+ * current raw item values.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+interface Collection<A> extends ReadonlyRef<readonly AtomRef<A>[]> {
+  readonly push: (item: A) => Collection<A>;
+  readonly insertAt: (index: number, item: A) => Collection<A>;
+  readonly remove: (ref: AtomRef<A>) => Collection<A>;
+  readonly toArray: () => A[];
+}
+/**
+ * Creates a mutable reactive reference initialized with the supplied value.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+declare const make: <A>(value: A) => AtomRef<A>;
+/**
+ * Creates a reactive collection from an iterable of initial item values.
+ *
+ * **Details**
+ *
+ * Each item is wrapped in an `AtomRef`, and changes to item refs notify the
+ * collection subscribers.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+declare const collection: <A>(items: Iterable<A>) => Collection<A>;
+//#endregion
+export { AtomRef, Collection, ReadonlyRef, TypeId, collection, make, AtomRef_d_exports as t };

package/dist/AtomRef.mjs

@@ -0,0 +1,248 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import * as Equal$1 from "effect/Equal";
+import * as Hash from "effect/Hash";
+//#region src/AtomRef.ts
+/**
+* Mutable reactive references for local, in-memory state.
+*
+* `AtomRef` provides small observable state cells that can be read, updated,
+* mapped, and subscribed to without going through an `AtomRegistry`. Mutable
+* refs can also create refs for nested properties. The module also provides a
+* collection helper that stores item refs and notifies subscribers when items are
+* inserted, removed, or changed.
+*
+* @since 4.0.0
+*/
+var AtomRef_exports = /* @__PURE__ */ __exportAll({
+	TypeId: () => TypeId,
+	collection: () => collection,
+	make: () => make
+});
+/**
+* The runtime type id used to identify `AtomRef` values.
+*
+* @category type IDs
+* @since 4.0.0
+*/
+const TypeId = "~effect/reactivity/AtomRef";
+/**
+* Creates a mutable reactive reference initialized with the supplied value.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make = (value) => new AtomRefImpl(value);
+/**
+* Creates a reactive collection from an iterable of initial item values.
+*
+* **Details**
+*
+* Each item is wrapped in an `AtomRef`, and changes to item refs notify the
+* collection subscribers.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const collection = (items) => new CollectionImpl(items);
+const isReadonlyRef = (u) => typeof u === "object" && u !== null && "~effect/reactivity/AtomRef" in u;
+const isArrayWithProp = (value, _prop) => Array.isArray(value);
+const keyState = {
+	count: 0,
+	generate() {
+		return `AtomRef-${this.count++}`;
+	}
+};
+var ReadonlyRefImpl = class {
+	[TypeId];
+	key = keyState.generate();
+	value;
+	constructor(value) {
+		this[TypeId] = TypeId;
+		this.value = value;
+	}
+	[Equal$1.symbol](that) {
+		return isReadonlyRef(that) && Equal$1.equals(this.value, that.value);
+	}
+	[Hash.symbol]() {
+		return Hash.hash(this.value);
+	}
+	listeners = null;
+	notify(a) {
+		let listener = this.listeners;
+		while (listener !== null) {
+			listener.f(a);
+			listener = listener.next;
+		}
+	}
+	subscribe(f) {
+		const listener = {
+			f,
+			prev: null,
+			next: this.listeners
+		};
+		if (this.listeners) this.listeners.prev = listener;
+		this.listeners = listener;
+		return () => {
+			if (this.listeners === listener) this.listeners = listener.next;
+			if (listener.prev) listener.prev.next = listener.next;
+			if (listener.next) listener.next.prev = listener.prev;
+		};
+	}
+	map(f) {
+		return new MapRefImpl(this, f);
+	}
+};
+var AtomRefImpl = class extends ReadonlyRefImpl {
+	prop(prop) {
+		return new PropRefImpl(this, prop);
+	}
+	set(value) {
+		if (Equal$1.equals(value, this.value)) return this;
+		this.value = value;
+		this.notify(value);
+		return this;
+	}
+	update(f) {
+		return this.set(f(this.value));
+	}
+};
+var MapRefImpl = class MapRefImpl {
+	[TypeId];
+	key = keyState.generate();
+	parent;
+	transform;
+	constructor(parent, transform) {
+		this[TypeId] = TypeId;
+		this.parent = parent;
+		this.transform = transform;
+	}
+	[Equal$1.symbol](that) {
+		return isReadonlyRef(that) && Equal$1.equals(this.value, that.value);
+	}
+	[Hash.symbol]() {
+		return Hash.hash(this.value);
+	}
+	get value() {
+		return this.transform(this.parent.value);
+	}
+	subscribe(f) {
+		let previous = this.transform(this.parent.value);
+		return this.parent.subscribe((a) => {
+			const next = this.transform(a);
+			if (Equal$1.equals(next, previous)) return;
+			previous = next;
+			f(next);
+		});
+	}
+	map(f) {
+		return new MapRefImpl(this, f);
+	}
+};
+var PropRefImpl = class PropRefImpl {
+	[TypeId];
+	key = keyState.generate();
+	previous;
+	parent;
+	_prop;
+	constructor(parent, _prop) {
+		this[TypeId] = TypeId;
+		this.parent = parent;
+		this._prop = _prop;
+		this.previous = parent.value[_prop];
+	}
+	[Equal$1.symbol](that) {
+		return isReadonlyRef(that) && Equal$1.equals(this.value, that.value);
+	}
+	[Hash.symbol]() {
+		return Hash.hash(this.value);
+	}
+	get value() {
+		if (this.parent.value && this._prop in this.parent.value) this.previous = this.parent.value[this._prop];
+		return this.previous;
+	}
+	subscribe(f) {
+		let previous = this.value;
+		return this.parent.subscribe((a) => {
+			if (!a || !(this._prop in a)) return;
+			const next = a[this._prop];
+			if (Equal$1.equals(next, previous)) return;
+			previous = next;
+			f(next);
+		});
+	}
+	map(f) {
+		return new MapRefImpl(this, f);
+	}
+	prop(prop) {
+		return new PropRefImpl(this, prop);
+	}
+	set(value) {
+		if (isArrayWithProp(this.parent.value, this._prop)) {
+			const newArray = Object.assign(new Array(), this.parent.value);
+			newArray[Number(this._prop)] = value;
+			this.parent.set(newArray);
+		} else this.parent.set({
+			...this.parent.value,
+			[this._prop]: value
+		});
+		return this;
+	}
+	update(f) {
+		if (isArrayWithProp(this.parent.value, this._prop)) {
+			const newArray = Object.assign(new Array(), this.parent.value);
+			newArray[Number(this._prop)] = f(this.parent.value[this._prop]);
+			this.parent.set(newArray);
+		} else this.parent.set({
+			...this.parent.value,
+			[this._prop]: f(this.parent.value[this._prop])
+		});
+		return this;
+	}
+};
+var CollectionImpl = class extends ReadonlyRefImpl {
+	linked = /* @__PURE__ */ new Set();
+	constructor(items) {
+		super([]);
+		for (const item of items) this.value.push(this.makeRef(item));
+	}
+	makeRef(value) {
+		const ref = new AtomRefImpl(value);
+		let proxy;
+		const notify = (value) => {
+			ref.notify(value);
+			if (this.linked.has(proxy)) this.notify(this.value);
+		};
+		proxy = new Proxy(ref, { get(target, p, receiver) {
+			if (p === "notify") return notify;
+			return Reflect.get(target, p, receiver);
+		} });
+		this.linked.add(proxy);
+		return proxy;
+	}
+	push(item) {
+		const ref = this.makeRef(item);
+		this.value.push(ref);
+		this.notify(this.value);
+		return this;
+	}
+	insertAt(index, item) {
+		const ref = this.makeRef(item);
+		this.value.splice(index, 0, ref);
+		this.notify(this.value);
+		return this;
+	}
+	remove(ref) {
+		const index = this.value.indexOf(ref);
+		if (index !== -1) {
+			this.value.splice(index, 1);
+			this.linked.delete(ref);
+			this.notify(this.value);
+		}
+		return this;
+	}
+	toArray() {
+		return this.value.map((ref) => ref.value);
+	}
+};
+//#endregion
+export { TypeId, collection, make, AtomRef_exports as t };

package/dist/AtomRpc.d.ts

@@ -0,0 +1,73 @@
+import { i as AtomRuntime, l as PullResult, n as AtomContext, p as RuntimeFactory, r as AtomResultFn, t as Atom, x as Writable } from "./Atom-BgqgP-Qc.js";
+import { L as Result } from "./Result-BHH-qTvm.js";
+import * as Context from "effect/Context";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Scope from "effect/Scope";
+import * as Headers from "effect/unstable/http/Headers";
+import * as RpcClient from "effect/unstable/rpc/RpcClient";
+import { RpcClientError } from "effect/unstable/rpc/RpcClientError";
+import * as RpcSchema from "effect/unstable/rpc/RpcSchema";
+import { ReadonlyRecord } from "effect/Record";
+import { NoInfer } from "effect/Types";
+import * as Rpc from "effect/unstable/rpc/Rpc";
+import * as RpcGroup from "effect/unstable/rpc/RpcGroup";
+import { RequestId } from "effect/unstable/rpc/RpcMessage";
+declare namespace AtomRpc_d_exports {
+  export { AtomRpcClient, Service };
+}
+/**
+ * A `Context.Service` for a flattened RPC client integrated with atom reactivity.
+ *
+ * **Details**
+ *
+ * It exposes the RPC client, an atom runtime, mutation helpers that return `AtomResultFn`s, and query helpers that
+ * return atoms or pull atoms for RPC results.
+ *
+ * @category services
+ * @since 4.0.0
+ */
+interface AtomRpcClient<Self, Id extends string, Rpcs extends Rpc.Any> extends Context.Service<Self, RpcClient.RpcClient.Flat<Rpcs, RpcClientError>> {
+  new (_: never): Context.ServiceClass.Shape<Id, RpcClient.RpcClient.Flat<Rpcs, RpcClientError>>;
+  readonly runtime: AtomRuntime<Self>;
+  readonly mutation: <Tag extends Rpc.Tag<Rpcs>>(arg: Tag) => Rpc.ExtractTag<Rpcs, Tag> extends Rpc.Rpc<infer _Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware, infer _Requires> ? [_Success] extends [RpcSchema.Stream<infer _A, infer _E>] ? never : AtomResultFn<{
+    readonly payload: Rpc.PayloadConstructor<Rpc.ExtractTag<Rpcs, Tag>>;
+    readonly reactivityKeys?: readonly unknown[] | ReadonlyRecord<string, readonly unknown[]> | undefined;
+    readonly headers?: Headers.Input | undefined;
+  }, _Success['Type'], _Error['Type'] | RpcClientError | _Middleware['error']['Type']> : never;
+  readonly query: <Tag extends Rpc.Tag<Rpcs>>(tag: Tag, payload: Rpc.PayloadConstructor<Rpc.ExtractTag<Rpcs, Tag>>, options?: {
+    readonly headers?: Headers.Input | undefined;
+    readonly reactivityKeys?: readonly unknown[] | ReadonlyRecord<string, readonly unknown[]> | undefined;
+    readonly timeToLive?: Duration.Input | undefined;
+    readonly serializationKey?: string | undefined;
+  }) => Rpc.ExtractTag<Rpcs, Tag> extends Rpc.Rpc<infer _Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware> ? [_Success] extends [RpcSchema.Stream<infer _A, infer _E>] ? Writable<PullResult<_A['Type'], _E['Type'] | _Error['Type'] | RpcClientError | _Middleware['error']['Type']>, void> : Atom<Result<_Success['Type'], _Error['Type'] | RpcClientError | _Middleware['error']['Type']>> : never;
+}
+declare global {
+  interface ErrorConstructor {
+    stackTraceLimit: number;
+  }
+}
+/**
+ * Creates a `Context.Service` class for an RPC client backed by an atom runtime.
+ *
+ * **Details**
+ *
+ * The options provide the RPC group, protocol layer, tracing options, request id generation, optional custom client
+ * effect, and runtime factory used by the query and mutation helpers.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+declare const Service: <Self>() => <const Id extends string, Rpcs extends Rpc.Any, ER, RM = RpcClient.Protocol | Rpc.MiddlewareClient<NoInfer<Rpcs>> | Rpc.ServicesClient<NoInfer<Rpcs>>>(id: Id, options: {
+  readonly group: RpcGroup.RpcGroup<Rpcs>;
+  readonly protocol: Layer.Layer<Exclude<NoInfer<RM>, Scope.Scope>, ER> | ((get: AtomContext) => Layer.Layer<Exclude<NoInfer<RM>, Scope.Scope>, ER>);
+  readonly spanPrefix?: string | undefined;
+  readonly spanAttributes?: Record<string, unknown> | undefined;
+  readonly generateRequestId?: (() => RequestId) | undefined;
+  readonly disableTracing?: boolean | undefined;
+  readonly makeEffect?: Effect.Effect<RpcClient.RpcClient.Flat<Rpcs, RpcClientError>, never, RM | RpcClient.Protocol | Rpc.MiddlewareClient<Rpcs> | Scope.Scope> | undefined;
+  readonly runtime?: RuntimeFactory | undefined;
+}) => AtomRpcClient<Self, Id, Rpcs>;
+//#endregion
+export { AtomRpcClient, Service, AtomRpc_d_exports as t };