@systemfsoftware/effect-atom 0.5.3

package/dist/Result-rlUvoHzK.mjs

@@ -0,0 +1,624 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import { constTrue, dual, identity } from "effect/Function";
+import * as Option from "effect/Option";
+import * as Schema_ from "effect/Schema";
+import { pipeArguments } from "effect/Pipeable";
+import { hasProperty, isIterable, isTagged } from "effect/Predicate";
+import * as Either from "effect/Result";
+import * as Match from "effect/Match";
+import * as Clock from "effect/Clock";
+import * as Equal$1 from "effect/Equal";
+import * as Hash from "effect/Hash";
+import * as SchemaIssue from "effect/SchemaIssue";
+import * as SchemaParser from "effect/SchemaParser";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+//#region src/internal/ResultValues.ts
+const now = () => Effect.runSync(Clock.currentTimeMillis);
+/**
+* Runtime identifier attached to `Result` values and used by `isResult`.
+*
+* @category type IDs
+* @since 4.0.0
+*/
+const TypeId = "~effect-atom/atom/Result";
+/**
+* Shared prototype every `Result` variant inherits from. The three
+* constructors (`initial`, `success`, `failure`) use it; `waiting` in
+* `Result.ts` also reaches it directly.
+*
+* The schema codec (`internal/result-schema.ts`) serializes only the tagged
+* variant fields (`value`, `waiting`, `timestamp`, `cause`,
+* `previousSuccess`) — nothing added to this prototype is wire-carried, so
+* any future proto-private state must be mirrored in that encode/decode pair.
+*
+* @since 4.0.0
+*/
+const ResultProto = {
+	[TypeId]: {
+		E: identity,
+		A: identity
+	},
+	pipe() {
+		return pipeArguments(this, arguments);
+	},
+	[Equal$1.symbol](that) {
+		if (this.waiting !== that.waiting) return false;
+		return Match.value(this).pipe(Match.tag("Initial", () => Match.value(that).pipe(Match.tag("Initial", () => true), Match.orElse(() => false))), Match.tag("Success", (s) => Match.value(that).pipe(Match.tag("Success", (t) => Equal$1.equals(s.value, t.value)), Match.orElse(() => false))), Match.tag("Failure", (f) => Match.value(that).pipe(Match.tag("Failure", (g) => Equal$1.equals(f.cause, g.cause)), Match.orElse(() => false))), Match.exhaustive);
+	},
+	[Hash.symbol]() {
+		const tagHash = Hash.string(`${this._tag}:${this.waiting}`);
+		return Match.value(this).pipe(Match.tag("Initial", () => tagHash), Match.tag("Success", (s) => Hash.combine(tagHash)(Hash.hash(s.value))), Match.tag("Failure", (f) => Hash.combine(tagHash)(Hash.hash(f.cause))), Match.exhaustive);
+	}
+};
+/**
+* Returns `true` when a value is an `Result`.
+*
+* @category guards
+* @since 4.0.0
+*/
+const isResult = (u) => hasProperty(u, TypeId);
+/**
+* Creates an `Initial` result, optionally marking it as waiting.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const initial = (waiting = false) => {
+	return {
+		...ResultProto,
+		_tag: "Initial",
+		waiting
+	};
+};
+/**
+* Creates a `Success` result with a value and optional `waiting` flag or
+* timestamp override.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const success = (value, options) => {
+	return {
+		...ResultProto,
+		_tag: "Success",
+		value,
+		waiting: options?.waiting ?? false,
+		timestamp: options?.timestamp ?? now()
+	};
+};
+/**
+* Creates a `Failure` result from a `Cause`, optionally preserving a previous
+* success and marking the result as waiting.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const failure = (cause, options) => {
+	return {
+		...ResultProto,
+		_tag: "Failure",
+		cause,
+		...options?.previousSuccess === void 0 ? { previousSuccess: Option.none() } : { previousSuccess: options.previousSuccess },
+		waiting: options?.waiting ?? false
+	};
+};
+//#endregion
+//#region src/internal/ResultSchema.ts
+/**
+* Creates a schema for `Result` values using optional schemas for success values and failure errors.
+*
+* @category schemas
+* @since 4.0.0
+*/
+const Schema = (options) => {
+	const success_ = options.success ?? Schema_.Never;
+	const error_ = options.error ?? Schema_.Never;
+	const schema = Schema_.declareConstructor()([success_, Schema_.Cause(error_, Schema_.Defect())], ([value, cause]) => (input, ast, options) => {
+		if (!isResult(input)) return Effect.fail(new SchemaIssue.InvalidType(ast, input, options));
+		if (!hasProperty(input, "value") && !hasProperty(input, "cause")) return Effect.succeed(initial(input.waiting));
+		if (hasProperty(input, "cause")) {
+			const prevSuccessEffect = input.previousSuccess.pipe(Option.map((ps) => Effect.mapBothEager(SchemaParser.decodeUnknownEffect(value)(ps.value, options), {
+				onSuccess: (value) => Option.some(success(value, ps)),
+				onFailure: (issue) => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer(["previousSuccess", "value"], issue)], input, options)
+			})), Option.getOrElse(() => Effect.succeedNone));
+			const causeEffect = Effect.mapErrorEager(SchemaParser.decodeUnknownEffect(cause)(input.cause, options), (issue) => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer(["cause"], issue)], input, options));
+			return Effect.flatMapEager(prevSuccessEffect, (previousSuccess) => Effect.mapEager(causeEffect, (cause) => failure(cause, {
+				previousSuccess,
+				waiting: input.waiting
+			})));
+		}
+		return Effect.mapBothEager(SchemaParser.decodeUnknownEffect(value)(input.value, options), {
+			onSuccess: (value) => success(value, input),
+			onFailure: (issue) => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer(["value"], issue)], input, options)
+		});
+	}, {
+		expected: "Result",
+		toCodec([value, cause]) {
+			const SuccessSchema = Schema_.TaggedStruct("Success", {
+				value,
+				waiting: Schema_.Boolean,
+				timestamp: Schema_.Finite
+			});
+			return Schema_.link()(Schema_.Union([
+				Schema_.TaggedStruct("Initial", { waiting: Schema_.Boolean }),
+				SuccessSchema,
+				Schema_.TaggedStruct("Failure", {
+					cause,
+					previousSuccess: Schema_.Option(SuccessSchema),
+					waiting: Schema_.Boolean
+				})
+			]), SchemaTransformation.transform({
+				decode: (encoded) => {
+					if (hasProperty(encoded, "value")) return success(encoded.value, {
+						waiting: encoded.waiting,
+						timestamp: encoded.timestamp
+					});
+					if (hasProperty(encoded, "cause")) return failure(encoded.cause, {
+						previousSuccess: Option.map(encoded.previousSuccess, (ps) => success(ps.value, ps)),
+						waiting: encoded.waiting
+					});
+					return initial(encoded.waiting);
+				},
+				encode(result) {
+					if (hasProperty(result, "value")) return {
+						_tag: "Success",
+						value: result.value,
+						waiting: result.waiting,
+						timestamp: result.timestamp
+					};
+					if (hasProperty(result, "cause")) return {
+						_tag: "Failure",
+						cause: result.cause,
+						previousSuccess: result.previousSuccess,
+						waiting: result.waiting
+					};
+					return {
+						_tag: "Initial",
+						waiting: result.waiting
+					};
+				}
+			}));
+		},
+		toEquivalence: Equal$1.asEquivalence,
+		toArbitrary: () => (fc) => fc.constant(initial(false)),
+		toFormatter: ([value, cause]) => (t) => {
+			if (hasProperty(t, "value")) return `Result.Success(${value(t.value)}, ${t.waiting}, ${t.timestamp})`;
+			if (hasProperty(t, "cause")) return `Result.Failure(${cause(t.cause)}, ${t.waiting})`;
+			return `Result.Initial(${t.waiting})`;
+		}
+	});
+	return Object.assign(schema, {
+		success: success_,
+		error: error_
+	});
+};
+/**
+* A codec for `Result` values built from the given success and error schemas.
+*
+* @internal
+*/
+const schemaCodec = (success, error) => Schema({
+	success,
+	error
+});
+//#endregion
+//#region src/Result.ts
+/**
+* Represents observable state for asynchronous values.
+*
+* `Result<A, E>` records whether asynchronous work has no value yet,
+* succeeded with an `A`, or failed with an `E`. Every state also carries a
+* `waiting` flag, so callers can keep showing the current value while newer
+* work is loading, refreshing, retrying, or recovering. This module includes
+* constructors, checks, accessors, mapping and matching helpers, ways to combine
+* several results, and schemas for encoding or decoding results.
+*
+* @since 4.0.0
+*/
+var Result_exports = /* @__PURE__ */ __exportAll({
+	Schema: () => Schema,
+	TypeId: () => TypeId,
+	all: () => all,
+	builder: () => builder,
+	cause: () => cause,
+	error: () => error,
+	fail: () => fail,
+	failWithPrevious: () => failWithPrevious,
+	failure: () => failure,
+	failureWithPrevious: () => failureWithPrevious,
+	flatMap: () => flatMap,
+	fromExit: () => fromExit,
+	fromExitWithPrevious: () => fromExitWithPrevious,
+	getOrElse: () => getOrElse,
+	getOrThrow: () => getOrThrow,
+	initial: () => initial,
+	isAsyncResult: () => isResult,
+	isFailure: () => isFailure,
+	isInitial: () => isInitial,
+	isInterrupted: () => isInterrupted,
+	isNotInitial: () => isNotInitial,
+	isResult: () => isResult,
+	isSuccess: () => isSuccess,
+	isWaiting: () => isWaiting,
+	map: () => map,
+	match: () => match,
+	matchWithError: () => matchWithError,
+	matchWithWaiting: () => matchWithWaiting,
+	replacePrevious: () => replacePrevious,
+	success: () => success,
+	toExit: () => toExit,
+	touch: () => touch,
+	value: () => value,
+	waiting: () => waiting,
+	waitingFrom: () => waitingFrom
+});
+/**
+* Returns whether an `Result` is currently waiting for an asynchronous computation or refresh to finish.
+*
+* @category predicates
+* @since 4.0.0
+*/
+const isWaiting = (result) => result.waiting;
+/**
+* Converts an `Exit` into a `Success` when it succeeds or a `Failure` carrying the exit cause when it fails.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const fromExit = (exit) => Exit.isSuccess(exit) ? success(exit.value) : failure(exit.cause);
+/**
+* Converts an `Exit` to a result, preserving the latest previous success when the exit is a failure.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const fromExitWithPrevious = (exit, previous) => Exit.isSuccess(exit) ? success(exit.value) : failureWithPrevious(exit.cause, { previous });
+/**
+* Creates a waiting result from an optional previous result, using `Initial(true)` when no previous result exists.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const waitingFrom = (previous) => {
+	if (Option.isNone(previous)) return initial(true);
+	return waiting(previous.value);
+};
+/**
+* Returns `true` when an `Result` is in the `Initial` state.
+*
+* @category guards
+* @since 4.0.0
+*/
+const isInitial = (result) => isTagged(result, "Initial");
+/**
+* Returns `true` when an `Result` is either `Success` or `Failure`.
+*
+* @category guards
+* @since 4.0.0
+*/
+const isNotInitial = (result) => !isInitial(result);
+/**
+* Returns `true` when an `Result` is a `Success`.
+*
+* @category guards
+* @since 4.0.0
+*/
+const isSuccess = (result) => isTagged(result, "Success");
+/**
+* Returns `true` when an `Result` is a `Failure`.
+*
+* @category guards
+* @since 4.0.0
+*/
+const isFailure = (result) => isTagged(result, "Failure");
+/**
+* Returns `true` when an `Result` is a `Failure` whose cause contains only interruptions.
+*
+* @category guards
+* @since 4.0.0
+*/
+const isInterrupted = (result) => isFailure(result) && Cause.hasInterruptsOnly(result.cause);
+/**
+* Creates a `Failure` result from a `Cause`, carrying forward the latest success stored in a previous result.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const failureWithPrevious = (cause, options) => failure(cause, {
+	previousSuccess: Option.flatMap(options.previous, (result) => isSuccess(result) ? Option.some(result) : isFailure(result) ? result.previousSuccess : Option.none()),
+	waiting: options.waiting
+});
+/**
+* Creates a `Failure` result from a typed error, wrapping it in `Cause.fail`.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const fail = (error, options) => failure(Cause.fail(error), options);
+/**
+* Creates a `Failure` result from a typed error while carrying forward the latest success stored in a previous result.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const failWithPrevious = (error, options) => failureWithPrevious(Cause.fail(error), options);
+/**
+* Marks an `Result` as waiting, optionally touching the timestamp when the result is a `Success`.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const waiting = (self, options) => {
+	if (self.waiting) return options?.touch ? touch(self) : self;
+	const result = {
+		...self,
+		waiting: true
+	};
+	return options?.touch ? touch(result) : result;
+};
+/**
+* Refreshes the timestamp of a `Success` result while preserving its value and waiting flag; non-success results are returned unchanged.
+*
+* @category combinators
+* @since 4.0.0
+*/
+const touch = (result) => {
+	if (isSuccess(result)) return {
+		...result,
+		timestamp: Effect.runSync(Clock.currentTimeMillis)
+	};
+	return result;
+};
+function replacePrevious(self, previous) {
+	return isFailure(self) ? failureWithPrevious(self.cause, {
+		previous,
+		waiting: self.waiting
+	}) : self;
+}
+/**
+* Returns the current success value, or the previous success value stored in a failure, as an `Option`.
+*
+* @category accessors
+* @since 4.0.0
+*/
+const value = (self) => {
+	if (isSuccess(self)) return Option.some(self.value);
+	if (isFailure(self)) return Option.map(self.previousSuccess, (s) => s.value);
+	return Option.none();
+};
+/**
+* Returns the available value from `value`, or evaluates the fallback when no current or previous success exists.
+*
+* @category accessors
+* @since 4.0.0
+*/
+const getOrElse = dual(2, (self, orElse) => Option.getOrElse(value(self), orElse));
+/**
+* Returns the available value from `value`, or throws `NoSuchElementError` when no current or previous success exists.
+*
+* @category accessors
+* @since 4.0.0
+*/
+const getOrThrow = (self) => Option.getOrThrowWith(value(self), () => new Cause.NoSuchElementError("Result.getOrThrow: no value found"));
+/**
+* Returns the failure cause when the result is a `Failure`, otherwise `None`.
+*
+* @category accessors
+* @since 4.0.0
+*/
+const cause = (self) => isFailure(self) ? Option.some(self.cause) : Option.none();
+/**
+* Returns the first typed error from a failure cause, or `None` for successes, initial results, defects, and interrupt-only causes.
+*
+* @category accessors
+* @since 4.0.0
+*/
+const error = (self) => isFailure(self) ? Cause.findErrorOption(self.cause) : Option.none();
+/**
+* Converts a result to an `Exit`, succeeding with a success value, failing with a failure cause, or failing with `NoSuchElementError` for `Initial`.
+*
+* @category combinators
+* @since 4.0.0
+*/
+const toExit = (self) => {
+	if (isSuccess(self)) return Exit.succeed(self.value);
+	if (isFailure(self)) return Exit.failCause(self.cause);
+	return Exit.fail(new Cause.NoSuchElementError());
+};
+/**
+* Maps the success value of an `Result`, also mapping any previous success stored in a failure while leaving initial results unchanged.
+*
+* @category combinators
+* @since 4.0.0
+*/
+const map = dual(2, (self, f) => {
+	if (isSuccess(self)) return success(f(self.value), self);
+	if (isFailure(self)) return failure(self.cause, {
+		previousSuccess: Option.map(self.previousSuccess, (s) => success(f(s.value), s)),
+		waiting: self.waiting
+	});
+	return initial(self.waiting);
+});
+/**
+* Maps the success value of an `Result` and flattens the result.
+*
+* **When to use**
+*
+* Use to sequence computations that may return another `Result` while
+* preserving initial and failure states.
+*
+* **Details**
+*
+* Initial results are left unchanged. Failures preserve their cause and remap
+* the stored previous success when the mapping function returns a success.
+*
+* @category combinators
+* @since 4.0.0
+*/
+const flatMap = dual(2, (self, f) => {
+	if (isSuccess(self)) return f(self.value, self);
+	if (isFailure(self)) return failure(self.cause, {
+		previousSuccess: Option.flatMap(self.previousSuccess, (s) => {
+			const next = f(s.value, s);
+			return isSuccess(next) ? Option.some(next) : Option.none();
+		}),
+		waiting: self.waiting
+	});
+	return initial(self.waiting);
+});
+/**
+* Pattern matches an `Result` by calling the handler for `Initial`, `Failure`, or `Success`.
+*
+* @category combinators
+* @since 4.0.0
+*/
+const match = dual(2, (self, options) => {
+	if (isSuccess(self)) return options.onSuccess(self);
+	if (isFailure(self)) return options.onFailure(self);
+	return options.onInitial(self);
+});
+/**
+* Pattern matches a result, handling successes and initials directly while splitting failures into typed errors or squashed non-error causes passed to `onDefect`.
+*
+* @category combinators
+* @since 4.0.0
+*/
+const matchWithError = dual(2, (self, options) => {
+	if (isSuccess(self)) return options.onSuccess(self);
+	if (isFailure(self)) {
+		const result = Cause.findError(self.cause);
+		if (Either.isFailure(result)) return options.onDefect(Cause.squash(result.failure), self);
+		return options.onError(result.success, self);
+	}
+	return options.onInitial(self);
+});
+/**
+* Pattern matches a result by calling `onWaiting` for waiting or initial states, otherwise handling successes and splitting failures into typed errors or squashed non-error causes.
+*
+* @category combinators
+* @since 4.0.0
+*/
+const matchWithWaiting = dual(2, (self, options) => {
+	if (self.waiting) return options.onWaiting(self);
+	if (isSuccess(self)) return options.onSuccess(self);
+	if (isFailure(self)) {
+		const e = Cause.findError(self.cause);
+		if (Either.isFailure(e)) return options.onDefect(Cause.squash(e.failure), self);
+		return options.onError(e.success, self);
+	}
+	return options.onWaiting(self);
+});
+function all(results) {
+	return allImpl(results);
+}
+const allImpl = (results) => {
+	let waiting = false;
+	if (isIterable(results)) {
+		const successes = [];
+		for (const result of results) {
+			if (!isResult(result)) {
+				successes.push(result);
+				continue;
+			}
+			if (!isSuccess(result)) return result;
+			successes.push(result.value);
+			if (result.waiting) waiting = true;
+		}
+		return success(successes, { waiting });
+	}
+	const successes = {};
+	for (const [key, result] of Object.entries(results)) {
+		if (!isResult(result)) {
+			successes[key] = result;
+			continue;
+		}
+		if (!isSuccess(result)) return result;
+		successes[key] = result.value;
+		if (result.waiting) waiting = true;
+	}
+	return success(successes, { waiting });
+};
+/**
+* The implementation signature is erased because `Builder` is a phantom state
+* machine and `BuilderImpl` is not. `Builder` records what has been handled in
+* its own parameters - `onError` returns a builder whose error type is `never`,
+* `onDefect` drops `Defect` from the outstanding set - while the class keeps one
+* mutable value and its parameters unchanged, so no instantiation of it relates
+* to `BuilderFor` (measured: TS2322 through `onWaiting` into `onErrorIf`). The
+* declaration above is the contract; the class is the mechanism.
+*/
+function builder(self) {
+	return new BuilderImpl(self);
+}
+var BuilderImpl = class {
+	constructor(result) {
+		this.result = result;
+	}
+	result;
+	output = Option.none();
+	when(refinement, f) {
+		if (Option.isNone(this.output) && refinement(this.result)) {
+			const b = f(this.result);
+			if (Option.isSome(b)) this.output = b;
+		}
+		return this;
+	}
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+	onWaiting(f) {
+		return this.when((r) => r.waiting, (r) => Option.some(f(r)));
+	}
+	onInitialOrWaiting(f) {
+		return this.when((r) => isInitial(r) || r.waiting, (r) => Option.some(f(r)));
+	}
+	onInitial(f) {
+		return this.when(isInitial, (r) => Option.some(f(r)));
+	}
+	onSuccess(f) {
+		return this.when(isSuccess, (r) => Option.some(f(r.value, r)));
+	}
+	onFailure(f) {
+		return this.when(isFailure, (r) => Option.some(f(r.cause, r)));
+	}
+	onError(f) {
+		return this.onErrorIf(constTrue, f);
+	}
+	onErrorIf(refinement, f) {
+		return this.when(isFailure, (result) => Cause.findErrorOption(result.cause).pipe(Option.filter(refinement), Option.map((error) => f(error, result))));
+	}
+	onErrorTag(tag, f) {
+		return this.onErrorIf((e) => typeof tag === "string" ? isTagged(e, tag) : tag.some((t) => isTagged(e, t)), f);
+	}
+	onDefect(f) {
+		return this.when(isFailure, (result) => {
+			const defect = Cause.findDefect(result.cause);
+			return Either.isFailure(defect) ? Option.none() : Option.some(f(defect.success, result));
+		});
+	}
+	onInterrupt(f) {
+		return this.when(isFailure, (result) => {
+			const interruptors = Cause.filterInterruptors(result.cause);
+			return Either.isFailure(interruptors) ? Option.none() : Option.some(f(interruptors.success, result));
+		});
+	}
+	orElse(orElse) {
+		return Option.getOrElse(this.output, orElse);
+	}
+	orNull() {
+		return Option.getOrNull(this.output);
+	}
+	render() {
+		if (Option.isSome(this.output)) return this.output.value;
+		else if (isFailure(this.result)) throw Cause.squash(this.result.cause);
+		return null;
+	}
+	exhaustive() {
+		return this.render();
+	}
+};
+//#endregion
+export { Schema as A, matchWithWaiting as C, value as D, touch as E, isResult as F, success as I, TypeId as M, failure as N, waiting as O, initial as P, matchWithError as S, toExit as T, isNotInitial as _, error as a, map as b, failureWithPrevious as c, fromExitWithPrevious as d, getOrElse as f, isInterrupted as g, isInitial as h, cause as i, schemaCodec as j, waitingFrom as k, flatMap as l, isFailure as m, all as n, fail as o, getOrThrow as p, builder as r, failWithPrevious as s, Result_exports as t, fromExit as u, isSuccess as v, replacePrevious as w, match as x, isWaiting as y };

package/dist/Result.d.ts

@@ -0,0 +1,2 @@
+import { A as touch, B as failure, C as isWaiting, D as matchWithWaiting, E as matchWithError, F as Failure, H as isResult, I as Initial, L as Result, M as waiting, N as waitingFrom, O as replacePrevious, P as Schema, R as Success, S as isSuccess, T as match, U as success, V as initial, _ as getOrThrow, a as With, b as isInterrupted, c as cause, d as failWithPrevious, f as failureWithPrevious, g as getOrElse, h as fromExitWithPrevious, j as value, k as toExit, l as error, m as fromExit, n as Defect, o as all, p as flatMap, r as Interrupt, s as builder, t as Builder, u as fail, v as isFailure, w as map, x as isNotInitial, y as isInitial, z as TypeId } from "./Result-BHH-qTvm.js";
+export { Builder, Defect, type Failure, type Initial, Interrupt, type Result, Schema, type Success, TypeId, With, all, builder, cause, error, fail, failWithPrevious, failure, failureWithPrevious, flatMap, fromExit, fromExitWithPrevious, getOrElse, getOrThrow, initial, isResult as isAsyncResult, isResult, isFailure, isInitial, isInterrupted, isNotInitial, isSuccess, isWaiting, map, match, matchWithError, matchWithWaiting, replacePrevious, success, toExit, touch, value, waiting, waitingFrom };

package/dist/Result.mjs

@@ -0,0 +1,2 @@
+import { A as Schema, C as matchWithWaiting, D as value, E as touch, F as isResult, I as success, M as TypeId, N as failure, O as waiting, P as initial, S as matchWithError, T as toExit, _ as isNotInitial, a as error, b as map, c as failureWithPrevious, d as fromExitWithPrevious, f as getOrElse, g as isInterrupted, h as isInitial, i as cause, k as waitingFrom, l as flatMap, m as isFailure, n as all, o as fail, p as getOrThrow, r as builder, s as failWithPrevious, u as fromExit, v as isSuccess, w as replacePrevious, x as match, y as isWaiting } from "./Result-rlUvoHzK.mjs";
+export { Schema, TypeId, all, builder, cause, error, fail, failWithPrevious, failure, failureWithPrevious, flatMap, fromExit, fromExitWithPrevious, getOrElse, getOrThrow, initial, isResult as isAsyncResult, isResult, isFailure, isInitial, isInterrupted, isNotInitial, isSuccess, isWaiting, map, match, matchWithError, matchWithWaiting, replacePrevious, success, toExit, touch, value, waiting, waitingFrom };

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { a as Atom_d_exports, vt as Registry_d_exports } from "./Atom-BgqgP-Qc.js";
+import { i as Result_d_exports } from "./Result-BHH-qTvm.js";
+import { t as AtomHttpApi_d_exports } from "./AtomHttpApi.js";
+import { t as AtomRef_d_exports } from "./AtomRef.js";
+import { t as AtomRpc_d_exports } from "./AtomRpc.js";
+import { t as Hydration_d_exports } from "./Hydration.js";
+export { Atom_d_exports as Atom, AtomHttpApi_d_exports as AtomHttpApi, AtomRef_d_exports as AtomRef, AtomRpc_d_exports as AtomRpc, Hydration_d_exports as Hydration, Registry_d_exports as Registry, Result_d_exports as Result };

package/dist/index.mjs

@@ -0,0 +1,8 @@
+import { t as Atom_exports } from "./Atom-DVWTGeoV.mjs";
+import { r as Registry_exports } from "./Registry-BE4aKSZk.mjs";
+import { t as Result_exports } from "./Result-rlUvoHzK.mjs";
+import { t as AtomHttpApi_exports } from "./AtomHttpApi.mjs";
+import { t as AtomRef_exports } from "./AtomRef.mjs";
+import { t as AtomRpc_exports } from "./AtomRpc.mjs";
+import { t as Hydration_exports } from "./Hydration.mjs";
+export { Atom_exports as Atom, AtomHttpApi_exports as AtomHttpApi, AtomRef_exports as AtomRef, AtomRpc_exports as AtomRpc, Hydration_exports as Hydration, Registry_exports as Registry, Result_exports as Result };

package/dist/rolldown-runtime-D7D4PA-g.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };