@typed/fx 2.0.0-beta.4 → 2.0.0-beta.6

package/dist/Versioned/Versioned.js

@@ -28,6 +28,32 @@ import * as Subject from "../Subject/Subject.js";
 /**
  * Creates a Versioned value from its components.
  *
+ * @remarks
+ * ## Why
+ *
+ * Builds one Versioned value from independently typed version, update, and current-value channels
+ * instead of forcing them into one error or environment type.
+ *
+ * ## Ownership and lifetime
+ *
+ * Construction is lazy with respect to the Fx channel. Current reads share in-flight work until
+ * interrupt is run; each component retains its declared errors and services.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Fx from "@typed/fx/Fx"
+ * import * as Versioned from "@typed/fx/Versioned"
+ *
+ * const status = Versioned.make(
+ *   Effect.succeed(1),
+ *   Fx.succeed("ready"),
+ *   Effect.succeed("ready")
+ * )
+ *
+ * const snapshot = Effect.all({ value: status, version: status.version })
+ * ```
+ *
  * @param version - An effect that retrieves the current version number.
  * @param fx - The stream of updates.
  * @param effect - An effect that retrieves the current value.
@@ -36,7 +62,7 @@ import * as Subject from "../Subject/Subject.js";
  * @category constructors
  */
 export function make(version, fx, effect) {
-    return new VersionedImpl(version, fx, effect.asEffect());
+    return new VersionedImpl(version, fx, effect);
 }
 class VersionedImpl extends YieldableFx {
     version;
@@ -52,13 +78,24 @@ class VersionedImpl extends YieldableFx {
         return this.fx.run(sink);
     }
     toEffect() {
-        return this.effect.asEffect();
+        return this.effect;
     }
     interrupt = Effect.suspend(() => this.effect.interrupt());
 }
 /**
  * Transforms a Versioned value into another Versioned value.
  *
+ * @remarks
+ * ## Why
+ *
+ * Transforms the pushed and sampled channels together while retaining one version source, so both
+ * ways of consuming the value stay coherent.
+ *
+ * ## Ownership and lifetime
+ *
+ * transform does not take ownership of its inputs. Its observation and current-read channels
+ * retain upstream lifetime, typed failures, services, and interruption behavior.
+ *
  * @param input - The source Versioned value.
  * @param transformFx - A function to transform the update stream.
  * @param transformGet - A function to transform the current value effect.
@@ -96,7 +133,7 @@ export class VersionedTransform extends YieldableFx {
         return this._fx.run(sink);
     }
     toEffect() {
-        const transformed = this._transformEffect(this.input.asEffect());
+        const transformed = this._transformEffect(this.input);
         const update = (v) => Effect.tapCause(Effect.tap(transformed, (value) => Effect.sync(() => {
             this._currentValue = Option.some(Exit.succeed(value));
             this._version = v;
@@ -110,7 +147,7 @@ export class VersionedTransform extends YieldableFx {
             }
             return update(version);
         }));
-        return multicastEffect.asEffect();
+        return multicastEffect;
     }
     interrupt = Effect.suspend(() => {
         if (!this._effect)
@@ -124,6 +161,33 @@ function isVersionedTransform(u) {
 }
 /**
  * Transform a Versioned's output value as both an Fx and Effect.
+ * @remarks
+ * ## Why
+ *
+ * Applies corresponding pure projections to pushed and sampled values while leaving the version
+ * token unchanged.
+ *
+ * ## Ownership and lifetime
+ *
+ * map does not take ownership of its inputs. Its observation and current-read channels retain
+ * upstream lifetime, typed failures, services, and interruption behavior.
+ *
+ * Pure callbacks preserve push order and cardinality. `onFx` applies to every pushed update;
+ * `onEffect` applies only when the current value is sampled.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Versioned from "@typed/fx/Versioned"
+ *
+ * const length = Versioned.map(Versioned.of("typed"), {
+ *   onFx: (value) => value.length,
+ *   onEffect: (value) => value.length
+ * })
+ *
+ * const currentLength = Effect.runPromise(length)
+ * ```
+ *
  * @since 1.18.0
  * @category combinators
  */
@@ -132,6 +196,17 @@ export const map = dual(2, function map(versioned, options) {
 });
 /**
  * Transform a Versioned's output value as both an Fx and Effect using an Effect.
+ * @remarks
+ * ## Why
+ *
+ * Allows pushed and sampled projections to require services or fail, and exposes those additions
+ * in the corresponding output channels.
+ *
+ * ## Ownership and lifetime
+ *
+ * No subscription starts during transformation. Callback effects run when their push or read
+ * channel is consumed and are interrupted with that consumer.
+ *
  * @since 1.18.0
  * @category combinators
  */
@@ -140,6 +215,17 @@ export const mapEffect = dual(2, function mapEffect(versioned, options) {
 });
 /**
  * Filter-maps a Versioned's output as both an Fx and Effect; the Effect value becomes `Option` (Some when the predicate holds, None otherwise).
+ * @remarks
+ * ## Why
+ *
+ * Drops absent pushed values while preserving an Option for the current read, making the two
+ * absence semantics explicit.
+ *
+ * ## Ownership and lifetime
+ *
+ * filterMap does not take ownership of its inputs. Its observation and current-read channels
+ * retain upstream lifetime, typed failures, services, and interruption behavior.
+ *
  * @since 1.18.0
  * @category combinators
  */
@@ -148,6 +234,17 @@ export const filterMap = dual(2, function filterMap(versioned, options) {
 });
 /**
  * Filter-maps a Versioned's output as both an Fx and Effect using an Effect; the Effect value becomes `Option`.
+ * @remarks
+ * ## Why
+ *
+ * Adds Effectful filtering independently to the push and current-read channels while preserving
+ * their separate error and service types.
+ *
+ * ## Ownership and lifetime
+ *
+ * No subscription starts during transformation. Callback effects run when their push or read
+ * channel is consumed and are interrupted with that consumer.
+ *
  * @since 1.18.0
  * @category combinators
  */
@@ -156,33 +253,77 @@ export const filterMapEffect = dual(2, function filterMapEffect(versioned, optio
 });
 /**
  * Combines multiple Versioned values into a single tuple.
+ * @remarks
+ * ## Why
+ *
+ * Combines several Versioned values positionally and uses their versions as one invalidation token
+ * for the assembled tuple.
+ *
+ * ## Ownership and lifetime
+ *
+ * tuple does not take ownership of its inputs. Its observation and current-read channels retain
+ * upstream lifetime, typed failures, services, and interruption behavior.
+ *
  * @since 1.0.0
  * @category combinators
  */
 export function tuple(versioneds) {
-    return make(Effect.map(Effect.all(versioneds.map((v) => v.version)), (versions) => versions.reduce(sum, 0)), fxTuple(...versioneds), Effect.all(versioneds.map((v) => v.asEffect()), { concurrency: "unbounded" }));
+    return make(Effect.map(Effect.all(versioneds.map((v) => v.version)), (versions) => versions.reduce(sum, 0)), fxTuple(...versioneds), Effect.all(versioneds.map((v) => v), { concurrency: "unbounded" }));
 }
 /**
  * Combines multiple Versioned values into a single struct.
+ * @remarks
+ * ## Why
+ *
+ * Combines named Versioned values and preserves each field's pushed value, sampled value, errors,
+ * and services in the resulting structure.
+ *
+ * ## Ownership and lifetime
+ *
+ * struct does not take ownership of its inputs. Its observation and current-read channels retain
+ * upstream lifetime, typed failures, services, and interruption behavior.
+ *
  * @since 1.0.0
  * @category combinators
  */
 export function struct(versioneds) {
-    return make(Effect.map(Effect.all(Object.values(versioneds).map((v) => v.version)), (versions) => versions.reduce(sum, 0)), fxStruct(versioneds), Effect.all(mapRecord(versioneds, (v) => v.asEffect()), { concurrency: "unbounded" }));
+    return make(Effect.map(Effect.all(Object.values(versioneds).map((v) => v.version)), (versions) => versions.reduce(sum, 0)), fxStruct(versioneds), Effect.all(mapRecord(versioneds, (v) => v), { concurrency: "unbounded" }));
 }
 /**
  * Provides context to a Versioned value.
+ * @remarks
+ * ## Why
+ *
+ * Supplies one Layer to all three Versioned channels so service elimination is consistent for
+ * version reads, pushed updates, and current reads.
+ *
+ * ## Ownership and lifetime
+ *
+ * provide does not take ownership of its inputs. Its observation and current-read channels retain
+ * upstream lifetime, typed failures, services, and interruption behavior.
+ *
  * @since 1.0.0
  * @category combinators
  */
 export const provide = (versioned, layer) => {
-    return make(Effect.provide(versioned.version, layer), fxProvide(versioned, layer), Effect.provide(versioned.asEffect(), layer));
+    return make(Effect.provide(versioned.version, layer), fxProvide(versioned, layer), Effect.provide(versioned, layer));
 };
 function mapRecord(record, f) {
     return Object.fromEntries(Object.entries(record).map(([k, v]) => [k, f(v, k)]));
 }
 /**
  * Creates a Versioned value from a constant.
+ * @remarks
+ * ## Why
+ *
+ * Creates constant versioned state for composition and testing without starting a fiber or
+ * requiring a Scope.
+ *
+ * ## Ownership and lifetime
+ *
+ * of does not take ownership of its inputs. Its observation and current-read channels retain
+ * upstream lifetime, typed failures, services, and interruption behavior.
+ *
  * @since 1.0.0
  * @category constructors
  */
@@ -191,6 +332,28 @@ export function of(value) {
 }
 /**
  * Holds the latest value of a Versioned stream.
+ * @remarks
+ * ## Why
+ *
+ * Retains the latest pushed value for later subscribers while leaving current-value reads
+ * delegated to the original Versioned Effect.
+ *
+ * ## Ownership and lifetime
+ *
+ * The returned Fx requires Scope; its shared upstream subscription and retained buffer are
+ * finalized when that Scope closes. Current reads retain input errors and services.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Versioned from "@typed/fx/Versioned"
+ *
+ * const program = Effect.scoped(Effect.gen(function* () {
+ *   const shared = Versioned.hold(Versioned.of({ status: "ready" as const }))
+ *   return yield* shared
+ * }))
+ * ```
+ *
  * @since 1.0.0
  * @category combinators
  */
@@ -199,6 +362,19 @@ export function hold(versioned) {
 }
 /**
  * Multicasts a Versioned stream.
+ * @remarks
+ * ## Why
+ *
+ * Shares one upstream push subscription among concurrent observers while retaining the original
+ * current-read and version effects. Unlike `hold` and `replay`, `multicast` retains zero values: a
+ * late observer receives only pushes that happen after it subscribes.
+ *
+ * ## Ownership and lifetime
+ *
+ * The returned Fx requires Scope; that Scope owns and finalizes the shared upstream subscription.
+ * There is no replay buffer or held latest value. Current reads bypass the multicast channel and
+ * retain the input's errors and services.
+ *
  * @since 1.0.0
  * @category combinators
  */
@@ -207,6 +383,17 @@ export function multicast(versioned) {
 }
 /**
  * Replays the last `bufferSize` values of a Versioned stream.
+ * @remarks
+ * ## Why
+ *
+ * Shares an upstream push subscription and replays a bounded number of updates to late observers
+ * without changing current-value reads.
+ *
+ * ## Ownership and lifetime
+ *
+ * The returned Fx requires Scope; its shared upstream subscription and retained buffer are
+ * finalized when that Scope closes. Current reads retain input errors and services.
+ *
  * @since 1.0.0
  * @category combinators
  */
@@ -218,6 +405,40 @@ const VARIANCE = {
     _E: identity,
     _R: identity,
 };
+/**
+ * Creates a Context-backed Versioned service facade and Layer constructor.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Creates an Effect service tag that exposes current reads, pushed updates, and versions through
+ * one Layer-provided state dependency.
+ *
+ * ## Ownership and lifetime
+ *
+ * Calling Service is pure. The generated make Layer captures required environments and owns the
+ * provided state for the Layer Scope.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Fx from "@typed/fx/Fx"
+ * import * as Versioned from "@typed/fx/Versioned"
+ *
+ * class Status extends Versioned.Service<Status, never, string, never, string>()(
+ *   "example/Status"
+ * ) {}
+ *
+ * const StatusLive = Status.make(
+ *   Effect.succeed(1),
+ *   Fx.succeed("ready"),
+ *   Effect.succeed("ready")
+ * )
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
 export function Service() {
     return (id) => {
         const service = Context.Service(id);
@@ -225,19 +446,24 @@ export function Service() {
         return class VersionedService {
             static id = id;
             static service = service;
-            static make = (version, fx, effect) => Layer.effect(service, Effect.context().pipe(Effect.map((context) => make(Effect.provide(version, context), fxprovideContext(fx, context), Effect.provide(effect.asEffect(), context)))));
+            static {
+                // @effect-diagnostics-next-line floatingEffect:off
+                Object.assign(this, service);
+                Object.assign(this.prototype, Object.getPrototypeOf(service));
+            }
+            static make = (version, fx, effect) => Layer.effect(service, Effect.context().pipe(Effect.map((context) => make(Effect.provide(version, context), fxprovideContext(fx, context), Effect.provide(effect, context)))));
             static [FxTypeId] = VARIANCE;
             static pipe = function () {
                 return pipeArguments(this, arguments);
             };
-            static version = Effect.flatMap(service.asEffect(), (v) => v.version);
-            static interrupt = Effect.flatMap(service.asEffect(), (v) => v.interrupt);
-            static run = (sink) => Effect.flatMap(service.asEffect(), (v) => v.run(sink));
+            static version = Effect.flatMap(service, (v) => v.version);
+            static interrupt = Effect.flatMap(service, (v) => v.interrupt);
+            static run = (sink) => Effect.flatMap(service, (v) => v.run(sink));
+            static override = service;
             static [Symbol.iterator] = function* () {
                 const v = yield* service;
                 return yield* v;
             };
-            static asEffect = () => Effect.flatMap(service.asEffect(), (v) => v.asEffect());
             constructor() {
                 return VersionedService;
             }

package/dist/index.d.ts

@@ -1,8 +1,27 @@
 export * as Fx from "./Fx.js";
 export * as Push from "./Push.js";
-export * as RefArray from "./RefSubject/RefArray.js";
-export * as RefSubject from "./RefSubject/RefSubject.js";
-export * as Sink from "./Sink/index.js";
+export * as RefArray from "./RefArray.js";
+export * as RefBigDecimal from "./RefBigDecimal.js";
+export * as RefBigInt from "./RefBigInt.js";
+export * as RefBoolean from "./RefBoolean.js";
+export * as RefCause from "./RefCause.js";
+export * as RefChunk from "./RefChunk.js";
+export * as RefDateTime from "./RefDateTime.js";
+export * as RefDuration from "./RefDuration.js";
+export * as RefGraph from "./RefGraph.js";
+export * as RefHashMap from "./RefHashMap.js";
+export * as RefHashRing from "./RefHashRing.js";
+export * as RefHashSet from "./RefHashSet.js";
+export * as RefIterable from "./RefIterable.js";
+export * as RefOption from "./RefOption.js";
+export * as RefRecord from "./RefRecord.js";
+export * as RefResult from "./RefResult.js";
+export * as RefString from "./RefString.js";
+export * as RefStruct from "./RefStruct.js";
+export * as RefSubject from "./RefSubject.js";
+export * as RefTrie from "./RefTrie.js";
+export * as RefTuple from "./RefTuple.js";
+export * as Sink from "./Sink.js";
 export * as Subject from "./Subject.js";
 export * as Versioned from "./Versioned.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAC9B,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,QAAQ,MAAM,0BAA0B,CAAC;AACrD,OAAO,KAAK,UAAU,MAAM,4BAA4B,CAAC;AACzD,OAAO,KAAK,IAAI,MAAM,iBAAiB,CAAC;AACxC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAC9B,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAC;AAChD,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAC;AAChD,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAC;AAChD,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAC;AAChD,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -1,7 +1,26 @@
 export * as Fx from "./Fx.js";
 export * as Push from "./Push.js";
-export * as RefArray from "./RefSubject/RefArray.js";
-export * as RefSubject from "./RefSubject/RefSubject.js";
-export * as Sink from "./Sink/index.js";
+export * as RefArray from "./RefArray.js";
+export * as RefBigDecimal from "./RefBigDecimal.js";
+export * as RefBigInt from "./RefBigInt.js";
+export * as RefBoolean from "./RefBoolean.js";
+export * as RefCause from "./RefCause.js";
+export * as RefChunk from "./RefChunk.js";
+export * as RefDateTime from "./RefDateTime.js";
+export * as RefDuration from "./RefDuration.js";
+export * as RefGraph from "./RefGraph.js";
+export * as RefHashMap from "./RefHashMap.js";
+export * as RefHashRing from "./RefHashRing.js";
+export * as RefHashSet from "./RefHashSet.js";
+export * as RefIterable from "./RefIterable.js";
+export * as RefOption from "./RefOption.js";
+export * as RefRecord from "./RefRecord.js";
+export * as RefResult from "./RefResult.js";
+export * as RefString from "./RefString.js";
+export * as RefStruct from "./RefStruct.js";
+export * as RefSubject from "./RefSubject.js";
+export * as RefTrie from "./RefTrie.js";
+export * as RefTuple from "./RefTuple.js";
+export * as Sink from "./Sink.js";
 export * as Subject from "./Subject.js";
 export * as Versioned from "./Versioned.js";

package/package.json

@@ -1,9 +1,17 @@
 {
   "name": "@typed/fx",
-  "version": "2.0.0-beta.4",
+  "version": "2.0.0-beta.6",
+  "description": "Reactive streams and state for Typed applications.",
+  "homepage": "https://github.com/TylorS/typed-smol/tree/main/packages/fx#readme",
+  "bugs": "https://github.com/TylorS/typed-smol/issues",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TylorS/typed-smol.git",
+    "directory": "packages/fx"
+  },
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "type": "module",
   "exports": {
@@ -11,23 +19,124 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./*": {
-      "types": "./dist/*.d.ts",
-      "import": "./dist/*.js"
+    "./Fx": {
+      "types": "./dist/Fx.d.ts",
+      "import": "./dist/Fx.js"
+    },
+    "./Push": {
+      "types": "./dist/Push.d.ts",
+      "import": "./dist/Push.js"
+    },
+    "./RefSubject": {
+      "types": "./dist/RefSubject.d.ts",
+      "import": "./dist/RefSubject.js"
+    },
+    "./Sink": {
+      "types": "./dist/Sink.d.ts",
+      "import": "./dist/Sink.js"
+    },
+    "./Subject": {
+      "types": "./dist/Subject.d.ts",
+      "import": "./dist/Subject.js"
+    },
+    "./Versioned": {
+      "types": "./dist/Versioned.d.ts",
+      "import": "./dist/Versioned.js"
+    },
+    "./RefArray": {
+      "types": "./dist/RefArray.d.ts",
+      "import": "./dist/RefArray.js"
+    },
+    "./RefBigDecimal": {
+      "types": "./dist/RefBigDecimal.d.ts",
+      "import": "./dist/RefBigDecimal.js"
+    },
+    "./RefBigInt": {
+      "types": "./dist/RefBigInt.d.ts",
+      "import": "./dist/RefBigInt.js"
+    },
+    "./RefBoolean": {
+      "types": "./dist/RefBoolean.d.ts",
+      "import": "./dist/RefBoolean.js"
+    },
+    "./RefCause": {
+      "types": "./dist/RefCause.d.ts",
+      "import": "./dist/RefCause.js"
+    },
+    "./RefChunk": {
+      "types": "./dist/RefChunk.d.ts",
+      "import": "./dist/RefChunk.js"
+    },
+    "./RefDateTime": {
+      "types": "./dist/RefDateTime.d.ts",
+      "import": "./dist/RefDateTime.js"
+    },
+    "./RefDuration": {
+      "types": "./dist/RefDuration.d.ts",
+      "import": "./dist/RefDuration.js"
+    },
+    "./RefGraph": {
+      "types": "./dist/RefGraph.d.ts",
+      "import": "./dist/RefGraph.js"
+    },
+    "./RefHashMap": {
+      "types": "./dist/RefHashMap.d.ts",
+      "import": "./dist/RefHashMap.js"
+    },
+    "./RefHashRing": {
+      "types": "./dist/RefHashRing.d.ts",
+      "import": "./dist/RefHashRing.js"
+    },
+    "./RefHashSet": {
+      "types": "./dist/RefHashSet.d.ts",
+      "import": "./dist/RefHashSet.js"
+    },
+    "./RefIterable": {
+      "types": "./dist/RefIterable.d.ts",
+      "import": "./dist/RefIterable.js"
+    },
+    "./RefOption": {
+      "types": "./dist/RefOption.d.ts",
+      "import": "./dist/RefOption.js"
+    },
+    "./RefRecord": {
+      "types": "./dist/RefRecord.d.ts",
+      "import": "./dist/RefRecord.js"
+    },
+    "./RefResult": {
+      "types": "./dist/RefResult.d.ts",
+      "import": "./dist/RefResult.js"
+    },
+    "./RefString": {
+      "types": "./dist/RefString.d.ts",
+      "import": "./dist/RefString.js"
+    },
+    "./RefStruct": {
+      "types": "./dist/RefStruct.d.ts",
+      "import": "./dist/RefStruct.js"
+    },
+    "./RefTrie": {
+      "types": "./dist/RefTrie.d.ts",
+      "import": "./dist/RefTrie.js"
+    },
+    "./RefTuple": {
+      "types": "./dist/RefTuple.d.ts",
+      "import": "./dist/RefTuple.js"
     }
   },
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "[ -d dist ] || rm -f tsconfig.tsbuildinfo; tsc",
-    "test": "vitest run --passWithNoTests"
-  },
   "dependencies": {
-    "effect": "catalog:"
+    "effect": "4.0.0-rc.112"
   },
   "devDependencies": {
-    "typescript": "catalog:",
-    "vitest": "catalog:"
+    "typescript": "7.0.2",
+    "vitest": "5.0.0"
+  },
+  "scripts": {
+    "build": "node -e \"const fs=require('node:fs'); fs.rmSync('dist',{recursive:true,force:true}); fs.rmSync('tsconfig.tsbuildinfo',{force:true})\" && tsc",
+    "test": "vitest run --config vitest.config.ts",
+    "test:types": "pnpm run build && tsc -p tsconfig.type-tests.json && tsc -p tsconfig.tests.json"
   }
-}
+}

package/dist/Fx/constructors/fromYieldable.d.ts

@@ -1,12 +0,0 @@
-import type { Yieldable } from "effect/Effect";
-import type { Fx } from "../Fx.js";
-/**
- * Creates an Fx from any Yieldable value (e.g., Effect, Promise, etc.).
- *
- * @param yieldable - The yieldable value to convert.
- * @returns An `Fx` that emits the result of the yieldable.
- * @since 1.0.0
- * @category constructors
- */
-export declare const fromYieldable: <A, E = never, R = never>(yieldable: Yieldable<any, A, E, R>) => Fx<A, E, R>;
-//# sourceMappingURL=fromYieldable.d.ts.map

package/dist/Fx/constructors/fromYieldable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fromYieldable.d.ts","sourceRoot":"","sources":["../../../src/Fx/constructors/fromYieldable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,EACnD,WAAW,SAAS,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KACjC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CACwE,CAAC"}

package/dist/Fx/constructors/fromYieldable.js

@@ -1,12 +0,0 @@
-import { matchCauseEffect } from "effect/Effect";
-import { make } from "./make.js";
-/**
- * Creates an Fx from any Yieldable value (e.g., Effect, Promise, etc.).
- *
- * @param yieldable - The yieldable value to convert.
- * @returns An `Fx` that emits the result of the yieldable.
- * @since 1.0.0
- * @category constructors
- */
-export const fromYieldable = (yieldable) => 
-/*#__PURE__*/ make((sink) => matchCauseEffect(yieldable.asEffect(), sink));