dfx 0.77.3 → 0.79.0

package/src/DiscordREST.ts

@@ -4,7 +4,7 @@ import { millis } from "effect/Duration"
 import { pipe } from "effect/Function"
 import * as HashSet from "effect/HashSet"
 import * as Option from "effect/Option"
-import * as ConfigSecret from "effect/ConfigSecret"
+import * as Secret from "effect/Secret"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Ref from "effect/Ref"
@@ -16,7 +16,6 @@ import {
   retryAfter,
   routeFromConfig,
 } from "dfx/DiscordREST/utils"
-import { Log } from "dfx/Log"
 import { RateLimiterLive, RateLimiter, RateLimitStore } from "dfx/RateLimit"
 import * as Discord from "dfx/types"
 import { LIB_VERSION } from "dfx/version"
@@ -33,7 +32,6 @@ const make = Effect.gen(function* (_) {
   const { rest, token } = yield* _(DiscordConfig)
 
   const http = yield* _(Http.client.Client)
-  const log = yield* _(Log)
   const store = yield* _(RateLimitStore)
   const { maybeWait } = yield* _(RateLimiter)
 
@@ -47,14 +45,13 @@ const make = Effect.gen(function* (_) {
   const badRoutesRef = yield* _(Ref.make(HashSet.empty<string>()))
   const tenMinutes = Duration.toMillis(Duration.minutes(10))
   const addBadRoute = (route: string) =>
-    log
-      .info("DiscordREST", "addBadRoute", route)
-      .pipe(
-        Effect.zipRight(Ref.update(badRoutesRef, HashSet.add(route))),
-        Effect.zipRight(
-          store.incrementCounter("dfx.rest.invalid", tenMinutes, 10000),
-        ),
-      )
+    Effect.logDebug("bad route").pipe(
+      Effect.zipRight(Ref.update(badRoutesRef, HashSet.add(route))),
+      Effect.zipRight(
+        store.incrementCounter("dfx.rest.invalid", tenMinutes, 10000),
+      ),
+      Effect.annotateLogs("route", route),
+    )
   const isBadRoute = (route: string) =>
     Effect.map(Ref.get(badRoutesRef), HashSet.has(route))
   const removeBadRoute = (route: string) =>
@@ -139,7 +136,7 @@ const make = Effect.gen(function* (_) {
       pipe(
         Http.request.prependUrl(req, rest.baseUrl),
         Http.request.setHeaders({
-          Authorization: `Bot ${ConfigSecret.value(token)}`,
+          Authorization: `Bot ${Secret.value(token)}`,
           "User-Agent": `DiscordBot (https://github.com/tim-smart/dfx, ${LIB_VERSION})`,
         }),
       ),
@@ -181,7 +178,11 @@ const make = Effect.gen(function* (_) {
             return Effect.zipRight(
               Effect.all(
                 [
-                  log.info("DiscordREST", "403", request.url),
+                  Effect.annotateLogs(
+                    Effect.logDebug("403"),
+                    "url",
+                    request.url,
+                  ),
                   addBadRoute(routeFromConfig(request.url, request.method)),
                   updateBuckets(request, response),
                 ],
@@ -191,26 +192,32 @@ const make = Effect.gen(function* (_) {
             )
 
           case 429:
-            return log
-              .info("DiscordREST", "429", request.url)
-              .pipe(
-                Effect.zipRight(
-                  addBadRoute(routeFromConfig(request.url, request.method)),
-                ),
-                Effect.zipRight(updateBuckets(request, response)),
-                Effect.zipRight(
-                  Effect.sleep(
-                    Option.getOrElse(retryAfter(response.headers), () =>
-                      Duration.seconds(5),
-                    ),
+            return Effect.annotateLogs(
+              Effect.logDebug("429"),
+              "url",
+              request.url,
+            ).pipe(
+              Effect.zipRight(
+                addBadRoute(routeFromConfig(request.url, request.method)),
+              ),
+              Effect.zipRight(updateBuckets(request, response)),
+              Effect.zipRight(
+                Effect.sleep(
+                  Option.getOrElse(retryAfter(response.headers), () =>
+                    Duration.seconds(5),
                   ),
                 ),
-                Effect.zipRight(executor<A>(request)),
-              )
+              ),
+              Effect.zipRight(executor<A>(request)),
+            )
         }
 
         return Effect.fail(e)
       }),
+      Effect.annotateLogs({
+        package: "dfx",
+        module: "DiscordREST",
+      }),
     )
 
   const routes = Discord.createRoutes<Partial<Http.request.Options.NoUrl>>(
@@ -246,14 +253,20 @@ const make = Effect.gen(function* (_) {
   }
 })
 
-export interface DiscordREST
+export interface DiscordREST {
+  readonly _: unique symbol
+}
+
+export interface DiscordRESTService
   extends Discord.Endpoints<Partial<Http.request.Options.NoUrl>> {
   readonly executor: <A = unknown>(
     request: Http.request.ClientRequest,
   ) => Effect.Effect<never, DiscordRESTError, ResponseWithData<A>>
 }
 
-export const DiscordREST = Tag<DiscordREST>()
+export const DiscordREST = Tag<DiscordREST, DiscordRESTService>(
+  "dfx/DiscordREST",
+)
 export const DiscordRESTLive = Layer.effect(DiscordREST, make).pipe(
   Layer.provide(RateLimiterLive),
   Layer.provide(Http.client.layer),

package/src/Interactions/context.ts

@@ -6,20 +6,57 @@ import * as Effect from "effect/Effect"
 import * as IxHelpers from "dfx/Helpers/interactions"
 import type * as Discord from "dfx/types"
 
-export const Interaction = Tag<Discord.Interaction>()
-export const ApplicationCommand = Tag<Discord.ApplicationCommandDatum>()
-export const MessageComponentData = Tag<Discord.MessageComponentDatum>()
-export const ModalSubmitData = Tag<Discord.ModalSubmitDatum>()
+export interface DiscordInteraction {
+  readonly _: unique symbol
+}
+export const Interaction = Tag<DiscordInteraction, Discord.Interaction>(
+  "dfx/Interactions/Interaction",
+)
+
+export interface DiscordApplicationCommand {
+  readonly _: unique symbol
+}
+export const ApplicationCommand = Tag<
+  DiscordApplicationCommand,
+  Discord.ApplicationCommandDatum
+>("dfx/Interactions/ApplicationCommand")
+
+export interface DiscordMessageComponent {
+  readonly _: unique symbol
+}
+export const MessageComponentData = Tag<
+  DiscordMessageComponent,
+  Discord.MessageComponentDatum
+>("dfx/Interactions/MessageComponentData")
 
+export interface DiscordModalSubmit {
+  readonly _: unique symbol
+}
+export const ModalSubmitData = Tag<
+  DiscordModalSubmit,
+  Discord.ModalSubmitDatum
+>("dfx/Interactions/ModalSubmitData")
+
+export interface DiscordFocusedOption {
+  readonly _: unique symbol
+}
 export interface FocusedOptionContext {
   readonly focusedOption: Discord.ApplicationCommandInteractionDataOption
 }
-export const FocusedOptionContext = Tag<FocusedOptionContext>()
+export const FocusedOptionContext = Tag<
+  DiscordFocusedOption,
+  FocusedOptionContext
+>("dfx/Interactions/FocusedOptionContext")
 
+export interface DiscordSubCommand {
+  readonly _: unique symbol
+}
 export interface SubCommandContext {
   readonly command: Discord.ApplicationCommandInteractionDataOption
 }
-export const SubCommandContext = Tag<SubCommandContext>()
+export const SubCommandContext = Tag<DiscordSubCommand, SubCommandContext>(
+  "dfx/Interactions/SubCommandContext",
+)
 
 export class ResolvedDataNotFound {
   readonly _tag = "ResolvedDataNotFound"
@@ -31,7 +68,7 @@ export class ResolvedDataNotFound {
 
 export const resolvedValues = <A>(
   f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => A | undefined,
-): Effect.Effect<Discord.Interaction, ResolvedDataNotFound, ReadonlyArray<A>> =>
+): Effect.Effect<DiscordInteraction, ResolvedDataNotFound, ReadonlyArray<A>> =>
   Effect.flatMap(Interaction, ix =>
     Effect.mapError(
       IxHelpers.resolveValues(f)(ix),
@@ -42,7 +79,7 @@ export const resolvedValues = <A>(
 export const resolved = <A>(
   name: string,
   f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => A | undefined,
-): Effect.Effect<Discord.Interaction, ResolvedDataNotFound, A> =>
+): Effect.Effect<DiscordInteraction, ResolvedDataNotFound, A> =>
   Effect.flatMap(Interaction, ix =>
     Effect.mapError(
       IxHelpers.resolveOptionValue(name, f)(ix),
@@ -101,13 +138,13 @@ export const handleSubCommands = <
   )
 
 export const currentSubCommand: Effect.Effect<
-  SubCommandContext,
+  DiscordSubCommand,
   never,
   Discord.ApplicationCommandInteractionDataOption
 > = Effect.map(SubCommandContext, _ => _.command)
 
 export const optionsMap: Effect.Effect<
-  Discord.ApplicationCommandDatum,
+  DiscordApplicationCommand,
   never,
   HashMap.HashMap<string, string | undefined>
 > = Effect.map(ApplicationCommand, IxHelpers.optionsMap)

package/src/Interactions/definitions.ts

@@ -1,7 +1,11 @@
 import type * as Option from "effect/Option"
 import type * as Effect from "effect/Effect"
 import type {
-  FocusedOptionContext,
+  DiscordApplicationCommand,
+  DiscordFocusedOption,
+  DiscordInteraction,
+  DiscordMessageComponent,
+  DiscordModalSubmit,
   ResolvedDataNotFound,
   SubCommandContext,
 } from "dfx/Interactions/context"
@@ -32,7 +36,7 @@ export const global = <
   handle: CommandHandler<R, E, A>,
 ) =>
   new GlobalApplicationCommand<
-    Exclude<R, Discord.Interaction | Discord.ApplicationCommandDatum>,
+    Exclude<R, DiscordInteraction | DiscordApplicationCommand>,
     E
   >(command as any, handle as any)
 
@@ -54,7 +58,7 @@ export const guild = <
   handle: CommandHandler<R, E, A>,
 ) =>
   new GuildApplicationCommand<
-    Exclude<R, Discord.Interaction | Discord.ApplicationCommandDatum>,
+    Exclude<R, DiscordInteraction | DiscordApplicationCommand>,
     E
   >(command as any, handle as any)
 
@@ -71,7 +75,7 @@ export const messageComponent = <R1, R2, E1, E2>(
   handle: CommandHandler<R2, E2, Discord.InteractionResponse>,
 ) =>
   new MessageComponent<
-    Exclude<R1 | R2, Discord.Interaction | Discord.MessageComponentDatum>,
+    Exclude<R1 | R2, DiscordInteraction | DiscordMessageComponent>,
     E1 | E2
   >(pred as any, handle as any)
 
@@ -88,7 +92,7 @@ export const modalSubmit = <R1, R2, E1, E2>(
   handle: Effect.Effect<R2, E2, Discord.InteractionResponse>,
 ) =>
   new ModalSubmit<
-    Exclude<R1 | R2, Discord.Interaction | Discord.ModalSubmitDatum>,
+    Exclude<R1 | R2, DiscordInteraction | DiscordModalSubmit>,
     E1 | E2
   >(pred as any, handle as any)
 
@@ -113,9 +117,7 @@ export const autocomplete = <R1, R2, E1, E2>(
   new Autocomplete<
     Exclude<
       R1 | R2,
-      | Discord.Interaction
-      | Discord.ApplicationCommandDatum
-      | FocusedOptionContext
+      DiscordInteraction | DiscordApplicationCommand | DiscordFocusedOption
     >,
     E1 | E2
   >(pred as any, handle as any)
@@ -124,10 +126,10 @@ export const autocomplete = <R1, R2, E1, E2>(
 type DeepReadonly<T> = T extends Array<infer R>
   ? ReadonlyArray<DeepReadonly<R>>
   : T extends Function
-  ? T
-  : T extends object
-  ? DeepReadonlyObject<T>
-  : T
+    ? T
+    : T extends object
+      ? DeepReadonlyObject<T>
+      : T
 type DeepReadonlyObject<T> = {
   readonly [P in keyof T]: DeepReadonly<T[P]>
 }
@@ -140,24 +142,24 @@ export interface CommandHelper<A> {
   resolve: <T>(
     name: AllResolvables<A>["name"],
     f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => T | undefined,
-  ) => Effect.Effect<Discord.Interaction, ResolvedDataNotFound, T>
+  ) => Effect.Effect<DiscordInteraction, ResolvedDataNotFound, T>
 
   option: (
     name: AllCommandOptions<A>["name"],
   ) => Effect.Effect<
-    Discord.ApplicationCommandDatum,
+    DiscordApplicationCommand,
     never,
     Option.Option<Discord.ApplicationCommandInteractionDataOption>
   >
 
   optionValue: <N extends AllRequiredCommandOptions<A>["name"]>(
     name: N,
-  ) => Effect.Effect<Discord.ApplicationCommandDatum, never, CommandValue<A, N>>
+  ) => Effect.Effect<DiscordApplicationCommand, never, CommandValue<A, N>>
 
   optionValueOptional: <N extends AllCommandOptions<A>["name"]>(
     name: N,
   ) => Effect.Effect<
-    Discord.ApplicationCommandDatum,
+    DiscordApplicationCommand,
     never,
     Option.Option<CommandValue<A, N>>
   >
@@ -180,8 +182,8 @@ export interface CommandHelper<A> {
           : never,
         SubCommandContext
       >
-    | Discord.Interaction
-    | Discord.ApplicationCommandDatum,
+    | DiscordInteraction
+    | DiscordApplicationCommand,
     [NER[keyof NER]] extends [
       { [Effect.EffectTypeId]: { _E: (_: never) => infer E } },
     ]
@@ -208,8 +210,8 @@ type SubCommands<A> = A extends {
 }
   ? A
   : A extends { readonly options: ReadonlyArray<CommandOption> }
-  ? SubCommands<A["options"][number]>
-  : never
+    ? SubCommands<A["options"][number]>
+    : never
 
 type SubCommandNames<A> = Option<SubCommands<A>>["name"]
 

package/src/Interactions/gateway.ts

@@ -16,9 +16,11 @@ import type {
 } 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 type {
+  DiscordInteraction,
+  InteractionBuilder,
+} from "dfx/Interactions/index"
 import { builder, Interaction } from "dfx/Interactions/index"
-import type * as Discord from "dfx/types"
 import * as EffectUtils from "dfx/utils/Effect"
 import * as Schedule from "effect/Schedule"
 import { globalValue } from "effect/GlobalValue"
@@ -36,7 +38,7 @@ export const run =
   <R, R2, E, TE, E2>(
     postHandler: (
       effect: Effect.Effect<
-        R | DiscordREST | Discord.Interaction,
+        R | DiscordREST | DiscordInteraction,
         TE | DiscordRESTError | DefinitionNotFound,
         void
       >,
@@ -45,7 +47,7 @@ export const run =
   (
     ix: InteractionBuilder<R, E, TE>,
   ): Effect.Effect<
-    DiscordREST | DiscordGateway | Exclude<R2, Discord.Interaction>,
+    DiscordREST | DiscordGateway | Exclude<R2, DiscordInteraction>,
     E2 | DiscordRESTError | Http.error.ResponseError,
     never
   > =>
@@ -155,13 +157,19 @@ const makeRegistry = Effect.gen(function* (_) {
   }),
 )
 
-export interface InteractionsRegistry {
+export interface InteractionsRegistryService {
   readonly register: <E>(
     ix: InteractionBuilder<never, E, never>,
   ) => Effect.Effect<never, never, void>
 }
+export interface InteractionsRegistry {
+  readonly _: unique symbol
+}
 
-export const InteractionsRegistry = Tag<InteractionsRegistry>()
+export const InteractionsRegistry = Tag<
+  InteractionsRegistry,
+  InteractionsRegistryService
+>("dfx/Interactions/InteractionsRegistry")
 export const InteractionsRegistryLive = Layer.scoped(
   InteractionsRegistry,
   makeRegistry,

package/src/Interactions/handlers.ts

@@ -13,7 +13,7 @@ export class DefinitionNotFound {
 }
 
 type Handler<R, E, A> = Effect.Effect<
-  R | Discord.Interaction,
+  R | Ctx.DiscordInteraction,
   E | DefinitionNotFound,
   A
 >

package/src/Interactions/webhook.ts

@@ -5,13 +5,16 @@ import * as Option from "effect/Option"
 import type * as Cause from "effect/Cause"
 import type * as Config from "effect/Config"
 import type * as ConfigError from "effect/ConfigError"
-import * as ConfigSecret from "effect/ConfigSecret"
+import * as Secret from "effect/Secret"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import type * as D 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 type {
+  DiscordInteraction,
+  InteractionBuilder,
+} from "dfx/Interactions/index"
 import { Interaction } from "dfx/Interactions/index"
 import type * as Discord from "dfx/types"
 import * as Verify from "discord-verify"
@@ -52,7 +55,7 @@ const checkSignature = (
 
 export interface MakeConfigOpts {
   readonly applicationId: string
-  readonly publicKey: ConfigSecret.ConfigSecret
+  readonly publicKey: Secret.Secret
   readonly crypto: SubtleCrypto
   readonly algorithm: keyof typeof Verify.PlatformAlgorithm
 }
@@ -63,13 +66,17 @@ const makeConfig = ({
   publicKey,
 }: MakeConfigOpts) => ({
   applicationId,
-  publicKey: ConfigSecret.value(publicKey),
+  publicKey: Secret.value(publicKey),
   crypto,
   algorithm: Verify.PlatformAlgorithm[algorithm],
 })
 
-export interface WebhookConfig extends ReturnType<typeof makeConfig> {}
-export const WebhookConfig = Tag<WebhookConfig>()
+export interface WebhookConfig {
+  readonly _: unique symbol
+}
+export const WebhookConfig = Tag<WebhookConfig, ReturnType<typeof makeConfig>>(
+  "dfx/Interactions/WebhookConfig",
+)
 
 export const layer = (opts: MakeConfigOpts) =>
   Layer.succeed(WebhookConfig, makeConfig(opts))
@@ -112,7 +119,14 @@ const run = <R, E>(
   ) => Effect.Effect<R, E, Discord.InteractionResponse>,
 ) => {
   const handler = handlers(definitions, handleResponse)
-  return (headers: Headers, body: string) =>
+  return (
+    headers: Headers,
+    body: string,
+  ): Effect.Effect<
+    WebhookConfig | Exclude<R, DiscordInteraction>,
+    BadWebhookSignature | WebhookParseError | E | DefinitionNotFound,
+    Discord.InteractionResponse
+  > =>
     Effect.flatMap(fromHeadersAndBody(headers, body), interaction =>
       Effect.provideService(
         handler[interaction.type](interaction),

package/src/RateLimit/memory.ts

@@ -1,13 +1,13 @@
 import * as Option from "effect/Option"
 import * as Effect from "effect/Effect"
-import type { BucketDetails, RateLimitStore } from "dfx/RateLimit"
+import type { BucketDetails, RateLimitStoreService } from "dfx/RateLimit"
 
 interface Counter {
   count: number
   expires: number
 }
 
-export const make = (): RateLimitStore => {
+export const make = (): RateLimitStoreService => {
   const buckets = new Map<string, BucketDetails>()
   const routes = new Map<string, string>()
   const counters = new Map<string, Counter>()

package/src/RateLimit.ts

@@ -3,7 +3,6 @@ import * as Duration from "effect/Duration"
 import type * as Option from "effect/Option"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
-import { Log } from "dfx/Log"
 import * as Memory from "dfx/RateLimit/memory"
 import { delayFrom } from "dfx/RateLimit/utils"
 
@@ -13,7 +12,7 @@ export type BucketDetails = {
   limit: number
 }
 
-export interface RateLimitStore {
+export interface RateLimitStoreService {
   readonly hasBucket: (
     bucketKey: string,
   ) => Effect.Effect<never, never, boolean>
@@ -40,12 +39,17 @@ export interface RateLimitStore {
   readonly removeCounter: (key: string) => Effect.Effect<never, never, void>
 }
 
-export const RateLimitStore = Tag<RateLimitStore>()
+export interface RateLimitStore {
+  readonly _: unique symbol
+}
+
+export const RateLimitStore = Tag<RateLimitStore, RateLimitStoreService>(
+  "dfx/RateLimit/RateLimitStore",
+)
 export const MemoryRateLimitStoreLive = Layer.sync(RateLimitStore, Memory.make)
 
 const makeLimiter = Effect.gen(function* (_) {
   const store = yield* _(RateLimitStore)
-  const log = yield* _(Log)
 
   const maybeWait = (
     key: string,
@@ -58,7 +62,8 @@ const makeLimiter = Effect.gen(function* (_) {
     return store.incrementCounter(key, windowMs, limit).pipe(
       Effect.map(([count, ttl]) => delayFrom(windowMs, limit, count, ttl)),
       Effect.tap(d =>
-        log.debug("RateLimitStore maybeWait", {
+        Effect.annotateLogs(Effect.logTrace("maybeWait"), {
+          service: "RateLimit",
           key,
           window: Duration.toMillis(window),
           windowMs,
@@ -76,7 +81,11 @@ const makeLimiter = Effect.gen(function* (_) {
   return { maybeWait }
 })
 
-export interface RateLimiter
-  extends Effect.Effect.Success<typeof makeLimiter> {}
-export const RateLimiter = Tag<RateLimiter>()
+export interface RateLimiter {
+  readonly _: unique symbol
+}
+export const RateLimiter = Tag<
+  RateLimiter,
+  Effect.Effect.Success<typeof makeLimiter>
+>("dfx/RateLimit/RateLimiter")
 export const RateLimiterLive = Layer.effect(RateLimiter, makeLimiter)

package/src/gateway.ts

@@ -9,7 +9,6 @@ import { MemoryShardStoreLive } from "dfx/DiscordGateway/ShardStore"
 import * as WS from "dfx/DiscordGateway/WS"
 import { DiscordRESTLive } from "dfx/DiscordREST"
 import { InteractionsRegistryLive } from "dfx/Interactions/gateway"
-import { LogLive } from "dfx/Log"
 import { MemoryRateLimitStoreLive, RateLimiterLive } from "dfx/RateLimit"
 import * as Layer from "effect/Layer"
 
@@ -33,7 +32,6 @@ export const DiscordLive = Layer.mergeAll(
   Layer.provide(JsonDiscordWSCodecLive),
   Layer.provide(MemoryRateLimitStoreLive),
   Layer.provide(MemoryShardStoreLive),
-  Layer.provideMerge(LogLive),
 )
 
 export const DiscordIxLive = InteractionsRegistryLive.pipe(

package/src/index.ts

@@ -7,7 +7,6 @@ import * as Members from "dfx/Helpers/members"
 import * as Perms from "dfx/Helpers/permissions"
 import * as UI from "dfx/Helpers/ui"
 import * as Ix from "dfx/Interactions/index"
-import * as Log from "dfx/Log"
 import * as Discord from "dfx/types"
 
 export { DiscordREST, DiscordRESTLive } from "dfx/DiscordREST"
@@ -28,7 +27,6 @@ export {
   Intents,
   Ix,
   IxHelpers,
-  Log,
   Members,
   Perms,
   UI,

package/src/version.ts

@@ -1 +1 @@
-export const LIB_VERSION = "0.77.3";
+export const LIB_VERSION = "0.79.0";

package/src/webhooks.ts

@@ -1,5 +1,4 @@
 import { DiscordRESTLive } from "dfx/DiscordREST"
-import * as Log from "dfx/Log"
 import {
   MemoryRateLimitStoreLive as MemoryRateLimitStoreLive,
   RateLimiterLive as RateLimiterLive,
@@ -19,4 +18,4 @@ export {
 export const DiscordLive = Layer.mergeAll(
   DiscordRESTLive,
   RateLimiterLive,
-).pipe(Layer.provide(MemoryRateLimitStoreLive), Layer.provideMerge(Log.LogLive))
+).pipe(Layer.provide(MemoryRateLimitStoreLive))

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const LIB_VERSION = "0.77.3";
+export declare const LIB_VERSION = "0.79.0";
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -4,5 +4,5 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.LIB_VERSION = void 0;
-const LIB_VERSION = exports.LIB_VERSION = "0.77.3";
+const LIB_VERSION = exports.LIB_VERSION = "0.79.0";
 //# sourceMappingURL=version.js.map

package/webhooks.d.ts

@@ -1,5 +1,4 @@
-import * as Log from "dfx/Log";
 import * as Layer from "effect/Layer";
 export { BadWebhookSignature, WebhookConfig, WebhookParseError, makeHandler, makeSimpleHandler, layer as webhookLayer, layerConfig as webhookLayerConfig, } from "dfx/Interactions/webhook";
-export declare const DiscordLive: Layer.Layer<import("./DiscordConfig").DiscordConfig, never, Log.Log | import("dfx/RateLimit").RateLimiter | import("dfx/DiscordREST").DiscordREST>;
+export declare const DiscordLive: Layer.Layer<import("./DiscordConfig").DiscordConfig, never, import("dfx/RateLimit").RateLimiter | import("dfx/DiscordREST").DiscordREST>;
 //# sourceMappingURL=webhooks.d.ts.map

package/webhooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webhooks.d.ts","sourceRoot":"","sources":["./src/webhooks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,GAAG,MAAM,SAAS,CAAA;AAK9B,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,EACL,mBAAmB,EACnB,aAAa,EACb,iBAAiB,EACjB,WAAW,EACX,iBAAiB,EACjB,KAAK,IAAI,YAAY,EACrB,WAAW,IAAI,kBAAkB,GAClC,MAAM,0BAA0B,CAAA;AAEjC,eAAO,MAAM,WAAW,oJAGwD,CAAA"}
+{"version":3,"file":"webhooks.d.ts","sourceRoot":"","sources":["./src/webhooks.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,EACL,mBAAmB,EACnB,aAAa,EACb,iBAAiB,EACjB,WAAW,EACX,iBAAiB,EACjB,KAAK,IAAI,YAAY,EACrB,WAAW,IAAI,kBAAkB,GAClC,MAAM,0BAA0B,CAAA;AAEjC,eAAO,MAAM,WAAW,0IAGuB,CAAA"}

package/webhooks.js

@@ -47,11 +47,10 @@ Object.defineProperty(exports, "webhookLayerConfig", {
   }
 });
 var _DiscordREST = /*#__PURE__*/require("dfx/DiscordREST");
-var Log = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("dfx/Log"));
 var _RateLimit = /*#__PURE__*/require("dfx/RateLimit");
 var Layer = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Layer"));
 var _webhook = /*#__PURE__*/require("dfx/Interactions/webhook");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-const DiscordLive = exports.DiscordLive = /*#__PURE__*/Layer.mergeAll(_DiscordREST.DiscordRESTLive, _RateLimit.RateLimiterLive).pipe( /*#__PURE__*/Layer.provide(_RateLimit.MemoryRateLimitStoreLive), /*#__PURE__*/Layer.provideMerge(Log.LogLive));
+const DiscordLive = exports.DiscordLive = /*#__PURE__*/Layer.mergeAll(_DiscordREST.DiscordRESTLive, _RateLimit.RateLimiterLive).pipe( /*#__PURE__*/Layer.provide(_RateLimit.MemoryRateLimitStoreLive));
 //# sourceMappingURL=webhooks.js.map