effect-app 4.0.0-beta.283 → 4.0.0-beta.285

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @effect-app/prelude
 
+## 4.0.0-beta.285
+
+### Patch Changes
+
+- 7bd8234: Use set-backed data dependencies and provide request-scoped dependency services through a shared root-checked helper.
+
+## 4.0.0-beta.284
+
 ## 4.0.0-beta.283
 
 ### Minor Changes

package/dist/DataDependencies.d.ts

@@ -1,6 +1,7 @@
 import * as Ref from "effect/Ref";
-import * as Context from "./Context.js";
+import * as Stream from "effect/Stream";
 import * as Effect from "./Effect.js";
+import * as RequestScopedDependencies from "./RequestScopedDependencies.js";
 import * as S from "./Schema.js";
 export declare const DataDependency: S.Struct<{
     readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
@@ -16,7 +17,7 @@ export declare const DataDependency: S.Struct<{
     readonly name: S.String;
 }>;
 export type DataDependency = S.Schema.Type<typeof DataDependency>;
-export declare const DataDependencies: S.$Array<S.Struct<{
+export declare const DataDependencies: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
     readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
         changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
             Default: A;
@@ -28,8 +29,44 @@ export declare const DataDependencies: S.$Array<S.Struct<{
         withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
     };
     readonly name: S.String;
-}>> & {
-    withConstructorDefault: S.withConstructorDefault<S.$Array<S.Struct<{
+}, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+            Default: A;
+            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+        };
+        Default: "repo";
+        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+    };
+    readonly name: S.String;
+}, "Type">>>, S.$Array<S.Struct<{
+    readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+        changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+            Default: A;
+            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+        };
+        Default: "repo";
+        withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+        withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+    };
+    readonly name: S.String;
+}>>, never, never> & {
+    withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+        readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+            changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                Default: A;
+                withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+            };
+            Default: "repo";
+            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+        };
+        readonly name: S.String;
+    }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
         readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
             changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
                 Default: A;
@@ -41,8 +78,7 @@ export declare const DataDependencies: S.$Array<S.Struct<{
             withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
         };
         readonly name: S.String;
-    }>>>;
-    withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Struct<{
+    }, "Type">>>, S.$Array<S.Struct<{
         readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
             changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
                 Default: A;
@@ -54,11 +90,49 @@ export declare const DataDependencies: S.$Array<S.Struct<{
             withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
         };
         readonly name: S.String;
-    }>>, never>;
+    }>>, never, never>>;
+    withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+        readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+            changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                Default: A;
+                withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+            };
+            Default: "repo";
+            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+        };
+        readonly name: S.String;
+    }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+        readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+            changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                Default: A;
+                withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+            };
+            Default: "repo";
+            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+        };
+        readonly name: S.String;
+    }, "Type">>>, S.$Array<S.Struct<{
+        readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+            changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                Default: A;
+                withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+            };
+            Default: "repo";
+            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+        };
+        readonly name: S.String;
+    }>>, never, never>, never>;
 };
 export type DataDependencies = S.Schema.Type<typeof DataDependencies>;
+export declare const empty: () => DataDependencies;
 export declare const DataDependencySet: S.Struct<{
-    readonly reads: S.$Array<S.Struct<{
+    readonly reads: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
         readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
             changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
                 Default: A;
@@ -70,8 +144,44 @@ export declare const DataDependencySet: S.Struct<{
             withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
         };
         readonly name: S.String;
-    }>> & {
-        withConstructorDefault: S.withConstructorDefault<S.$Array<S.Struct<{
+    }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+        readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+            changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                Default: A;
+                withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+            };
+            Default: "repo";
+            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+        };
+        readonly name: S.String;
+    }, "Type">>>, S.$Array<S.Struct<{
+        readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+            changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                Default: A;
+                withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+            };
+            Default: "repo";
+            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+        };
+        readonly name: S.String;
+    }>>, never, never> & {
+        withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+            readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    Default: A;
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                Default: "repo";
+                withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+            };
+            readonly name: S.String;
+        }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
             readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
                 changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
                     Default: A;
@@ -83,8 +193,7 @@ export declare const DataDependencySet: S.Struct<{
                 withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
             };
             readonly name: S.String;
-        }>>>;
-        withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Struct<{
+        }, "Type">>>, S.$Array<S.Struct<{
             readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
                 changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
                     Default: A;
@@ -96,9 +205,46 @@ export declare const DataDependencySet: S.Struct<{
                 withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
             };
             readonly name: S.String;
-        }>>, never>;
+        }>>, never, never>>;
+        withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+            readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    Default: A;
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                Default: "repo";
+                withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+            };
+            readonly name: S.String;
+        }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+            readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    Default: A;
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                Default: "repo";
+                withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+            };
+            readonly name: S.String;
+        }, "Type">>>, S.$Array<S.Struct<{
+            readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    Default: A;
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                Default: "repo";
+                withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+            };
+            readonly name: S.String;
+        }>>, never, never>, never>;
     };
-    readonly writes: S.$Array<S.Struct<{
+    readonly writes: S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
         readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
             changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
                 Default: A;
@@ -110,8 +256,81 @@ export declare const DataDependencySet: S.Struct<{
             withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
         };
         readonly name: S.String;
-    }>> & {
-        withConstructorDefault: S.withConstructorDefault<S.$Array<S.Struct<{
+    }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+        readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+            changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                Default: A;
+                withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+            };
+            Default: "repo";
+            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+        };
+        readonly name: S.String;
+    }, "Type">>>, S.$Array<S.Struct<{
+        readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+            changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                Default: A;
+                withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+            };
+            Default: "repo";
+            withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+        };
+        readonly name: S.String;
+    }>>, never, never> & {
+        withConstructorDefault: S.withConstructorDefault<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+            readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    Default: A;
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                Default: "repo";
+                withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+            };
+            readonly name: S.String;
+        }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+            readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    Default: A;
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                Default: "repo";
+                withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+            };
+            readonly name: S.String;
+        }, "Type">>>, S.$Array<S.Struct<{
+            readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    Default: A;
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                Default: "repo";
+                withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+            };
+            readonly name: S.String;
+        }>>, never, never>>;
+        withDecodingDefaultType: S.withDecodingDefaultType<S.decodeTo<S.instanceOf<ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
+            readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
+                    Default: A;
+                    withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                    withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+                };
+                Default: "repo";
+                withConstructorDefault: S.withConstructorDefault<import("effect/Schema").Literals<readonly ["repo", "signal"]>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
+            };
+            readonly name: S.String;
+        }, "Type">>, ReadonlySet<import("effect/Schema").Struct.ReadonlySide<{
             readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
                 changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
                     Default: A;
@@ -123,8 +342,7 @@ export declare const DataDependencySet: S.Struct<{
                 withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
             };
             readonly name: S.String;
-        }>>>;
-        withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Struct<{
+        }, "Type">>>, S.$Array<S.Struct<{
             readonly type: import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
                 changeDefault: <A extends "repo" | "signal">(a: A) => import("effect/Schema").Literals<readonly ["repo", "signal"]> & {
                     Default: A;
@@ -136,7 +354,7 @@ export declare const DataDependencySet: S.Struct<{
                 withDecodingDefaultType: S.withDecodingDefaultType<import("effect/Schema").Literals<readonly ["repo", "signal"]>, never>;
             };
             readonly name: S.String;
-        }>>, never>;
+        }>>, never, never>, never>;
     };
 }>;
 export type DataDependencySet = S.Schema.Type<typeof DataDependencySet>;
@@ -147,13 +365,24 @@ export interface DataDependencyRecorderService {
     readonly drain: Effect.Effect<DataDependencySet>;
     readonly drainWrites: Effect.Effect<DataDependencies>;
 }
-export declare const DataDependencyRecorder: Context.Reference<DataDependencyRecorderService>;
+export declare const DataDependencyRecorder: RequestScopedDependencies.RequestScopedDependency<DataDependencyRecorderService, never, never>;
 export type DataDependencyRecorder = typeof DataDependencyRecorder;
+export type DataDependencyRecorderNotStartedError = RequestScopedDependencies.RequestScopedDependencyNotStartedError;
+export declare const getDataDependencyRecorder: Effect.Effect<DataDependencyRecorderService, RequestScopedDependencies.RequestScopedDependencyNotStartedError, never>;
+/**
+ * Guarantee a recorder is in scope for `self`, providing a fresh one per request when none is
+ * (e.g. a top-level client call with no parent query/command tracking its dependencies). An
+ * existing recorder is inherited, so nested calls forward into their parent rather than shadow it.
+ */
+export declare const ensureDataDependencyRecorder: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/** Stream variant of {@link ensureDataDependencyRecorder}. */
+export declare const ensureDataDependencyRecorderStream: <A, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A, E, R>;
 export declare const makeDataDependencyRecorder: (readsRef: Ref.Ref<DataDependencies>, writesRef: Ref.Ref<DataDependencies>) => DataDependencyRecorderService;
 export declare const repo: (name: string) => DataDependency;
 export declare const signal: (name: string) => DataDependency;
 export declare const QueryReadDependenciesMetaKey = "effect-app.query.readDependencies";
-export declare const read: (dependency: DataDependency) => Effect.Effect<void, never, never>;
-export declare const write: (dependency: DataDependency) => Effect.Effect<void, never, never>;
-export declare const intersects: (a: ReadonlyArray<DataDependency>, b: ReadonlyArray<DataDependency>) => boolean;
+export declare const read: (dependency: DataDependency) => Effect.Effect<void, RequestScopedDependencies.RequestScopedDependencyNotStartedError, never>;
+export declare const write: (dependency: DataDependency) => Effect.Effect<void, RequestScopedDependencies.RequestScopedDependencyNotStartedError, never>;
+export declare const intersects: (a: ReadonlySet<DataDependency>, b: ReadonlySet<DataDependency>) => boolean;
+export declare const isNonEmpty: (dependencies: DataDependencies) => boolean;
 //# sourceMappingURL=DataDependencies.d.ts.map

package/dist/DataDependencies.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DataDependencies.d.ts","sourceRoot":"","sources":["../src/DataDependencies.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,YAAY,CAAA;AACjC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,CAAC,MAAM,aAAa,CAAA;AAEhC,eAAO,MAAM,cAAc;;;;;;;;;;;;EAGzB,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,cAAc,CAAC,CAAA;AAEjE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA0B,CAAA;AACvD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAErE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG5B,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAEvE,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,IAAI,EAAE,CAAC,UAAU,EAAE,cAAc,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAClE,QAAQ,CAAC,KAAK,EAAE,CAAC,UAAU,EAAE,cAAc,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACnE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAA;IAC9C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAA;IAChD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAA;CACtD;AAQD,eAAO,MAAM,sBAAsB,kDAWlC,CAAA;AACD,MAAM,MAAM,sBAAsB,GAAG,OAAO,sBAAsB,CAAA;AAElE,eAAO,MAAM,0BAA0B,aAC3B,GAAG,CAAC,GAAG,CAAC,gBAAgB,CAAC,aACxB,GAAG,CAAC,GAAG,CAAC,gBAAgB,CAAC,KACnC,6BAYD,CAAA;AAEF,eAAO,MAAM,IAAI,SAAU,MAAM,KAAG,cAA0C,CAAA;AAC9E,eAAO,MAAM,MAAM,SAAU,MAAM,KAAG,cAA4C,CAAA;AAElF,eAAO,MAAM,4BAA4B,sCAAsC,CAAA;AAE/E,eAAO,MAAM,IAAI,eAAgB,cAAc,sCAA0D,CAAA;AAEzG,eAAO,MAAM,KAAK,eAAgB,cAAc,sCAA2D,CAAA;AAE3G,eAAO,MAAM,UAAU,MAClB,aAAa,CAAC,cAAc,CAAC,KAC7B,aAAa,CAAC,cAAc,CAAC,YAC4B,CAAA"}
+{"version":3,"file":"DataDependencies.d.ts","sourceRoot":"","sources":["../src/DataDependencies.ts"],"names":[],"mappings":"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"}

package/dist/DataDependencies.js

@@ -1,27 +1,40 @@
 import * as Ref from "effect/Ref";
-import * as Context from "./Context.js";
+import * as Stream from "effect/Stream";
 import * as Effect from "./Effect.js";
+import * as RequestScopedDependencies from "./RequestScopedDependencies.js";
 import * as S from "./Schema.js";
 export const DataDependency = S.Struct({
     type: S.Literals(["repo", "signal"]),
     name: S.String
 });
-export const DataDependencies = S.Array(DataDependency);
+export const DataDependencies = S.ReadonlySet(DataDependency);
+export const empty = () => new Set();
 export const DataDependencySet = S.Struct({
     reads: DataDependencies,
     writes: DataDependencies
 });
-const containsDependency = (dependencies, dependency) => dependencies.some((_) => _.type === dependency.type && _.name === dependency.name);
-const appendDependency = (dependency) => (dependencies) => containsDependency(dependencies, dependency) ? dependencies : [...dependencies, dependency];
-export const DataDependencyRecorder = Context.Reference("effect-app/DataDependencyRecorder", {
-    defaultValue: () => ({
-        read: (_dependency) => Effect.void,
-        write: (_dependency) => Effect.void,
-        get: Effect.succeed({ reads: [], writes: [] }),
-        drain: Effect.succeed({ reads: [], writes: [] }),
-        drainWrites: Effect.succeed([])
-    })
-});
+const containsDependency = (dependencies, dependency) => {
+    for (const _ of dependencies) {
+        if (_.type === dependency.type && _.name === dependency.name)
+            return true;
+    }
+    return false;
+};
+const appendDependency = (dependency) => (dependencies) => containsDependency(dependencies, dependency) ? dependencies : new Set([...dependencies, dependency]);
+export const DataDependencyRecorder = RequestScopedDependencies.make("effect-app/DataDependencyRecorder", Effect.gen(function* () {
+    const readsRef = yield* Ref.make(empty());
+    const writesRef = yield* Ref.make(empty());
+    return makeDataDependencyRecorder(readsRef, writesRef);
+}));
+export const getDataDependencyRecorder = DataDependencyRecorder.current;
+/**
+ * Guarantee a recorder is in scope for `self`, providing a fresh one per request when none is
+ * (e.g. a top-level client call with no parent query/command tracking its dependencies). An
+ * existing recorder is inherited, so nested calls forward into their parent rather than shadow it.
+ */
+export const ensureDataDependencyRecorder = (self) => Effect.flatMap(DataDependencyRecorder, (current) => current === "root" ? Effect.provide(self, DataDependencyRecorder.layer) : self);
+/** Stream variant of {@link ensureDataDependencyRecorder}. */
+export const ensureDataDependencyRecorderStream = (self) => Stream.unwrap(Effect.map(DataDependencyRecorder, (current) => current === "root" ? Stream.provide(self, DataDependencyRecorder.layer) : self));
 export const makeDataDependencyRecorder = (readsRef, writesRef) => ({
     read: (dependency) => Ref.update(readsRef, appendDependency(dependency)),
     write: (dependency) => Ref.update(writesRef, appendDependency(dependency)),
@@ -30,15 +43,22 @@ export const makeDataDependencyRecorder = (readsRef, writesRef) => ({
         writes: Ref.get(writesRef)
     }),
     drain: Effect.all({
-        reads: Ref.getAndSet(readsRef, []),
-        writes: Ref.getAndSet(writesRef, [])
+        reads: Ref.getAndSet(readsRef, empty()),
+        writes: Ref.getAndSet(writesRef, empty())
     }),
-    drainWrites: Ref.getAndSet(writesRef, [])
+    drainWrites: Ref.getAndSet(writesRef, empty())
 });
 export const repo = (name) => ({ type: "repo", name });
 export const signal = (name) => ({ type: "signal", name });
 export const QueryReadDependenciesMetaKey = "effect-app.query.readDependencies";
-export const read = (dependency) => DataDependencyRecorder.use((_) => _.read(dependency));
-export const write = (dependency) => DataDependencyRecorder.use((_) => _.write(dependency));
-export const intersects = (a, b) => a.some((dependency) => containsDependency(b, dependency));
-//# sourceMappingURL=data:application/json;base64,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
+export const read = (dependency) => getDataDependencyRecorder.pipe(Effect.flatMap((_) => _.read(dependency)));
+export const write = (dependency) => getDataDependencyRecorder.pipe(Effect.flatMap((_) => _.write(dependency)));
+export const intersects = (a, b) => {
+    for (const dependency of a) {
+        if (containsDependency(b, dependency))
+            return true;
+    }
+    return false;
+};
+export const isNonEmpty = (dependencies) => dependencies.size > 0;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/RequestScopedDependencies.d.ts

@@ -0,0 +1,21 @@
+import type * as Scope from "effect/Scope";
+import * as Context from "./Context.js";
+import * as Effect from "./Effect.js";
+import * as Layer from "./Layer.js";
+export type Root = "root";
+declare const RequestScopedDependencyNotStartedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "RequestScopedDependencyNotStartedError";
+} & Readonly<A>;
+export declare class RequestScopedDependencyNotStartedError extends RequestScopedDependencyNotStartedError_base<{
+    readonly key: string;
+}> {
+}
+export interface RequestScopedDependency<Service, E = never, R = never> extends Context.Reference<Service | Root> {
+    readonly current: Effect.Effect<Service, RequestScopedDependencyNotStartedError>;
+    readonly layer: Layer.Layer<never, E, R>;
+}
+export declare const access: <Service>(dependency: Context.Reference<Service | Root>, key: string) => Effect.Effect<Service, RequestScopedDependencyNotStartedError>;
+export declare const make: <Service, E = never, R = never>(key: string, service: Effect.Effect<Service, E, R>) => RequestScopedDependency<Service, E, Exclude<R, Scope.Scope>>;
+export declare const layer: <Deps extends readonly [RequestScopedDependency<any, any, any>, ...Array<RequestScopedDependency<any, any, any>>]>(...dependencies: Deps) => Layer.Layer<never, { [K in keyof Deps]: Deps[K] extends RequestScopedDependency<any, infer E, any> ? E : never; }[number], { [K in keyof Deps]: Deps[K] extends RequestScopedDependency<any, any, infer R> ? R : never; }[number]>;
+export {};
+//# sourceMappingURL=RequestScopedDependencies.d.ts.map

package/dist/RequestScopedDependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RequestScopedDependencies.d.ts","sourceRoot":"","sources":["../src/RequestScopedDependencies.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC,MAAM,MAAM,IAAI,GAAG,MAAM,CAAA;;;;AAEzB,qBAAa,sCAAuC,SAAQ,4CAE1D;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;CAAG;AAE9B,MAAM,WAAW,uBAAuB,CAAC,OAAO,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,CAAE,SAAQ,OAAO,CAAC,SAAS,CAAC,OAAO,GAAG,IAAI,CAAC;IAC/G,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,sCAAsC,CAAC,CAAA;IAChF,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CACzC;AAED,eAAO,MAAM,MAAM,GAAI,OAAO,cAChB,OAAO,CAAC,SAAS,CAAC,OAAO,GAAG,IAAI,CAAC,OACxC,MAAM,KACV,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,sCAAsC,CAG7D,CAAA;AAEH,eAAO,MAAM,IAAI,GAAI,OAAO,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,OAC3C,MAAM,WACF,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC,KACpC,uBAAuB,CAAC,OAAO,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAM7D,CAAA;AAED,eAAO,MAAM,KAAK,GAChB,IAAI,SAAS,SAAS,CAAC,uBAAuB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,GAAG,KAAK,CAAC,uBAAuB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,mBAE/F,IAAI,KACpB,KAAK,CAAC,KAAK,CACZ,KAAK,EACL,GAAG,CAAC,IAAI,MAAM,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,SAAS,uBAAuB,CAAC,GAAG,EAAE,MAAM,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,GAAE,CAAC,MAAM,CAAC,EACrG,GAAG,CAAC,IAAI,MAAM,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,SAAS,uBAAuB,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,GAAE,CAAC,MAAM,CAAC,CACnB,CAAA"}

package/dist/RequestScopedDependencies.js

@@ -0,0 +1,16 @@
+import * as Data from "effect/Data";
+import * as Context from "./Context.js";
+import * as Effect from "./Effect.js";
+import * as Layer from "./Layer.js";
+export class RequestScopedDependencyNotStartedError extends Data.TaggedError("RequestScopedDependencyNotStartedError") {
+}
+export const access = (dependency, key) => dependency.pipe(Effect.filterOrFail((_) => _ !== "root", () => new RequestScopedDependencyNotStartedError({ key })));
+export const make = (key, service) => {
+    const dependency = Context.Reference(key, { defaultValue: () => "root" });
+    return Object.assign(dependency, {
+        current: access(dependency, key),
+        layer: Layer.effect(dependency, service)
+    });
+};
+export const layer = (...dependencies) => dependencies.map((_) => _.layer).reduce((acc, l) => Layer.merge(acc, l));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVxdWVzdFNjb3BlZERlcGVuZGVuY2llcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9SZXF1ZXN0U2NvcGVkRGVwZW5kZW5jaWVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxJQUFJLE1BQU0sYUFBYSxDQUFBO0FBRW5DLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFBO0FBQ3ZDLE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFBO0FBQ3JDLE9BQU8sS0FBSyxLQUFLLE1BQU0sWUFBWSxDQUFBO0FBSW5DLE1BQU0sT0FBTyxzQ0FBdUMsU0FBUSxJQUFJLENBQUMsV0FBVyxDQUMxRSx3Q0FBd0MsQ0FDZjtDQUFHO0FBTzlCLE1BQU0sQ0FBQyxNQUFNLE1BQU0sR0FBRyxDQUNwQixVQUE2QyxFQUM3QyxHQUFXLEVBQ3FELEVBQUUsQ0FDbEUsVUFBVSxDQUFDLElBQUksQ0FDYixNQUFNLENBQUMsWUFBWSxDQUFDLENBQUMsQ0FBQyxFQUFnQixFQUFFLENBQUMsQ0FBQyxLQUFLLE1BQU0sRUFBRSxHQUFHLEVBQUUsQ0FBQyxJQUFJLHNDQUFzQyxDQUFDLEVBQUUsR0FBRyxFQUFFLENBQUMsQ0FBQyxDQUNsSCxDQUFBO0FBRUgsTUFBTSxDQUFDLE1BQU0sSUFBSSxHQUFHLENBQ2xCLEdBQVcsRUFDWCxPQUFxQyxFQUN5QixFQUFFO0lBQ2hFLE1BQU0sVUFBVSxHQUFHLE9BQU8sQ0FBQyxTQUFTLENBQWlCLEdBQUcsRUFBRSxFQUFFLFlBQVksRUFBRSxHQUFHLEVBQUUsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFBO0lBQ3pGLE9BQU8sTUFBTSxDQUFDLE1BQU0sQ0FBQyxVQUFVLEVBQUU7UUFDL0IsT0FBTyxFQUFFLE1BQU0sQ0FBQyxVQUFVLEVBQUUsR0FBRyxDQUFDO1FBQ2hDLEtBQUssRUFBRSxLQUFLLENBQUMsTUFBTSxDQUFDLFVBQVUsRUFBRSxPQUFPLENBQUM7S0FDekMsQ0FBQyxDQUFBO0FBQ0osQ0FBQyxDQUFBO0FBRUQsTUFBTSxDQUFDLE1BQU0sS0FBSyxHQUFHLENBR25CLEdBQUcsWUFBa0IsRUFLckIsRUFBRSxDQUFDLFlBQVksQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLEdBQUcsRUFBRSxDQUFDLENBQUMsQ0FBUSxDQUFBIn0=

package/dist/Store.d.ts

@@ -3,12 +3,12 @@ import type { NonEmptyReadonlyArray } from "./Array.js";
 import type { DatabaseError, OptimisticConcurrencyException } from "./client/errors.js";
 import * as Context from "./Context.js";
 import * as Effect from "./Effect.js";
-import * as Layer from "./Layer.js";
 import type { FilterResult } from "./Model/filter/filterApi.js";
 import type { FieldValues } from "./Model/filter/types.js";
 import type { FieldPath } from "./Model/filter/types/path/index.js";
 import type { AggregateIrExpression, ComputedProjectionIrExpression, RawQuery } from "./Model/query.js";
 import type * as Option from "./Option.js";
+import * as RequestScopedDependencies from "./RequestScopedDependencies.js";
 import { NonEmptyString255 } from "./Schema.js";
 /**
  * Adapter-neutral unique-key definition for stores that support unique indexes,
@@ -137,16 +137,9 @@ declare const ContextMap_base: Context.OpaqueClass<ContextMap, "effect-app/Conte
 };
 export declare class ContextMap extends ContextMap_base {
 }
-declare const ContextMapContainer_base: Context.Reference<"root" | ContextMap>;
-export declare class ContextMapContainer extends ContextMapContainer_base {
-    static readonly layer: Layer.Layer<never, never, never>;
-}
-declare const ContextMapNotStartedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-    readonly _tag: "ContextMapNotStartedError";
-} & Readonly<A>;
-export declare class ContextMapNotStartedError extends ContextMapNotStartedError_base {
-}
-export declare const getContextMap: Effect.Effect<ContextMap, ContextMapNotStartedError, never>;
+export declare const ContextMapContainer: RequestScopedDependencies.RequestScopedDependency<ContextMap, never, never>;
+export type ContextMapNotStartedError = RequestScopedDependencies.RequestScopedDependencyNotStartedError;
+export declare const getContextMap: Effect.Effect<ContextMap, RequestScopedDependencies.RequestScopedDependencyNotStartedError, never>;
 /**
  * Runs `make` at most once per ContextMap (i.e. per request) and caches the
  * resulting value in the ContextMap under a fresh symbol. Subsequent calls of