@typed/fx 2.0.0-beta.1 → 2.0.0-beta.10

package/dist/Versioned/Versioned.js

@@ -7,18 +7,18 @@
  * @since 1.0.0
  */
 import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
+import * as Effectable from "effect/Effectable";
 import { dual, flow, identity } from "effect/Function";
 import * as Layer from "effect/Layer";
 import { sum } from "effect/Number";
 import * as Option from "effect/Option";
 import { pipeArguments } from "effect/Pipeable";
-import * as ServiceMap from "effect/ServiceMap";
+import * as Context from "effect/Context";
 import { filterMap as fxFilterMap } from "../Fx/combinators/filterMap.js";
 import { filterMapEffect as fxFilterMapEffect } from "../Fx/combinators/filterMapEffect.js";
 import { map as fxMap } from "../Fx/combinators/map.js";
 import { mapEffect as fxMapEffect } from "../Fx/combinators/mapEffect.js";
-import { provide as fxProvide, provideServices as fxProvideServices, } from "../Fx/combinators/provide.js";
+import { provide as fxProvide, provideContext as fxprovideContext, } from "../Fx/combinators/provide.js";
 import { struct as fxStruct, tuple as fxTuple } from "../Fx/combinators/tuple.js";
 import { succeed as fxSucceed } from "../Fx/constructors/succeed.js";
 import { MulticastEffect } from "../Fx/internal/multicast.js";
@@ -28,15 +28,41 @@ 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.
  * @returns A `Versioned` value.
  * @since 1.0.0
- * @category constructors
+ * @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,19 +78,32 @@ 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.
+ * Sampled projections and in-flight reads are cached separately for each Effect Context object.
+ * Interrupting a transformed value affects the current Context's in-flight read.
+ *
  * @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.
  * @returns A new `Versioned` value.
  * @since 1.0.0
- * @category combinators
+ * @category Channel transformations
  */
 export function transform(input, transformFx, transformGet) {
     if (isVersionedTransform(input)) {
@@ -81,6 +120,7 @@ export class VersionedTransform extends YieldableFx {
     _version = -1;
     _currentValue = Option.none();
     _fx;
+    contexts = new WeakMap();
     input;
     _transformFx;
     _transformEffect;
@@ -91,124 +131,274 @@ export class VersionedTransform extends YieldableFx {
         this._transformEffect = _transformEffect;
         this._fx = _transformFx(this.input);
     }
-    version = Effect.sync(() => this._version);
+    version = Effect.contextWith((context) => Effect.sync(() => this.contexts.get(context)?.version ?? -1));
     run(sink) {
         return this._fx.run(sink);
     }
     toEffect() {
-        const transformed = this._transformEffect(this.input.asEffect());
-        const update = (v) => Effect.tapCause(Effect.tap(transformed, (value) => Effect.sync(() => {
-            this._currentValue = Option.some(Exit.succeed(value));
-            this._version = v;
-        })), (cause) => Effect.sync(() => {
-            this._currentValue = Option.some(Exit.failCause(cause));
-            this._version = v;
-        }));
-        const multicastEffect = new MulticastEffect(Effect.flatMap(this.input.version, (version) => {
-            if (version === this._version && Option.isSome(this._currentValue)) {
-                return this._currentValue.value;
+        const transformed = this._transformEffect(this.input);
+        return Effect.contextWith((context) => {
+            let state = this.contexts.get(context);
+            if (!state) {
+                state = { version: -1, currentValue: Option.none() };
+                this.contexts.set(context, state);
             }
-            return update(version);
-        }));
-        return multicastEffect.asEffect();
+            const current = state;
+            return (current.effect ??= new MulticastEffect(Effect.flatMap(this.input.version, (version) => {
+                if (version === current.version && Option.isSome(current.currentValue)) {
+                    return current.currentValue.value;
+                }
+                return Effect.onExit(transformed, (exit) => Effect.sync(() => {
+                    current.currentValue = Option.some(exit);
+                    current.version = version;
+                    this._currentValue = current.currentValue;
+                    this._version = version;
+                }));
+            })));
+        });
     }
-    interrupt = Effect.suspend(() => {
-        if (!this._effect)
-            return Effect.void;
-        const me = this._effect;
-        return me.interrupt();
-    });
+    interrupt = Effect.contextWith((context) => this.contexts.get(context)?.effect?.interrupt() ?? Effect.void);
 }
 function isVersionedTransform(u) {
     return u instanceof VersionedTransform;
 }
 /**
  * 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
+ * @category Channel transformations
  */
 export const map = dual(2, function map(versioned, options) {
     return transform(versioned, (fx) => fxMap(fx, options.onFx), Effect.map(options.onEffect));
 });
 /**
  * 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
+ * @category Channel transformations
  */
 export const mapEffect = dual(2, function mapEffect(versioned, options) {
     return transform(versioned, (fx) => fxMapEffect(fx, options.onFx), Effect.flatMap(options.onEffect));
 });
 /**
  * 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
+ * @category Optional channel transformations
  */
 export const filterMap = dual(2, function filterMap(versioned, options) {
     return transform(versioned, (fx) => fxFilterMap(fx, options.onFx), (effect) => Effect.map(effect, options.onEffect));
 });
 /**
  * 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
+ * @category Optional channel transformations
  */
 export const filterMapEffect = dual(2, function filterMapEffect(versioned, options) {
     return transform(versioned, (fx) => fxFilterMapEffect(fx, options.onFx), (effect) => Effect.flatMap(effect, options.onEffect));
 });
 /**
  * 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
+ * @category State composition
  */
 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
+ * @category State composition
  */
 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
+ * @category Services
  */
 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
+ * @category Constructors
  */
 export function of(value) {
     return make(Effect.succeed(1), fxSucceed(value), Effect.succeed(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
+ * @category Shared observation
  */
 export function hold(versioned) {
     return make(versioned.version, Subject.hold(versioned), 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
+ * @category Shared observation
  */
 export function multicast(versioned) {
     return make(versioned.version, Subject.multicast(versioned), 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
+ * @category Shared observation
  */
 export function replay(versioned, bufferSize) {
     return make(versioned.version, Subject.replay(versioned, bufferSize), versioned);
@@ -218,26 +408,70 @@ 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 Services
+ */
 export function Service() {
     return (id) => {
-        const service = ServiceMap.Service(id);
+        const service = Context.Service(id);
         // eslint-disable-next-line @typescript-eslint/no-extraneous-class
         return class VersionedService {
             static id = id;
             static service = service;
-            static make = (version, fx, effect) => Layer.effect(service, Effect.services().pipe(Effect.map((context) => make(Effect.provide(version, context), fxProvideServices(fx, context), Effect.provide(effect.asEffect(), context)))));
+            static {
+                // @effect-diagnostics-next-line floatingEffect:off
+                Object.assign(this, service);
+                Object.setPrototypeOf(this, Object.getPrototypeOf(service));
+                // @effect-diagnostics-next-line floatingEffect:off
+                Object.assign(this, Effectable.Prototype({
+                    label: "Versioned.Service",
+                    evaluate: () => Effect.flatten(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 = Effect.flatMap(service, identity);
             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";