dfx 0.126.1 → 1.0.0

package/src/Interactions/context.ts

@@ -1,75 +1,56 @@
-import { TypeIdError } from "@effect/platform/Error"
-import * as IxHelpers from "dfx/Helpers/interactions"
-import { InteractionsErrorTypeId } from "dfx/Interactions/error"
-import type * as Discord from "dfx/types"
-import type { NoSuchElementException } from "effect/Cause"
-import { GenericTag } from "effect/Context"
+import * as IxHelpers from "../Helpers/interactions.ts"
+import type * as Discord from "../types.ts"
+import type { NoSuchElementError } from "effect/Cause"
+import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
-// @ts-ignore
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import * as Types from "effect/Types"
+import * as ServiceMap from "effect/ServiceMap"
 
-export interface DiscordInteraction {
-  readonly _: unique symbol
-}
-export const Interaction = GenericTag<
-  DiscordInteraction,
+export class Interaction extends ServiceMap.Service<
+  Interaction,
   Discord.APIInteraction
->("dfx/Interactions/Interaction")
+>()("dfx/Interactions/Interaction") {}
+export type DiscordInteraction = Interaction
 
-export interface DiscordApplicationCommand {
-  readonly _: unique symbol
-}
-export const ApplicationCommand = GenericTag<
-  DiscordApplicationCommand,
+export class ApplicationCommand extends ServiceMap.Service<
+  ApplicationCommand,
   Discord.APIApplicationCommandInteraction["data"]
->("dfx/Interactions/ApplicationCommand")
+>()("dfx/Interactions/ApplicationCommand") {}
+export type DiscordApplicationCommand = ApplicationCommand
 
-export interface DiscordMessageComponent {
-  readonly _: unique symbol
-}
-export const MessageComponentData = GenericTag<
-  DiscordMessageComponent,
+export class MessageComponentData extends ServiceMap.Service<
+  MessageComponentData,
   Discord.APIMessageComponentInteractionData
->("dfx/Interactions/MessageComponentData")
+>()("dfx/Interactions/MessageComponentData") {}
+export type DiscordMessageComponent = MessageComponentData
 
-export interface DiscordModalSubmit {
-  readonly _: unique symbol
-}
-export const ModalSubmitData = GenericTag<
-  DiscordModalSubmit,
+export class ModalSubmitData extends ServiceMap.Service<
+  ModalSubmitData,
   Discord.APIModalSubmission
->("dfx/Interactions/ModalSubmitData")
+>()("dfx/Interactions/ModalSubmitData") {}
+export type DiscordModalSubmit = ModalSubmitData
 
-export interface DiscordFocusedOption {
-  readonly _: unique symbol
-}
-export const FocusedOptionContext = GenericTag<
-  DiscordFocusedOption,
+export class FocusedOptionContext extends ServiceMap.Service<
+  FocusedOptionContext,
   Discord.APIApplicationCommandInteractionDataOption
->("dfx/Interactions/FocusedOptionContext")
+>()("dfx/Interactions/FocusedOptionContext") {}
+export type DiscordFocusedOption = FocusedOptionContext
 
-export interface DiscordSubCommand {
-  readonly _: unique symbol
-}
-export interface SubCommandContext {
+export interface SubCommandContextData {
   readonly command: Discord.APIApplicationCommandInteractionDataSubcommandOption
 }
-export const SubCommandContext = GenericTag<
-  DiscordSubCommand,
-  SubCommandContext
->("dfx/Interactions/SubCommandContext")
+export class SubCommandContext extends ServiceMap.Service<
+  SubCommandContext,
+  SubCommandContextData
+>()("dfx/Interactions/SubCommandContext") {}
+export type DiscordSubCommand = SubCommandContext
 
 export const resolvedValues = <A>(
   f: (
     id: Discord.Snowflake,
     data: Discord.InteractionDataResolved,
   ) => A | undefined,
-): Effect.Effect<
-  ReadonlyArray<A>,
-  NoSuchElementException,
-  DiscordInteraction
-> => Effect.flatMap(Interaction, ix => IxHelpers.resolveValues(f)(ix))
+): Effect.Effect<ReadonlyArray<A>, NoSuchElementError, DiscordInteraction> =>
+  Interaction.use(ix => Effect.fromOption(IxHelpers.resolveValues(f)(ix)))
 
 export const resolved = <A>(
   name: string,
@@ -77,17 +58,16 @@ export const resolved = <A>(
     id: Discord.Snowflake,
     data: Discord.InteractionDataResolved,
   ) => A | undefined,
-): Effect.Effect<A, NoSuchElementException, DiscordInteraction> =>
-  Effect.flatMap(Interaction, ix => IxHelpers.resolveOptionValue(name, f)(ix))
+): Effect.Effect<A, NoSuchElementError, DiscordInteraction> =>
+  Interaction.use(ix =>
+    Effect.fromOption(IxHelpers.resolveOptionValue(name, f)(ix)),
+  )
 
-export const focusedOptionValue = Effect.map(FocusedOptionContext, _ =>
-  "value" in _ ? _.value : "",
+export const focusedOptionValue = FocusedOptionContext.use(_ =>
+  Effect.succeed("value" in _ ? _.value : ""),
 )
 
-export class SubCommandNotFound extends TypeIdError(
-  InteractionsErrorTypeId,
-  "SubCommandNotFound",
-)<{
+export class SubCommandNotFound extends Data.TaggedError("SubCommandNotFound")<{
   data: Discord.APIApplicationCommandInteraction["data"]
 }> {}
 
@@ -95,7 +75,7 @@ export const currentSubCommand: Effect.Effect<
   Discord.APIApplicationCommandInteractionDataSubcommandOption,
   never,
   DiscordSubCommand
-> = Effect.map(SubCommandContext, _ => _.command)
+> = SubCommandContext.use(_ => Effect.succeed(_.command))
 
 export class RequiredOptionNotFound {
   readonly _tag = "RequiredOptionNotFound"
@@ -107,12 +87,18 @@ export class RequiredOptionNotFound {
   ) {}
 }
 
-export const modalValues = Effect.map(ModalSubmitData, IxHelpers.componentsMap)
+export const modalValues = ModalSubmitData.use(data =>
+  Effect.succeed(IxHelpers.componentsMap(data)),
+)
 
 export const modalValueOption = (name: string) =>
-  Effect.map(ModalSubmitData, IxHelpers.componentValue(name))
+  ModalSubmitData.use(data =>
+    Effect.succeed(IxHelpers.componentValue(name)(data)),
+  )
 
 export const modalValue = (
   name: string,
-): Effect.Effect<string, NoSuchElementException, DiscordModalSubmit> =>
-  Effect.flatMap(ModalSubmitData, data => IxHelpers.componentValue(name)(data))
+): Effect.Effect<string, NoSuchElementError, DiscordModalSubmit> =>
+  ModalSubmitData.use(data =>
+    Effect.fromOption(IxHelpers.componentValue(name)(data)),
+  )

package/src/Interactions/definitions.ts

@@ -5,10 +5,10 @@ import type {
   DiscordInteraction,
   DiscordMessageComponent,
   DiscordModalSubmit,
-} from "dfx/Interactions/context"
-import type * as Discord from "dfx/types"
+} from "./context.ts"
+import type * as Discord from "../types.ts"
 import type { Scope } from "effect/Scope"
-import type { CommandHelper } from "./commandHelper"
+import type { CommandHelper } from "./commandHelper.ts"
 
 export type InteractionDefinition<R, E> =
   | GlobalApplicationCommand<R, E>

package/src/Interactions/gateway.ts

@@ -1,40 +1,37 @@
+import * as Arr from "effect/Array"
 import * as Chunk from "effect/Chunk"
-import type { Tag } from "effect/Context"
-import { GenericTag } from "effect/Context"
 import * as Duration from "effect/Duration"
-import { pipe } from "effect/Function"
 import * as Effect from "effect/Effect"
+import { pipe } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as Queue from "effect/Queue"
 import * as Ref from "effect/Ref"
-import { DiscordGateway } from "dfx/DiscordGateway"
-import type { DiscordRESTError } from "dfx/DiscordREST"
-import { DiscordREST } from "dfx/DiscordREST"
+import * as Schedule from "effect/Schedule"
+import * as ServiceMap from "effect/ServiceMap"
+import { DiscordGateway } from "../DiscordGateway.ts"
+import type { DiscordRESTError } from "../DiscordREST.ts"
+import { DiscordREST } from "../DiscordREST.ts"
+import type { ListMyGuilds200, MyGuildResponse } from "../types.ts"
 import type {
   GlobalApplicationCommand,
   GuildApplicationCommand,
-} from "dfx/Interactions/definitions"
-import type { DefinitionNotFound } from "dfx/Interactions/handlers"
-import { handlers } from "dfx/Interactions/handlers"
-import type {
-  DiscordInteraction,
-  InteractionBuilder,
-} from "dfx/Interactions/index"
-import { builder, Interaction } from "dfx/Interactions/index"
-import * as EffectUtils from "dfx/utils/Effect"
-import * as Schedule from "effect/Schedule"
-import { globalValue } from "effect/GlobalValue"
-import * as FiberRef from "effect/FiberRef"
-import type { ListMyGuilds200, MyGuildResponse } from "dfx/types"
-import * as Arr from "effect/Array"
+} from "./definitions.ts"
+import type { DefinitionNotFound } from "./handlers.ts"
+import { handlers } from "./handlers.ts"
+import type { DiscordInteraction, InteractionBuilder } from "./index.ts"
+import { builder, Interaction } from "./index.ts"
+import * as EffectUtils from "../utils/Effect.ts"
 
-export const interactionsSync: FiberRef.FiberRef<boolean> = globalValue(
-  "dfx/Interactions/sync",
-  () => FiberRef.unsafeMake(true),
-)
+export const interactionsSync = ServiceMap.Reference("dfx/Interactions/sync", {
+  defaultValue: () => true,
+})
 
 export const setInteractionsSync = (enabled: boolean) =>
-  Layer.locally(interactionsSync, enabled)
+  Layer.provide(Layer.succeed(interactionsSync, enabled))
+
+const retryPolicy = Schedule.exponential("1 seconds").pipe(
+  Schedule.either(Schedule.spaced("20 seconds")),
+)
 
 export const run =
   <R, R2, E, TE, E2>(
@@ -89,7 +86,7 @@ export const run =
           const next: ListMyGuilds200 = yield* rest.listMyGuilds({
             after: results && Arr.lastNonEmpty(results).id,
           })
-          if (!Arr.isNonEmptyReadonlyArray(next)) break
+          if (!Arr.isReadonlyArrayNonEmpty(next)) break
           results = next
           yield* Effect.forEach(
             results!,
@@ -125,7 +122,7 @@ export const run =
         return hasFiles ? rest.withFiles(r.files as any)(effect) : effect
       })
 
-      const run = gateway.handleDispatch("INTERACTION_CREATE", i =>
+      const interactionRun = gateway.handleDispatch("INTERACTION_CREATE", i =>
         Effect.withSpan(
           Effect.provideService(postHandler(handle[i.type](i)), Interaction, i),
           "dfx.Interaction",
@@ -133,16 +130,16 @@ export const run =
         ),
       )
 
-      const sync = yield* FiberRef.get(interactionsSync)
+      const sync = yield* interactionsSync
 
       return yield* sync
         ? Effect.forever(
-            Effect.all([run, globalSync, guildSync], {
+            Effect.all([interactionRun, globalSync, guildSync], {
               concurrency: "unbounded",
               discard: true,
             }),
           )
-        : run
+        : interactionRun
     })
 
 const makeRegistry = Effect.gen(function* () {
@@ -160,16 +157,12 @@ const makeRegistry = Effect.gen(function* () {
   yield* EffectUtils.foreverSwitch(Queue.take(queue), ix =>
     pipe(
       ix,
-      run(Effect.catchAllCause(_ => Effect.logError("unhandled error", _))),
+      run(Effect.catchCause(_ => Effect.logError("unhandled error", _))),
       Effect.delay(Duration.seconds(5)),
     ),
   ).pipe(
-    Effect.tapErrorCause(_ => Effect.logError("registry error", _)),
-    Effect.retry(
-      Schedule.exponential("1 seconds").pipe(
-        Schedule.union(Schedule.spaced("20 seconds")),
-      ),
-    ),
+    Effect.tapCause(_ => Effect.logError("registry error", _)),
+    Effect.retry(retryPolicy),
     Effect.forkScoped,
     Effect.interruptible,
   )
@@ -187,19 +180,14 @@ export interface InteractionsRegistryService {
     ix: InteractionBuilder<never, E, never>,
   ) => Effect.Effect<void>
 }
-export interface InteractionsRegistry {
-  readonly _: unique symbol
-}
 
-export const InteractionsRegistry: Tag<
+export class InteractionsRegistry extends ServiceMap.Service<
   InteractionsRegistry,
   InteractionsRegistryService
-> = GenericTag<InteractionsRegistry, InteractionsRegistryService>(
-  "dfx/Interactions/InteractionsRegistry",
-)
+>()("dfx/Interactions/InteractionsRegistry") {}
 
 export const InteractionsRegistryLive: Layer.Layer<
   InteractionsRegistry,
   never,
   DiscordREST | DiscordGateway
-> = Layer.scoped(InteractionsRegistry, makeRegistry)
+> = Layer.effect(InteractionsRegistry, makeRegistry)

package/src/Interactions/handlers.ts

@@ -1,10 +1,10 @@
 import type * as Chunk from "effect/Chunk"
 import * as Effect from "effect/Effect"
-import * as IxHelpers from "dfx/Helpers/interactions"
-import * as Ctx from "dfx/Interactions/context"
-import type * as D from "dfx/Interactions/definitions"
-import { flattenDefinitions, splitDefinitions } from "dfx/Interactions/utils"
-import * as Discord from "dfx/types"
+import * as IxHelpers from "../Helpers/interactions.ts"
+import * as Ctx from "./context.ts"
+import type * as D from "./definitions.ts"
+import { flattenDefinitions, splitDefinitions } from "./utils.ts"
+import * as Discord from "../types.ts"
 import type { Scope } from "effect/Scope"
 
 export class DefinitionNotFound {
@@ -58,6 +58,9 @@ export const handlers = <R, E, TE, A, B>(
       ) as Handler<Exclude<R, Scope>, E, B>
     },
 
+    [Discord.InteractionTypes.SOCIAL_LAYER_SKU_PURCHASE_ELIGIBILITY]: i =>
+      Effect.fail(new DefinitionNotFound(i)),
+
     [Discord.InteractionTypes.MODAL_SUBMIT]: i => {
       const data = i.data as Discord.APIModalSubmission
       const match = ModalSubmit.find(_ => _.predicate(data.custom_id))

package/src/Interactions/index.ts

@@ -1,14 +1,14 @@
-export { response } from "dfx/Helpers/interactions"
-export * from "dfx/Interactions/builder"
-export * from "dfx/Interactions/context"
+export { response } from "../Helpers/interactions.ts"
+export * from "./builder.ts"
+export * from "./context.ts"
+export type { InteractionDefinition } from "./definitions.ts"
 export {
   autocomplete,
   global,
   guild,
-  InteractionDefinition,
   messageComponent,
   modalSubmit,
-} from "dfx/Interactions/definitions"
+} from "./definitions.ts"
 
 // Filters
 export const id = (query: string) => (customId: string) => query === customId

package/src/Interactions/utils.ts

@@ -1,16 +1,16 @@
 import * as Chunk from "effect/Chunk"
 import * as Effect from "effect/Effect"
-import type * as D from "dfx/Interactions/definitions"
-import type * as Discord from "dfx/types"
+import type * as D from "./definitions.ts"
+import type * as Discord from "../types.ts"
 import * as Array from "effect/Array"
-import { CommandHelper } from "dfx/Interactions/commandHelper"
+import { CommandHelper } from "./commandHelper.ts"
 
 export type DefinitionFlattened<R, E, TE, A> =
-  D.InteractionDefinition<R, E> extends infer D
+  D.InteractionDefinition<R, E> extends infer Def
     ? {
-        [K in keyof D]: K extends "handle"
+        [K in keyof Def]: K extends "handle"
           ? (_: Discord.APIInteraction) => Effect.Effect<A, TE, R>
-          : D[K]
+          : Def[K]
       }
     : never
 

package/src/Interactions/webhook.ts

@@ -1,25 +1,20 @@
 import * as Chunk from "effect/Chunk"
-import { GenericTag } from "effect/Context"
 import { identity } from "effect/Function"
 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 Redacted from "effect/Redacted"
 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 {
-  DiscordInteraction,
-  InteractionBuilder,
-} from "dfx/Interactions/index"
-import { Interaction } from "dfx/Interactions/index"
-import type * as Discord from "dfx/types"
+import * as ServiceMap from "effect/ServiceMap"
+import type * as D from "./definitions.ts"
+import type { DefinitionNotFound } from "./handlers.ts"
+import { handlers } from "./handlers.ts"
+import type { DiscordInteraction, InteractionBuilder } from "./index.ts"
+import { Interaction } from "./index.ts"
+import type * as Discord from "../types.ts"
 import * as Verify from "discord-verify"
-import { TypeIdError } from "@effect/platform/Error"
-import { InteractionsErrorTypeId } from "dfx/Interactions/error"
+import * as Data from "effect/Data"
 
 export class BadWebhookSignature {
   readonly _tag = "BadWebhookSignature"
@@ -34,10 +29,12 @@ const checkSignature = (
   crypto: SubtleCrypto,
   algorithm: any,
 ) =>
-  Option.all({
-    signature: Option.fromNullable(headers["x-signature-ed25519"]),
-    timestamp: Option.fromNullable(headers["x-signature-timestamp"]),
-  }).pipe(
+  Effect.fromOption(
+    Option.all({
+      signature: Option.fromNullishOr(headers["x-signature-ed25519"]),
+      timestamp: Option.fromNullishOr(headers["x-signature-timestamp"]),
+    }),
+  ).pipe(
     Effect.flatMap(_ =>
       Effect.promise(() =>
         Verify.verify(
@@ -51,7 +48,7 @@ const checkSignature = (
       ),
     ),
     Effect.filterOrFail(identity, () => new BadWebhookSignature()),
-    Effect.catchAllCause(() => Effect.fail(new BadWebhookSignature())),
+    Effect.catchCause(() => Effect.fail(new BadWebhookSignature())),
     Effect.asVoid,
   )
 
@@ -73,37 +70,33 @@ const makeConfig = ({
   algorithm: Verify.PlatformAlgorithm[algorithm],
 })
 
-export interface WebhookConfig {
-  readonly _: unique symbol
-}
-export const WebhookConfig = GenericTag<
+export class WebhookConfig extends ServiceMap.Service<
   WebhookConfig,
   ReturnType<typeof makeConfig>
->("dfx/Interactions/WebhookConfig")
+>()("dfx/Interactions/WebhookConfig") {}
 
 export const layer = (opts: MakeConfigOpts) =>
   Layer.succeed(WebhookConfig, makeConfig(opts))
 
 export const layerConfig: (
   config: Config.Config<MakeConfigOpts>,
-) => Layer.Layer<WebhookConfig, ConfigError.ConfigError> = (
+) => Layer.Layer<WebhookConfig, Config.ConfigError> = (
   config: Config.Config<MakeConfigOpts>,
-) => Layer.effect(WebhookConfig, Effect.map(config, makeConfig))
+) => Layer.effect(WebhookConfig, Effect.map(config.asEffect(), makeConfig))
 
-export class WebhookParseError extends TypeIdError(
-  InteractionsErrorTypeId,
-  "WebhookParseError",
-)<{ cause: unknown }> {}
+export class WebhookParseError extends Data.TaggedError("WebhookParseError")<{
+  cause: unknown
+}> {}
 
 const fromHeadersAndBody = (headers: Headers, body: string) =>
-  Effect.tap(WebhookConfig, ({ algorithm, crypto, publicKey }) =>
-    checkSignature(publicKey, headers, body, crypto, algorithm),
-  ).pipe(
-    Effect.flatMap(() =>
-      Effect.try({
-        try: () => JSON.parse(body) as Discord.APIInteraction,
-        catch: cause => new WebhookParseError({ cause }),
-      }),
+  WebhookConfig.use(({ algorithm, crypto, publicKey }) =>
+    checkSignature(publicKey, headers, body, crypto, algorithm).pipe(
+      Effect.andThen(
+        Effect.try({
+          try: () => JSON.parse(body) as Discord.APIInteraction,
+          catch: cause => new WebhookParseError({ cause }),
+        }),
+      ),
     ),
   )
 
@@ -181,7 +174,7 @@ export const makeHandler = <R, E, TE>(
   >): Effect.Effect<void, never, WebhookConfig> =>
     handle(headers, body).pipe(
       Effect.flatMap(success),
-      Effect.catchAllCause(error),
+      Effect.catchCause(error),
     )
 }
 

package/src/RateLimit/memory.ts

@@ -1,6 +1,6 @@
 import * as Option from "effect/Option"
 import * as Effect from "effect/Effect"
-import type { BucketDetails, RateLimitStoreService } from "dfx/RateLimit"
+import type { BucketDetails, RateLimitStoreService } from "../RateLimit.ts"
 
 interface Counter {
   count: number
@@ -14,12 +14,12 @@ export const make = (): RateLimitStoreService => {
 
   const getCounter = (key: string) =>
     Option.filter(
-      Option.fromNullable(counters.get(key)),
+      Option.fromNullishOr(counters.get(key)),
       c => c.expires > Date.now(),
     )
 
   const getBucketForRoute = (route: string) =>
-    Effect.sync(() => Option.fromNullable(buckets.get(routes.get(route)!)))
+    Effect.sync(() => Option.fromNullishOr(buckets.get(routes.get(route)!)))
 
   return {
     hasBucket: key => Effect.sync(() => buckets.has(key)),

package/src/RateLimit.ts

@@ -1,10 +1,10 @@
-import { GenericTag } from "effect/Context"
 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 * as Memory from "dfx/RateLimit/memory"
-import { delayFrom } from "dfx/RateLimit/utils"
+import * as Memory from "./RateLimit/memory.ts"
+import { delayFrom } from "./RateLimit/utils.ts"
+import * as ServiceMap from "effect/ServiceMap"
 
 export type BucketDetails = {
   key: "global" | string
@@ -35,13 +35,11 @@ export interface RateLimitStoreService {
   readonly removeCounter: (key: string) => Effect.Effect<void>
 }
 
-export interface RateLimitStore {
-  readonly _: unique symbol
-}
+export class RateLimitStore extends ServiceMap.Service<
+  RateLimitStore,
+  RateLimitStoreService
+>()("dfx/RateLimit/RateLimitStore") {}
 
-export const RateLimitStore = GenericTag<RateLimitStore, RateLimitStoreService>(
-  "dfx/RateLimit/RateLimitStore",
-)
 export const MemoryRateLimitStoreLive = Layer.sync(RateLimitStore, Memory.make)
 
 const makeLimiter = Effect.gen(function* () {
@@ -77,11 +75,16 @@ const makeLimiter = Effect.gen(function* () {
   return { maybeWait }
 })
 
-export interface RateLimiter {
-  readonly _: unique symbol
-}
-export const RateLimiter = GenericTag<
+export class RateLimiter extends ServiceMap.Service<
   RateLimiter,
-  Effect.Effect.Success<typeof makeLimiter>
->("dfx/RateLimit/RateLimiter")
+  {
+    maybeWait: (
+      key: string,
+      window: Duration.Duration,
+      limit: number,
+      multiplier?: number,
+    ) => Effect.Effect<void, never, never>
+  }
+>()("dfx/RateLimit/RateLimiter") {}
+
 export const RateLimiterLive = Layer.effect(RateLimiter, makeLimiter)

package/src/gateway.ts

@@ -1,25 +1,25 @@
-import * as CachePrelude from "dfx/Cache/prelude"
-import type { DiscordGateway } from "dfx/DiscordGateway"
-import { DiscordGatewayLive } from "dfx/DiscordGateway"
-import * as DiscordWS from "dfx/DiscordGateway/DiscordWS"
-import { JsonDiscordWSCodecLive } from "dfx/DiscordGateway/DiscordWS"
-import * as Shard from "dfx/DiscordGateway/Shard"
-import { ShardStateStore } from "dfx/DiscordGateway/Shard/StateStore"
-import * as SendEvent from "dfx/DiscordGateway/Shard/sendEvents"
-import * as ShardStore from "dfx/DiscordGateway/ShardStore"
-import { MemoryShardStoreLive } from "dfx/DiscordGateway/ShardStore"
-import type { DiscordREST } from "dfx/DiscordREST"
-import { DiscordRESTLive } from "dfx/DiscordREST"
-import type { InteractionsRegistry } from "dfx/Interactions/gateway"
-import { InteractionsRegistryLive } from "dfx/Interactions/gateway"
-import type { RateLimiter } from "dfx/RateLimit"
-import { MemoryRateLimitStoreLive, RateLimiterLive } from "dfx/RateLimit"
+import * as CachePrelude from "./Cache/prelude.ts"
+import type { DiscordGateway } from "./DiscordGateway.ts"
+import { DiscordGatewayLive } from "./DiscordGateway.ts"
+import * as DiscordWS from "./DiscordGateway/DiscordWS.ts"
+import { JsonDiscordWSCodecLive } from "./DiscordGateway/DiscordWS.ts"
+import * as Shard from "./DiscordGateway/Shard.ts"
+import { ShardStateStore } from "./DiscordGateway/Shard/StateStore.ts"
+import * as SendEvent from "./DiscordGateway/Shard/sendEvents.ts"
+import * as ShardStore from "./DiscordGateway/ShardStore.ts"
+import { MemoryShardStoreLive } from "./DiscordGateway/ShardStore.ts"
+import type { DiscordREST } from "./DiscordREST.ts"
+import { DiscordRESTLive } from "./DiscordREST.ts"
+import type { InteractionsRegistry } from "./Interactions/gateway.ts"
+import { InteractionsRegistryLive } from "./Interactions/gateway.ts"
+import type { RateLimiter } from "./RateLimit.ts"
+import { MemoryRateLimitStoreLive, RateLimiterLive } from "./RateLimit.ts"
 import * as Layer from "effect/Layer"
-import type * as HttpClient from "@effect/platform/HttpClient"
-import type { DiscordConfig } from "dfx/DiscordConfig"
-import type { WebSocketConstructor } from "@effect/platform/Socket"
+import type * as HttpClient from "effect/unstable/http/HttpClient"
+import type { DiscordConfig } from "./DiscordConfig.ts"
+import type { WebSocketConstructor } from "effect/unstable/socket/Socket"
 
-export { DiscordGateway, DiscordGatewayLive } from "dfx/DiscordGateway"
+export { DiscordGateway, DiscordGatewayLive } from "./DiscordGateway.ts"
 
 export {
   InteractionsRegistry,
@@ -27,7 +27,7 @@ export {
   interactionsSync,
   run as runIx,
   setInteractionsSync,
-} from "dfx/Interactions/gateway"
+} from "./Interactions/gateway.ts"
 
 export { CachePrelude, DiscordWS, SendEvent, Shard, ShardStore }