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

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)) }))

package/_src/services/Store/index.test.ts.bak

@@ -17,7 +17,7 @@ describe("Optimistic Concurrency", () => {
           { _etag: string | undefined; id: string; a: string }
         >()
         const { make } = makeMemoryStore()
-        const store = yield* $(make("test", Effect(existing)))
+        const store = yield* $(make("test", Effect.sync(() => existing)))
 
         const result1 = yield* $(store.set({ id: "1", a: "string", _etag: undefined }))
         const result2_1 = yield* $(
@@ -51,7 +51,7 @@ describe("Optimistic Concurrency", () => {
           { _etag: string | undefined; id: string; a: string }
         >()
         const { make } = makeMemoryStore()
-        const store = yield* $(make("test", Effect(existing)))
+        const store = yield* $(make("test", Effect.sync(() => existing)))
 
         const [result1] = yield* $(
           store.bulkSet([{ id: "1", a: "string", _etag: undefined }])
@@ -89,7 +89,7 @@ describe("Optimistic Concurrency", () => {
           { _etag: string | undefined; id: string; a: string }
         >()
         const { make } = makeMemoryStore()
-        const store = yield* $(make("test", Effect(existing)))
+        const store = yield* $(make("test", Effect.sync(() => existing)))
 
         const item1 = { id: "1", a: "string", _etag: undefined }
         const item2 = { id: "2", a: "string", _etag: undefined }
@@ -102,8 +102,8 @@ describe("Optimistic Concurrency", () => {
         const failResult = yield* $(
           store.batchSet([{ id: "1", a: "another-string3", _etag: "abc" }]).result
         )
-        expect(result1).toEqual(Option({ ...item1, _etag: expect.any(String) }))
-        expect(result2).toEqual(Option({ ...item2, _etag: expect.any(String) }))
+        expect(result1).toEqual(Option.some({ ...item1, _etag: expect.any(String) }))
+        expect(result2).toEqual(Option.some({ ...item2, _etag: expect.any(String) }))
         expect(Exit.untraced(failResult)).toEqual(
           Exit.fail(new OptimisticConcurrencyException("test", "1"))
         )

package/_src/services/Store/index.ts

@@ -20,7 +20,7 @@ export function StoreMakerLive(config: Config<StorageConfig>) {
       const storageUrl = cfg.url.value
       if (storageUrl.startsWith("mem://")) {
         console.log("Using in memory store")
-        return Effect(makeMemoryStore())
+        return Effect.sync(() => makeMemoryStore())
       }
       if (storageUrl.startsWith("disk://")) {
         const dir = storageUrl.replace("disk://", "")

package/_src/services/Store/utils.ts

@@ -41,19 +41,19 @@ export function codeFilter<E extends { id: string }, NE extends E>(filter: Filte
     filter.type === "startsWith"
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       ? lowercaseIfString((x as any)[filter.by]).startsWith(filter.value.toLowerCase())
-        ? Option(x as unknown as NE)
-        : Option.none
+        ? Option.some(x as unknown as NE)
+        : Option.none()
       : filter.type === "endsWith"
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       ? lowercaseIfString((x as any)[filter.by]).endsWith(filter.value.toLowerCase())
-        ? Option(x as unknown as NE)
-        : Option.none
+        ? Option.some(x as unknown as NE)
+        : Option.none()
       : filter.type === "contains"
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       // eslint-disable-next-line @typescript-eslint/no-unsafe-call
       ? lowercaseIfString((x as any)[filter.by]).includes(filter.value.toLowerCase())
-        ? Option(x as unknown as NE)
-        : Option.none
+        ? Option.some(x as unknown as NE)
+        : Option.none()
       : filter.type === "join_find"
       ? filter.keys.some((k) => {
           const value = get(x, k) as Record<string, unknown>[]
@@ -63,8 +63,8 @@ export function codeFilter<E extends { id: string }, NE extends E>(filter: Filte
             && value.some((v) => compareCaseInsensitive(v[filter.valueKey], filter.value))
           )
         })
-        ? Option(x as unknown as NE)
-        : Option.none
+        ? Option.some(x as unknown as NE)
+        : Option.none()
       // TODO: support mixed or/and
       : filter.mode === "or"
       ? filter
@@ -101,8 +101,8 @@ export function codeFilter<E extends { id: string }, NE extends E>(filter: Filte
                 return compareCaseInsensitive(k, p.value)
             }
           })
-        ? Option(x as unknown as NE)
-        : Option.none
+        ? Option.some(x as unknown as NE)
+        : Option.none()
       : filter
           .where
           .every((p) => {
@@ -145,8 +145,8 @@ export function codeFilter<E extends { id: string }, NE extends E>(filter: Filte
                   : compareCaseInsensitive(k, p.value)
             }
           })
-      ? Option(x as unknown as NE)
-      : Option.none
+      ? Option.some(x as unknown as NE)
+      : Option.none()
 }
 
 export function codeFilterJoinSelect<E extends { id: string }, NE>(
@@ -159,15 +159,15 @@ export function codeFilterJoinSelect<E extends { id: string }, NE>(
         const value = get(x, k)
         // we mimic the behavior of cosmosdb; if the shape in db does not match what we're looking for, we imagine false hit
         return value
-          ? Option(
+          ? Option.some(
             (value as readonly NE[]).filterMap((v) =>
               // eslint-disable-next-line @typescript-eslint/no-explicit-any
               compareCaseInsensitive((v as any)[filter.valueKey], filter.value)
-                ? Option({ ...v, _rootId: x.id })
-                : Option.none
+                ? Option.some({ ...v, _rootId: x.id })
+                : Option.none()
             )
           )
-          : Option.none
+          : Option.none()
       })
       .flatMap((_) => _)
 }

package/_src/services/simpledb/diskdb.ts

@@ -133,7 +133,7 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
     function tryRead(filePath: string) {
       return fu
         .fileExists(filePath)
-        .flatMap((exists) => !exists ? Effect(Option.none) : readFile(filePath).map(Option.some))
+        .flatMap((exists) => !exists ? Effect.sync(() => Option.none()) : readFile(filePath).map(Option.some))
     }
 
     function getFilename(type: string, id: string) {

package/_src/services/simpledb/memdb.ts

@@ -47,7 +47,7 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
               decode(cr.data)
                 .flatMap((d) =>
                   eq(keys, d as unknown as V)
-                    ? Effect(d)
+                    ? Effect.sync(() => d)
                     : Effect.fail("not equals")
                 )
                 .exit

package/_src/services/simpledb/redisdb.ts

@@ -180,7 +180,7 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
             (err) =>
               err
                 ? res(new ConnectionException(err))
-                : res(Effect(void 0))
+                : res(Effect.sync(() => void 0))
           )
         })
         .uninterruptible

package/_src/services/simpledb/shared.ts

@@ -64,7 +64,7 @@ export function getRecordName(type: string, id: string) {
 export function makeMap<TKey, T>() {
   const map = new Map<TKey, T>()
   return {
-    find: (k: TKey) => Effect(Option.fromNullable(map.get(k))),
+    find: (k: TKey) => Effect.sync(() => Option.fromNullable(map.get(k))),
     [Symbol.iterator]: () => map[Symbol.iterator](),
     set: (k: TKey, v: T) =>
       Effect.sync(() => {

package/_src/services/simpledb/simpledb.ts

@@ -28,7 +28,7 @@ export interface RecordCache extends ReturnType<typeof makeLiveRecordCache> {}
 // module tag
 export const RecordCache = Tag<RecordCache>()
 
-export const LiveRecordCache = Effect(makeLiveRecordCache()).toLayer(RecordCache)
+export const LiveRecordCache = Effect.sync(() => makeLiveRecordCache()).toLayer(RecordCache)
 
 const getM = <T>(type: string) => <R, E, A>(eff: (m: EffectMap<string, CachedRecord<T>>) => Effect<R, E, A>) =>
   Effect.gen(function*($) {
@@ -90,7 +90,7 @@ export function store<R, E, R2, E2, TKey extends string, EA, A extends DBRecord<
       c
         .find(record.id)
         .mapOpt((x) => x.version)
-        .flatMap((_) => _.match({ onNone: () => save(record, Option.none), onSome: confirmVersionAndSave(record) }))
+        .flatMap((_) => _.match({ onNone: () => save(record, Option.none()), onSome: confirmVersionAndSave(record) }))
         .tap((r) => c.set(record.id, r))
         .map((r) => r.data)
     )
@@ -110,7 +110,7 @@ export function store<R, E, R2, E2, TKey extends string, EA, A extends DBRecord<
                 ? new OptimisticLockException(type, record.id)
                 : Effect.unit
             )
-            .zipRight(save(record, Option(cv)))
+            .zipRight(save(record, Option.some(cv)))
         )
         .scoped
   }

package/dist/RequestContext.d.ts

@@ -5,8 +5,8 @@ declare const RequestContextParent_base: import("@effect-app/schema").MNModel<im
     id: import("@effect-app/schema").SchemaDefaultSchema<unknown, RequestId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<RequestId>> & import("@effect-app/schema").Utils<import("@effect-app/schema").SchemaDefaultSchema<unknown, RequestId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<RequestId>>> & {
         EParser: import("@effect-app/schema/custom/_parser").Parser<string, any, RequestId>;
         make: () => RequestId;
-        eq: import("effect/Equivalence").Equivalence<RequestId>;
-        withDefault: import("@effect-app/schema").Property<import("@effect-app/schema").SchemaDefaultSchema<unknown, RequestId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<RequestId>>, "required", import("effect/Option").None<any>, import("effect/Option").Some<["constructor", () => RequestId]>>;
+        eq: import("effect/Equivalence")<RequestId>;
+        withDefault: import("@effect-app/schema").Property<import("@effect-app/schema").SchemaDefaultSchema<unknown, RequestId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<RequestId>>, "required", import("effect/Option.impl").None<any>, import("effect/Option.impl").Some<["constructor", () => RequestId]>>;
     };
     name: import("@effect-app/schema").SchemaDefaultSchema<unknown, import("@effect-app/schema").ReasonableString, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").ReasonableString>> & import("@effect-app/schema").Utils<import("@effect-app/schema").SchemaDefaultSchema<unknown, import("@effect-app/schema").ReasonableString, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").ReasonableString>>>;
     userProfile: import("@effect-app/schema").Property<import("@effect-app/schema").Schema<unknown, {
@@ -20,30 +20,30 @@ declare const RequestContextParent_base: import("@effect-app/schema").MNModel<im
             sub: import("@effect-app/schema").Property<import("@effect-app/schema").SchemaDefaultSchema<unknown, UserProfileId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<UserProfileId>> & import("@effect-app/schema").Utils<import("@effect-app/schema").SchemaDefaultSchema<unknown, UserProfileId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<UserProfileId>>> & {
                 EParser: import("@effect-app/schema/custom/_parser").Parser<string, any, UserProfileId>;
                 make: () => UserProfileId;
-                eq: import("effect/Equivalence").Equivalence<UserProfileId>;
-                withDefault: import("@effect-app/schema").Property<import("@effect-app/schema").SchemaDefaultSchema<unknown, UserProfileId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<UserProfileId>>, "required", import("effect/Option").None<any>, import("effect/Option").Some<["constructor", () => UserProfileId]>>;
-            }, "required", import("effect/Option").None<any>, import("effect/Option").None<any>>;
+                eq: import("effect/Equivalence")<UserProfileId>;
+                withDefault: import("@effect-app/schema").Property<import("@effect-app/schema").SchemaDefaultSchema<unknown, UserProfileId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<UserProfileId>>, "required", import("effect/Option.impl").None<any>, import("effect/Option.impl").Some<["constructor", () => UserProfileId]>>;
+            }, "required", import("effect/Option.impl").None<any>, import("effect/Option.impl").None<any>>;
         }>;
-    }>, "optional", import("effect/Option").None<any>, import("effect/Option").None<any>>;
+    }>, "optional", import("effect/Option.impl").None<any>, import("effect/Option.impl").None<any>>;
     locale: import("@effect-app/schema").DefaultSchema<unknown, "en" | "de", "en" | "de", "en" | "de", import("@effect-app/schema").LiteralApi<["en", "de"]>>;
-    createdAt: import("@effect-app/schema").FromProperty<import("@effect-app/schema").Schema<unknown, Date, Date, string, {}>, "required", import("effect/Option").None<any>, import("effect/Option").Some<["constructor", () => Date]>>;
+    createdAt: import("@effect-app/schema").FromProperty<import("@effect-app/schema").Schema<unknown, Date, Date, string, {}>, "required", import("effect/Option.impl").None<any>, import("effect/Option.impl").Some<["constructor", () => Date]>>;
 }>>, RequestContextParent, RequestContextParent.ConstructorInput, RequestContextParent.Encoded, RequestContextParent.Props> & import("@effect-app/schema").PropsExtensions<RequestContextParent.Props>;
 export declare class RequestContextParent extends RequestContextParent_base {
 }
 declare const RequestContext_base: import("@effect-app/schema").MNModel<import("@effect-app/schema").SchemaProperties<import("@effect-app/schema").ToProps<{
-    id: import("@effect-app/schema").Property<import("@effect-app/schema").SchemaDefaultSchema<unknown, RequestId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<RequestId>>, "required", import("effect/Option").None<any>, import("effect/Option").Some<["constructor", () => RequestId]>>;
+    id: import("@effect-app/schema").Property<import("@effect-app/schema").SchemaDefaultSchema<unknown, RequestId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<RequestId>>, "required", import("effect/Option.impl").None<any>, import("effect/Option.impl").Some<["constructor", () => RequestId]>>;
     rootId: import("@effect-app/schema").SchemaDefaultSchema<unknown, RequestId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<RequestId>> & import("@effect-app/schema").Utils<import("@effect-app/schema").SchemaDefaultSchema<unknown, RequestId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<RequestId>>> & {
         EParser: import("@effect-app/schema/custom/_parser").Parser<string, any, RequestId>;
         make: () => RequestId;
-        eq: import("effect/Equivalence").Equivalence<RequestId>;
-        withDefault: import("@effect-app/schema").Property<import("@effect-app/schema").SchemaDefaultSchema<unknown, RequestId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<RequestId>>, "required", import("effect/Option").None<any>, import("effect/Option").Some<["constructor", () => RequestId]>>;
+        eq: import("effect/Equivalence")<RequestId>;
+        withDefault: import("@effect-app/schema").Property<import("@effect-app/schema").SchemaDefaultSchema<unknown, RequestId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<RequestId>>, "required", import("effect/Option.impl").None<any>, import("effect/Option.impl").Some<["constructor", () => RequestId]>>;
     };
     parent: import("@effect-app/schema").Property<import("@effect-app/schema").Schema<unknown, RequestContextParent, RequestContextParent.ConstructorInput, RequestContextParent.Encoded, {
         props: RequestContextParent.Props;
-    }>, "optional", import("effect/Option").None<any>, import("effect/Option").None<any>>;
-    namespace: import("@effect-app/schema").Property<import("@effect-app/schema").Schema<unknown, import("@effect-app/schema").ReasonableString, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").ReasonableString>>, "optional", import("effect/Option").None<any>, import("effect/Option").None<any>>;
-    _tag: import("@effect-app/schema").Property<import("@effect-app/schema").DefaultSchema<unknown, "RequestContext", "RequestContext", "RequestContext", import("@effect-app/schema").LiteralApi<["RequestContext"]>>, "required", import("effect/Option").None<any>, import("effect/Option").None<any>>;
-    name: import("@effect-app/schema").Property<import("@effect-app/schema").SchemaDefaultSchema<unknown, import("@effect-app/schema").ReasonableString, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").ReasonableString>> & import("@effect-app/schema").Utils<import("@effect-app/schema").SchemaDefaultSchema<unknown, import("@effect-app/schema").ReasonableString, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").ReasonableString>>>, "required", import("effect/Option").None<any>, import("effect/Option").None<any>>;
+    }>, "optional", import("effect/Option.impl").None<any>, import("effect/Option.impl").None<any>>;
+    namespace: import("@effect-app/schema").Property<import("@effect-app/schema").Schema<unknown, import("@effect-app/schema").ReasonableString, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").ReasonableString>>, "optional", import("effect/Option.impl").None<any>, import("effect/Option.impl").None<any>>;
+    _tag: import("@effect-app/schema").Property<import("@effect-app/schema").DefaultSchema<unknown, "RequestContext", "RequestContext", "RequestContext", import("@effect-app/schema").LiteralApi<["RequestContext"]>>, "required", import("effect/Option.impl").None<any>, import("effect/Option.impl").None<any>>;
+    name: import("@effect-app/schema").Property<import("@effect-app/schema").SchemaDefaultSchema<unknown, import("@effect-app/schema").ReasonableString, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").ReasonableString>> & import("@effect-app/schema").Utils<import("@effect-app/schema").SchemaDefaultSchema<unknown, import("@effect-app/schema").ReasonableString, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/schema").ReasonableString>>>, "required", import("effect/Option.impl").None<any>, import("effect/Option.impl").None<any>>;
     userProfile: import("@effect-app/schema").Property<import("@effect-app/schema").Schema<unknown, {
         readonly sub: UserProfileId;
     }, {
@@ -55,13 +55,13 @@ declare const RequestContext_base: import("@effect-app/schema").MNModel<import("
             sub: import("@effect-app/schema").Property<import("@effect-app/schema").SchemaDefaultSchema<unknown, UserProfileId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<UserProfileId>> & import("@effect-app/schema").Utils<import("@effect-app/schema").SchemaDefaultSchema<unknown, UserProfileId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<UserProfileId>>> & {
                 EParser: import("@effect-app/schema/custom/_parser").Parser<string, any, UserProfileId>;
                 make: () => UserProfileId;
-                eq: import("effect/Equivalence").Equivalence<UserProfileId>;
-                withDefault: import("@effect-app/schema").Property<import("@effect-app/schema").SchemaDefaultSchema<unknown, UserProfileId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<UserProfileId>>, "required", import("effect/Option").None<any>, import("effect/Option").Some<["constructor", () => UserProfileId]>>;
-            }, "required", import("effect/Option").None<any>, import("effect/Option").None<any>>;
+                eq: import("effect/Equivalence")<UserProfileId>;
+                withDefault: import("@effect-app/schema").Property<import("@effect-app/schema").SchemaDefaultSchema<unknown, UserProfileId, string, string, import("@effect-app/schema").ApiSelfType<import("@effect-app/prelude/schema").StringId> & import("@effect-app/schema").ApiSelfType<UserProfileId>>, "required", import("effect/Option.impl").None<any>, import("effect/Option.impl").Some<["constructor", () => UserProfileId]>>;
+            }, "required", import("effect/Option.impl").None<any>, import("effect/Option.impl").None<any>>;
         }>;
-    }>, "optional", import("effect/Option").None<any>, import("effect/Option").None<any>>;
-    locale: import("@effect-app/schema").Property<import("@effect-app/schema").DefaultSchema<unknown, "en" | "de", "en" | "de", "en" | "de", import("@effect-app/schema").LiteralApi<["en", "de"]>>, "required", import("effect/Option").None<any>, import("effect/Option").None<any>>;
-    createdAt: import("@effect-app/schema").FromProperty<import("@effect-app/schema").Schema<unknown, Date, Date, string, {}>, "required", import("effect/Option").None<any>, import("effect/Option").Some<["constructor", () => Date]>>;
+    }>, "optional", import("effect/Option.impl").None<any>, import("effect/Option.impl").None<any>>;
+    locale: import("@effect-app/schema").Property<import("@effect-app/schema").DefaultSchema<unknown, "en" | "de", "en" | "de", "en" | "de", import("@effect-app/schema").LiteralApi<["en", "de"]>>, "required", import("effect/Option.impl").None<any>, import("effect/Option.impl").None<any>>;
+    createdAt: import("@effect-app/schema").FromProperty<import("@effect-app/schema").Schema<unknown, Date, Date, string, {}>, "required", import("effect/Option.impl").None<any>, import("effect/Option.impl").Some<["constructor", () => Date]>>;
 }>>, RequestContext, RequestContext.ConstructorInput, RequestContext.Encoded, RequestContext.Props> & import("@effect-app/schema").PropsExtensions<RequestContext.Props>;
 /**
  * @tsplus type RequestContext

package/dist/_ext/Array.js

@@ -1,5 +1,6 @@
 import * as tsplus_module_1 from "effect/Chunk";
-import * as tsplus_module_2 from "@effect-app/prelude/_ext/misc";
+import * as tsplus_module_2 from "effect/Chunk.int";
+import * as tsplus_module_3 from "@effect-app/prelude/_ext/misc";
 import { inspect } from "util";
 import { NotFoundError } from "../errors.js";
 /**
@@ -10,7 +11,7 @@ import { NotFoundError } from "../errors.js";
  * @tsplus fluent ReadonlyArray getFirstById
  */
 export function getFirstById_(a, id, type) {
-    return tsplus_module_2.encaseMaybeInEffect_(tsplus_module_1.findFirst(tsplus_module_1.fromIterable(a), (_) => _.id === id), () => new NotFoundError({ type, id }));
+    return tsplus_module_3.encaseMaybeInEffect_(tsplus_module_2.findFirst(tsplus_module_1.Chunk.fromIterable(a), (_) => _.id === id), () => new NotFoundError({ type, id }));
 }
 /**
  * @tsplus fluent Object.Ops inspect
@@ -18,4 +19,4 @@ export function getFirstById_(a, id, type) {
 export function RecordInspect(o, showHidden, depth, color) {
     return inspect(o.subject, showHidden, depth, color);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQXJyYXkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9fc3JjL19leHQvQXJyYXkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFDQSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sTUFBTSxDQUFBO0FBQzlCLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxjQUFjLENBQUE7QUFFNUM7Ozs7OztHQU1HO0FBQ0gsTUFBTSxVQUFVLGFBQWEsQ0FDM0IsQ0FBYyxFQUNkLEVBQU0sRUFDTixJQUFVO0lBRVYsT0FBTyxxQ0FBQSwwQkFBQSw2QkFDUyxDQUFDLENBQUMsRUFDTCxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsS0FBSyxFQUFFLENBQUMsRUFDZCxHQUFHLEVBQUUsQ0FBQyxJQUFJLGFBQWEsQ0FBQyxFQUFFLElBQUksRUFBRSxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUE7QUFDMUQsQ0FBQztBQUVEOztHQUVHO0FBQ0gsTUFBTSxVQUFVLGFBQWEsQ0FDM0IsQ0FBZ0IsRUFDaEIsVUFBZ0MsRUFDaEMsS0FBaUMsRUFDakMsS0FBMkI7SUFFM0IsT0FBTyxPQUFPLENBQUMsQ0FBQyxDQUFDLE9BQU8sRUFBRSxVQUFVLEVBQUUsS0FBSyxFQUFFLEtBQUssQ0FBQyxDQUFBO0FBQ3JELENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQXJyYXkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9fc3JjL19leHQvQXJyYXkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLE1BQU0sQ0FBQTtBQUM5QixPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sY0FBYyxDQUFBO0FBRTVDOzs7Ozs7R0FNRztBQUNILE1BQU0sVUFBVSxhQUFhLENBQzNCLENBQWMsRUFDZCxFQUFNLEVBQ04sSUFBVTtJQUVWLE9BQU8scUNBQUEsMEJBQUEsZ0JBQUEsS0FBSyxDQUNULFlBQVksQ0FBQyxDQUFDLENBQUMsRUFDTCxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsS0FBSyxFQUFFLENBQUMsRUFDZCxHQUFHLEVBQUUsQ0FBQyxJQUFJLGFBQWEsQ0FBQyxFQUFFLElBQUksRUFBRSxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUE7QUFDMUQsQ0FBQztBQUVEOztHQUVHO0FBQ0gsTUFBTSxVQUFVLGFBQWEsQ0FDM0IsQ0FBZ0IsRUFDaEIsVUFBZ0MsRUFDaEMsS0FBaUMsRUFDakMsS0FBMkI7SUFFM0IsT0FBTyxPQUFPLENBQUMsQ0FBQyxDQUFDLE9BQU8sRUFBRSxVQUFVLEVBQUUsS0FBSyxFQUFFLEtBQUssQ0FBQyxDQUFBO0FBQ3JELENBQUMifQ==