@effect-app/infra 4.0.0-beta.22 → 4.0.0-beta.220

package/src/Model/Repository/internal/internal.ts

@@ -1,7 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import type {} from "effect/Equal"
-import type {} from "effect/Hash"
-import { Array, Chunk, Effect, Equivalence, flow, type NonEmptyReadonlyArray, Option, pipe, Pipeable, PubSub, Result, S, SchemaAST, ServiceMap, Unify } from "effect-app"
+
+import { Array, Chunk, Context, Effect, Equivalence, flow, type NonEmptyReadonlyArray, Option, pipe, Pipeable, PubSub, Result, S, SchemaAST, Unify } from "effect-app"
 import { toNonEmptyArray } from "effect-app/Array"
 import { NotFoundError } from "effect-app/client/errors"
 import { flatMapOption } from "effect-app/Effect"
@@ -55,14 +54,14 @@ export function makeRepoInternal<
 
     function make<RInitial = never, E = never, RPublish = never, RCtx = never>(
       args: [Evt] extends [never] ? {
-          schemaContext?: ServiceMap.ServiceMap<RCtx>
+          schemaContext?: Context.Context<RCtx>
           makeInitial?: Effect.Effect<readonly T[], E, RInitial> | undefined
           config?: Omit<StoreConfig<Encoded>, "partitionValue"> & {
             partitionValue?: (e?: Encoded) => string
           }
         }
         : {
-          schemaContext?: ServiceMap.ServiceMap<RCtx>
+          schemaContext?: Context.Context<RCtx>
           publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect.Effect<void, never, RPublish>
           makeInitial?: Effect.Effect<readonly T[], E, RInitial> | undefined
           config?: Omit<StoreConfig<Encoded>, "partitionValue"> & {
@@ -72,16 +71,16 @@ export function makeRepoInternal<
     ) {
       return Effect
         .gen(function*() {
-          const rctx: ServiceMap.ServiceMap<RCtx> = args.schemaContext ?? ServiceMap.empty() as any
+          const rctx: Context.Context<RCtx> = args.schemaContext ?? Context.empty() as any
           const provideRctx = Effect.provide(rctx)
           const encodeMany = flow(
             S.encodeEffect(S.Array(schema)),
             provideRctx,
-            Effect.withSpan("encodeMany", {}, { captureStackTrace: false })
+            Effect.withSpan("encodeMany", { attributes: { "app.entity": name } }, { captureStackTrace: false })
           )
-          const decode = flow(S.decodeEffect(schema), provideRctx)
+          const decode = flow(S.decodeEffectConcurrently(schema), provideRctx)
           const decodeMany = flow(
-            S.decodeEffect(S.Array(schema)),
+            S.decodeEffectConcurrently(S.Array(schema)),
             provideRctx
           )
 
@@ -104,7 +103,13 @@ export function makeRepoInternal<
               allE,
               (_) => decodeMany(_).pipe(Effect.orDie)
             )
-            .pipe(Effect.map((_) => _ as T[]))
+            .pipe(
+              Effect.map((_) => _ as T[]),
+              Effect.withSpan("Repository.all", {
+                kind: "client",
+                attributes: { "app.entity": name }
+              }, { captureStackTrace: false })
+            )
 
           const fieldsSchema = schema as unknown as { fields: any }
           // assumes the id field never needs a service...
@@ -113,11 +118,14 @@ export function makeRepoInternal<
               let ast = _.ast
               if (ast._tag === "Declaration") ast = ast.typeParameters[0]!
 
-              // In v4, to get the encoded (from) side of a schema, use SchemaAST.toEncoded
               const pickIdFromAst = (a: SchemaAST.AST) => {
-                const encoded = SchemaAST.toEncoded(a)
-                if (SchemaAST.isObjects(encoded)) {
-                  const field = encoded.propertySignatures.find((_) => _.name === idKey)
+                // Unwrap Declaration (e.g. TaggedClass) to get the underlying Objects AST
+                let inner = a
+                if (inner._tag === "Declaration") inner = inner.typeParameters[0]!
+                // Pick from the original AST to preserve the full encoding chain (e.g. decodeTo transformations).
+                // Using toEncoded would lose transformation info needed to encode Type -> Encoded.
+                if (SchemaAST.isObjects(inner)) {
+                  const field = inner.propertySignatures.find((_) => _.name === idKey)
                   if (field) {
                     return S.Struct({ [idKey]: S.make(field.type) }) as unknown as Codec<T, Encoded>
                   }
@@ -138,7 +146,7 @@ export function makeRepoInternal<
               Effect.map((_: Record<string, unknown>) => _[idKey as string] as Encoded[IdKey])
             )
           const findEId = Effect.fnUntraced(function*(id: Encoded[IdKey]) {
-            yield* Effect.annotateCurrentSpan({ itemId: id })
+            yield* Effect.annotateCurrentSpan({ "app.entity.id": id })
 
             return yield* Effect.flatMap(
               store.find(id),
@@ -151,7 +159,7 @@ export function makeRepoInternal<
           })
           // TODO: select the particular field, instead of as struct
           const findE = Effect.fnUntraced(function*(id: T[IdKey]) {
-            yield* Effect.annotateCurrentSpan({ itemId: id })
+            yield* Effect.annotateCurrentSpan({ "app.entity.id": id })
 
             return yield* pipe(
               encodeId({ [idKey]: id } as any),
@@ -161,9 +169,11 @@ export function makeRepoInternal<
             )
           })
 
-          const find = Effect.fn("find")(function*(id: T[IdKey]) {
-            yield* Effect.annotateCurrentSpan({ itemId: id })
-
+          const find = Effect.fn("Repository.find", {
+            kind: "client",
+            attributes: { "app.entity": name }
+          })(function*(id: T[IdKey]) {
+            yield* Effect.annotateCurrentSpan({ "app.entity.id": id })
             return yield* flatMapOption(findE(id), (_) => Effect.orDie(decode(_)))
           })
 
@@ -188,73 +198,96 @@ export function makeRepoInternal<
                 Effect.andThen(saveAllE)
               )
 
-          const saveAndPublish = Effect.fn("saveAndPublish")(function*(items: Iterable<T>, events: Iterable<Evt> = []) {
-            const it = Chunk.fromIterable(items)
-            const evts = [...events]
-            yield* Effect.annotateCurrentSpan({ itemIds: [...Chunk.map(it, (_) => _[idKey])], events: evts.length })
-            return yield* saveAll(it)
-              .pipe(
-                Effect.andThen(Effect.sync(() => toNonEmptyArray(evts))),
-                // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
-                (_) => flatMapOption(_, pub),
-                Effect.andThen(PubSub.publish(changeFeed, [Chunk.toArray(it), "save"] as [T[], "save" | "remove"])),
-                Effect.asVoid
-              )
-          })
+          const saveAndPublish = Effect.fn("Repository.saveAndPublish", { attributes: { "app.entity": name } })(
+            function*(items: Iterable<T>, events: Iterable<Evt> = []) {
+              const it = Chunk.fromIterable(items)
+              const evts = [...events]
+              yield* Effect.annotateCurrentSpan({
+                "app.entity.ids": Chunk.map(it, (_) => _[idKey]),
+                "app.event.count": evts.length
+              })
+              return yield* saveAll(it)
+                .pipe(
+                  Effect.andThen(Effect.sync(() => toNonEmptyArray(evts))),
+                  // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
+                  (_) => flatMapOption(_, pub),
+                  Effect.andThen(PubSub.publish(changeFeed, [Chunk.toArray(it), "save"] as [T[], "save" | "remove"])),
+                  Effect.asVoid
+                )
+            }
+          )
 
-          const removeAndPublish = Effect.fn("removeAndPublish")(function*(a: Iterable<T>, events: Iterable<Evt> = []) {
-            const { set } = yield* cms
-            const it = [...a]
-            const evts = [...events]
-            yield* Effect.annotateCurrentSpan({ itemIds: it.map((_) => _[idKey]), eventCount: evts.length })
-            const items = yield* encodeMany(it).pipe(Effect.orDie)
-            if (Array.isReadonlyArrayNonEmpty(items)) {
-              yield* store.batchRemove(
-                items.map((_) => (_[idKey])),
-                args.config?.partitionValue?.(items[0])
-              )
-              for (const e of items) {
-                set(e[idKey], undefined)
+          const removeAndPublish = Effect.fn("Repository.removeAndPublish", { attributes: { "app.entity": name } })(
+            function*(a: Iterable<T>, events: Iterable<Evt> = []) {
+              const { set } = yield* cms
+              const it = [...a]
+              const evts = [...events]
+              yield* Effect.annotateCurrentSpan({
+                "app.entity.ids": it.map((_) => _[idKey]),
+                "app.event.count": evts.length
+              })
+              const items = yield* encodeMany(it).pipe(Effect.orDie)
+              if (Array.isReadonlyArrayNonEmpty(items)) {
+                yield* store.batchRemove(
+                  items.map((_) => (_[idKey])),
+                  args.config?.partitionValue?.(items[0])
+                )
+                for (const e of items) {
+                  set(e[idKey], undefined)
+                }
+                yield* Effect
+                  .sync(() => toNonEmptyArray(evts))
+                  // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
+                  .pipe((_) => flatMapOption(_, pub))
+
+                yield* PubSub.publish(changeFeed, [it, "remove"] as [T[], "save" | "remove"])
               }
-              yield* Effect
-                .sync(() => toNonEmptyArray(evts))
-                // TODO: for full consistency the events should be stored within the same database transaction, and then picked up.
-                .pipe((_) => flatMapOption(_, pub))
+            }
+          )
 
-              yield* PubSub.publish(changeFeed, [it, "remove"] as [T[], "save" | "remove"])
+          const removeById = Effect.fn("Repository.removeById", { attributes: { "app.entity": name } })(
+            function*(idOrIds: T[IdKey] | ReadonlyArray<T[IdKey]>) {
+              const ids = globalThis.Array.isArray(idOrIds)
+                ? idOrIds as readonly T[IdKey][]
+                : [idOrIds as T[IdKey]]
+              if (!Array.isReadonlyArrayNonEmpty(ids)) {
+                return
+              }
+              const { set } = yield* cms
+              const eids = yield* Effect.forEach(ids, (_) => encodeIdOnly(_ as any)).pipe(Effect.orDie)
+              yield* Effect.annotateCurrentSpan({ "app.entity.ids": eids })
+              yield* store.batchRemove(eids)
+              for (const id of eids) {
+                set(id, undefined)
+              }
+              yield* PubSub.publish(changeFeed, [[], "remove"] as [T[], "save" | "remove"])
             }
-          })
+          )
 
-          const removeById = Effect.fn("removeById")(function*(...ids: readonly T[IdKey][]) {
-            if (!Array.isReadonlyArrayNonEmpty(ids)) {
-              return
+          const parseMany = Effect.fn("parseMany", { attributes: { "app.entity": name } })(
+            function*(items: readonly PM[]) {
+              const cm = yield* cms
+              return yield* decodeMany(items.map((_) => mapReverse(_, cm.set))).pipe(Effect.orDie)
             }
-            const { set } = yield* cms
-            const eids = yield* Effect.forEach(ids, (_) => encodeIdOnly(_ as any)).pipe(Effect.orDie)
-            yield* Effect.annotateCurrentSpan({ itemIds: eids })
-            yield* store.batchRemove(eids)
-            for (const id of eids) {
-              set(id, undefined)
+          )
+          const decodeManyCache = new WeakMap<
+            S.Codec<any, any, any>,
+            (i: readonly any[]) => Effect.Effect<any, any, any>
+          >()
+          const getDecodeMany = (s: S.Codec<any, Encoded, any>) => {
+            let dec = decodeManyCache.get(s)
+            if (!dec) {
+              dec = S.decodeEffectConcurrently(S.Array(s))
+              decodeManyCache.set(s, dec)
             }
-            yield* PubSub.publish(changeFeed, [[], "remove"] as [T[], "save" | "remove"])
-          })
-
-          const parseMany = (items: readonly PM[]) =>
-            Effect
-              .flatMap(cms, (cm) =>
-                decodeMany(items.map((_) => mapReverse(_, cm.set)))
-                  .pipe(Effect.orDie, Effect.withSpan("parseMany", {}, { captureStackTrace: false })))
-          const parseMany2 = <A, R>(
-            items: readonly PM[],
-            schema: S.Codec<A, Encoded, R>
-          ) =>
-            Effect
-              .flatMap(cms, (cm) =>
-                S
-                  .decodeEffect(S.Array(schema))(
-                    items.map((_) => mapReverse(_, cm.set))
-                  )
-                  .pipe(Effect.orDie, Effect.withSpan("parseMany2", {}, { captureStackTrace: false })))
+            return dec
+          }
+          const parseMany2 = Effect.fn("parseMany2", { attributes: { "app.entity": name } })(
+            function*<A, R>(items: readonly PM[], schema: S.Codec<A, Encoded, R>) {
+              const cm = yield* cms
+              return yield* getDecodeMany(schema)(items.map((_) => mapReverse(_, cm.set))).pipe(Effect.orDie)
+            }
+          )
           const filter = <U extends keyof Encoded = keyof Encoded>(args: FilterArgs<Encoded, U>) =>
             store
               .filter(
@@ -276,24 +309,28 @@ export function makeRepoInternal<
           const query: {
             <A, R, From extends FieldValues>(
               q: Q.QueryProjection<Encoded extends From ? From : never, A, R>
-            ): Effect.Effect<readonly A[], S.SchemaError, R>
+            ): Effect.Effect<readonly A[], S.SchemaError, Exclude<R, RCtx>>
             <A, R, EncodedRefined extends Encoded = Encoded>(
               q: Q.QAll<NoInfer<Encoded>, NoInfer<EncodedRefined>, A, R>
-            ): Effect.Effect<readonly A[], never, R>
+            ): Effect.Effect<readonly A[], never, Exclude<R, RCtx>>
           } = (<A, R, EncodedRefined extends Encoded = Encoded>(q: Q.QAll<Encoded, EncodedRefined, A, R>) => {
-            const a = Q.toFilter(q)
+            const a = Q.toFilter(q, schema)
+            // Mode dispatch — see `Q.project` JSDoc for the contract:
+            //   project  : decode raw encoded rows with schema; no PM reverse-mapping; SchemaError surfaces.
+            //   collect  : same as project, but schema yields Option and None rows are dropped.
+            //   transform: PM reverse-map (re-inject _etag/PM state from cms cache) then decode; orDie.
             const eff = a.mode === "project"
               ? filter(a)
                 // TODO: mapFrom but need to support per field and dependencies
                 .pipe(
-                  Effect.andThen(flow(S.decodeEffect(S.Array(a.schema ?? schema)), provideRctx))
+                  Effect.andThen(flow(S.decodeEffectConcurrently(S.Array(a.schema ?? schema)), provideRctx))
                 )
               : a.mode === "collect"
               ? filter(a)
                 // TODO: mapFrom but need to support per field and dependencies
                 .pipe(
                   Effect.flatMap(flow(
-                    S.decodeEffect(S.Array(a.schema)),
+                    S.decodeEffectConcurrently(S.Array(a.schema)),
                     Effect.map(Array.getSomes),
                     provideRctx
                   ))
@@ -325,72 +362,89 @@ export function makeRepoInternal<
                   .map(eff, (_) => NonNegativeInt(_.length))
                   .pipe(Effect.catchTag("SchemaError", (e) => Effect.die(e)))
                 : eff,
-              Effect.withSpan("Repository.query [effect-app/infra]", {
-                attributes: {
-                  "repository.model_name": name,
-                  query: { ...a, schema: a.schema ? "__SCHEMA__" : a.schema, filter: a.filter }
-                }
+              Effect.tap((r) =>
+                Effect.annotateCurrentSpan({
+                  "app.query.ttype": a.ttype,
+                  "app.query.mode": a.mode,
+                  "db.response.returned_rows": Array.isArray(r) ? r.length : 1
+                })
+              ),
+              Effect.withSpan("Repository.query", {
+                kind: "client",
+                attributes: { "app.entity": name }
               }, { captureStackTrace: false })
             )
           }) as any
 
-          const validateSample = Effect.fn("validateSample")(function*(options?: {
-            percentage?: number
-            maxItems?: number
-          }) {
-            const percentage = options?.percentage ?? 0.1 // default 10%
-            const maxItems = options?.maxItems
-
-            // 1. get all IDs with projection (bypasses main schema decode)
-            const allIds = yield* store.filter({
-              t: null as unknown as Encoded,
-              select: [idKey as keyof Encoded]
-            })
-
-            // 2. random subset
-            const shuffled = [...allIds].sort(() => Math.random() - 0.5)
-            const sampleSize = Math.min(
-              maxItems ?? Infinity,
-              Math.ceil(allIds.length * percentage)
-            )
-            const sample = shuffled.slice(0, sampleSize)
-
-            // 3. validate each item
-            const errors: ValidationError[] = []
-
-            for (const item of sample) {
-              const id = item[idKey]
-              const rawResult = yield* store.find(id)
-
-              if (Option.isNone(rawResult)) continue
+          const validateSample = Effect.fn("Repository.validateSample", { attributes: { "app.entity": name } })(
+            function*(options?: {
+              percentage?: number
+              maxItems?: number
+            }) {
+              const percentage = options?.percentage ?? 0.1 // default 10%
+              const maxItems = options?.maxItems
+
+              // 1. get all IDs with projection (bypasses main schema decode)
+              const allIds = yield* store
+                .filter({
+                  t: null as unknown as Encoded,
+                  select: [idKey as keyof Encoded]
+                })
+                .pipe(Effect.withSpan("Repository.filter", {
+                  kind: "client",
+                  attributes: { "app.entity": name }
+                }, { captureStackTrace: false }))
+
+              // 2. random subset
+              const shuffled = [...allIds].sort(() => Math.random() - 0.5)
+              const sampleSize = Math.min(
+                maxItems ?? Infinity,
+                Math.ceil(allIds.length * percentage)
+              )
+              const sample = shuffled.slice(0, sampleSize)
+
+              // 3. validate each item
+              const errors: ValidationError[] = []
+
+              for (const item of sample) {
+                const id = item[idKey]
+                const rawResult = yield* store.find(id).pipe(
+                  Effect.withSpan("Repository.find", {
+                    kind: "client",
+                    attributes: { "app.entity": name, "app.entity.id": id }
+                  }, { captureStackTrace: false })
+                )
 
-              const rawData = rawResult.value as Encoded
-              const jitMResult = mapFrom(rawData) // apply jitM
+                if (Option.isNone(rawResult)) continue
 
-              const decodeResult = yield* S.decodeEffect(schema)(jitMResult).pipe(
-                Effect.result,
-                provideRctx
-              )
+                const rawData = rawResult.value as Encoded
+                const jitMResult = mapFrom(rawData) // apply jitM
 
-              if (Result.isFailure(decodeResult)) {
-                errors.push(
-                  new ValidationError({
-                    id,
-                    rawData,
-                    jitMResult,
-                    error: decodeResult.failure
-                  })
+                const decodeResult = yield* S.decodeEffectConcurrently(schema)(jitMResult).pipe(
+                  Effect.result,
+                  provideRctx
                 )
+
+                if (Result.isFailure(decodeResult)) {
+                  errors.push(
+                    ValidationError.make({
+                      id,
+                      rawData,
+                      jitMResult,
+                      error: decodeResult.failure
+                    })
+                  )
+                }
               }
-            }
 
-            return new ValidationResult({
-              total: NonNegativeInt(allIds.length),
-              sampled: NonNegativeInt(sample.length),
-              valid: NonNegativeInt(sample.length - errors.length),
-              errors
-            })
-          })
+              return ValidationResult.make({
+                total: NonNegativeInt(allIds.length),
+                sampled: NonNegativeInt(sample.length),
+                valid: NonNegativeInt(sample.length - errors.length),
+                errors
+              })
+            }
+          )
 
           const r = {
             changeFeed,
@@ -401,10 +455,17 @@ export function makeRepoInternal<
             saveAndPublish,
             removeAndPublish,
             removeById,
+            seedNamespace: (namespace: string) => store.seedNamespace(namespace),
             validateSample,
             queryRaw<A, Out, QR>(schema: S.Codec<A, Out, QR>, q: Q.RawQuery<Encoded, Out>) {
-              const dec = S.decodeEffect(S.Array(schema))
-              return store.queryRaw(q).pipe(Effect.flatMap(dec))
+              const dec = S.decodeEffectConcurrently(S.Array(schema))
+              return store.queryRaw(q).pipe(
+                Effect.flatMap(dec),
+                Effect.withSpan("Repository.queryRaw", {
+                  kind: "client",
+                  attributes: { "app.entity": name }
+                }, { captureStackTrace: false })
+              )
             },
             query(q: any) {
               // eslint-disable-next-line prefer-rest-params
@@ -414,15 +475,23 @@ export function makeRepoInternal<
              * @internal
              */
             mapped: <A, R>(schema: S.Codec<A, any, R>) => {
-              const dec = S.decodeEffect(schema)
+              const dec = S.decodeEffectConcurrently(schema)
               const encMany = S.encodeEffect(S.Array(schema))
-              const decMany = S.decodeEffect(S.Array(schema))
+              const decMany = S.decodeEffectConcurrently(S.Array(schema))
+              const spanAttrs = { kind: "client" as const, attributes: { "app.entity": name } }
               return {
                 all: allE.pipe(
                   Effect.flatMap(decMany),
-                  Effect.map((_) => _ as any[])
+                  Effect.map((_) => _ as any[]),
+                  Effect.withSpan("Repository.mapped.all", spanAttrs, { captureStackTrace: false })
                 ),
-                find: (id: T[IdKey]) => flatMapOption(findE(id), dec),
+                find: (id: T[IdKey]) =>
+                  flatMapOption(findE(id), dec).pipe(
+                    Effect.withSpan("Repository.mapped.find", {
+                      ...spanAttrs,
+                      attributes: { ...spanAttrs.attributes, "app.entity.id": id }
+                    }, { captureStackTrace: false })
+                  ),
                 // query: (q: any) => {
                 //   const a = Q.toFilter(q)
 
@@ -441,12 +510,12 @@ export function makeRepoInternal<
                 // },
                 save: (...xes: any[]) =>
                   Effect.flatMap(encMany(xes), (_) => saveAllE(_)).pipe(
-                    Effect.withSpan("mapped.save", {}, { captureStackTrace: false })
+                    Effect.withSpan("Repository.mapped.save", spanAttrs, { captureStackTrace: false })
                   )
               }
             }
           }
-          return r as Repository<T, Encoded, Evt, ItemType, IdKey, Exclude<R, RCtx>, RPublish>
+          return r as Repository<T, Encoded, Evt, ItemType, IdKey, Exclude<R, RCtx>, RPublish, RCtx>
         })
         .pipe(Effect
           // .withSpan("Repository.make [effect-app/infra]", { attributes: { "repository.model_name": name } })
@@ -513,7 +582,7 @@ export function makeStore<Encoded extends FieldValues>() {
               .pipe(
                 Effect.flatMap(Effect.forEach(encodeToEncoded())),
                 setupRequestContextFromCurrent("Repository.makeInitial [effect-app/infra]", {
-                  attributes: { "repository.model_name": name }
+                  attributes: { "app.entity": name }
                 })
               )
             : undefined,

package/src/Model/Repository/makeRepo.ts

@@ -5,13 +5,13 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 // import type { ParserEnv } from "effect-app/Schema/custom/Parser"
-import type {} from "effect/Equal"
-import type {} from "effect/Hash"
-import { Effect, type NonEmptyReadonlyArray, type S, type ServiceMap } from "effect-app"
+
+import { type Context, Effect, type NonEmptyReadonlyArray, type S } from "effect-app"
 import type { StoreConfig, StoreMaker } from "../../Store.js"
 import type { FieldValues } from "../filter/types.js"
 import { type ExtendedRepository, extendRepo } from "./ext.js"
 import { makeRepoInternal } from "./internal/internal.js"
+import { RepositoryRegistry } from "./Registry.js"
 import type { Repository } from "./service.js"
 
 export interface RepositoryOptions<
@@ -52,11 +52,11 @@ export interface RepositoryOptions<
    * Optional context to be provided to Schema decode/encode.
    * Useful for effectful transformations like XWithItems, where items is a transformation retrieving elements from another database table or other source.
    */
-  schemaContext?: ServiceMap.ServiceMap<RCtx>
+  schemaContext?: Context.Context<RCtx>
 
   overrides?: (
-    repo: Repository<T, Encoded, Evt, ItemType, IdKey, Exclude<RSchema, RCtx>, RPublish>
-  ) => Repository<T, Encoded, Evt, ItemType, IdKey, Exclude<RSchema, RCtx>, RPublish>
+    repo: Repository<T, Encoded, Evt, ItemType, IdKey, Exclude<RSchema, RCtx>, RPublish, RCtx>
+  ) => Repository<T, Encoded, Evt, ItemType, IdKey, Exclude<RSchema, RCtx>, RPublish, RCtx>
 }
 
 /**
@@ -83,9 +83,9 @@ export const makeRepo: {
     schema: S.Codec<T, Encoded, RSchema>,
     options: RepositoryOptions<IdKey, Encoded, T, ItemType, Evt, RPublish, E, RInitial, RCtx, RSchema>
   ): Effect.Effect<
-    ExtendedRepository<T, Encoded, Evt, ItemType, IdKey, Exclude<RSchema, RCtx>, RPublish>,
+    ExtendedRepository<T, Encoded, Evt, ItemType, IdKey, Exclude<RSchema, RCtx>, RPublish, RCtx>,
     E,
-    RInitial | StoreMaker
+    RInitial | StoreMaker | RepositoryRegistry
   >
   <
     ItemType extends string,
@@ -102,9 +102,9 @@ export const makeRepo: {
     schema: S.Codec<T, Encoded, RSchema>,
     options: Omit<RepositoryOptions<"id", Encoded, T, ItemType, Evt, RPublish, E, RInitial, RCtx, RSchema>, "idKey">
   ): Effect.Effect<
-    ExtendedRepository<T, Encoded, Evt, ItemType, "id", Exclude<RSchema, RCtx>, RPublish>,
+    ExtendedRepository<T, Encoded, Evt, ItemType, "id", Exclude<RSchema, RCtx>, RPublish, RCtx>,
     E,
-    RInitial | StoreMaker
+    RInitial | StoreMaker | RepositoryRegistry
   >
 } = <
   ItemType extends string,
@@ -135,5 +135,7 @@ export const makeRepo: {
     let r = yield* mkRepo.make<RInitial, E, RPublish, RCtx>(options as any)
     if (options.overrides) r = options.overrides(r)
     const repo = extendRepo(r)
+    const registry = yield* RepositoryRegistry
+    registry.register(itemType, repo)
     return repo
   })