dfx 0.51.0 → 0.51.2

package/src/Interactions/gateway.ts

@@ -1,12 +1,26 @@
 import * as Http from "@effect-http/client"
+import * as Chunk from "@effect/data/Chunk"
+import { Tag } from "@effect/data/Context"
+import * as Duration from "@effect/data/Duration"
+import { pipe } from "@effect/data/Function"
+import type { Cause } from "@effect/io/Cause"
+import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
+import * as Queue from "@effect/io/Queue"
+import * as Ref from "@effect/io/Ref"
 import { DiscordGateway } from "dfx/DiscordGateway"
-import { DiscordREST, DiscordRESTError } from "dfx/DiscordREST"
-import { DefinitionNotFound, handlers } from "./handlers.js"
-import { Interaction, InteractionBuilder, builder } from "./index.js"
+import type { DiscordRESTError } from "dfx/DiscordREST"
+import { DiscordREST } from "dfx/DiscordREST"
 import type {
   GlobalApplicationCommand,
   GuildApplicationCommand,
-} from "./definitions.js"
+} from "dfx/Interactions/definitions"
+import type { DefinitionNotFound } from "dfx/Interactions/handlers"
+import { handlers } from "dfx/Interactions/handlers"
+import type { InteractionBuilder } from "dfx/Interactions/index"
+import { Interaction, builder } from "dfx/Interactions/index"
+import type * as Discord from "dfx/types"
+import * as EffectUtils from "dfx/utils/Effect"
 
 export interface RunOpts {
   sync?: boolean
@@ -18,47 +32,50 @@ export interface RunOpts {
 export const run =
   <R, R2, E, TE, E2>(
     postHandler: (
-      effect: Effect<
+      effect: Effect.Effect<
         R | DiscordREST | Discord.Interaction,
         TE | DiscordRESTError | DefinitionNotFound,
         void
       >,
-    ) => Effect<R2, E2, void>,
+    ) => Effect.Effect<R2, E2, void>,
     { sync = true }: RunOpts = {},
   ) =>
   (
     ix: InteractionBuilder<R, E, TE>,
-  ): Effect<
+  ): Effect.Effect<
     DiscordREST | DiscordGateway | Exclude<R2, Discord.Interaction>,
     E2 | DiscordRESTError | Http.ResponseDecodeError,
     never
   > =>
-    Do($ => {
-      const GlobalApplicationCommand = ix.definitions
-        .map(_ => _[0])
-        .filter(
+    Effect.gen(function* (_) {
+      const GlobalApplicationCommand = ix.definitions.pipe(
+        Chunk.map(_ => _[0]),
+        Chunk.filter(
           (_): _ is GlobalApplicationCommand<R, E> =>
             _._tag === "GlobalApplicationCommand",
-        ).toReadonlyArray
-      const GuildApplicationCommand = ix.definitions
-        .map(_ => _[0])
-        .filter(
+        ),
+        Chunk.toReadonlyArray,
+      )
+      const GuildApplicationCommand = ix.definitions.pipe(
+        Chunk.map(_ => _[0]),
+        Chunk.filter(
           (_): _ is GuildApplicationCommand<R, E> =>
             _._tag === "GuildApplicationCommand",
-        ).toReadonlyArray
+        ),
+        Chunk.toReadonlyArray,
+      )
 
-      const gateway = $(DiscordGateway.accessWith(identity))
-      const rest = $(DiscordREST.accessWith(identity))
+      const gateway = yield* _(DiscordGateway)
+      const rest = yield* _(DiscordREST)
 
-      const application = $(
-        rest.getCurrentBotApplicationInformation().flatMap(a => a.json),
+      const application = yield* _(
+        rest.getCurrentBotApplicationInformation(),
+        Effect.flatMap(a => a.json),
       )
 
       const globalSync = rest.bulkOverwriteGlobalApplicationCommands(
         application.id,
-        {
-          body: Http.body.json(GlobalApplicationCommand.map(_ => _.command)),
-        },
+        { body: Http.body.json(GlobalApplicationCommand.map(_ => _.command)) },
       )
 
       const guildSync = GuildApplicationCommand.length
@@ -76,54 +93,62 @@ export const run =
       )
 
       const run = gateway.handleDispatch("INTERACTION_CREATE", i =>
-        postHandler(handle[i.type](i)).provideService(Interaction, i),
+        Effect.provideService(postHandler(handle[i.type](i)), Interaction, i),
       )
 
-      return $(
+      return yield* _(
         sync
-          ? Effect.all(run, globalSync, guildSync, {
-              concurrency: "unbounded",
-              discard: true,
-            }).forever
+          ? Effect.forever(
+              Effect.all(run, globalSync, guildSync, {
+                concurrency: "unbounded",
+                discard: true,
+              }),
+            )
           : run,
       )
     })
 
-const makeRegistry = Do($ => {
-  const ref = $(Ref.make(builder as InteractionBuilder<never, never, never>))
-  const queue = $(Queue.sliding<InteractionBuilder<never, never, never>>(1))
+const makeRegistry = Effect.gen(function* (_) {
+  const ref = yield* _(
+    Ref.make(builder as InteractionBuilder<never, never, never>),
+  )
+  const queue = yield* _(
+    Queue.sliding<InteractionBuilder<never, never, never>>(1),
+  )
 
   const register = <E>(ix: InteractionBuilder<never, E, never>) =>
-    ref.updateAndGet(_ => _.concat(ix as any)).flatMap(_ => queue.offer(_))
+    Effect.flatMap(
+      Ref.updateAndGet(ref, _ => _.concat(ix as any)),
+      _ => Queue.offer(queue, _),
+    )
 
-  const run = <R, E>(
+  const run_ = <R, E>(
     onError: (
       _: Cause<DiscordRESTError | DefinitionNotFound>,
-    ) => Effect<R, E, void>,
+    ) => Effect.Effect<R, E, void>,
     opts?: RunOpts,
   ) =>
-    queue
-      .take()
-      .foreverSwitch(ix =>
-        ix
-          .runGateway(_ => _.catchAllCause(onError), opts)
-          .delay(Duration.seconds(0.1)),
-      )
-
-  return { register, run } as const
+    EffectUtils.foreverSwitch(Queue.take(queue), ix =>
+      Effect.delay(
+        pipe(ix, run(Effect.catchAllCause(onError), opts)),
+        Duration.seconds(0.1),
+      ),
+    )
+
+  return { register, run: run_ } as const
 })
 
 export interface InteractionsRegistry {
   readonly register: <E>(
     ix: InteractionBuilder<never, E, never>,
-  ) => Effect<never, never, void>
+  ) => Effect.Effect<never, never, void>
 
   readonly run: <R, E>(
     onError: (
       _: Cause<DiscordRESTError | DefinitionNotFound>,
-    ) => Effect<R, E, void>,
+    ) => Effect.Effect<R, E, void>,
     opts?: RunOpts,
-  ) => Effect<
+  ) => Effect.Effect<
     DiscordREST | DiscordGateway | Exclude<R, Discord.Interaction>,
     DiscordRESTError | Http.ResponseDecodeError | E,
     never

package/src/Interactions/handlers.ts

@@ -1,30 +1,34 @@
+import * as Chunk from "@effect/data/Chunk"
+import * as Option from "@effect/data/Option"
+import * as Effect from "@effect/io/Effect"
 import * as IxHelpers from "dfx/Helpers/interactions"
-import * as Ctx from "./context.js"
-import * as D from "./definitions.js"
-import { flattenDefinitions, splitDefinitions } from "./utils.js"
+import * as Ctx from "dfx/Interactions/context"
+import * as D from "dfx/Interactions/definitions"
+import { flattenDefinitions, splitDefinitions } from "dfx/Interactions/utils"
+import * as Discord from "dfx/types"
 
 export class DefinitionNotFound {
   readonly _tag = "DefinitionNotFound"
   constructor(readonly interaction: Discord.Interaction) {}
 }
 
-type Handler<R, E, A> = Effect<
+type Handler<R, E, A> = Effect.Effect<
   R | Discord.Interaction,
   E | DefinitionNotFound,
   A
 >
 
 export const handlers = <R, E, TE, A, B>(
-  definitions: Chunk<
+  definitions: Chunk.Chunk<
     readonly [
       handler: D.InteractionDefinition<R, E>,
-      transform: (self: Effect<R, E, A>) => Effect<R, TE, B>,
+      transform: (self: Effect.Effect<R, E, A>) => Effect.Effect<R, TE, B>,
     ]
   >,
   handleResponse: (
     ix: Discord.Interaction,
     _: Discord.InteractionResponse,
-  ) => Effect<R, E, A>,
+  ) => Effect.Effect<R, E, A>,
 ): Record<
   Discord.InteractionType,
   (i: Discord.Interaction) => Handler<R, E, B>
@@ -43,68 +47,81 @@ export const handlers = <R, E, TE, A, B>(
     [Discord.InteractionType.APPLICATION_COMMAND]: i => {
       const data = i.data as Discord.ApplicationCommandDatum
 
-      return Maybe.fromNullable(Commands[data.name]).match({
+      return Option.match(Option.fromNullable(Commands[data.name]), {
         onNone: () => Effect.fail(new DefinitionNotFound(i)),
         onSome: command =>
-          command
-            .handle(i)
-            .provideService(Ctx.ApplicationCommand, data) as Handler<R, E, B>,
+          Effect.provideService(
+            command.handle(i),
+            Ctx.ApplicationCommand,
+            data,
+          ) as Handler<R, E, B>,
       })
     },
 
     [Discord.InteractionType.MODAL_SUBMIT]: i => {
       const data = i.data as Discord.ModalSubmitDatum
 
-      return ModalSubmit.findFirst(_ => _.predicate(data.custom_id)).flatMap(
-        _ =>
-          _.match({
+      return Effect.findFirst(ModalSubmit, _ =>
+        _.predicate(data.custom_id),
+      ).pipe(
+        Effect.flatMap(
+          Option.match({
             onNone: () => Effect.fail(new DefinitionNotFound(i)),
             onSome: match =>
-              match
-                .handle(i)
-                .provideService(Ctx.ModalSubmitData, data) as Handler<R, E, B>,
+              Effect.provideService(
+                match.handle(i),
+                Ctx.ModalSubmitData,
+                data,
+              ) as Handler<R, E, B>,
           }),
+        ),
       )
     },
 
     [Discord.InteractionType.MESSAGE_COMPONENT]: i => {
       const data = i.data as Discord.MessageComponentDatum
 
-      return MessageComponent.findFirst(_ =>
+      return Effect.findFirst(MessageComponent, _ =>
         _.predicate(data.custom_id),
-      ).flatMap(_ =>
-        _.match({
-          onNone: () => Effect.fail(new DefinitionNotFound(i)),
-          onSome: match =>
-            match
-              .handle(i)
-              .provideService(Ctx.MessageComponentData, data) as Handler<
-              R,
-              E,
-              B
-            >,
-        }),
+      ).pipe(
+        Effect.flatMap(
+          Option.match({
+            onNone: () => Effect.fail(new DefinitionNotFound(i)),
+            onSome: match =>
+              Effect.provideService(
+                match.handle(i),
+                Ctx.MessageComponentData,
+                data,
+              ) as Handler<R, E, B>,
+          }),
+        ),
       )
     },
 
     [Discord.InteractionType.APPLICATION_COMMAND_AUTOCOMPLETE]: i => {
       const data = i.data as Discord.ApplicationCommandDatum
 
-      return IxHelpers.focusedOption(data).match({
+      return Option.match(IxHelpers.focusedOption(data), {
         onNone: () => Effect.fail(new DefinitionNotFound(i)),
         onSome: focusedOption =>
-          Autocomplete.findFirst(_ => _.predicate(data, focusedOption)).flatMap(
-            _ =>
-              _.match({
+          Effect.findFirst(Autocomplete, _ =>
+            _.predicate(data, focusedOption),
+          ).pipe(
+            Effect.flatMap(
+              Option.match({
                 onNone: () => Effect.fail(new DefinitionNotFound(i)),
                 onSome: match =>
-                  match
-                    .handle(i)
-                    .provideService(Ctx.ApplicationCommand, data)
-                    .provideService(Ctx.FocusedOptionContext, {
+                  Effect.provideService(
+                    match.handle(i),
+                    Ctx.ApplicationCommand,
+                    data,
+                  ).pipe(
+                    Effect.provideService(Ctx.FocusedOptionContext, {
                       focusedOption,
-                    }) as Handler<R, E, B>,
+                    }),
+                  ) as Handler<R, E, B>,
               }),
+            ),
           ),
       })
     },

package/src/Interactions/index.ts

@@ -1,8 +1,9 @@
-import { Discord, Effect } from "dfx/_common"
+import * as Effect from "@effect/io/Effect"
+import type * as Discord from "dfx/types"
 
-export { response } from "../Helpers/interactions.js"
-export * from "./builder.js"
-export * from "./context.js"
+export { response } from "dfx/Helpers/interactions"
+export * from "dfx/Interactions/builder"
+export * from "dfx/Interactions/context"
 export {
   InteractionDefinition,
   autocomplete,
@@ -10,7 +11,7 @@ export {
   guild,
   messageComponent,
   modalSubmit,
-} from "./definitions.js"
+} from "dfx/Interactions/definitions"
 
 // Filters
 export const id = (query: string) => (customId: string) =>

package/src/Interactions/utils.ts

@@ -1,5 +1,8 @@
-import * as D from "./definitions.js"
-import * as Ctx from "./context.js"
+import * as Chunk from "@effect/data/Chunk"
+import * as Effect from "@effect/io/Effect"
+import * as Ctx from "dfx/Interactions/context"
+import * as D from "dfx/Interactions/definitions"
+import * as Discord from "dfx/types"
 
 export type DefinitionFlattened<R, E, TE, A> = D.InteractionDefinition<
   R,
@@ -7,7 +10,7 @@ export type DefinitionFlattened<R, E, TE, A> = D.InteractionDefinition<
 > extends infer D
   ? {
       [K in keyof D]: K extends "handle"
-        ? (_: Discord.Interaction) => Effect<R, TE, A>
+        ? (_: Discord.Interaction) => Effect.Effect<R, TE, A>
         : D[K]
     }
   : never
@@ -26,31 +29,36 @@ const context: D.CommandHelper<any> = {
 } as any
 
 export const flattenDefinitions = <R, E, TE, A, B>(
-  definitions: Chunk<
+  definitions: Chunk.Chunk<
     readonly [
       handler: D.InteractionDefinition<R, E>,
-      transform: (self: Effect<R, E, A>) => Effect<R, TE, B>,
+      transform: (self: Effect.Effect<R, E, A>) => Effect.Effect<R, TE, B>,
     ]
   >,
   handleResponse: (
     ix: Discord.Interaction,
     _: Discord.InteractionResponse,
-  ) => Effect<R, E, A>,
+  ) => Effect.Effect<R, E, A>,
 ) =>
-  definitions.map(([definition, transform]) => ({
+  Chunk.map(definitions, ([definition, transform]) => ({
     ...definition,
     handle: (i: Discord.Interaction) =>
       Effect.isEffect(definition.handle)
-        ? transform(definition.handle.flatMap(_ => handleResponse(i, _)))
+        ? transform(
+            Effect.flatMap(definition.handle, _ => handleResponse(i, _)),
+          )
         : transform(
-            definition.handle(context).flatMap(_ => handleResponse(i, _)),
+            Effect.flatMap(definition.handle(context), _ =>
+              handleResponse(i, _),
+            ),
           ),
   }))
 
 export const splitDefinitions = <R, E, TE, A>(
-  definitions: Chunk<DefinitionFlattened<R, E, TE, A>>,
+  definitions: Chunk.Chunk<DefinitionFlattened<R, E, TE, A>>,
 ) => {
-  const grouped = definitions.reduce(
+  const grouped = Chunk.reduce(
+    definitions,
     {
       Autocomplete: Chunk.empty(),
       GlobalApplicationCommand: Chunk.empty(),
@@ -58,25 +66,28 @@ export const splitDefinitions = <R, E, TE, A>(
       MessageComponent: Chunk.empty(),
       ModalSubmit: Chunk.empty(),
     } as {
-      [K in D.InteractionDefinition<R, E>["_tag"]]: Chunk<
+      [K in D.InteractionDefinition<R, E>["_tag"]]: Chunk.Chunk<
         Extract<DefinitionFlattened<R, E, TE, A>, { _tag: K }>
       >
     },
     (acc, d) => ({
       ...acc,
-      [d._tag]: (acc[d._tag] as Chunk<any>).append(d),
+      [d._tag]: Chunk.append(acc[d._tag] as Chunk.Chunk<any>, d),
     }),
   )
 
-  const Commands = grouped.GlobalApplicationCommand.appendAll(
+  const Commands = Chunk.appendAll(
+    grouped.GlobalApplicationCommand,
     grouped.GuildApplicationCommand,
-  ).reduce(
-    {} as Record<string, DefinitionFlattenedCommand<R, E, TE, A>>,
-    (acc, d) =>
-      ({
-        ...acc,
-        [d.command.name]: d,
-      } as any),
+  ).pipe(
+    Chunk.reduce(
+      {} as Record<string, DefinitionFlattenedCommand<R, E, TE, A>>,
+      (acc, d) =>
+        ({
+          ...acc,
+          [d.command.name]: d,
+        } as any),
+    ),
   )
 
   return {

package/src/Interactions/webhook.ts

@@ -1,9 +1,18 @@
-import * as Verify from "discord-verify"
-import * as D from "./definitions.js"
-import { DefinitionNotFound, handlers } from "./handlers.js"
-import { InteractionBuilder, Interaction } from "./index.js"
+import * as Chunk from "@effect/data/Chunk"
+import { Tag } from "@effect/data/Context"
+import { identity } from "@effect/data/Function"
 import * as Option from "@effect/data/Option"
+import * as Cause from "@effect/io/Cause"
+import * as Config from "@effect/io/Config"
+import * as ConfigError from "@effect/io/Config/Error"
+import * as ConfigSecret from "@effect/io/Config/Secret"
 import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
+import * as D from "dfx/Interactions/definitions"
+import { DefinitionNotFound, handlers } from "dfx/Interactions/handlers"
+import { Interaction, InteractionBuilder } from "dfx/Interactions/index"
+import * as Discord from "dfx/types"
+import * as Verify from "discord-verify"
 
 export class BadWebhookSignature {
   readonly _tag = "BadWebhookSignature"
@@ -19,10 +28,10 @@ const checkSignature = (
   algorithm: any,
 ) =>
   Option.all({
-    signature: Maybe.fromNullable(headers["x-signature-ed25519"]),
-    timestamp: Maybe.fromNullable(headers["x-signature-timestamp"]),
-  })
-    .flatMap(_ =>
+    signature: Option.fromNullable(headers["x-signature-ed25519"]),
+    timestamp: Option.fromNullable(headers["x-signature-timestamp"]),
+  }).pipe(
+    Effect.flatMap(_ =>
       Effect.promise(() =>
         Verify.verify(
           body,
@@ -33,15 +42,17 @@ const checkSignature = (
           algorithm,
         ),
       ),
-    )
-    .filterOrFail(identity, () => new BadWebhookSignature())
-    .catchAllCause(() => Effect.fail(new BadWebhookSignature())).asUnit
+    ),
+    Effect.filterOrFail(identity, () => new BadWebhookSignature()),
+    Effect.catchAllCause(() => Effect.fail(new BadWebhookSignature())),
+    Effect.asUnit,
+  )
 
 export interface MakeConfigOpts {
-  applicationId: string
-  publicKey: ConfigSecret
-  crypto: SubtleCrypto
-  algorithm: keyof typeof Verify.PlatformAlgorithm
+  readonly applicationId: string
+  readonly publicKey: ConfigSecret.ConfigSecret
+  readonly crypto: SubtleCrypto
+  readonly algorithm: keyof typeof Verify.PlatformAlgorithm
 }
 const makeConfig = ({
   applicationId,
@@ -50,16 +61,22 @@ const makeConfig = ({
   algorithm,
 }: MakeConfigOpts) => ({
   applicationId,
-  publicKey: publicKey.value,
+  publicKey: ConfigSecret.value(publicKey),
   crypto,
   algorithm: Verify.PlatformAlgorithm[algorithm],
 })
+
 export interface WebhookConfig extends ReturnType<typeof makeConfig> {}
 export const WebhookConfig = Tag<WebhookConfig>()
+
 export const makeConfigLayer = (opts: MakeConfigOpts) =>
   Layer.succeed(WebhookConfig, makeConfig(opts))
-export const makeFromConfig = (a: Config<MakeConfigOpts>) =>
-  Layer.effect(WebhookConfig, a.config.map(makeConfig))
+
+export const makeFromConfig: (
+  a: Config.Config<MakeConfigOpts>,
+) => Layer.Layer<never, ConfigError.ConfigError, WebhookConfig> = (
+  a: Config.Config<MakeConfigOpts>,
+) => Layer.effect(WebhookConfig, Effect.map(Effect.config(a), makeConfig))
 
 export class WebhookParseError {
   readonly _tag = "WebhookParseError"
@@ -67,21 +84,19 @@ export class WebhookParseError {
 }
 
 const fromHeadersAndBody = (headers: Headers, body: string) =>
-  Do($ => {
-    const { publicKey, crypto, algorithm } = $(
-      WebhookConfig.accessWith(identity),
-    )
-    $(checkSignature(publicKey, headers, body, crypto, algorithm))
-    return $(
+  Effect.tap(WebhookConfig, ({ publicKey, crypto, algorithm }) =>
+    checkSignature(publicKey, headers, body, crypto, algorithm),
+  ).pipe(
+    Effect.flatMap(() =>
       Effect.try({
         try: () => JSON.parse(body) as Discord.Interaction,
         catch: reason => new WebhookParseError(reason),
       }),
-    )
-  })
+    ),
+  )
 
 const run = <R, E>(
-  definitions: Chunk<
+  definitions: Chunk.Chunk<
     readonly [
       handler: D.InteractionDefinition<R, E>,
       transform: (
@@ -96,30 +111,37 @@ const run = <R, E>(
 ) => {
   const handler = handlers(definitions, handleResponse)
   return (headers: Headers, body: string) =>
-    Do($ => {
-      const interaction = $(fromHeadersAndBody(headers, body))
-      return $(
-        handler[interaction.type](interaction).provideService(
-          Interaction,
-          interaction,
-        ),
-      )
-    })
+    Effect.flatMap(fromHeadersAndBody(headers, body), interaction =>
+      Effect.provideService(
+        handler[interaction.type](interaction),
+        Interaction,
+        interaction,
+      ),
+    )
 }
 
 export interface HandleWebhookOpts<E> {
   headers: Headers
   body: string
   success: (a: Discord.InteractionResponse) => Effect.Effect<never, never, void>
-  error: (e: Cause<E>) => Effect.Effect<never, never, void>
+  error: (e: Cause.Cause<E>) => Effect.Effect<never, never, void>
 }
 
 /**
  * @tsplus getter dfx/InteractionBuilder webhookHandler
  */
-export const makeHandler = <R, E, TE>(ix: InteractionBuilder<R, E, TE>) => {
+export const makeHandler = <R, E, TE>(
+  ix: InteractionBuilder<R, E, TE>,
+): (({
+  headers,
+  body,
+  success,
+  error,
+}: HandleWebhookOpts<
+  E | WebhookParseError | BadWebhookSignature | DefinitionNotFound
+>) => Effect.Effect<WebhookConfig, never, void>) => {
   const handle = run(
-    ix.definitions.map(([d]) => [d, identity] as any),
+    Chunk.map(ix.definitions, ([d]) => [d, identity] as any),
     (_i, r) => Effect.succeed(r),
   )
 
@@ -130,7 +152,11 @@ export const makeHandler = <R, E, TE>(ix: InteractionBuilder<R, E, TE>) => {
     error,
   }: HandleWebhookOpts<
     E | WebhookParseError | BadWebhookSignature | DefinitionNotFound
-  >) => handle(headers, body).flatMap(success).catchAllCause(error)
+  >): Effect.Effect<WebhookConfig, never, void> =>
+    handle(headers, body).pipe(
+      Effect.flatMap(success),
+      Effect.catchAllCause(error),
+    )
 }
 
 /**
@@ -138,9 +164,19 @@ export const makeHandler = <R, E, TE>(ix: InteractionBuilder<R, E, TE>) => {
  */
 export const makeSimpleHandler = <R, E, TE>(
   ix: InteractionBuilder<R, E, TE>,
-) => {
+): (({
+  headers,
+  body,
+}: {
+  headers: Headers
+  body: string
+}) => Effect.Effect<
+  WebhookConfig,
+  BadWebhookSignature | WebhookParseError | DefinitionNotFound,
+  Discord.InteractionResponse
+>) => {
   const handle = run(
-    ix.definitions.map(([d]) => [d, identity] as any),
+    Chunk.map(ix.definitions, ([d]) => [d, identity] as any),
     (_i, r) => Effect.succeed(r),
   )