@effect/stm - npm Package Compare versions

Comparing version 0.0.1 to 0.0.2

package.json

 {
   "name": "@effect/stm",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "license": "MIT",
@@ -10,6 +10,5 @@ "repository": {
   "dependencies": {
-    "@effect/io": "^0.0.29",
-    "@effect/printer": "^0.1.7",
+    "@effect/io": "^0.0.35",
     "@fp-ts/core": "^0.0.9",
-    "@fp-ts/data": "^0.0.19"
+    "@fp-ts/data": "^0.0.26"
   },
@@ -16,0 +15,0 @@ "publishConfig": {

src/STM.ts

@@ -6,14 +6,14 @@ /**
 import type * as Effect from "@effect/io/Effect"
+import * as core from "@effect/stm/internal/core"
 import type * as Context from "@fp-ts/data/Context"
 
-/** @internal */
-import * as internal from "@effect/io/internal/stm"
-
 /**
  * @since 1.0.0
+ * @category symbols
  */
-export const STMTypeId: unique symbol = internal.STMTypeId as unknown as STMTypeId
+export const STMTypeId: unique symbol = core.STMTypeId
 
 /**
  * @since 1.0.0
+ * @category symbols
  */
@@ -57,4 +57,12 @@ export type STMTypeId = typeof STMTypeId
  * @since 1.0.0
+ * @category models
  */
-export interface STM<R, E, A> extends STM.Variance<R, E, A>, Effect.Effect<R, E, A> {}
+export interface STM<R, E, A> extends STM.Variance<R, E, A>, Effect.Effect<R, E, A> {
+  /** @internal */
+  trace: string | undefined
+  /** @internal */
+  traced(trace: string | undefined): STM<R, E, A>
+  /** @internal */
+  commit(): Effect.Effect<R, E, A>
+}
 
@@ -67,2 +75,3 @@ /**
    * @since 1.0.0
+   * @category models
    */
@@ -79,39 +88,53 @@ export interface Variance<R, E, A> {
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category error handling
  */
 export const catchAll: <E, R1, E1, B>(
   f: (e: E) => STM<R1, E1, B>
-) => <R, A>(self: STM<R, E, A>) => STM<R1 | R, E1, B | A> = internal.catchAll
+) => <R, A>(self: STM<R, E, A>) => STM<R1 | R, E1, B | A> = core.catchAll
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category destructors
  */
-export const commit: <R, E, A>(self: STM<R, E, A>) => Effect.Effect<R, E, A> = internal.commit
+export const commit: <R, E, A>(self: STM<R, E, A>) => Effect.Effect<R, E, A> = core.commit
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category constructors
  */
-export const die: (defect: unknown) => STM<never, never, never> = internal.die
+export const die: (defect: unknown) => STM<never, never, never> = core.die
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category finalization
  */
 export const ensuring: <R1, B>(
   finalizer: STM<R1, never, B>
-) => <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E, A> = internal.ensuring
+) => <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E, A> = core.ensuring
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category constructors
  */
-export const fail: <E>(error: E) => STM<never, E, never> = internal.fail
+export const fail: <E>(error: E) => STM<never, E, never> = core.fail
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category sequencing
  */
 export const flatMap: <A, R1, E1, A2>(
   f: (a: A) => STM<R1, E1, A2>
-) => <R, E>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, A2> = internal.flatMap
+) => <R, E>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, A2> = core.flatMap
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category folding
  */
@@ -121,66 +144,88 @@ export const foldSTM: <E, R1, E1, A1, A, R2, E2, A2>(
   onSuccess: (a: A) => STM<R2, E2, A2>
-) => <R>(self: STM<R, E, A>) => STM<R1 | R2 | R, E1 | E2, A1 | A2> = internal.foldSTM
+) => <R>(self: STM<R, E, A>) => STM<R1 | R2 | R, E1 | E2, A1 | A2> = core.foldSTM
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category constructors
  */
-export const interrupt: () => STM<never, never, never> = internal.interrupt
+export const interrupt: () => STM<never, never, never> = core.interrupt
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mapping
  */
-export const map: <A, B>(f: (a: A) => B) => <R, E>(self: STM<R, E, A>) => STM<R, E, B> = internal.map
+export const map: <A, B>(f: (a: A) => B) => <R, E>(self: STM<R, E, A>) => STM<R, E, B> = core.map
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category error handling
  */
 export const orTry: <R1, E1, A1>(
   that: () => STM<R1, E1, A1>
-) => <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, A1 | A> = internal.orTry
+) => <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, A1 | A> = core.orTry
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category environment
  */
 export const provideSomeEnvironment: <R0, R>(
   f: (context: Context.Context<R0>) => Context.Context<R>
-) => <E, A>(self: STM<R, E, A>) => STM<R0, E, A> = internal.provideSomeEnvironment
+) => <E, A>(self: STM<R, E, A>) => STM<R0, E, A> = core.provideSomeEnvironment
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category error handling
  */
-export const retry: () => STM<never, never, never> = internal.retry
+export const retry: () => STM<never, never, never> = core.retry
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category constructors
  */
-export const succeed: <A>(value: A) => STM<never, never, A> = internal.succeed
+export const succeed: <A>(value: A) => STM<never, never, A> = core.succeed
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category constructors
  */
-export const sync: <A>(evaluate: () => A) => STM<never, never, A> = internal.sync
+export const sync: <A>(evaluate: () => A) => STM<never, never, A> = core.sync
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category zipping
  */
 export const zip: <R1, E1, A1>(
   that: STM<R1, E1, A1>
-) => <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, readonly [A, A1]> = internal.zip
+) => <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, readonly [A, A1]> = core.zip
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category zipping
  */
 export const zipLeft: <R1, E1, A1>(
   that: STM<R1, E1, A1>
-) => <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, A> = internal.zipLeft
+) => <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, A> = core.zipLeft
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category zipping
  */
 export const zipRight: <R1, E1, A1>(
   that: STM<R1, E1, A1>
-) => <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, A1> = internal.zipRight
+) => <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, A1> = core.zipRight
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category zipping
  */
@@ -190,2 +235,2 @@ export const zipWith: <R1, E1, A1, A, A2>(
   f: (a: A, b: A1) => A2
-) => <R, E>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, A2> = internal.zipWith
+) => <R, E>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, A2> = core.zipWith

src/TRef.ts

@@ -5,15 +5,18 @@ /**
 
-import type { STM } from "@effect/stm/STM"
-import type { Option } from "@fp-ts/data/Option"
+import type * as Journal from "@effect/stm/internal/stm/journal"
+import type * as TxnId from "@effect/stm/internal/stm/txnId"
+import type * as Versioned from "@effect/stm/internal/stm/versioned"
+import * as internal from "@effect/stm/internal/tRef"
+import type * as STM from "@effect/stm/STM"
+import type * as Option from "@fp-ts/data/Option"
 
-/** @internal */
-import * as internal from "@effect/io/internal/stm/ref"
-
 /**
  * @since 1.0.0
+ * @category symbols
  */
-export const TRefTypeId: unique symbol = internal.RefTypeId as unknown as TRefTypeId
+export const TRefTypeId: unique symbol = internal.TRefTypeId
 
 /**
  * @since 1.0.0
+ * @category symbols
  */
@@ -32,2 +35,3 @@ export type TRefTypeId = typeof TRefTypeId
  * @since 1.0.0
+ * @category models
  */
@@ -38,3 +42,7 @@ export interface TRef<A> extends TRef.Variance<A> {
    */
-  modify<B>(f: (a: A) => readonly [B, A]): STM<never, never, B>
+  modify<B>(f: (a: A) => readonly [B, A]): STM.STM<never, never, B>
+  /** @internal */
+  todos: Map<TxnId.TxnId, Journal.Todo>
+  /** @internal */
+  versioned: Versioned.Versioned<A>
 }
@@ -57,69 +65,109 @@
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export const get: <A>(self: TRef<A>) => STM<never, never, A> = internal.get
+export const get: <A>(self: TRef<A>) => STM.STM<never, never, A> = internal.get
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export const getAndSet: <A>(value: A) => (self: TRef<A>) => STM<never, never, A> = internal.getAndSet
+export const getAndSet: <A>(value: A) => (self: TRef<A>) => STM.STM<never, never, A> = internal.getAndSet
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export const getAndUpdate: <A>(f: (a: A) => A) => (self: TRef<A>) => STM<never, never, A> = internal.getAndUpdate
+export const getAndUpdate: <A>(f: (a: A) => A) => (self: TRef<A>) => STM.STM<never, never, A> = internal.getAndUpdate
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export const getAndUpdateSome: <A>(f: (a: A) => Option<A>) => (self: TRef<A>) => STM<never, never, A> =
+export const getAndUpdateSome: <A>(f: (a: A) => Option.Option<A>) => (self: TRef<A>) => STM.STM<never, never, A> =
   internal.getAndUpdateSome
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category constructors
  */
-export const make: <A>(value: A) => STM<never, never, TRef<A>> = internal.make
+export const make: <A>(value: A) => STM.STM<never, never, TRef<A>> = internal.make
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export const modify: <A, B>(f: (a: A) => readonly [B, A]) => (self: TRef<A>) => STM<never, never, B> = internal.modify
+export const modify: <A, B>(f: (a: A) => readonly [B, A]) => (self: TRef<A>) => STM.STM<never, never, B> =
+  internal.modify
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
 export const modifySome: <A, B>(
   fallback: B,
-  f: (a: A) => Option<readonly [B, A]>
-) => (self: TRef<A>) => STM<never, never, B> = internal.modifySome
+  f: (a: A) => Option.Option<readonly [B, A]>
+) => (self: TRef<A>) => STM.STM<never, never, B> = internal.modifySome
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export const set: <A>(value: A) => (self: TRef<A>) => STM<never, never, void> = internal.set
+export const set: <A>(value: A) => (self: TRef<A>) => STM.STM<never, never, void> = internal.set
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export const setAndGet: <A>(value: A) => (self: TRef<A>) => STM<never, never, A> = internal.setAndGet
+export const setAndGet: <A>(value: A) => (self: TRef<A>) => STM.STM<never, never, A> = internal.setAndGet
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export const update: <A>(f: (a: A) => A) => (self: TRef<A>) => STM<never, never, void> = internal.update
+export const update: <A>(f: (a: A) => A) => (self: TRef<A>) => STM.STM<never, never, void> = internal.update
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export const updateAndGet: <A>(f: (a: A) => A) => (self: TRef<A>) => STM<never, never, A> = internal.updateAndGet
+export const updateAndGet: <A>(f: (a: A) => A) => (self: TRef<A>) => STM.STM<never, never, A> = internal.updateAndGet
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export const updateSome: <A>(f: (a: A) => Option<A>) => (self: TRef<A>) => STM<never, never, void> = internal.updateSome
+export const updateSome: <A>(f: (a: A) => Option.Option<A>) => (self: TRef<A>) => STM.STM<never, never, void> =
+  internal.updateSome
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export const updateSomeAndGet: <A>(f: (a: A) => Option<A>) => (self: TRef<A>) => STM<never, never, A> =
+export const updateSomeAndGet: <A>(f: (a: A) => Option.Option<A>) => (self: TRef<A>) => STM.STM<never, never, A> =
   internal.updateSomeAndGet
+
+/**
+ * @since 1.0.0
+ * @category unsafe
+ */
+export const unsafeGet: (journal: Journal.Journal) => <A>(self: TRef<A>) => A = internal.unsafeGet
+
+/**
+ * @since 1.0.0
+ * @category unsafe
+ */
+export const unsafeSet: <A>(value: A, journal: Journal.Journal) => (self: TRef<A>) => void = internal.unsafeSet

src/TSemaphore.ts

@@ -5,18 +5,17 @@ /**
 
-import type { Effect } from "@effect/io/Effect"
-import type { Scope } from "@effect/io/Scope"
-import type { STM } from "@effect/stm/STM"
+import type * as Effect from "@effect/io/Effect"
+import type * as Scope from "@effect/io/Scope"
+import * as internal from "@effect/stm/internal/tSemaphore"
+import type * as STM from "@effect/stm/STM"
+import type * as TRef from "@effect/stm/TRef"
 
-/** @internal */
-import * as circular from "@effect/io/internal/effect/circular"
-/** @internal */
-import * as internal from "@effect/io/internal/semaphore"
-
 /**
  * @since 1.0.0
+ * @category symbols
  */
-export const TSemaphoreTypeId: unique symbol = circular.SemaphoreTypeId as unknown as TSemaphoreTypeId
+export const TSemaphoreTypeId: unique symbol = internal.TSemaphoreTypeId
 
 /**
  * @since 1.0.0
+ * @category symbols
  */
@@ -26,65 +25,90 @@ export type TSemaphoreTypeId = typeof TSemaphoreTypeId
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category models
  */
 export interface TSemaphore {
   readonly [TSemaphoreTypeId]: TSemaphoreTypeId
+  /** @internal */
+  readonly permits: TRef.TRef<number>
 }
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export const acquire: (self: TSemaphore) => STM<never, never, void> = internal.acquire
+export const acquire: (self: TSemaphore) => STM.STM<never, never, void> = internal.acquire
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export const available: (self: TSemaphore) => STM<never, never, number> = internal.available
+export const acquireN: (n: number) => (self: TSemaphore) => STM.STM<never, never, void> = internal.acquireN
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category getters
  */
-export const make: (permits: number) => STM<never, never, TSemaphore> = internal.make
+export const available: (self: TSemaphore) => STM.STM<never, never, number> = internal.available
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category constructors
  */
-export const release: (self: TSemaphore) => STM<never, never, void> = internal.release
+export const make: (permits: number) => STM.STM<never, never, TSemaphore> = internal.make
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export const withPermit: (semaphore: TSemaphore) => <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A> =
-  internal.withPermit
+export const release: (self: TSemaphore) => STM.STM<never, never, void> = internal.release
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export const withPermitScoped: (self: TSemaphore) => Effect<Scope, never, void> = internal.withPermitScoped
+export const releaseN: (n: number) => (self: TSemaphore) => STM.STM<never, never, void> = internal.releaseN
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export const unsafeMake: (permits: number) => TSemaphore = circular.unsafeMakeSemaphore
+export const withPermit: (semaphore: TSemaphore) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A> =
+  internal.withPermit
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export const acquireN: (n: number) => (self: TSemaphore) => STM<never, never, void> = circular.acquireN
+export const withPermits: (
+  permits: number
+) => (semaphore: TSemaphore) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A> = internal.withPermits
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export const releaseN: (n: number) => (self: TSemaphore) => STM<never, never, void> = circular.releaseN
+export const withPermitScoped: (self: TSemaphore) => Effect.Effect<Scope.Scope, never, void> = internal.withPermitScoped
 
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export const withPermits: (
-  permits: number
-) => (semaphore: TSemaphore) => <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A> = circular.withPermits
+export const withPermitsScoped: (permits: number) => (self: TSemaphore) => Effect.Effect<Scope.Scope, never, void> =
+  internal.withPermitsScoped
 
 /**
  * @since 1.0.0
+ * @category unsafe
  */
-export const withPermitsScoped: (permits: number) => (self: TSemaphore) => Effect<Scope, never, void> =
-  circular.withPermitsScoped
+export const unsafeMake: (permits: number) => TSemaphore = internal.unsafeMakeSemaphore

STM.d.ts

@@ -8,2 +8,3 @@ /**
  * @since 1.0.0
+ * @category symbols
  */
@@ -13,2 +14,3 @@ export declare const STMTypeId: unique symbol;
  * @since 1.0.0
+ * @category symbols
  */
@@ -51,2 +53,3 @@ export type STMTypeId = typeof STMTypeId;
  * @since 1.0.0
+ * @category models
  */
@@ -61,2 +64,3 @@ export interface STM<R, E, A> extends STM.Variance<R, E, A>, Effect.Effect<R, E, A> {
      * @since 1.0.0
+     * @category models
      */
@@ -72,73 +76,109 @@ interface Variance<R, E, A> {
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category error handling
  */
 export declare const catchAll: <E, R1, E1, B>(f: (e: E) => STM<R1, E1, B>) => <R, A>(self: STM<R, E, A>) => STM<R1 | R, E1, B | A>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category destructors
  */
 export declare const commit: <R, E, A>(self: STM<R, E, A>) => Effect.Effect<R, E, A>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category constructors
  */
 export declare const die: (defect: unknown) => STM<never, never, never>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category finalization
  */
 export declare const ensuring: <R1, B>(finalizer: STM<R1, never, B>) => <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E, A>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category constructors
  */
 export declare const fail: <E>(error: E) => STM<never, E, never>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category sequencing
  */
 export declare const flatMap: <A, R1, E1, A2>(f: (a: A) => STM<R1, E1, A2>) => <R, E>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, A2>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category folding
  */
 export declare const foldSTM: <E, R1, E1, A1, A, R2, E2, A2>(onFailure: (e: E) => STM<R1, E1, A1>, onSuccess: (a: A) => STM<R2, E2, A2>) => <R>(self: STM<R, E, A>) => STM<R1 | R2 | R, E1 | E2, A1 | A2>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category constructors
  */
 export declare const interrupt: () => STM<never, never, never>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mapping
  */
 export declare const map: <A, B>(f: (a: A) => B) => <R, E>(self: STM<R, E, A>) => STM<R, E, B>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category error handling
  */
 export declare const orTry: <R1, E1, A1>(that: () => STM<R1, E1, A1>) => <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, A1 | A>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category environment
  */
 export declare const provideSomeEnvironment: <R0, R>(f: (context: Context.Context<R0>) => Context.Context<R>) => <E, A>(self: STM<R, E, A>) => STM<R0, E, A>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category error handling
  */
 export declare const retry: () => STM<never, never, never>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category constructors
  */
 export declare const succeed: <A>(value: A) => STM<never, never, A>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category constructors
  */
 export declare const sync: <A>(evaluate: () => A) => STM<never, never, A>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category zipping
  */
 export declare const zip: <R1, E1, A1>(that: STM<R1, E1, A1>) => <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, readonly [A, A1]>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category zipping
  */
 export declare const zipLeft: <R1, E1, A1>(that: STM<R1, E1, A1>) => <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, A>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category zipping
  */
 export declare const zipRight: <R1, E1, A1>(that: STM<R1, E1, A1>) => <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, A1>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category zipping
  */
 export declare const zipWith: <R1, E1, A1, A, A2>(that: STM<R1, E1, A1>, f: (a: A, b: A1) => A2) => <R, E>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, A2>;
 //# sourceMappingURL=STM.d.ts.map

STM.js

@@ -7,102 +7,137 @@ "use strict";
 exports.zipWith = exports.zipRight = exports.zipLeft = exports.zip = exports.sync = exports.succeed = exports.retry = exports.provideSomeEnvironment = exports.orTry = exports.map = exports.interrupt = exports.foldSTM = exports.flatMap = exports.fail = exports.ensuring = exports.die = exports.commit = exports.catchAll = exports.STMTypeId = void 0;
-var internal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/io/internal/stm"));
+var core = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/stm/internal/core"));
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-/** @internal */
-
 /**
  * @since 1.0.0
+ * @category symbols
  */
-const STMTypeId = internal.STMTypeId;
+const STMTypeId = core.STMTypeId;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category error handling
  */
 exports.STMTypeId = STMTypeId;
-const catchAll = internal.catchAll;
+const catchAll = core.catchAll;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category destructors
  */
 exports.catchAll = catchAll;
-const commit = internal.commit;
+const commit = core.commit;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category constructors
  */
 exports.commit = commit;
-const die = internal.die;
+const die = core.die;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category finalization
  */
 exports.die = die;
-const ensuring = internal.ensuring;
+const ensuring = core.ensuring;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category constructors
  */
 exports.ensuring = ensuring;
-const fail = internal.fail;
+const fail = core.fail;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category sequencing
  */
 exports.fail = fail;
-const flatMap = internal.flatMap;
+const flatMap = core.flatMap;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category folding
  */
 exports.flatMap = flatMap;
-const foldSTM = internal.foldSTM;
+const foldSTM = core.foldSTM;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category constructors
  */
 exports.foldSTM = foldSTM;
-const interrupt = internal.interrupt;
+const interrupt = core.interrupt;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mapping
  */
 exports.interrupt = interrupt;
-const map = internal.map;
+const map = core.map;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category error handling
  */
 exports.map = map;
-const orTry = internal.orTry;
+const orTry = core.orTry;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category environment
  */
 exports.orTry = orTry;
-const provideSomeEnvironment = internal.provideSomeEnvironment;
+const provideSomeEnvironment = core.provideSomeEnvironment;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category error handling
  */
 exports.provideSomeEnvironment = provideSomeEnvironment;
-const retry = internal.retry;
+const retry = core.retry;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category constructors
  */
 exports.retry = retry;
-const succeed = internal.succeed;
+const succeed = core.succeed;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category constructors
  */
 exports.succeed = succeed;
-const sync = internal.sync;
+const sync = core.sync;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category zipping
  */
 exports.sync = sync;
-const zip = internal.zip;
+const zip = core.zip;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category zipping
  */
 exports.zip = zip;
-const zipLeft = internal.zipLeft;
+const zipLeft = core.zipLeft;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category zipping
  */
 exports.zipLeft = zipLeft;
-const zipRight = internal.zipRight;
+const zipRight = core.zipRight;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category zipping
  */
 exports.zipRight = zipRight;
-const zipWith = internal.zipWith;
+const zipWith = core.zipWith;
 exports.zipWith = zipWith;
 //# sourceMappingURL=STM.js.map

TRef.d.ts

 /**
  * @since 1.0.0
  */
-import type { STM } from "@effect/stm/STM";
-import type { Option } from "@fp-ts/data/Option";
+import type * as Journal from "@effect/stm/internal/stm/journal";
+import type * as STM from "@effect/stm/STM";
+import type * as Option from "@fp-ts/data/Option";
 /**
  * @since 1.0.0
+ * @category symbols
  */
@@ -12,2 +14,3 @@ export declare const TRefTypeId: unique symbol;
  * @since 1.0.0
+ * @category symbols
  */
@@ -25,2 +28,3 @@ export type TRefTypeId = typeof TRefTypeId;
  * @since 1.0.0
+ * @category models
  */
@@ -31,3 +35,3 @@ export interface TRef<A> extends TRef.Variance<A> {
      */
-    modify<B>(f: (a: A) => readonly [B, A]): STM<never, never, B>;
+    modify<B>(f: (a: A) => readonly [B, A]): STM.STM<never, never, B>;
 }
@@ -48,53 +52,89 @@ /**
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export declare const get: <A>(self: TRef<A>) => STM<never, never, A>;
+export declare const get: <A>(self: TRef<A>) => STM.STM<never, never, A>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export declare const getAndSet: <A>(value: A) => (self: TRef<A>) => STM<never, never, A>;
+export declare const getAndSet: <A>(value: A) => (self: TRef<A>) => STM.STM<never, never, A>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export declare const getAndUpdate: <A>(f: (a: A) => A) => (self: TRef<A>) => STM<never, never, A>;
+export declare const getAndUpdate: <A>(f: (a: A) => A) => (self: TRef<A>) => STM.STM<never, never, A>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export declare const getAndUpdateSome: <A>(f: (a: A) => Option<A>) => (self: TRef<A>) => STM<never, never, A>;
+export declare const getAndUpdateSome: <A>(f: (a: A) => Option.Option<A>) => (self: TRef<A>) => STM.STM<never, never, A>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category constructors
  */
-export declare const make: <A>(value: A) => STM<never, never, TRef<A>>;
+export declare const make: <A>(value: A) => STM.STM<never, never, TRef<A>>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export declare const modify: <A, B>(f: (a: A) => readonly [B, A]) => (self: TRef<A>) => STM<never, never, B>;
+export declare const modify: <A, B>(f: (a: A) => readonly [B, A]) => (self: TRef<A>) => STM.STM<never, never, B>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export declare const modifySome: <A, B>(fallback: B, f: (a: A) => Option<readonly [B, A]>) => (self: TRef<A>) => STM<never, never, B>;
+export declare const modifySome: <A, B>(fallback: B, f: (a: A) => Option.Option<readonly [B, A]>) => (self: TRef<A>) => STM.STM<never, never, B>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export declare const set: <A>(value: A) => (self: TRef<A>) => STM<never, never, void>;
+export declare const set: <A>(value: A) => (self: TRef<A>) => STM.STM<never, never, void>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export declare const setAndGet: <A>(value: A) => (self: TRef<A>) => STM<never, never, A>;
+export declare const setAndGet: <A>(value: A) => (self: TRef<A>) => STM.STM<never, never, A>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export declare const update: <A>(f: (a: A) => A) => (self: TRef<A>) => STM<never, never, void>;
+export declare const update: <A>(f: (a: A) => A) => (self: TRef<A>) => STM.STM<never, never, void>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export declare const updateAndGet: <A>(f: (a: A) => A) => (self: TRef<A>) => STM<never, never, A>;
+export declare const updateAndGet: <A>(f: (a: A) => A) => (self: TRef<A>) => STM.STM<never, never, A>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export declare const updateSome: <A>(f: (a: A) => Option<A>) => (self: TRef<A>) => STM<never, never, void>;
+export declare const updateSome: <A>(f: (a: A) => Option.Option<A>) => (self: TRef<A>) => STM.STM<never, never, void>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export declare const updateSomeAndGet: <A>(f: (a: A) => Option<A>) => (self: TRef<A>) => STM<never, never, A>;
+export declare const updateSomeAndGet: <A>(f: (a: A) => Option.Option<A>) => (self: TRef<A>) => STM.STM<never, never, A>;
+/**
+ * @since 1.0.0
+ * @category unsafe
+ */
+export declare const unsafeGet: (journal: Journal.Journal) => <A>(self: TRef<A>) => A;
+/**
+ * @since 1.0.0
+ * @category unsafe
+ */
+export declare const unsafeSet: <A>(value: A, journal: Journal.Journal) => (self: TRef<A>) => void;
 //# sourceMappingURL=TRef.d.ts.map

TRef.js

@@ -6,14 +6,15 @@ "use strict";
 });
-exports.updateSomeAndGet = exports.updateSome = exports.updateAndGet = exports.update = exports.setAndGet = exports.set = exports.modifySome = exports.modify = exports.make = exports.getAndUpdateSome = exports.getAndUpdate = exports.getAndSet = exports.get = exports.TRefTypeId = void 0;
-var internal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/io/internal/stm/ref"));
+exports.updateSomeAndGet = exports.updateSome = exports.updateAndGet = exports.update = exports.unsafeSet = exports.unsafeGet = exports.setAndGet = exports.set = exports.modifySome = exports.modify = exports.make = exports.getAndUpdateSome = exports.getAndUpdate = exports.getAndSet = exports.get = exports.TRefTypeId = void 0;
+var internal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/stm/internal/tRef"));
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-/** @internal */
-
 /**
  * @since 1.0.0
+ * @category symbols
  */
-const TRefTypeId = internal.RefTypeId;
+const TRefTypeId = internal.TRefTypeId;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
@@ -23,3 +24,5 @@ exports.TRefTypeId = TRefTypeId;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
@@ -29,3 +32,5 @@ exports.get = get;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
@@ -35,3 +40,5 @@ exports.getAndSet = getAndSet;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
@@ -41,3 +48,5 @@ exports.getAndUpdate = getAndUpdate;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category constructors
  */
@@ -47,3 +56,5 @@ exports.getAndUpdateSome = getAndUpdateSome;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
@@ -53,3 +64,5 @@ exports.make = make;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
@@ -59,3 +72,5 @@ exports.modify = modify;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
@@ -65,3 +80,5 @@ exports.modifySome = modifySome;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
@@ -71,3 +88,5 @@ exports.set = set;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
@@ -77,3 +96,5 @@ exports.setAndGet = setAndGet;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
@@ -83,3 +104,5 @@ exports.update = update;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
@@ -89,7 +112,21 @@ exports.updateAndGet = updateAndGet;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
 exports.updateSome = updateSome;
 const updateSomeAndGet = internal.updateSomeAndGet;
+/**
+ * @since 1.0.0
+ * @category unsafe
+ */
 exports.updateSomeAndGet = updateSomeAndGet;
+const unsafeGet = internal.unsafeGet;
+/**
+ * @since 1.0.0
+ * @category unsafe
+ */
+exports.unsafeGet = unsafeGet;
+const unsafeSet = internal.unsafeSet;
+exports.unsafeSet = unsafeSet;
 //# sourceMappingURL=TRef.js.map

TSemaphore.d.ts

 /**
  * @since 1.0.0
  */
-import type { Effect } from "@effect/io/Effect";
-import type { Scope } from "@effect/io/Scope";
-import type { STM } from "@effect/stm/STM";
+import type * as Effect from "@effect/io/Effect";
+import type * as Scope from "@effect/io/Scope";
+import type * as STM from "@effect/stm/STM";
 /**
  * @since 1.0.0
+ * @category symbols
  */
@@ -13,6 +14,9 @@ export declare const TSemaphoreTypeId: unique symbol;
  * @since 1.0.0
+ * @category symbols
  */
 export type TSemaphoreTypeId = typeof TSemaphoreTypeId;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category models
  */
@@ -23,45 +27,66 @@ export interface TSemaphore {
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export declare const acquire: (self: TSemaphore) => STM<never, never, void>;
+export declare const acquire: (self: TSemaphore) => STM.STM<never, never, void>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export declare const available: (self: TSemaphore) => STM<never, never, number>;
+export declare const acquireN: (n: number) => (self: TSemaphore) => STM.STM<never, never, void>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category getters
  */
-export declare const make: (permits: number) => STM<never, never, TSemaphore>;
+export declare const available: (self: TSemaphore) => STM.STM<never, never, number>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category constructors
  */
-export declare const release: (self: TSemaphore) => STM<never, never, void>;
+export declare const make: (permits: number) => STM.STM<never, never, TSemaphore>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export declare const withPermit: (semaphore: TSemaphore) => <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+export declare const release: (self: TSemaphore) => STM.STM<never, never, void>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export declare const withPermitScoped: (self: TSemaphore) => Effect<Scope, never, void>;
+export declare const releaseN: (n: number) => (self: TSemaphore) => STM.STM<never, never, void>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export declare const unsafeMake: (permits: number) => TSemaphore;
+export declare const withPermit: (semaphore: TSemaphore) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export declare const acquireN: (n: number) => (self: TSemaphore) => STM<never, never, void>;
+export declare const withPermits: (permits: number) => (semaphore: TSemaphore) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export declare const releaseN: (n: number) => (self: TSemaphore) => STM<never, never, void>;
+export declare const withPermitScoped: (self: TSemaphore) => Effect.Effect<Scope.Scope, never, void>;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-export declare const withPermits: (permits: number) => (semaphore: TSemaphore) => <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+export declare const withPermitsScoped: (permits: number) => (self: TSemaphore) => Effect.Effect<Scope.Scope, never, void>;
 /**
  * @since 1.0.0
+ * @category unsafe
  */
-export declare const withPermitsScoped: (permits: number) => (self: TSemaphore) => Effect<Scope, never, void>;
+export declare const unsafeMake: (permits: number) => TSemaphore;
 //# sourceMappingURL=TSemaphore.d.ts.map

TSemaphore.js

@@ -7,16 +7,14 @@ "use strict";
 exports.withPermitsScoped = exports.withPermits = exports.withPermitScoped = exports.withPermit = exports.unsafeMake = exports.releaseN = exports.release = exports.make = exports.available = exports.acquireN = exports.acquire = exports.TSemaphoreTypeId = void 0;
-var circular = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/io/internal/effect/circular"));
-var internal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/io/internal/semaphore"));
+var internal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/stm/internal/tSemaphore"));
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-/** @internal */
-
-/** @internal */
-
 /**
  * @since 1.0.0
+ * @category symbols
  */
-const TSemaphoreTypeId = circular.SemaphoreTypeId;
+const TSemaphoreTypeId = internal.TSemaphoreTypeId;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
@@ -26,8 +24,19 @@ exports.TSemaphoreTypeId = TSemaphoreTypeId;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
 exports.acquire = acquire;
+const acquireN = internal.acquireN;
+/**
+ * @macro traced
+ * @since 1.0.0
+ * @category getters
+ */
+exports.acquireN = acquireN;
 const available = internal.available;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category constructors
  */
@@ -37,3 +46,5 @@ exports.available = available;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
@@ -43,37 +54,43 @@ exports.make = make;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
 exports.release = release;
-const withPermit = internal.withPermit;
+const releaseN = internal.releaseN;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-exports.withPermit = withPermit;
-const withPermitScoped = internal.withPermitScoped;
+exports.releaseN = releaseN;
+const withPermit = internal.withPermit;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-exports.withPermitScoped = withPermitScoped;
-const unsafeMake = circular.unsafeMakeSemaphore;
+exports.withPermit = withPermit;
+const withPermits = internal.withPermits;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-exports.unsafeMake = unsafeMake;
-const acquireN = circular.acquireN;
+exports.withPermits = withPermits;
+const withPermitScoped = internal.withPermitScoped;
 /**
+ * @macro traced
  * @since 1.0.0
+ * @category mutations
  */
-exports.acquireN = acquireN;
-const releaseN = circular.releaseN;
+exports.withPermitScoped = withPermitScoped;
+const withPermitsScoped = internal.withPermitsScoped;
 /**
  * @since 1.0.0
+ * @category unsafe
  */
-exports.releaseN = releaseN;
-const withPermits = circular.withPermits;
-/**
- * @since 1.0.0
- */
-exports.withPermits = withPermits;
-const withPermitsScoped = circular.withPermitsScoped;
 exports.withPermitsScoped = withPermitsScoped;
+const unsafeMake = internal.unsafeMakeSemaphore;
+exports.unsafeMake = unsafeMake;
 //# sourceMappingURL=TSemaphore.js.map

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

285033

increased by457.43%

Dependency count

3

decreased by-25%

Number of package files

121

increased by404.17%

Lines of code

6035

increased by434.54%

Worsened metrics

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• + Added@effect/io@0.0.35(transitive)

• + Added@fp-ts/data@0.0.26(transitive)

• - Removed@effect/printer@^0.1.7

• - Removed@effect/io@0.0.29(transitive)

• - Removed@effect/printer@0.1.11(transitive)

• - Removed@fp-ts/core@0.0.11(transitive)

• - Removed@fp-ts/data@0.0.190.0.41(transitive)

• Updated@effect/io@^0.0.35

• Updated@fp-ts/data@^0.0.26