@typed/fx 1.18.2 → 1.18.3

package/src/Idle.ts

@@ -15,8 +15,8 @@ import * as Layer from "effect/Layer"
 import type * as Queue from "effect/Queue"
 import * as Scheduler from "effect/Scheduler"
 import * as Scope from "effect/Scope"
-import { dequeueIsActive } from "./internal/fx"
-import { cancelIdleCallback, requestIdleCallback } from "./internal/requestIdleCallback"
+import { dequeueIsActive } from "./internal/fx.js"
+import { cancelIdleCallback, requestIdleCallback } from "./internal/requestIdleCallback.js"
 
 /**
  * The IdleScheduler is an implementation of Effect's Scheduler interface, which utilizes a priority queue
@@ -94,7 +94,7 @@ class IdleSchedulerImpl implements IdleScheduler {
  * @category instances
  */
 export const defaultIdleScheduler: IdleScheduler = globalValue(
-  Symbol("./Scheduler/Idle"),
+  Symbol("./Scheduler/Idle.js"),
   () => new IdleSchedulerImpl()
 )
 

package/src/Match.ts

@@ -8,14 +8,14 @@ import * as Chunk from "effect/Chunk"
 import { identity } from "effect/Function"
 import * as Option from "effect/Option"
 import { isNonEmptyReadonlyArray, reduce } from "effect/ReadonlyArray"
-import * as Fx from "./Fx"
-import type { Guard } from "./Guard"
-import * as RefSubject from "./RefSubject"
+import * as Fx from "./Fx.js"
+import type { Guard } from "./Guard.js"
+import * as RefSubject from "./RefSubject.js"
 
 /**
  * @since 1.18.0
  */
-export const MatcherTypeId: unique symbol = Symbol.for("./Matcher")
+export const MatcherTypeId: unique symbol = Symbol.for("./Matcher.js")
 /**
  * @since 1.18.0
  */

package/src/Model.ts

@@ -10,19 +10,19 @@ import type { Equivalence } from "effect/Equivalence"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import type { Scope } from "effect/Scope"
-import { Computed } from "./Computed"
-import { Filtered } from "./Filtered"
-import type { Fx, FxInput } from "./Fx"
-import { struct } from "./Fx"
-import { FxEffectBase } from "./internal/protos"
-import type { RefSubject } from "./RefSubject"
-import type { Versioned } from "./Versioned"
+import { Computed } from "./Computed.js"
+import { Filtered } from "./Filtered.js"
+import type { Fx, FxInput } from "./Fx.js"
+import { struct } from "./Fx.js"
+import { FxEffectBase } from "./internal/protos.js"
+import type { RefSubject } from "./RefSubject.js"
+import type { Versioned } from "./Versioned.js"
 
 /**
  * @since 1.18.0
  * @category symbols
  */
-export const ModelTypeId = Symbol.for("./Model")
+export const ModelTypeId = Symbol.for("./Model.js")
 
 /**
  * @since 1.18.0

package/src/Pull.ts

@@ -13,7 +13,7 @@ import * as Either from "effect/Either"
 import { dual } from "effect/Function"
 import * as Option from "effect/Option"
 import type * as Schedule from "effect/Schedule"
-import type { WithContext } from "./Sink"
+import type { WithContext } from "./Sink.js"
 
 /**
  * An Effect which can be used to pull values of a Stream.

package/src/RefArray.ts

@@ -12,10 +12,10 @@ import * as Option from "effect/Option"
 import type * as Order from "effect/Order"
 import * as ReadonlyArray from "effect/ReadonlyArray"
 import type * as Scope from "effect/Scope"
-import type * as Computed from "./Computed"
-import type * as Filtered from "./Filtered"
-import type * as Fx from "./Fx"
-import * as RefSubject from "./RefSubject"
+import type * as Computed from "./Computed.js"
+import type * as Filtered from "./Filtered.js"
+import type * as Fx from "./Fx.js"
+import * as RefSubject from "./RefSubject.js"
 
 /**
  * A RefArray is a RefSubject that is specialized over an array of values.

package/src/RefAsyncData.ts

@@ -12,12 +12,12 @@ import * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
 import type { Schedule } from "effect/Schedule"
-import type * as Computed from "./Computed"
-import type * as Filtered from "./Filtered"
-import * as Fx from "./Fx"
-import * as RefSubject from "./RefSubject"
-import * as Sink from "./Sink"
-import { RefSubjectTypeId } from "./TypeId"
+import type * as Computed from "./Computed.js"
+import type * as Filtered from "./Filtered.js"
+import * as Fx from "./Fx.js"
+import * as RefSubject from "./RefSubject.js"
+import * as Sink from "./Sink.js"
+import { RefSubjectTypeId } from "./TypeId.js"
 
 /**
  * A RefAsyncData is a RefSubject that holds an AsyncData value.

package/src/RefAsyncDataArray.ts

@@ -8,9 +8,9 @@ import type { IdentifierConstructor, IdentifierOf } from "@typed/context/Identif
 import type { Scope } from "effect"
 import type * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
-import type * as Computed from "./Computed"
-import * as Fx from "./Fx"
-import * as RefAsyncData from "./RefAsyncData"
+import type * as Computed from "./Computed.js"
+import * as Fx from "./Fx.js"
+import * as RefAsyncData from "./RefAsyncData.js"
 
 /**
  * A RefAsyncDataArray is a RefSubject that holds a AsyncData value of an array.

package/src/RefBoolean.ts

@@ -7,8 +7,8 @@ import type { Effect } from "effect"
 import { not } from "effect/Boolean"
 import { strict } from "effect/Equivalence"
 import type { Scope } from "effect/Scope"
-import type * as Fx from "./Fx"
-import * as RefSubject from "./RefSubject"
+import type * as Fx from "./Fx.js"
+import * as RefSubject from "./RefSubject.js"
 
 /**
  * A RefSubject holding a boolean values

package/src/RefChunk.ts

@@ -10,10 +10,10 @@ import { equals } from "effect/Equal"
 import type { Equivalence } from "effect/Equivalence"
 import { dual } from "effect/Function"
 import type * as Scope from "effect/Scope"
-import type * as Computed from "./Computed"
-import type * as Filtered from "./Filtered"
-import type * as Fx from "./Fx"
-import * as RefSubject from "./RefSubject"
+import type * as Computed from "./Computed.js"
+import type * as Filtered from "./Filtered.js"
+import type * as Fx from "./Fx.js"
+import * as RefSubject from "./RefSubject.js"
 
 /**
  * A RefChunk is a RefSubject that is specialized over an Chunk of values.

package/src/RefHashMap.ts

@@ -8,10 +8,10 @@ import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
 import * as HashMap from "effect/HashMap"
 import type { Option } from "effect/Option"
-import type { Computed } from "./Computed"
-import type { Filtered } from "./Filtered"
-import type * as Fx from "./Fx"
-import * as RefSubject from "./RefSubject"
+import type { Computed } from "./Computed.js"
+import type { Filtered } from "./Filtered.js"
+import type * as Fx from "./Fx.js"
+import * as RefSubject from "./RefSubject.js"
 
 /**
  * A RefHashMap is a RefSubject that is specialized over a HashMap of values.

package/src/RefHashSet.ts

@@ -8,9 +8,9 @@ import type * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
 import * as HashSet from "effect/HashSet"
 import type * as Scope from "effect/Scope"
-import type * as Computed from "./Computed"
-import type * as Fx from "./Fx"
-import * as RefSubject from "./RefSubject"
+import type * as Computed from "./Computed.js"
+import type * as Fx from "./Fx.js"
+import * as RefSubject from "./RefSubject.js"
 
 /**
  * A RefHashSet is a RefSubject that is specialized over an HashSet of values.

package/src/RefNumber.ts

@@ -6,8 +6,8 @@ import type { IdentifierConstructor, IdentifierOf } from "@typed/context/Identif
 import type { Effect } from "effect"
 import { strict } from "effect/Equivalence"
 import type { Scope } from "effect/Scope"
-import type * as Fx from "./Fx"
-import * as RefSubject from "./RefSubject"
+import type * as Fx from "./Fx.js"
+import * as RefSubject from "./RefSubject.js"
 
 const add = (x: number): number => x + 1
 const sub = (x: number): number => x - 1

package/src/RefSubject.ts

@@ -16,17 +16,17 @@ import { dual } from "effect/Function"
 import type * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import type * as Scope from "effect/Scope"
-import { Computed, fromTag } from "./Computed"
-import { Filtered } from "./Filtered"
-import type * as Fx from "./Fx"
-import { fromStream, provide, skipRepeatsWith } from "./internal/core"
-import * as coreRefSubject from "./internal/core-ref-subject"
-import { exit, fromFxEffect } from "./internal/fx"
-import { FxEffectBase } from "./internal/protos"
-import { fromRefSubject, toRefSubject } from "./internal/schema-ref-subject"
-import type * as Subject from "./Subject"
-import { ComputedTypeId, RefSubjectTypeId } from "./TypeId"
-import * as Versioned from "./Versioned"
+import { Computed, fromTag } from "./Computed.js"
+import { Filtered } from "./Filtered.js"
+import type * as Fx from "./Fx.js"
+import * as coreRefSubject from "./internal/core-ref-subject.js"
+import { fromStream, provide, skipRepeatsWith } from "./internal/core.js"
+import { exit, fromFxEffect } from "./internal/fx.js"
+import { FxEffectBase } from "./internal/protos.js"
+import { fromRefSubject, toRefSubject } from "./internal/schema-ref-subject.js"
+import type * as Subject from "./Subject.js"
+import { ComputedTypeId, RefSubjectTypeId } from "./TypeId.js"
+import * as Versioned from "./Versioned.js"
 
 /**
  * A RefSubject is a Subject that has a current value that can be read and updated.

package/src/Stream.ts

@@ -11,8 +11,8 @@ import * as Option from "effect/Option"
 import * as Queue from "effect/Queue"
 import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
-import * as Fx from "./Fx"
-import { Sink } from "./Sink"
+import * as Fx from "./Fx.js"
+import { Sink } from "./Sink.js"
 
 /**
  * Convert an Fx to a Stream

package/src/Subject.ts

@@ -8,11 +8,11 @@ import * as C from "@typed/context"
 import type { Cause } from "effect/Cause"
 import * as Effect from "effect/Effect"
 import type * as Layer from "effect/Layer"
-import { type Fx, ToFx } from "./Fx"
-import { provide } from "./internal/core"
-import * as internal from "./internal/core-subject"
-import { fromFxEffect } from "./internal/fx"
-import type { WithContext } from "./Sink"
+import { type Fx, ToFx } from "./Fx.js"
+import * as internal from "./internal/core-subject.js"
+import { provide } from "./internal/core.js"
+import { fromFxEffect } from "./internal/fx.js"
+import type { WithContext } from "./Sink.js"
 
 /**
  * A Subject is an Fx which is also a Sink, and can be used to

package/src/TypeId.ts

@@ -2,7 +2,7 @@
  * @since 1.18.0
  * @category symbols
  */
-export const TypeId = Symbol.for("./Fx")
+export const TypeId = Symbol.for("./Fx.js")
 
 /**
  * @since 1.18.0
@@ -14,7 +14,7 @@ export type TypeId = typeof TypeId
  * @since 1.18.0
  * @category symbols
  */
-export const RefSubjectTypeId = Symbol.for("./RefSubject")
+export const RefSubjectTypeId = Symbol.for("./RefSubject.js")
 
 /**
  * @since 1.18.0
@@ -26,7 +26,7 @@ export type RefSubjectTypeId = typeof RefSubjectTypeId
  * @since 1.18.0
  * @category symbols
  */
-export const ComputedTypeId = Symbol.for("./Computed")
+export const ComputedTypeId = Symbol.for("./Computed.js")
 
 /**
  * @since 1.18.0
@@ -38,7 +38,7 @@ export type ComputedTypeId = typeof ComputedTypeId
  * @since 1.18.0
  * @category symbols
  */
-export const FilteredTypeId = Symbol.for("./Filtered")
+export const FilteredTypeId = Symbol.for("./Filtered.js")
 
 /**
  * @since 1.18.0

package/src/Typeclass.ts

@@ -23,10 +23,10 @@ import type { Either } from "effect/Either"
 import { dual } from "effect/Function"
 import type * as HKT from "effect/HKT"
 import { getLeft, getRight } from "effect/Option"
-import type { Fx } from "./Fx"
+import type { Fx } from "./Fx.js"
 
-import * as core from "./internal/core"
-import { multicast } from "./internal/share"
+import * as core from "./internal/core.js"
+import { multicast } from "./internal/share.js"
 
 /**
  * TypeLambda for an Fx

package/src/Versioned.ts

@@ -9,10 +9,10 @@ import type { Context, Layer, Runtime } from "effect"
 import { Effect, identity } from "effect"
 import { dual } from "effect/Function"
 import { sum } from "effect/Number"
-import type * as Fx from "./Fx"
-import * as core from "./internal/core"
-import * as fxEffectProto from "./internal/fx-effect-proto"
-import { VersionedTransform } from "./internal/versioned-transform"
+import type * as Fx from "./Fx.js"
+import * as core from "./internal/core.js"
+import * as fxEffectProto from "./internal/fx-effect-proto.js"
+import { VersionedTransform } from "./internal/versioned-transform.js"
 
 /**
  * A data type which is both an Fx and an Effect. This is a more advanced type, and is the basis

package/src/index.ts

@@ -13,52 +13,52 @@
  * [Computed documentation](https://tylors.github.io/typed/fx/Computed.ts.html)
  * @since 1.18.0
  */
-export * as Computed from "./Computed"
+export * as Computed from "./Computed.js"
 
 /**
  * [Filtered documentation](https://tylors.github.io/typed/fx/Filtered.ts.html)
  * @since 1.18.0
  */
-export * as Filtered from "./Filtered"
+export * as Filtered from "./Filtered.js"
 
 /**
  * [Fx documentation](https://tylors.github.io/typed/fx/Fx.ts.html)
  * @since 1.18.0
  */
-export * from "./Fx"
+export * from "./Fx.js"
 
 /**
  * [RefArray documentation](https://tylors.github.io/typed/fx/RefArray.ts.html)
  * @since 1.18.0
  */
-export * as RefArray from "./RefArray"
+export * as RefArray from "./RefArray.js"
 
 /**
  * [RefSubject documentation](https://tylors.github.io/typed/fx/RefSubject.ts.html)
  * @since 1.18.0
  */
-export * as RefSubject from "./RefSubject"
+export * as RefSubject from "./RefSubject.js"
 
 /**
  * [Sink documentation](https://tylors.github.io/typed/fx/Sink.ts.html)
  * @since 1.18.0
  */
-export * as Sink from "./Sink"
+export * as Sink from "./Sink.js"
 
 /**
  * [Subject documentation](https://tylors.github.io/typed/fx/Subject.ts.html)
  * @since 1.18.0
  */
-export * as Subject from "./Subject"
+export * as Subject from "./Subject.js"
 
 /**
  * [Typeclass documentation](https://tylors.github.io/typed/fx/Typeclass.ts.html)
  * @since 1.18.0
  */
-export * as Typeclass from "./Typeclass"
+export * as Typeclass from "./Typeclass.js"
 
 /**
  * [TypeId documentation](https://tylors.github.io/typed/fx/TypeId.ts.html)
  * @since 1.18.0
  */
-export * from "./TypeId"
+export * from "./TypeId.js"

package/src/internal/core-ref-subject.ts

@@ -18,14 +18,14 @@ import { Sink, WithContext } from "../Sink"
 import type * as Subject from "../Subject"
 import { ComputedTypeId, RefSubjectTypeId } from "../TypeId"
 import { transformFx } from "../Versioned"
-import * as core from "./core"
-import { makeHoldSubject } from "./core-subject"
-import { DeferredRef } from "./deferred-ref"
-import { fromFxEffect } from "./fx"
-import { matchFxInput } from "./matchers"
-import { FxEffectBase } from "./protos"
-import { run } from "./run"
-import { share } from "./share"
+import { makeHoldSubject } from "./core-subject.js"
+import * as core from "./core.js"
+import { DeferredRef } from "./deferred-ref.js"
+import { fromFxEffect } from "./fx.js"
+import { matchFxInput } from "./matchers.js"
+import { FxEffectBase } from "./protos.js"
+import { run } from "./run.js"
+import { share } from "./share.js"
 
 export class RefSubjectImpl<R, E, A> extends FxEffectBase<R, E, A, R, E, A> implements RefSubject<R, E, A> {
   readonly [RefSubjectTypeId]: RefSubjectTypeId = RefSubjectTypeId

package/src/internal/core-subject.ts

@@ -7,9 +7,9 @@ import * as Scope from "effect/Scope"
 import type { Fx } from "../Fx"
 import type { Sink } from "../Sink"
 import type { Subject } from "../Subject"
-import { fromSink } from "./core"
-import { ToFx } from "./fx-primitive"
-import { RingBuffer } from "./helpers"
+import { fromSink } from "./core.js"
+import { ToFx } from "./fx-primitive.js"
+import { RingBuffer } from "./helpers.js"
 
 export function makeSubject<E, A>(): Subject<never, E, A> {
   return new SubjectImpl<E, A>()

package/src/internal/core.ts

@@ -27,11 +27,11 @@ import {
   liftSyncOperator,
   MapEffect,
   TapEffect
-} from "./effect-operator"
-import * as helpers from "./helpers"
-import * as Provide from "./provide"
-import * as strategies from "./strategies"
-import { compileSyncReducer, Filter, FilterMap, Map } from "./sync-operator"
+} from "./effect-operator.js"
+import * as helpers from "./helpers.js"
+import * as Provide from "./provide.js"
+import * as strategies from "./strategies.js"
+import { compileSyncReducer, Filter, FilterMap, Map } from "./sync-operator.js"
 
 import type { DurationInput } from "effect/Duration"
 import type { Equivalence } from "effect/Equivalence"
@@ -47,8 +47,8 @@ import type {
   WithScopedForkParams
 } from "../Fx"
 import * as Sink from "../Sink"
-import { type Bounds, boundsFrom, mergeBounds } from "./bounds"
-import { type InternalEffect, matchEffectPrimitive } from "./effect-primitive"
+import { type Bounds, boundsFrom, mergeBounds } from "./bounds.js"
+import { type InternalEffect, matchEffectPrimitive } from "./effect-primitive.js"
 import {
   Empty,
   Fail,
@@ -65,11 +65,11 @@ import {
   WithEarlyExit,
   WithFlattenStrategy,
   WithScopedFork
-} from "./fx-primitive"
-import { adjustTime } from "./helpers"
-import { matchFxInput } from "./matchers"
-import { OnceEffect } from "./protos"
-import { run } from "./run"
+} from "./fx-primitive.js"
+import { adjustTime } from "./helpers.js"
+import { matchFxInput } from "./matchers.js"
+import { OnceEffect } from "./protos.js"
+import { run } from "./run.js"
 
 const constUnit = () => Effect.unit
 

package/src/internal/effect-operator.ts

@@ -2,7 +2,7 @@ import * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 import { WithContext } from "../Sink"
-import type { SyncOperator } from "./sync-operator"
+import type { SyncOperator } from "./sync-operator.js"
 
 // Effect operators are a subset of operators which can be safely fused together assynchronously
 

package/src/internal/fx-effect-proto.ts

@@ -1,8 +1,8 @@
 import * as Effect from "effect/Effect"
 import type { Fx } from "../Fx"
 import type { Versioned } from "../Versioned"
-import { succeed } from "./core"
-import { FxEffectBase } from "./protos"
+import { succeed } from "./core.js"
+import { FxEffectBase } from "./protos.js"
 
 /**
  * Construct a Versioned type.

package/src/internal/fx-primitive.ts

@@ -3,11 +3,11 @@ import type * as Effect from "effect/Effect"
 import type * as Scope from "effect/Scope"
 
 import type * as Sink from "../Sink"
-import { type EffectOperator, fuseEffectOperators, liftSyncOperator } from "./effect-operator"
-import * as syncOperator from "./sync-operator"
+import { type EffectOperator, fuseEffectOperators, liftSyncOperator } from "./effect-operator.js"
+import * as syncOperator from "./sync-operator.js"
 
 import type { FlattenStrategy, Fx, FxFork, WithEarlyExitParams, WithScopedForkParams } from "../Fx"
-import { FxProto } from "./protos"
+import { FxProto } from "./protos.js"
 
 export type Primitive =
   | Empty

package/src/internal/fx.ts

@@ -25,9 +25,9 @@ import * as Tracer from "effect/Tracer"
 import type { Fx, FxInput } from "../Fx"
 import * as Sink from "../Sink"
 import * as Typeclass from "../Typeclass"
-import * as core from "./core"
-import { run } from "./run"
-import { multicast } from "./share"
+import * as core from "./core.js"
+import { run } from "./run.js"
+import { multicast } from "./share.js"
 
 /**
  * Create an Fx which will emit a value after waiting for a specified duration.

package/src/internal/helpers.ts

@@ -11,8 +11,8 @@ import * as Scope from "effect/Scope"
 import * as SynchronizedRef from "effect/SynchronizedRef"
 import type { FlattenStrategy, FxFork, ScopedFork } from "../Fx"
 import type * as Sink from "../Sink"
-import type { InternalEffect } from "./effect-primitive"
-import { matchEffectPrimitive } from "./effect-primitive"
+import type { InternalEffect } from "./effect-primitive.js"
+import { matchEffectPrimitive } from "./effect-primitive.js"
 
 export function withScopedFork<R, E, A>(
   f: (fork: ScopedFork, scope: Scope.Scope) => Effect.Effect<R, E, A>

package/src/internal/keyed.ts

@@ -10,10 +10,10 @@ import type * as Fx from "../Fx"
 import { fromEffect, type RefSubject } from "../RefSubject"
 import { WithContext } from "../Sink"
 import type { Subject } from "../Subject"
-import { from, skipRepeatsWith, withScopedFork } from "./core"
-import { makeHoldSubject } from "./core-subject"
-import { adjustTime } from "./helpers"
-import { run } from "./run"
+import { makeHoldSubject } from "./core-subject.js"
+import { from, skipRepeatsWith, withScopedFork } from "./core.js"
+import { adjustTime } from "./helpers.js"
+import { run } from "./run.js"
 
 export function keyed<R, E, A, B, R2, E2, C>(
   fx: Fx.Fx<R, E, ReadonlyArray<A>>,

package/src/internal/matchers.ts

@@ -6,7 +6,7 @@ import type * as Sink from "../Sink"
 
 import type { Fx, FxInput } from "../Fx"
 import type { RefSubject } from "../RefSubject"
-import type * as Primitive from "./fx-primitive"
+import type * as Primitive from "./fx-primitive.js"
 
 export function matchFxPrimitive<B>(
   matchers: {

package/src/internal/run.ts

@@ -1,12 +1,12 @@
 import * as Effect from "effect/Effect"
 
 import * as Sink from "../Sink"
-import { compileCauseEffectOperatorSink, compileEffectOperatorSink } from "./effect-operator"
-import * as helpers from "./helpers"
-import { compileSyncOperatorFailureSink, compileSyncOperatorSink } from "./sync-operator"
+import { compileCauseEffectOperatorSink, compileEffectOperatorSink } from "./effect-operator.js"
+import * as helpers from "./helpers.js"
+import { compileSyncOperatorFailureSink, compileSyncOperatorSink } from "./sync-operator.js"
 
 import type { Fx } from "../Fx"
-import { matchFxPrimitive } from "./matchers"
+import { matchFxPrimitive } from "./matchers.js"
 
 const constUnit = () => Effect.unit
 

package/src/internal/schema-ref-subject.ts

@@ -8,9 +8,9 @@ import type * as Scope from "effect/Scope"
 import type { Fx, FxInput } from "../Fx"
 import type { MakeRefSubject, RefSubject, ToRefSubject } from "../RefSubject"
 import { ComputedTypeId, FilteredTypeId, RefSubjectTypeId } from "../TypeId"
-import { map } from "./core"
-import { make, struct } from "./core-ref-subject"
-import { matchFxInput } from "./matchers"
+import { make, struct } from "./core-ref-subject.js"
+import { map } from "./core.js"
+import { matchFxInput } from "./matchers.js"
 
 const makeSchema = <O>(
   f: <R, E>(

package/src/internal/share.ts

@@ -5,10 +5,10 @@ import * as MutableRef from "effect/MutableRef"
 import * as Option from "effect/Option"
 import type { Fx } from "../Fx"
 import type { Subject } from "../Subject"
-import { withScopedFork } from "./core"
-import { makeHoldSubject, makeReplaySubject, makeSubject } from "./core-subject"
-import { ToFx } from "./fx-primitive"
-import { run } from "./run"
+import { makeHoldSubject, makeReplaySubject, makeSubject } from "./core-subject.js"
+import { withScopedFork } from "./core.js"
+import { ToFx } from "./fx-primitive.js"
+import { run } from "./run.js"
 
 export function share<R, E, A, R2>(
   fx: Fx<R, E, A>,

package/src/internal/versioned-transform.ts

@@ -2,8 +2,8 @@ import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 import type { Fx } from "../Fx"
 import type { Versioned } from "../Versioned"
-import { MulticastEffect } from "./helpers"
-import { FxEffectBase } from "./protos"
+import { MulticastEffect } from "./helpers.js"
+import { FxEffectBase } from "./protos.js"
 
 export class VersionedTransform<R0, E0, R, E, A, R2, E2, B, R3, E3, C, R4, E4, D>
   extends FxEffectBase<R3, E3, C, R0 | R4, E0 | E4, D>