@effect-app/infra 0.83.12 → 0.84.0-next.1

package/_src/api/express/schema/requestHandler.ts

@@ -77,7 +77,7 @@ export function parseRequestParams<PathA, CookieA, QueryA, BodyA, HeaderA>(
           .flatMap((_) =>
             _.isFailure() && !_.cause.isFailure()
               ? (Effect.failCauseSync(() => _.cause) as Effect<never, ValidationError, never>)
-              : Effect(
+              : Effect.sync(() =>
                 _.isSuccess()
                   ? { _tag: "Success" as const, value: _.value }
                   : { _tag: "Failure", errors: _.cause.failures }
@@ -89,7 +89,7 @@ export function parseRequestParams<PathA, CookieA, QueryA, BodyA, HeaderA>(
           .flatMap((_) =>
             _.isFailure() && !_.cause.isFailure()
               ? (Effect.failCauseSync(() => _.cause) as Effect<never, ValidationError, never>)
-              : Effect(
+              : Effect.sync(() =>
                 _.isSuccess()
                   ? { _tag: "Success" as const, value: _.value }
                   : { _tag: "Failure", errors: _.cause.failures }
@@ -101,7 +101,7 @@ export function parseRequestParams<PathA, CookieA, QueryA, BodyA, HeaderA>(
           .flatMap((_) =>
             _.isFailure() && !_.cause.isFailure()
               ? (Effect.failCauseSync(() => _.cause) as Effect<never, ValidationError, never>)
-              : Effect(
+              : Effect.sync(() =>
                 _.isSuccess()
                   ? { _tag: "Success" as const, value: _.value }
                   : { _tag: "Failure", errors: _.cause.failures }
@@ -113,7 +113,7 @@ export function parseRequestParams<PathA, CookieA, QueryA, BodyA, HeaderA>(
           .flatMap((_) =>
             _.isFailure() && !_.cause.isFailure()
               ? (Effect.failCauseSync(() => _.cause) as Effect<never, ValidationError, never>)
-              : Effect(
+              : Effect.sync(() =>
                 _.isSuccess()
                   ? { _tag: "Success" as const, value: _.value }
                   : { _tag: "Failure", errors: _.cause.failures }
@@ -125,7 +125,7 @@ export function parseRequestParams<PathA, CookieA, QueryA, BodyA, HeaderA>(
           .flatMap((_) =>
             _.isFailure() && !_.cause.isFailure()
               ? (Effect.failCauseSync(() => _.cause) as Effect<never, ValidationError, never>)
-              : Effect(
+              : Effect.sync(() =>
                 _.isSuccess()
                   ? { _tag: "Success" as const, value: _.value }
                   : { _tag: "Failure", errors: _.cause.failures }
@@ -152,13 +152,13 @@ export function parseRequestParams<PathA, CookieA, QueryA, BodyA, HeaderA>(
         if (errors.length) {
           return new ValidationError({ errors })
         }
-        return Effect({
+        return Effect.sync(() => ({
           body: body.value!,
           cookie: cookie.value!,
           headers: headers.value!,
           path: path.value!,
           query: query.value!
-        })
+        }))
       })
 }
 
@@ -307,7 +307,7 @@ export function makeRequestParsers<
     Errors
   >["Request"]
 ): RequestParsers<PathA, CookieA, QueryA, BodyA, HeaderA> {
-  const ph = Effect(
+  const ph = Effect.sync(() =>
     Option
       .fromNullable(Request.Headers)
       .map((s) => s)
@@ -316,7 +316,7 @@ export function makeRequestParsers<
   )
   const parseHeaders = (u: unknown) => ph.flatMapOpt((d) => d(u))
 
-  const pq = Effect(
+  const pq = Effect.sync(() =>
     Option
       .fromNullable(Request.Query)
       .map((s) => s)
@@ -325,7 +325,7 @@ export function makeRequestParsers<
   )
   const parseQuery = (u: unknown) => pq.flatMapOpt((d) => d(u))
 
-  const pb = Effect(
+  const pb = Effect.sync(() =>
     Option
       .fromNullable(Request.Body)
       .map((s) => s)
@@ -334,7 +334,7 @@ export function makeRequestParsers<
   )
   const parseBody = (u: unknown) => pb.flatMapOpt((d) => d(u))
 
-  const pp = Effect(
+  const pp = Effect.sync(() =>
     Option
       .fromNullable(Request.Path)
       .map((s) => s)
@@ -343,7 +343,7 @@ export function makeRequestParsers<
   )
   const parsePath = (u: unknown) => pp.flatMapOpt((d) => d(u))
 
-  const pc = Effect(
+  const pc = Effect.sync(() =>
     Option
       .fromNullable(Request.Cookie)
       .map((s) => s)

package/_src/api/express/schema/routing.ts

@@ -99,33 +99,33 @@ export function makeFromSchema<ResA>(
   const Res = r ? MO.extractSchema(r) : MO.Void
   // TODO EffectOption.fromNullable(Req.Headers).flatMapOpt(jsonSchema)
   // TODO: use the path vs body etc serialisation also in the Client.
-  const makeReqQuerySchema = Effect(Option.fromNullable(Req.Query)).flatMap((_) =>
+  const makeReqQuerySchema = Effect.sync(() => Option.fromNullable(Req.Query)).flatMap((_) =>
     _.match({
-      onNone: () => Effect(Option.none),
+      onNone: () => Effect.sync(() => Option.none()),
       onSome: (_) => jsonSchema(_).map(Option.some)
     })
   )
-  const makeReqHeadersSchema = Effect(Option.fromNullable(Req.Headers)).flatMap((_) =>
+  const makeReqHeadersSchema = Effect.sync(() => Option.fromNullable(Req.Headers)).flatMap((_) =>
     _.match({
-      onNone: () => Effect(Option.none),
+      onNone: () => Effect.sync(() => Option.none()),
       onSome: (_) => jsonSchema(_).map(Option.some)
     })
   )
-  const makeReqCookieSchema = Effect(Option.fromNullable(Req.Cookie)).flatMap((_) =>
+  const makeReqCookieSchema = Effect.sync(() => Option.fromNullable(Req.Cookie)).flatMap((_) =>
     _.match({
-      onNone: () => Effect(Option.none),
+      onNone: () => Effect.sync(() => Option.none()),
       onSome: (_) => jsonSchema(_).map(Option.some)
     })
   )
-  const makeReqPathSchema = Effect(Option.fromNullable(Req.Path)).flatMap((_) =>
+  const makeReqPathSchema = Effect.sync(() => Option.fromNullable(Req.Path)).flatMap((_) =>
     _.match({
-      onNone: () => Effect(Option.none),
+      onNone: () => Effect.sync(() => Option.none()),
       onSome: (_) => jsonSchema(_).map(Option.some)
     })
   )
-  const makeReqBodySchema = Effect(Option.fromNullable(Req.Body)).flatMap((_) =>
+  const makeReqBodySchema = Effect.sync(() => Option.fromNullable(Req.Body)).flatMap((_) =>
     _.match({
-      onNone: () => Effect(Option.none),
+      onNone: () => Effect.sync(() => Option.none()),
       onSome: (_) => jsonSchema(_).map(Option.some)
     })
   )
@@ -136,7 +136,7 @@ export function makeFromSchema<ResA>(
   function makeParameters(inn: ParameterLocation) {
     return (a: Option<JSONSchema | SubSchema>) => {
       return a
-        .flatMap((o) => (isObjectSchema(o) ? Option(o) : Option.none))
+        .flatMap((o) => (isObjectSchema(o) ? Option.some(o) : Option.none()))
         .map((x) => {
           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
           return Object.keys(x.properties!).map((p) => {

package/_src/api/routing.ts

@@ -47,7 +47,7 @@ export function makeRequestParsers<
     Errors
   >["Request"]
 ): RequestParsers<PathA, CookieA, QueryA, BodyA, HeaderA> {
-  const ph = Effect(
+  const ph = Effect.sync(() =>
     Option
       .fromNullable(Request.Headers)
       .map((s) => s)
@@ -56,7 +56,7 @@ export function makeRequestParsers<
   )
   const parseHeaders = (u: unknown) => ph.flatMapOpt((d) => d(u))
 
-  const pq = Effect(
+  const pq = Effect.sync(() =>
     Option
       .fromNullable(Request.Query)
       .map((s) => s)
@@ -65,7 +65,7 @@ export function makeRequestParsers<
   )
   const parseQuery = (u: unknown) => pq.flatMapOpt((d) => d(u))
 
-  const pb = Effect(
+  const pb = Effect.sync(() =>
     Option
       .fromNullable(Request.Body)
       .map((s) => s)
@@ -74,7 +74,7 @@ export function makeRequestParsers<
   )
   const parseBody = (u: unknown) => pb.flatMapOpt((d) => d(u))
 
-  const pp = Effect(
+  const pp = Effect.sync(() =>
     Option
       .fromNullable(Request.Path)
       .map((s) => s)
@@ -83,7 +83,7 @@ export function makeRequestParsers<
   )
   const parsePath = (u: unknown) => pp.flatMapOpt((d) => d(u))
 
-  const pc = Effect(
+  const pc = Effect.sync(() =>
     Option
       .fromNullable(Request.Cookie)
       .map((s) => s)
@@ -185,7 +185,7 @@ export function match<
       )
     )
     .zipRight(
-      Effect(
+      Effect.sync(() =>
         makeRouteDescriptor(
           requestHandler.Request.path,
           requestHandler.Request.method,
@@ -199,7 +199,8 @@ export function respondSuccess<ReqA, A, E>(
   encodeResponse: (req: ReqA) => Encode<A, E>
 ) {
   return (req: ReqA, res: express.Response, a: A) =>
-    Effect(encodeResponse(req)(a))
+    Effect
+      .sync(() => encodeResponse(req)(a))
       .flatMap((r) =>
         Effect.sync(() => {
           r === undefined
@@ -258,13 +259,13 @@ export function makeRequestHandler<
   const respond = respondSuccess(encodeResponse)
 
   function getParams(req: express.Request) {
-    return Effect({
+    return Effect.sync(() => ({
       path: req.params,
       query: req.query,
       body: req.body,
       headers: req.headers,
       cookies: req.cookies
-    })
+    }))
   }
 
   function makeContext(req: express.Request) {
@@ -380,8 +381,8 @@ export function makeRequestHandler<
             Effect
               .all(
                 [
-                  Effect(res.status(500).send()),
-                  Effect(
+                  Effect.sync(() => res.status(500).send()),
+                  Effect.sync(() =>
                     reportRequestError(cause, {
                       path: req.originalUrl,
                       method: req.method
@@ -418,7 +419,7 @@ export function makeRequestHandler<
                 ],
                 { concurrency: "inherit" }
               )
-              .tapErrorCause((cause) => Effect(console.error("Error occurred while reporting error", cause)))
+              .tapErrorCause((cause) => Effect.sync(() => console.error("Error occurred while reporting error", cause)))
           )
           .tap(() =>
             RequestSettings
@@ -618,7 +619,7 @@ export interface ReqHandler<
  * class SayHelloResponse extends Model<SayHelloRequest>()({ message: prop(LongString) }) {}
  *
  * export const SayHelloControllers = matchResource({ SayHello: { SayHelloRequest, SayHelloResponse } })({
- *   SayHello: (req) => Effect({ message: `Hi ${req.name}` })
+ *   SayHello: (req) => Effect.sync(() => { message: `Hi ${req.name}` })
  * })
  * ```
  */

package/_src/errorReporter.ts

@@ -73,5 +73,5 @@ export function reportMessage(message: string) {
 }
 
 export function reportMessageM(message: string) {
-  return Effect(reportMessage(message))
+  return Effect.sync(() => reportMessage(message))
 }

package/_src/services/Emailer/Sendgrid.ts

@@ -32,7 +32,7 @@ const makeLiveSendgrid = ({ apiKey, defaultFrom, defaultReplyTo, realMail, subje
                 void sgMail.send(renderedMsg, false, (err, result) =>
                   err
                     ? cb(Effect.fail(err))
-                    : cb(Effect(result)))
+                    : cb(Effect.sync(() => result)))
             )
           )
 

package/_src/services/Operations/live.ts

@@ -8,7 +8,7 @@ const reportAppError = reportError((cause) => new RequestException(cause))
 
 const make = Effect.sync((): Operations => {
   const ops = new Map<OperationId, Operation>()
-  const makeOp = Effect(OperationId.make())
+  const makeOp = Effect.sync(() => OperationId.make())
 
   const cleanup = Effect.sync(() => {
     const before = new Date().subHours(1)
@@ -29,7 +29,7 @@ const make = Effect.sync((): Operations => {
     })
   }
   function findOp(id: OperationId) {
-    return Effect(Option.fromNullable(ops.get(id)))
+    return Effect.sync(() => Option.fromNullable(ops.get(id)))
   }
   function finishOp(id: OperationId, exit: Exit<unknown, unknown>) {
     return findOp(id).flatMap((_) =>
@@ -52,8 +52,8 @@ const make = Effect.sync((): Operations => {
                   .failureOption
                   .flatMap((_) =>
                     typeof _ === "object" && _ !== null && "message" in _ && LongString.Guard(_.message)
-                      ? Option(_.message)
-                      : Option.none
+                      ? Option.some(_.message)
+                      : Option.none()
                   )
                   .value ?? null
             })
@@ -75,7 +75,7 @@ const make = Effect.sync((): Operations => {
     cleanup,
     register: makeOp
       .tap((id) =>
-        Effect.annotateLogscoped("operationId", id)
+        EffectX.annotateLogscoped("operationId", id)
           > addOp(id).acquireRelease(
             (_, exit) => finishOp(id, exit)
           )

package/_src/services/QueueMaker/errors.ts

@@ -42,7 +42,7 @@ export function reportNonInterruptedFailure(context?: Record<string, unknown>) {
       .exit
       .flatMap((result) =>
         result.match(
-          { onFailure: (cause) => report(cause).map(() => result), onSuccess: () => Effect(result) }
+          { onFailure: (cause) => report(cause).map(() => result), onSuccess: () => Effect.sync(() => result) }
         )
       )
 }

package/_src/services/QueueMaker/memQueue.ts

@@ -43,7 +43,7 @@ export function makeMemQueue<
             messages
               .forEachEffect((m) =>
                 // we JSON encode, because that is what the wire also does, and it reveals holes in e.g unknown encoders (Date->String)
-                Effect(
+                Effect.sync(() => 
                   JSON.stringify(
                     encoder({ body: m, meta: requestContext })
                   )
@@ -60,7 +60,7 @@ export function makeMemQueue<
         const silenceAndReportError = reportNonInterruptedFailure({ name: "MemQueue.drain." + queueDrainName })
         const processMessage = (msg: string) =>
           // we JSON parse, because that is what the wire also does, and it reveals holes in e.g unknown encoders (Date->String)
-          Effect(JSON.parse(msg))
+          Effect.sync(() => JSON.parse(msg))
             .flatMap(parseDrain)
             .orDie
             .flatMap(({ body, meta }) =>

package/_src/services/QueueMaker/sbqueue.ts

@@ -81,7 +81,7 @@ export function makeServiceBusQueue<
         return yield* $(
           subscribe({
             processMessage: (x) => processMessage(x.body).uninterruptible,
-            processError: (err) => Effect(captureException(err.error))
+            processError: (err) => Effect.sync(() => captureException(err.error))
           })
             .provide(receiverLayer)
         )

package/_src/services/Repository.ts

@@ -155,7 +155,7 @@ export function project<
   self: Repository<T, PM, Evt, ItemType>,
   map: { filter?: Filter<PM>; collect?: (t: PM) => Option<S>; limit?: number; skip?: number }
 ) {
-  return self.projectEffect(Effect(map))
+  return self.projectEffect(Effect.sync(() => map))
 }
 
 /**
@@ -235,7 +235,7 @@ export function query<
   // TODO: think about collectPM, collectE, and collect(Parsed)
   map: { filter?: Filter<PM>; collect?: (t: T) => Option<S>; limit?: number; skip?: number }
 ) {
-  return self.queryEffect(Effect(map))
+  return self.queryEffect(Effect.sync(() => map))
 }
 
 /**
@@ -252,7 +252,7 @@ export function queryOne<
   // TODO: think about collectPM, collectE, and collect(Parsed)
   map: { filter?: Filter<PM>; collect?: (t: T) => Option<S> }
 ) {
-  return self.queryOneEffect(Effect(map))
+  return self.queryOneEffect(Effect.sync(() => map))
 }
 
 /**
@@ -290,7 +290,7 @@ export function queryAndSavePure<
   // TODO: think about collectPM, collectE, and collect(Parsed)
   map: { filter: Filter<PM>; collect?: (t: T) => Option<S>; limit?: number; skip?: number }
 ) {
-  return self.queryAndSavePureEffect(Effect(map))
+  return self.queryAndSavePureEffect(Effect.sync(() => map))
 }
 
 /**
@@ -443,7 +443,7 @@ export function queryAndSavePureBatched<
   map: { filter: Filter<PM>; collect?: (t: T) => Option<S>; limit?: number; skip?: number },
   batchSize = 100
 ) {
-  return self.queryAndSavePureEffectBatched(Effect(map), batchSize)
+  return self.queryAndSavePureEffectBatched(Effect.sync(() => map), batchSize)
 }
 
 /**
@@ -536,7 +536,7 @@ export interface OneDSLExt<T, Evt> {
  * @tsplus fluent DSLExt updateWith
  */
 export function updateWithOne<T, Evt, S1 extends T, S2 extends T>(self: OneDSL<T, Evt>, upd: (item: S1) => S2) {
-  return self.update((_: S1) => Effect(upd(_)))
+  return self.update((_: S1) => Effect.sync(() => upd(_)))
 }
 
 /**
@@ -546,7 +546,7 @@ export function updateWith<T, Evt, S1 extends T, S2 extends T>(
   self: AllDSL<T, Evt>,
   upd: (item: S1[]) => S2[]
 ) {
-  return self.update((_: S1[]) => Effect(upd(_)))
+  return self.update((_: S1[]) => Effect.sync(() => upd(_)))
 }
 
 export function makeOneDSL<T, Evt>(): OneDSL<T, Evt> {
@@ -603,14 +603,14 @@ export function makeDSL<S1, S2, Evt>() {
 export interface DSLExt<S1, S2, Evt> extends ReturnType<typeof makeDSL<S1, S2, Evt>> {}
 
 export function ifAny<T, R, E, A>(fn: (items: NonEmptyReadonlyArray<T>) => Effect<R, E, A>) {
-  return (items: Iterable<T>) => Effect(items.toNonEmptyArray).flatMapOpt(fn)
+  return (items: Iterable<T>) => Effect.sync(() => items.toNonEmptyArray).flatMapOpt(fn)
 }
 
 /**
  * @tsplus fluent Iterable ifAny
  */
 export function ifAny_<T, R, E, A>(items: Iterable<T>, fn: (items: NonEmptyReadonlyArray<T>) => Effect<R, E, A>) {
-  return Effect(items.toNonEmptyArray).flatMapOpt(fn)
+  return Effect.sync(() => items.toNonEmptyArray).flatMapOpt(fn)
 }
 
 /**

package/_src/services/RepositoryBase.ts

@@ -5,10 +5,9 @@ import { ContextMap, StoreMaker } from "./Store.js"
 import type { Filter, StoreConfig, Where } from "./Store.js"
 import type {} from "effect/Equal"
 import type {} from "effect/Hash"
-import type { Opt } from "@effect-app/core/Option"
 import { makeCodec } from "@effect-app/infra/api/codec"
 import { makeFilters } from "@effect-app/infra/filter"
-import type { Schema } from "@effect-app/prelude"
+import type { Option, Schema } from "@effect-app/prelude"
 import { EParserFor } from "@effect-app/prelude/schema"
 import type { InvalidStateError, OptimisticConcurrencyException } from "../errors.js"
 
@@ -21,7 +20,7 @@ export const RepositoryBase = <Service>() => {
   ) => {
     abstract class RepositoryBaseC implements Repository<T, PM, Evt, ItemType> {
       itemType: ItemType = itemType
-      abstract find: (id: T["id"]) => Effect<ContextMap | RequestContextContainer, never, Opt<T>>
+      abstract find: (id: T["id"]) => Effect<ContextMap | RequestContextContainer, never, Option<T>>
       abstract all: Effect<ContextMap, never, T[]>
       abstract saveAndPublish: (
         items: Iterable<T>,
@@ -130,7 +129,8 @@ export function makeRepo<
         }
 
         const saveAllE = (a: Iterable<E>) =>
-          Effect(a.toNonEmptyArray)
+          Effect
+            .sync(() => a.toNonEmptyArray)
             .flatMapOpt((a) =>
               Do(($) => {
                 const { get, set } = $(ContextMap)
@@ -145,7 +145,8 @@ export function makeRepo<
 
         const saveAndPublish = (items: Iterable<T>, events: Iterable<Evt> = []) =>
           saveAll(items)
-            > Effect(events.toNonEmptyArray)
+            > Effect
+              .sync(() => events.toNonEmptyArray)
               // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
               .flatMapOpt(publishEvents)
 
@@ -159,7 +160,8 @@ export function makeRepo<
               set(e.id, undefined)
             }
             yield* $(
-              Effect(events.toNonEmptyArray)
+              Effect
+                .sync(() => events.toNonEmptyArray)
                 // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
                 .flatMapOpt(publishEvents)
             )

package/_src/services/RequestContextContainer.ts

@@ -15,7 +15,7 @@ export abstract class RequestContextContainer extends TagClass<RequestContextCon
       .flatMap((requestContext) =>
         requestContext.isSome()
           ? requestContext.value.requestContext.map(Option.some)
-          : Effect(Option.none)
+          : Effect.sync(() => Option.none())
       )
   }
 }

package/_src/services/Store/Cosmos.ts

@@ -84,7 +84,7 @@ export function makeCosmosStore({ prefix }: StorageConfig) {
                       ([i, batch]) =>
                         Effect
                           .promise(() => bulk(batch.map(([, op]) => op)))
-                          .delay(Duration.makeMillis(i === 0 ? 0 : 1100))
+                          .delay(Duration.millis(i === 0 ? 0 : 1100))
                           .flatMap((responses) =>
                             Effect.gen(function*($) {
                               const r = responses.find((x) => x.statusCode === 412 || x.statusCode === 404)
@@ -188,10 +188,11 @@ export function makeCosmosStore({ prefix }: StorageConfig) {
           }
 
           const s: Store<PM, Id> = {
-            all: Effect({
-              query: `SELECT * FROM ${name} f WHERE f.id != @id`,
-              parameters: [{ name: "@id", value: importedMarkerId }]
-            })
+            all: Effect
+              .sync(() => ({
+                query: `SELECT * FROM ${name} f WHERE f.id != @id`,
+                parameters: [{ name: "@id", value: importedMarkerId }]
+              }))
               .tap((q) => logQuery(q))
               .flatMap((q) =>
                 Effect.promise(() =>
@@ -211,7 +212,8 @@ export function makeCosmosStore({ prefix }: StorageConfig) {
               filter
                 .keys
                 .forEachEffect((k) =>
-                  Effect(buildFilterJoinSelectCosmosQuery(filter, k, name, cursor?.skip, cursor?.limit))
+                  Effect
+                    .sync(() => buildFilterJoinSelectCosmosQuery(filter, k, name, cursor?.skip, cursor?.limit))
                     .tap((q) => logQuery(q))
                     .flatMap((q) =>
                       Effect.promise(() =>
@@ -249,7 +251,8 @@ export function makeCosmosStore({ prefix }: StorageConfig) {
                 ? filter
                   .keys
                   .forEachEffect((k) =>
-                    Effect(buildFindJoinCosmosQuery(filter, k, name, skip, limit))
+                    Effect
+                      .sync(() => buildFindJoinCosmosQuery(filter, k, name, skip, limit))
                       .tap((q) => logQuery(q))
                       .flatMap((q) =>
                         Effect.promise(() =>
@@ -262,7 +265,8 @@ export function makeCosmosStore({ prefix }: StorageConfig) {
                       )
                   )
                   .map((_) => _.flatMap((_) => _))
-                : Effect(buildCosmosQuery(filter, name, importedMarkerId, skip, limit))
+                : Effect
+                  .sync(() => buildCosmosQuery(filter, name, importedMarkerId, skip, limit))
                   .tap((q) => logQuery(q))
                   .flatMap((q) =>
                     Effect.promise(() =>
@@ -325,10 +329,10 @@ export function makeCosmosStore({ prefix }: StorageConfig) {
                       )
                     )
                   }
-                  return Effect({
+                  return Effect.sync(() => ({
                     ...e,
                     _etag: x.etag
-                  })
+                  }))
                 })
                 .instrument("cosmos.set")
                 .annotateLogs("cosmos.db", containerId),
@@ -356,13 +360,14 @@ export function makeCosmosStore({ prefix }: StorageConfig) {
             if (seed) {
               const m = yield* $(seed)
               yield* $(
-                Effect(m.toNonEmptyArray)
+                Effect
+                  .sync(() => m.toNonEmptyArray)
                   .flatMapOpt((a) =>
                     s
                       .bulkSet(a)
                       .orDie
                       // we delay extra here, so that initial creation between Companies/POs also have an interval between them.
-                      .delay(Duration.makeMillis(1100))
+                      .delay(Duration.millis(1100))
                   )
               )
             }

package/_src/services/Store/Disk.ts

@@ -39,7 +39,7 @@ function makeDiskStoreInt<Id extends string, PM extends PersistenceModelType<Id>
     const withPermit = sem.withPermits(1)
     const flushToDisk = store.all.flatMap(fsStore.setRaw).apply(withPermit)
     const flushToDiskInBackground = flushToDisk
-      .tapErrorCause((err) => Effect(console.error(err)))
+      .tapErrorCause((err) => Effect.sync(() => console.error(err)))
       .uninterruptible
       .forkDaemon
 
@@ -84,10 +84,10 @@ export function makeDiskStore({ prefix }: StorageConfig, dir: string) {
           const storesSem = Semaphore.unsafeMake(1)
           const primary = yield* $(makeDiskStoreInt(prefix, "primary", dir, name, seed))
           const stores = new Map<string, Store<PM, Id>>([["primary", primary]])
-          const getStore = !config?.allowNamespace ? Effect.succeed(primary) : storeId.get.flatMap((namespace) => {
+          const getStore = !config?.allowNamespace ? Effect.sync(() => primary) : storeId.get.flatMap((namespace) => {
             const store = stores.get(namespace)
             if (store) {
-              return Effect.succeed(store)
+              return Effect.sync(() => store)
             }
             if (!config.allowNamespace!(namespace)) {
               throw new Error(`Namespace ${namespace} not allowed!`)
@@ -95,7 +95,7 @@ export function makeDiskStore({ prefix }: StorageConfig, dir: string) {
             return storesSem.withPermits(1)(
               Effect.suspend(() => {
                 const existing = stores.get(namespace)
-                if (existing) return Effect(existing)
+                if (existing) return Effect.sync(() => existing)
                 return makeDiskStoreInt<Id, PM>(prefix, namespace, dir, name, seed).tap((store) =>
                   Effect.sync(() => stores.set(namespace, store))
                 )

package/_src/services/Store/Memory.ts

@@ -47,7 +47,7 @@ export function makeMemoryStoreInt<Id extends string, PM extends PersistenceMode
 ) {
   return Effect.gen(function*($) {
     const updateETag = makeUpdateETag(name)
-    const items_ = yield* $(seed ?? Effect([]))
+    const items_ = yield* $(seed ?? Effect.sync(() => []))
     const items = new Map(items_.toChunk.map((_) => [_.id, _] as const))
     const makeStore = (): ReadonlyMap<Id, PM> => new Map([...items.entries()].map(([id, e]) => [id, makeETag(e)]))
     const store = Ref.unsafeMake(makeStore())
@@ -108,17 +108,17 @@ export const makeMemoryStore = () => ({
       const storesSem = Semaphore.unsafeMake(1)
       const primary = yield* $(makeMemoryStoreInt<Id, PM>(name, seed))
       const stores = new Map([["primary", primary]])
-      const getStore = !config?.allowNamespace ? Effect.succeed(primary) : storeId.get.flatMap((namespace) => {
+      const getStore = !config?.allowNamespace ? Effect.sync(() => primary) : storeId.get.flatMap((namespace) => {
         const store = stores.get(namespace)
         if (store) {
-          return Effect.succeed(store)
+          return Effect.sync(() => store)
         }
         if (!config.allowNamespace!(namespace)) {
           throw new Error(`Namespace ${namespace} not allowed!`)
         }
         return storesSem.withPermits(1)(Effect.suspend(() => {
           const store = stores.get(namespace)
-          if (store) return Effect(store)
+          if (store) return Effect.sync(() => store)
           return makeMemoryStoreInt(name, seed).tap((store) => Effect.sync(() => stores.set(namespace, store)))
         }))
       })

package/_src/services/Store/Redis.ts

@@ -22,7 +22,7 @@ export function makeRedisStore({ prefix }: StorageConfig) {
           const key = `${prefix}${name}`
           const current = yield* $(redis.get(key).orDie.provideService(RedisClient, redis))
           if (!current.isSome()) {
-            const m = yield* $(seed ?? Effect([]))
+            const m = yield* $(seed ?? Effect.sync(() => []))
             yield* $(
               redis
                 .set(key, JSON.stringify({ data: [...m].map((e) => makeETag(e)) }))