@livestore/utils 0.4.0 → 0.5.0-dev.0

package/src/effect/Schema/debug-diff.test.ts

@@ -8,7 +8,7 @@ describe('debug-diff', () => {
   test('simple object', () => {
     const schema = Schema.Struct({
       a: Schema.String,
-      b: Schema.Number,
+      b: Schema.Finite,
     })
 
     const a = { a: 'hello', b: 1 }
@@ -35,7 +35,7 @@ describe('debug-diff', () => {
     const schema = Schema.Struct({
       a: Schema.String,
       b: Schema.Struct({
-        c: Schema.Number,
+        c: Schema.Finite,
       }),
     })
     const a = { a: 'hello', b: { c: 1 } }
@@ -58,7 +58,7 @@ describe('debug-diff', () => {
   })
 
   test('union', () => {
-    const schema = Schema.Union(Schema.String, Schema.Number)
+    const schema = Schema.Union([Schema.String, Schema.Finite])
     const a = 'hello'
     const b = 1
     const diff = debugDiff(schema)(a, b)
@@ -74,10 +74,10 @@ describe('debug-diff', () => {
   })
 
   test('tagged union', () => {
-    const schema = Schema.Union(
+    const schema = Schema.Union([
       Schema.TaggedStruct('a', { a: Schema.String }),
-      Schema.TaggedStruct('b', { b: Schema.Number }),
-    )
+      Schema.TaggedStruct('b', { b: Schema.Finite }),
+    ])
     const a = { _tag: 'a', a: 'hello' } as const
     const b = { _tag: 'b', b: 1 } as const
     const diff = debugDiff(schema)(a, b)

package/src/effect/Schema/debug-diff.ts

@@ -11,7 +11,7 @@ export type DiffItem = {
  * Diffs two values for a given schema and traverses downwards and returns a list of differences.
  */
 export const debugDiff =
-  <A, I, R>(base: Schema.Schema<A, I, R>) =>
+  <A, I, R>(base: Schema.Top) =>
   (a: A, b: A): DiffItem[] => {
     const bag = [] as DiffItem[]
     debugDiffImpl(base.ast, a, b, '', bag)
@@ -19,7 +19,7 @@ export const debugDiff =
   }
 
 const debugDiffImpl = (ast: SchemaAST.AST, a: any, b: any, path: string, bag: DiffItem[]) => {
-  const eq = Schema.equivalence({ ast } as any)
+  const eq = Schema.toEquivalence({ ast } as any)
   if (eq(a, b) === false) {
     // bag.push({ path, a, b, ast })
 
@@ -35,9 +35,8 @@ const debugDiffImpl = (ast: SchemaAST.AST, a: any, b: any, path: string, bag: Di
           } catch {}
         }
       }
-    } else if (SchemaAST.isTypeLiteral(ast) === true) {
-      const props = SchemaAST.getPropertySignatures(ast)
-      for (const prop of props) {
+    } else if (SchemaAST.isObjects(ast) === true) {
+      for (const prop of ast.propertySignatures) {
         debugDiffImpl(prop.type, a[prop.name], b[prop.name], `${path}.${prop.name.toString()}`, bag)
       }
     } else {
@@ -50,9 +49,8 @@ const debugDiffImpl = (ast: SchemaAST.AST, a: any, b: any, path: string, bag: Di
 const isTaggedUnion = (ast: SchemaAST.AST): boolean => {
   if (SchemaAST.isUnion(ast) === true) {
     return ast.types.every((type) => {
-      if (SchemaAST.isTypeLiteral(type) === false) return false
-      const props = SchemaAST.getPropertySignatures(type)
-      return props.some((prop) => prop.name.toString() === '_tag')
+      if (SchemaAST.isObjects(type) === false) return false
+      return type.propertySignatures.some((prop) => prop.name.toString() === '_tag')
     })
   }
   return false

package/src/effect/Schema/index.ts

@@ -1,18 +1,115 @@
-import { Transferable } from '@effect/platform'
-import { Effect, Hash, ParseResult, Schema } from 'effect'
-import type { ParseError } from 'effect/ParseResult'
-import type { ParseOptions } from 'effect/SchemaAST'
-import * as SchemaAST from 'effect/SchemaAST'
-
-import { shouldNeverHappen } from '../../mod.ts'
+import {
+  Array,
+  Effect,
+  Function,
+  Hash,
+  Option,
+  Result,
+  Schema,
+  SchemaAST,
+  SchemaGetter,
+  SchemaIssue,
+  SchemaTransformation,
+  Struct,
+} from 'effect'
+import { Transferable } from 'effect/unstable/workers'
+
+import { shouldNeverHappen } from '../../misc.ts'
 
 export * from 'effect/Schema'
 export * from './debug-diff.ts'
 
+type PluckSchema<Fields extends Schema.Struct.Fields, K extends keyof Fields> = Schema.Codec<
+  Fields[K]['Type'],
+  Schema.Struct<Pick<Fields, K>>['Encoded'],
+  Schema.Struct<Pick<Fields, K>>['DecodingServices'],
+  Schema.Struct<Pick<Fields, K>>['EncodingServices']
+>
+
+export const pluck =
+  <const K extends PropertyKey>(key: K) =>
+  <Fields extends { readonly [P in K]: Schema.Top }>(
+    schema: Schema.Struct<Fields>,
+  ): PluckSchema<Fields, K & keyof Fields> => {
+    const field = schema.fields[key] as Fields[K & keyof Fields]
+
+    return schema.mapFields(Struct.pick([key])).pipe(
+      Schema.decodeTo(Schema.toType(field), {
+        decode: SchemaGetter.transform((whole: any) => whole[key]),
+        encode: SchemaGetter.transform((value) => ({ [key]: value }) as any),
+      }),
+    ) as unknown as PluckSchema<Fields, K & keyof Fields>
+  }
+
+/**
+ * Like {@link fromJsonString}, but the ENCODED form is an *indented* JSON string
+ * (default 2-space) instead of compact — for committed/human-read JSON files
+ * (package.json, release plans, CI previews) that must stay diff-friendly while
+ * still round-tripping through the schema.
+ *
+ * Use a concrete schema for known shapes (adds validation) or `Schema.Unknown`
+ * for open-ended ones (the indented analogue of `fromJsonString(Schema.Unknown)`).
+ *
+ * TODO collapse into `fromJsonString(schema, { space })` now that Effect 4 accepts a
+ * `space` option; kept separate here to keep the Effect upgrade free of release-tooling changes.
+ */
+export const jsonStringIndented = <S extends Schema.Top>(schema: S, space: number | string = 2) =>
+  schema.pipe(
+    Schema.encodeTo(Schema.String, {
+      decode: SchemaGetter.parseJson(),
+      encode: SchemaGetter.stringifyJson({ space }),
+    }),
+  )
+
+export const head = <S extends Schema.Top>(
+  array: Schema.$Array<S>,
+): Schema.decodeTo<Schema.Option<Schema.toType<S>>, Schema.$Array<S>> =>
+  array.pipe(
+    Schema.decodeTo(
+      Schema.Option(Schema.toType(array.value)),
+      SchemaTransformation.transform({
+        decode: Array.head,
+        encode: Option.match({
+          onNone: () => [],
+          onSome: Array.of,
+        }),
+      }),
+    ),
+  )
+
+type HeadOrElse<S extends Schema.Top> = Schema.decodeTo<Schema.toType<S>, Schema.$Array<S>>
+
+export const headOrElse: {
+  <S extends Schema.Top>(array: Schema.$Array<S>, orElse?: () => S['Type']): HeadOrElse<S>
+  (): <S extends Schema.Top>(array: Schema.$Array<S>) => HeadOrElse<S>
+  <S extends Schema.Top>(orElse: () => S['Type']): (array: Schema.$Array<S>) => HeadOrElse<S>
+} = Function.dual(
+  (args) => Schema.isSchema(args[0]),
+  <S extends Schema.Top>(array: Schema.$Array<S>, orElse?: () => S['Type']): HeadOrElse<S> =>
+    array.pipe(
+      Schema.decodeTo(
+        Schema.toType(array.value),
+        SchemaTransformation.transformOrFail({
+          decode: (array) =>
+            Array.isReadonlyArrayNonEmpty(array) === true
+              ? Effect.succeed(Array.headNonEmpty(array))
+              : orElse === undefined
+                ? Effect.fail(
+                    new SchemaIssue.InvalidValue({
+                      message: 'Unable to retrieve the first element of an empty array',
+                    }),
+                  )
+                : Effect.succeed(orElse()),
+          encode: (value) => Effect.succeed(Array.of(value)),
+        }),
+      ),
+    ),
+)
+
 // NOTE this is a temporary workaround until Effect schema has a better way to hash schemas
 // https://github.com/Effect-TS/effect/issues/2719
 // TODO remove this once the issue is resolved
-export const hash = (schema: Schema.Schema<any>) => {
+export const hash = (schema: Schema.Top) => {
   try {
     return Hash.string(JSON.stringify(schema.ast, null, 2))
   } catch {
@@ -23,80 +120,44 @@ export const hash = (schema: Schema.Schema<any>) => {
   }
 }
 
-const resolveStructAst = (ast: SchemaAST.AST): SchemaAST.AST => {
-  if (SchemaAST.isTransformation(ast) === true) {
-    return resolveStructAst(ast.from)
-  }
-
-  return ast
+export const getResolvedPropertySignatures = (schema: Schema.Top): ReadonlyArray<SchemaAST.PropertySignature> => {
+  const resolvedAst = SchemaAST.toType(schema.ast)
+  return SchemaAST.isObjects(resolvedAst) === true ? resolvedAst.propertySignatures : []
 }
 
-export const getResolvedPropertySignatures = (
-  schema: Schema.Schema.AnyNoContext,
-): ReadonlyArray<SchemaAST.PropertySignature> => {
-  const resolvedAst = resolveStructAst(schema.ast)
-  return SchemaAST.getPropertySignatures(resolvedAst)
-}
-
-/** Objects that can be transferred between contexts (workers, etc.) */
-type TransferableObject = ArrayBuffer | MessagePort
-
 export const encodeWithTransferables =
-  <A, I, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions) =>
-  (a: A, overrideOptions?: ParseOptions): Effect.Effect<[I, TransferableObject[]], ParseError, R> =>
+  <A, I>(schema: Schema.Codec<A, I>, options?: SchemaAST.ParseOptions) =>
+  (a: A, overrideOptions?: SchemaAST.ParseOptions) =>
     Effect.gen(function* () {
       const collector = yield* Transferable.makeCollector
 
-      const encoded: I = yield* Schema.encode(schema, options)(a, overrideOptions).pipe(
+      const encoded = yield* Schema.encodeEffect(schema, options)(a, overrideOptions).pipe(
         Effect.provideService(Transferable.Collector, collector),
       )
 
-      return [encoded, collector.unsafeRead() as TransferableObject[]]
+      return [encoded, collector.readUnsafe()] as const
     })
 
 export const decodeSyncDebug: <A, I>(
-  schema: Schema.Schema<A, I>,
+  schema: Schema.Codec<A, I>,
   options?: SchemaAST.ParseOptions,
 ) => (i: I, overrideOptions?: SchemaAST.ParseOptions) => A = (schema, options) => (input, overrideOptions) => {
-  const res = Schema.decodeEither(schema, options)(input, overrideOptions)
-  if (res._tag === 'Left') {
-    return shouldNeverHappen(`decodeSyncDebug failed:`, res.left)
+  const res = Schema.decodeResult(schema, options)(input, overrideOptions)
+  if (Result.isFailure(res) === true) {
+    return shouldNeverHappen(`decodeSyncDebug failed:`, res.failure)
   } else {
-    return res.right
+    return res.success
   }
 }
 
 export const encodeSyncDebug: <A, I>(
-  schema: Schema.Schema<A, I>,
+  schema: Schema.Codec<A, I>,
   options?: SchemaAST.ParseOptions,
 ) => (a: A, overrideOptions?: SchemaAST.ParseOptions) => I = (schema, options) => (input, overrideOptions) => {
-  const res = Schema.encodeEither(schema, options)(input, overrideOptions)
-  if (res._tag === 'Left') {
-    return shouldNeverHappen(`encodeSyncDebug failed:`, res.left)
+  const res = Schema.encodeResult(schema, options)(input, overrideOptions)
+  if (Result.isFailure(res) === true) {
+    return shouldNeverHappen(`encodeSyncDebug failed:`, res.failure)
   } else {
-    return res.right
+    return res.success
   }
 }
-
-export const swap = <A, I, R>(schema: Schema.Schema<A, I, R>): Schema.Schema<I, A, R> =>
-  Schema.transformOrFail(Schema.typeSchema(schema), Schema.encodedSchema(schema), {
-    decode: ParseResult.encode(schema),
-    encode: ParseResult.decode(schema),
-  })
-
-export const Base64FromUint8Array: Schema.Schema<string, Uint8Array> = swap(Schema.Uint8ArrayFromBase64)
-
-export interface JsonArray extends ReadonlyArray<JsonValue> {}
-export interface JsonObject {
-  [key: string]: JsonValue
-}
-export type JsonValue = string | number | boolean | null | JsonObject | JsonArray
-
-export const JsonValue: Schema.Schema<JsonValue> = Schema.Union(
-  Schema.String,
-  Schema.Number,
-  Schema.Boolean,
-  Schema.Null,
-  Schema.Array(Schema.suspend(() => JsonValue)),
-  Schema.Record({ key: Schema.String, value: Schema.suspend(() => JsonValue) }),
-).annotations({ identifier: 'JsonValue' })

package/src/effect/Stream.test.ts

@@ -1,4 +1,4 @@
-import { Effect, Option, Stream } from 'effect'
+import { Effect, Option, Result, Stream } from 'effect'
 import { describe, expect, it } from 'vitest'
 
 import { concatWithLastElement, runCollectReadonlyArray } from './Stream.ts'
@@ -61,10 +61,10 @@ describe('concatWithLastElement', () => {
     const stream1 = Stream.fail('first-error')
     const result = concatWithLastElement(stream1, () => Stream.make('should-not-reach'))
 
-    const outcome = await Effect.runPromise(Effect.either(runCollectReadonlyArray(result)))
-    expect(outcome._tag).toBe('Left')
-    if (outcome._tag === 'Left') {
-      expect(outcome.left).toBe('first-error')
+    const outcome = await Effect.runPromise(Effect.result(runCollectReadonlyArray(result)))
+    expect(outcome._tag).toBe('Failure')
+    if (Result.isFailure(outcome) === true) {
+      expect(outcome.failure).toBe('first-error')
     }
   })
 
@@ -72,10 +72,10 @@ describe('concatWithLastElement', () => {
     const stream1 = Stream.make(1, 2)
     const result = concatWithLastElement(stream1, () => Stream.fail('second-error'))
 
-    const outcome = await Effect.runPromise(Effect.either(runCollectReadonlyArray(result)))
-    expect(outcome._tag).toBe('Left')
-    if (outcome._tag === 'Left') {
-      expect(outcome.left).toBe('second-error')
+    const outcome = await Effect.runPromise(Effect.result(runCollectReadonlyArray(result)))
+    expect(outcome._tag).toBe('Failure')
+    if (Result.isFailure(outcome) === true) {
+      expect(outcome.failure).toBe('second-error')
     }
   })
 

package/src/effect/Stream.ts

@@ -1,11 +1,9 @@
-/** biome-ignore-all lint/suspicious/useIterableCallbackReturn: Biome bug */
 export * from 'effect/Stream'
 
-import { type Cause, Chunk, Effect, Option, pipe, Ref, Stream } from 'effect'
-import { dual } from 'effect/Function'
+import { type Cause, Array, Effect, Function, Option, pipe, Ref, Stream } from 'effect'
 
 export const tapLog = <R, E, A>(stream: Stream.Stream<A, E, R>): Stream.Stream<A, E, R> =>
-  tapChunk<never, never, A, void>(Effect.forEach((_) => Effect.succeed(console.log(_))))(stream)
+  tapArray<never, never, A, void>(Effect.forEach((_) => Effect.succeed(console.log(_))))(stream)
 
 export const tapSync =
   <A>(tapFn: (a: A) => unknown) =>
@@ -15,15 +13,24 @@ export const tapSync =
 export const tapLogWithLabel =
   (label: string) =>
   <R, E, A>(stream: Stream.Stream<A, E, R>): Stream.Stream<A, E, R> =>
-    tapChunk<never, never, A, void>(Effect.forEach((_) => Effect.succeed(console.log(label, _))))(stream)
+    tapArray<never, never, A, void>(Effect.forEach((_) => Effect.succeed(console.log(label, _))))(stream)
 
-export const tapChunk =
-  <R1, E1, A, Z>(f: (a: Chunk.Chunk<A>) => Effect.Effect<Z, E1, R1>) =>
+/**
+ * Runs an effect once for each array batch emitted by the stream, preserving
+ * the original stream elements.
+ *
+ * Use this for batch-oriented side effects such as `Queue.offerAll`. For
+ * element-wise side effects, prefer `Stream.tap`.
+ *
+ * @see {@link Stream.tap} for running an effect once per element.
+ */
+export const tapArray =
+  <R1, E1, A, Z>(f: (a: ReadonlyArray<A>) => Effect.Effect<Z, E1, R1>) =>
   <R, E>(self: Stream.Stream<A, E, R>): Stream.Stream<A, E1 | E, R1 | R> =>
-    Stream.mapChunksEffect(self, (chunks) =>
+    Stream.mapArrayEffect(self, (array) =>
       pipe(
-        f(chunks),
-        Effect.map(() => chunks),
+        f(array),
+        Effect.map(() => array),
       ),
     )
 
@@ -68,18 +75,18 @@ export const skipRepeated_ = <R, E, A>(
  * It's different than `Stream.runHead` which runs the stream to completion.
  * */
 export const runFirst = <A, E, R>(stream: Stream.Stream<A, E, R>): Effect.Effect<Option.Option<A>, E, R> =>
-  stream.pipe(Stream.take(1), Stream.runCollect, Effect.map(Chunk.head))
+  stream.pipe(Stream.take(1), Stream.runCollect, Effect.map(Array.head))
 
 /**
- * Returns the first element of the stream or throws a `NoSuchElementException` if the stream is empty.
+ * Returns the first element of the stream or throws a `NoSuchElementError` if the stream is empty.
  * It's different than `Stream.runHead` which runs the stream to completion.
  * */
 export const runFirstUnsafe = <A, E, R>(
   stream: Stream.Stream<A, E, R>,
-): Effect.Effect<A, Cause.NoSuchElementException | E, R> => runFirst(stream).pipe(Effect.flatten)
+): Effect.Effect<A, Cause.NoSuchElementError | E, R> => runFirst(stream).pipe(Effect.flatMap(Effect.fromOption))
 
 export const runCollectReadonlyArray = <A, E, R>(stream: Stream.Stream<A, E, R>): Effect.Effect<readonly A[], E, R> =>
-  stream.pipe(Stream.runCollect, Effect.map(Chunk.toReadonlyArray))
+  stream.pipe(Stream.runCollect)
 
 /**
  * Concatenates two streams where the second stream has access to the last element
@@ -120,7 +127,7 @@ export const concatWithLastElement: {
     stream: Stream.Stream<A1, E1, R1>,
     getStream2: (lastElement: Option.Option<A1>) => Stream.Stream<A2, E2, R2>,
   ): Stream.Stream<A1 | A2, E1 | E2, R1 | R2>
-} = dual(
+} = Function.dual(
   2,
   <A1, E1, R1, A2, E2, R2>(
     stream1: Stream.Stream<A1, E1, R1>,
@@ -163,7 +170,7 @@ export const concatWithLastElement: {
 export const emitIfEmpty: {
   <A>(fallbackValue: A): <E, R>(stream: Stream.Stream<A, E, R>) => Stream.Stream<A, E, R>
   <A, E, R>(stream: Stream.Stream<A, E, R>, fallbackValue: A): Stream.Stream<A, E, R>
-} = dual(
+} = Function.dual(
   2,
   <A, E, R>(stream: Stream.Stream<A, E, R>, fallbackValue: A): Stream.Stream<A, E, R> =>
     concatWithLastElement(stream, (lastElement) =>

package/src/effect/Subscribable.ts

@@ -4,10 +4,15 @@
  * @since 2.0.0
  */
 
-import type { SubscriptionRef } from 'effect'
-import { Effect, Effectable, Readable, Stream } from 'effect'
-import { dual } from 'effect/Function'
-import { hasProperty } from 'effect/Predicate'
+import { Effect, Effectable, Function, Predicate, Stream, SubscriptionRef } from 'effect'
+
+const ReadableTypeId: unique symbol = Symbol.for('effect/Readable')
+type ReadableTypeId = typeof ReadableTypeId
+
+interface Readable<A, E = never, R = never> {
+  readonly [ReadableTypeId]: ReadableTypeId
+  readonly get: Effect.Effect<A, E, R>
+}
 
 /**
  * @since 2.0.0
@@ -25,7 +30,7 @@ export type TypeId = typeof TypeId
  * @since 2.0.0
  * @category models
  */
-export interface Subscribable<A, E = never, R = never> extends Readable.Readable<A, E, R>, Effect.Effect<A, E, R> {
+export interface Subscribable<A, E = never, R = never> extends Readable<A, E, R>, Effect.Effect<A, E, R> {
   readonly [TypeId]: TypeId
   readonly changes: Stream.Stream<A, E, R>
 }
@@ -34,52 +39,36 @@ export interface Subscribable<A, E = never, R = never> extends Readable.Readable
  * @since 2.0.0
  * @category refinements
  */
-export const isSubscribable = (u: unknown): u is Subscribable<unknown, unknown, unknown> => hasProperty(u, TypeId)
-
-// const Proto: Omit<Subscribable<any>, 'get' | 'changes'> = {
-//   [Readable.TypeId]: Readable.TypeId,
-//   [TypeId]: TypeId,
-//   pipe() {
-//     return pipeArguments(this, arguments)
-//   },
-// }
-
-class SubscribableImpl<in out A> extends Effectable.Class<A> implements Subscribable<A> {
-  // @ts-expect-error type symbol
-  readonly [TypeId] = TypeId
-  // @ts-expect-error type symbol
-  readonly [Readable.TypeId] = Readable.TypeId
-  readonly get: Effect.Effect<A>
-  readonly changes: Stream.Stream<A>
-  constructor(get: Effect.Effect<A>, changes: Stream.Stream<A>) {
-    super()
-    this.get = get
-    this.changes = changes
-  }
-
-  commit() {
-    return this.get
-  }
-}
+export const isSubscribable = (u: unknown): u is Subscribable<unknown, unknown, unknown> =>
+  Predicate.hasProperty(u, TypeId)
+
+const Proto: Omit<Subscribable<unknown, unknown, unknown>, 'get' | 'changes'> = Object.assign(
+  Effectable.Prototype<Subscribable<unknown, unknown, unknown>>({
+    label: 'Subscribable',
+    evaluate() {
+      // @effect-diagnostics-next-line anyUnknownInErrorContext:off -- vendored fork; this shared prototype is generic over all A, E, R, so `unknown` in the error/requirements channels is structural, not a real error type
+      return this.get
+    },
+  }),
+  {
+    [ReadableTypeId]: ReadableTypeId,
+    [TypeId]: TypeId,
+  } as const,
+)
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-// export const make = <A, E, R>(options: {
-//   readonly get: Effect.Effect<A, E, R>
-//   readonly changes: Stream.Stream<A, E, R>
-// }): Subscribable<A, E, R> => Object.assign(Object.create(Proto), options)
-
 export const make = <A, E, R>(options: {
   readonly get: Effect.Effect<A, E, R>
   readonly changes: Stream.Stream<A, E, R>
-}): Subscribable<A, E, R> => new SubscribableImpl(options.get as any, options.changes as any) as Subscribable<A, E, R>
+}): Subscribable<A, E, R> => Object.assign(Object.create(Proto), options)
 
 export const fromSubscriptionRef = <A>(ref: SubscriptionRef.SubscriptionRef<A>): Subscribable<A> =>
   make({
-    get: ref.get,
-    changes: ref.changes,
+    get: SubscriptionRef.get(ref),
+    changes: SubscriptionRef.changes(ref),
   })
 
 /**
@@ -97,7 +86,7 @@ export const map: {
    * @category combinators
    */
   <A, E, R, B>(self: Subscribable<A, E, R>, f: (a: NoInfer<A>) => B): Subscribable<B, E, R>
-} = dual(
+} = Function.dual(
   2,
   <A, E, R, B>(self: Subscribable<A, E, R>, f: (a: NoInfer<A>) => B): Subscribable<B, E, R> =>
     make({
@@ -126,7 +115,7 @@ export const mapEffect: {
     self: Subscribable<A, E, R>,
     f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>,
   ): Subscribable<B, E | E2, R | R2>
-} = dual(
+} = Function.dual(
   2,
   <A, E, R, B, E2, R2>(
     self: Subscribable<A, E, R>,

package/src/effect/SubscriptionRef.ts

@@ -1,23 +1,19 @@
-import { Chunk, Effect, pipe, Stream, SubscriptionRef } from 'effect'
-import { dual } from 'effect/Function'
-import type { Predicate, Refinement } from 'effect/Predicate'
+import { Effect, Function, pipe, Stream, SubscriptionRef, type Predicate } from 'effect'
 
 export * from 'effect/SubscriptionRef'
 
 export const waitUntil: {
-    <A, B extends A>(
-    refinement: Refinement<NoInfer<A>, B>,
-  ): (sref: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<B>
   <A, B extends A>(
-    predicate: Predicate<B>,
-  ): (sref: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<A>
+    refinement: Predicate.Refinement<NoInfer<A>, B>,
+  ): (sref: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<B>
+  <A, B extends A>(predicate: Predicate.Predicate<B>): (sref: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<A>
   <A, B extends A>(
     sref: SubscriptionRef.SubscriptionRef<A>,
-    refinement: Refinement<NoInfer<A>, B>,
+    refinement: Predicate.Refinement<NoInfer<A>, B>,
   ): Effect.Effect<B>
-  <A, B extends A>(sref: SubscriptionRef.SubscriptionRef<A>, predicate: Predicate<B>): Effect.Effect<A>
-} = dual(2, <A>(sref: SubscriptionRef.SubscriptionRef<A>, predicate: (a: A) => boolean) =>
-  pipe(sref.changes, Stream.filter(predicate), Stream.take(1), Stream.runCollect, Effect.map(Chunk.unsafeHead)),
+  <A, B extends A>(sref: SubscriptionRef.SubscriptionRef<A>, predicate: Predicate.Predicate<B>): Effect.Effect<A>
+} = Function.dual(2, <A>(sref: SubscriptionRef.SubscriptionRef<A>, predicate: (a: A) => boolean) =>
+  pipe(SubscriptionRef.changes(sref), Stream.filter(predicate), Stream.runHead, Effect.flatMap(Effect.fromOption)),
 )
 
 export const fromStream = <A>(stream: Stream.Stream<A>, initialValue: A) =>

package/src/effect/TaskTracing.ts

@@ -1,9 +1,4 @@
-import { Predicate } from 'effect'
-import * as Context from 'effect/Context'
-import * as Effect from 'effect/Effect'
-import { pipe } from 'effect/Function'
-import * as Layer from 'effect/Layer'
-import * as Tracer from 'effect/Tracer'
+import { Context, Effect, Layer, Predicate, Tracer } from 'effect'
 
 export const withAsyncTaggingTracing =
   (makeTrace: (name: string) => { run: (fn: any) => any }) =>
@@ -14,30 +9,32 @@ export const withAsyncTaggingTracing =
 
     const makeTracer = Effect.gen(function* () {
       const oldTracer = yield* Effect.tracer
+      const evaluate = <X>(primitive: Tracer.EffectPrimitive<X>, fiber: any) =>
+        oldTracer.context?.(primitive, fiber) ?? primitive['~effect/Effect/evaluate'](fiber)
       return Tracer.make({
-        span: (name, ...args) => {
-          const span = oldTracer.span(name, ...args)
-          const trace = makeTrace(name)
+        span: (options) => {
+          const span = oldTracer.span(options)
+          const trace = makeTrace(options.name)
           ;(span as any).runInTask = (f: any) => trace.run(f)
           return span
         },
-        context: (f, fiber) => {
-          const maybeParentSpan = Context.getOption(Tracer.ParentSpan)(fiber.currentContext)
+        context: (primitive, fiber) => {
+          const maybeParentSpan = Context.getOption(fiber.context, Tracer.ParentSpan)
 
-          if (maybeParentSpan._tag === 'None') return oldTracer.context(f, fiber)
+          if (maybeParentSpan._tag === 'None') return evaluate(primitive, fiber)
           const parentSpan = maybeParentSpan.value
-          if (parentSpan._tag === 'ExternalSpan') return oldTracer.context(f, fiber)
+          if (parentSpan._tag === 'ExternalSpan') return evaluate(primitive, fiber)
           const span = parentSpan
           if ('runInTask' in span && typeof span.runInTask === 'function') {
-            return span.runInTask(() => oldTracer.context(f, fiber))
+            return span.runInTask(() => evaluate(primitive, fiber))
           }
 
-          return oldTracer.context(f, fiber)
+          return evaluate(primitive, fiber)
         },
       })
     })
 
-    const withTracerLayer = pipe(makeTracer, Effect.map(Layer.setTracer), Layer.unwrapEffect)
+    const withTracerLayer = Layer.effect(Tracer.Tracer, makeTracer)
 
     return Effect.provide(eff, withTracerLayer)
   }