dfx 0.126.1 → 1.0.0

package/src/Cache.ts

@@ -1,20 +1,20 @@
-import { TypeIdError } from "@effect/platform/Error"
-import type { CacheDriver, ParentCacheDriver } from "dfx/Cache/driver"
+import type { CacheDriver, ParentCacheDriver } from "./Cache/driver.ts"
+import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 import * as Schedule from "effect/Schedule"
 import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 
-export * from "dfx/Cache/driver"
+export * from "./Cache/driver.ts"
 export {
   create as memoryDriver,
   createWithParent as memoryParentDriver,
-} from "dfx/Cache/memory"
+} from "./Cache/memory.ts"
 export {
   create as memoryTTLDriver,
   createWithParent as memoryTTLParentDriver,
-} from "dfx/Cache/memoryTTL"
+} from "./Cache/memoryTTL.ts"
 
 export type ParentCacheOp<T> =
   | { op: "create"; parentId: string; resourceId: string; resource: T }
@@ -28,7 +28,7 @@ export type CacheOp<T> =
   | { op: "delete"; resourceId: string }
 
 const retryPolicy = Schedule.exponential("500 millis").pipe(
-  Schedule.union(Schedule.spaced("10 seconds")),
+  Schedule.either(Schedule.spaced("10 seconds")),
 )
 
 export interface ParentCache<EDriver, EMiss, EPMiss, A> {
@@ -65,7 +65,7 @@ export interface ParentCache<EDriver, EMiss, EPMiss, A> {
 
 export const makeWithParent = <EOps, EDriver, EMiss, EPMiss, A>({
   driver,
-  id,
+  id: identify,
   onMiss,
   onParentMiss,
   ops = Stream.empty,
@@ -94,14 +94,14 @@ export const makeWithParent = <EOps, EDriver, EMiss, EPMiss, A>({
         }
       }),
     ).pipe(
-      Effect.tapErrorCause(_ => Effect.logError("ops error, restarting", _)),
+      Effect.tapCause(cause => Effect.logError("ops error, restarting", cause)),
       Effect.retry(retryPolicy),
       Effect.forkScoped,
       Effect.interruptible,
     )
     yield* driver.run.pipe(
-      Effect.tapErrorCause(_ =>
-        Effect.logError("cache driver error, restarting", _),
+      Effect.tapCause(cause =>
+        Effect.logError("cache driver error, restarting", cause),
       ),
       Effect.retry(retryPolicy),
       Effect.forkScoped,
@@ -109,9 +109,8 @@ export const makeWithParent = <EOps, EDriver, EMiss, EPMiss, A>({
     )
 
     const get = (parentId: string, id: string) =>
-      Effect.flatMap(
-        driver.get(parentId, id),
-        Option.match({
+      Effect.flatMap(driver.get(parentId, id), option =>
+        Option.match(option, {
           onNone: () =>
             Effect.tap(onMiss(parentId, id), a => driver.set(parentId, id, a)),
           onSome: Effect.succeed,
@@ -119,16 +118,17 @@ export const makeWithParent = <EOps, EDriver, EMiss, EPMiss, A>({
       )
 
     const put = (_: A) =>
-      Effect.flatMap(id(_), ([parentId, id]) => driver.set(parentId, id, _))
+      Effect.flatMap(identify(_), ([parentId, id]) =>
+        driver.set(parentId, id, _),
+      )
 
     const update = <R, E>(
       parentId: string,
       id: string,
       f: (_: A) => Effect.Effect<A, E, R>,
     ) =>
-      get(parentId, id).pipe(
-        Effect.flatMap(f),
-        Effect.tap(_ => driver.set(parentId, id, _)),
+      Effect.flatMap(get(parentId, id), a =>
+        Effect.tap(f(a), next => driver.set(parentId, id, next)),
       )
 
     return {
@@ -139,9 +139,8 @@ export const makeWithParent = <EOps, EDriver, EMiss, EPMiss, A>({
       update,
 
       getForParent: (parentId: string) =>
-        Effect.flatMap(
-          driver.getForParent(parentId),
-          Option.match({
+        Effect.flatMap(driver.getForParent(parentId), option =>
+          Option.match(option, {
             onNone: () =>
               onParentMiss(parentId).pipe(
                 Effect.tap(entries =>
@@ -183,7 +182,7 @@ export interface Cache<EDriver, EMiss, A> {
 
 export const make = <EOps, EDriver, EMiss, A>({
   driver,
-  id,
+  id: identify,
   onMiss,
   ops = Stream.empty,
 }: {
@@ -205,15 +204,15 @@ export const make = <EOps, EDriver, EMiss, A>({
         }
       }),
     ).pipe(
-      Effect.tapErrorCause(_ => Effect.logError("ops error, restarting", _)),
+      Effect.tapCause(cause => Effect.logError("ops error, restarting", cause)),
       Effect.retry(retryPolicy),
       Effect.forkScoped,
       Effect.interruptible,
     )
 
     yield* driver.run.pipe(
-      Effect.tapErrorCause(_ =>
-        Effect.logError("cache driver error, restarting", _),
+      Effect.tapCause(cause =>
+        Effect.logError("cache driver error, restarting", cause),
       ),
       Effect.retry(retryPolicy),
       Effect.forkScoped,
@@ -221,20 +220,18 @@ export const make = <EOps, EDriver, EMiss, A>({
     )
 
     const get = (id: string) =>
-      Effect.flatMap(
-        driver.get(id),
-        Option.match({
+      Effect.flatMap(driver.get(id), option =>
+        Option.match(option, {
           onNone: () => Effect.tap(onMiss(id), a => driver.set(id, a)),
           onSome: Effect.succeed,
         }),
       )
 
-    const put = (_: A) => driver.set(id(_), _)
+    const put = (_: A) => driver.set(identify(_), _)
 
     const update = <R, E>(id: string, f: (_: A) => Effect.Effect<A, E, R>) =>
-      get(id).pipe(
-        Effect.flatMap(f),
-        Effect.tap(_ => driver.set(id, _)),
+      Effect.flatMap(get(id), a =>
+        Effect.tap(f(a), next => driver.set(id, next)),
       )
 
     return {
@@ -252,13 +249,12 @@ export const make = <EOps, EDriver, EMiss, A>({
 
 export const CacheErrorTypeId = Symbol.for("dfx/Cache/CacheError")
 
-export class CacheMissError extends TypeIdError(
-  CacheErrorTypeId,
-  "CacheMissError",
-)<{
+export class CacheMissError extends Data.Error<{
   cacheName: string
   id: string
 }> {
+  readonly _tag = "CacheMissError"
+
   get message() {
     return `Cache miss for "${this.cacheName}" with id: ${this.id}`
   }

package/src/DiscordConfig.ts

@@ -1,18 +1,13 @@
-import * as Discord from "dfx/types"
+import * as Discord from "./types.ts"
 import * as Config from "effect/Config"
-import type * as ConfigError from "effect/ConfigError"
-import { GenericTag } from "effect/Context"
 import * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import type * as Redacted from "effect/Redacted"
+import * as ServiceMap from "effect/ServiceMap"
 
 const VERSION = 10
 
-export interface DiscordConfig {
-  readonly _: unique symbol
-}
-
 export interface DiscordConfigService {
   readonly token: Redacted.Redacted
   readonly rest: {
@@ -30,9 +25,10 @@ export interface DiscordConfigService {
     readonly identifyRateLimit: readonly [window: number, limit: number]
   }
 }
-export const DiscordConfig = GenericTag<DiscordConfig, DiscordConfigService>(
-  "dfx/DiscordConfig",
-)
+export class DiscordConfig extends ServiceMap.Service<
+  DiscordConfig,
+  DiscordConfigService
+>()("dfx/DiscordConfig") {}
 
 export interface MakeOpts {
   readonly token: Redacted.Redacted
@@ -48,17 +44,17 @@ export const make = ({
   token,
   rest: {
     baseUrl: `https://discord.com/api/v${VERSION}`,
-    ...(rest ?? {}),
+    ...rest,
     globalRateLimit: {
       limit: 50,
       window: Duration.seconds(1),
-      ...(rest?.globalRateLimit ?? {}),
+      ...rest?.globalRateLimit,
     },
   },
   gateway: {
     intents: Discord.GatewayIntentBits.Guilds,
     identifyRateLimit: [5000, 1],
-    ...(gateway ?? {}),
+    ...gateway,
   },
 })
 
@@ -66,6 +62,6 @@ export const layer = (opts: MakeOpts): Layer.Layer<DiscordConfig> =>
   Layer.succeed(DiscordConfig, make(opts))
 
 export const layerConfig = (
-  _: Config.Config.Wrap<MakeOpts>,
-): Layer.Layer<DiscordConfig, ConfigError.ConfigError> =>
-  Layer.effect(DiscordConfig, Effect.map(Config.unwrap(_), make))
+  _: Config.Wrap<MakeOpts>,
+): Layer.Layer<DiscordConfig, Config.ConfigError> =>
+  Layer.effect(DiscordConfig, Effect.map(Config.unwrap(_).asEffect(), make))

package/src/DiscordGateway/DiscordWS.ts

@@ -1,14 +1,16 @@
-import { GenericTag } from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Ref from "effect/Ref"
-import type * as Discord from "dfx/types"
-import * as Socket from "@effect/platform/Socket"
-import * as Mailbox from "effect/Mailbox"
+import type * as Discord from "../types.ts"
 import * as Schedule from "effect/Schedule"
 import * as Cause from "effect/Cause"
-import * as Option from "effect/Option"
+import * as ServiceMap from "effect/ServiceMap"
+import * as Queue from "effect/Queue"
+import * as Socket from "effect/unstable/socket/Socket"
+import type * as Scope from "effect/Scope"
+import { CurrentLoggers } from "effect/Logger"
 import * as LogLevel from "effect/LogLevel"
+import { MinimumLogLevel } from "effect/References"
 
 export type Message = Discord.GatewayReceivePayload
 export type MessageSend = Discord.GatewaySendPayload | Reconnect
@@ -28,16 +30,14 @@ export interface DiscordWSCodecService {
   encode: (p: Discord.GatewaySendPayload) => Uint8Array | string
   decode: (p: Uint8Array | string) => Discord.GatewayReceivePayload
 }
-export interface DiscordWSCodec {
-  readonly _: unique symbol
-}
 
 const decoder = new TextDecoder()
-const logLevelTrace = Option.some(LogLevel.Trace)
 
-export const DiscordWSCodec = GenericTag<DiscordWSCodec, DiscordWSCodecService>(
-  "dfx/DiscordGateway/DiscordWS/Codec",
-)
+export class DiscordWSCodec extends ServiceMap.Service<
+  DiscordWSCodec,
+  DiscordWSCodecService
+>()("dfx/DiscordGateway/DiscordWS/Codec") {}
+
 export const JsonDiscordWSCodecLive = Layer.succeed(DiscordWSCodec, {
   type: "json",
   encode: p => JSON.stringify(p),
@@ -56,9 +56,9 @@ const make = Effect.gen(function* () {
       const urlRef = yield* Ref.make(
         `${url}?v=${version}&encoding=${encoding.type}`,
       )
-      const setUrl = (url: string) =>
-        Ref.set(urlRef, `${url}?v=${version}&encoding=${encoding.type}`)
-      const messages = yield* Mailbox.make<Message>()
+      const setUrl = (nextUrl: string) =>
+        Ref.set(urlRef, `${nextUrl}?v=${version}&encoding=${encoding.type}`)
+      const messages = yield* Queue.make<Message>()
       const socket = yield* Socket.makeWebSocket(Ref.get(urlRef), {
         closeCodeIsError: _ => true,
         openTimeout: 5000,
@@ -71,44 +71,58 @@ const make = Effect.gen(function* () {
         })
       const write = (message: MessageSend): Effect.Effect<void> => {
         if (message === Reconnect) {
-          return Effect.catchAllCause(
+          return Effect.catchCause(
             writeRaw(new Socket.CloseEvent(3000, "reconnecting")),
             logWriteError,
           )
         }
-        return Effect.catchAllCause(
+        return Effect.catchCause(
           writeRaw(encoding.encode(message)),
           logWriteError,
         )
       }
+      const traceEnabled = LogLevel.isLessThanOrEqualTo(
+        yield* MinimumLogLevel,
+        "Trace",
+      )
+      const loggers = yield* CurrentLoggers
       yield* onConnecting.pipe(
-        Effect.zipRight(
-          Effect.withFiberRuntime<void, Socket.SocketError>(fiber =>
+        Effect.andThen(
+          Effect.withFiber<void, Socket.SocketError>(fiber =>
             socket.runRaw(_ => {
               const message = encoding.decode(_)
-              messages.unsafeOffer(message)
-              ;(fiber as any).log([message], Cause.empty, logLevelTrace)
+              Queue.offerUnsafe(messages, message)
+              if (!traceEnabled) return
+              loggers.forEach(logger => {
+                logger.log({
+                  message,
+                  cause: Cause.empty,
+                  fiber,
+                  logLevel: "Trace",
+                  date: new Date(),
+                })
+              })
             }),
           ),
         ),
         Effect.retry({
-          while: e => e.reason === "Close" && e.code === 3000,
+          while: e =>
+            e.reason._tag === "SocketCloseError" && e.reason.code === 3000,
         }),
-        Effect.catchAllCause(cause =>
+        Effect.catchCause(cause =>
           Effect.logDebug("Got socket error, reconnecting", cause),
         ),
         Effect.repeat(
           Schedule.exponential(500).pipe(
-            Schedule.union(Schedule.spaced(10000)),
+            Schedule.either(Schedule.spaced(10000)),
           ),
         ),
         Effect.annotateLogs("channel", "inbound"),
         Effect.forkScoped,
-        Effect.interruptible,
       )
 
       return {
-        take: messages.take,
+        take: Queue.take(messages),
         setUrl,
         write,
       } as const
@@ -121,11 +135,23 @@ const make = Effect.gen(function* () {
   return { connect } as const
 })
 
-export interface DiscordWS {
-  readonly _: unique symbol
-}
-export const DiscordWS = GenericTag<
+export class DiscordWS extends ServiceMap.Service<
   DiscordWS,
-  Effect.Effect.Success<typeof make>
->("dfx/DiscordGateway/DiscordWS")
+  {
+    readonly connect: (args_0: OpenOpts) => Effect.Effect<
+      {
+        readonly take: Effect.Effect<
+          Discord.GatewayReceivePayload,
+          never,
+          never
+        >
+        readonly setUrl: (url: string) => Effect.Effect<void, never, never>
+        readonly write: (message: MessageSend) => Effect.Effect<void>
+      },
+      never,
+      Socket.WebSocketConstructor | Scope.Scope
+    >
+  }
+>()("dfx/DiscordGateway/DiscordWS") {}
+
 export const DiscordWSLive = Layer.effect(DiscordWS, make)

package/src/DiscordGateway/Messaging.ts

@@ -1,11 +1,11 @@
-import { GenericTag } from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as PubSub from "effect/PubSub"
 import * as Layer from "effect/Layer"
-import * as Mailbox from "effect/Mailbox"
 import * as Stream from "effect/Stream"
-import type * as Discord from "dfx/types"
-import * as EffectUtils from "dfx/utils/Effect"
+import type * as Discord from "../types.ts"
+import * as EffectUtils from "../utils/Effect.ts"
+import * as Queue from "effect/Queue"
+import * as ServiceMap from "effect/ServiceMap"
 
 const fromDispatchFactory =
   <R, E>(source: Stream.Stream<Discord.GatewayReceivePayload, E, R>) =>
@@ -43,11 +43,11 @@ export const make = Effect.gen(function* () {
   )
 
   const sendMailbox = yield* Effect.acquireRelease(
-    Mailbox.make<Discord.GatewaySendPayload>(),
-    _ => _.shutdown,
+    Queue.make<Discord.GatewaySendPayload>(),
+    Queue.shutdown,
   )
   const send = (payload: Discord.GatewaySendPayload) =>
-    sendMailbox.offer(payload)
+    Queue.offer(sendMailbox, payload)
 
   const dispatch = Stream.fromPubSub(hub)
   const fromDispatch = fromDispatchFactory(dispatch)
@@ -63,11 +63,9 @@ export const make = Effect.gen(function* () {
   } as const
 })
 
-export interface Messsaging {
-  readonly _: unique symbol
-}
-export const Messaging = GenericTag<
-  Messsaging,
-  Effect.Effect.Success<typeof make>
->("dfx/DiscordGateway/Messaging")
-export const MesssagingLive = Layer.scoped(Messaging, make)
+export class Messaging extends ServiceMap.Service<Messaging>()(
+  "dfx/DiscordGateway/Messaging",
+  { make },
+) {}
+export type Messsaging = Messaging
+export const MesssagingLive = Layer.effect(Messaging, make)

package/src/DiscordGateway/Shard/StateStore.ts

@@ -1,8 +1,9 @@
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
-import * as Context from "effect/Context"
 import * as Layer from "effect/Layer"
-import * as KVS from "@effect/platform/KeyValueStore"
+import * as ServiceMap from "effect/ServiceMap"
+import * as KeyValueStore from "effect/unstable/persistence/KeyValueStore"
+import { flow, pipe } from "effect/Function"
 
 export interface ShardState {
   readonly resumeUrl: string
@@ -16,10 +17,10 @@ export interface StateStore {
   readonly clear: Effect.Effect<void>
 }
 
-export class ShardStateStore extends Context.Tag("dfx/Shard/StateStore")<
+export class ShardStateStore extends ServiceMap.Service<
   ShardStateStore,
   { readonly forShard: (id: [id: number, count: number]) => StateStore }
->() {
+>()("dfx/Shard/StateStore") {
   static MemoryLive: Layer.Layer<ShardStateStore> = Layer.sync(
     ShardStateStore,
     () => {
@@ -29,7 +30,7 @@ export class ShardStateStore extends Context.Tag("dfx/Shard/StateStore")<
         forShard: ([id, count]) => {
           const key = `${id}-${count}`
           return {
-            get: Effect.sync(() => Option.fromNullable(store.get(key))),
+            get: Effect.sync(() => Option.fromUndefinedOr(store.get(key))),
             set(state) {
               return Effect.sync(() => {
                 store.set(key, state)
@@ -44,24 +45,28 @@ export class ShardStateStore extends Context.Tag("dfx/Shard/StateStore")<
     },
   )
 
-  static KVSLive: Layer.Layer<ShardStateStore, never, KVS.KeyValueStore> =
-    Layer.effect(
-      ShardStateStore,
-      Effect.gen(function* () {
-        const store = yield* KVS.KeyValueStore
-        return ShardStateStore.of({
-          forShard([id, count]) {
-            const key = `dfx-shard-state-${id}-${count}`
-            return {
-              get: Effect.map(
-                Effect.orDie(store.get(key)),
-                Option.map(JSON.parse),
-              ),
-              set: state => Effect.orDie(store.set(key, JSON.stringify(state))),
-              clear: Effect.orDie(store.remove(key)),
-            }
-          },
-        })
-      }),
-    )
+  static KVSLive: Layer.Layer<
+    ShardStateStore,
+    never,
+    KeyValueStore.KeyValueStore
+  > = Layer.effect(
+    ShardStateStore,
+    Effect.gen(function* () {
+      const store = yield* KeyValueStore.KeyValueStore
+      return ShardStateStore.of({
+        forShard([id, count]) {
+          const key = `dfx-shard-state-${id}-${count}`
+          return {
+            get: pipe(
+              store.get(key),
+              Effect.orDie,
+              Effect.map(flow(Option.fromUndefinedOr, Option.map(JSON.parse))),
+            ),
+            set: state => Effect.orDie(store.set(key, JSON.stringify(state))),
+            clear: Effect.orDie(store.remove(key)),
+          }
+        },
+      })
+    }),
+  )
 }

package/src/DiscordGateway/Shard/heartbeats.ts

@@ -1,18 +1,18 @@
-import * as Duration from "effect/Duration"
 import * as Option from "effect/Option"
 import * as Effect from "effect/Effect"
 import * as Ref from "effect/Ref"
-import * as Schedule from "effect/Schedule"
-import * as DiscordWS from "dfx/DiscordGateway/DiscordWS"
-import * as SendEvents from "dfx/DiscordGateway/Shard/sendEvents"
-import type * as Discord from "dfx/types"
-import * as EffectU from "dfx/utils/Effect"
-import type { ShardState } from "dfx/DiscordGateway/Shard/StateStore"
-import type * as Mailbox from "effect/Mailbox"
+import * as DiscordWS from "../DiscordWS.ts"
+import * as SendEvents from "./sendEvents.ts"
+import type * as Discord from "../../types.ts"
+import * as EffectU from "../../utils/Effect.ts"
+import type { ShardState } from "./StateStore.ts"
+import * as Queue from "effect/Queue"
 
 const payload = (state: Effect.Effect<Option.Option<ShardState>>) =>
-  Effect.map(state, state =>
-    SendEvents.heartbeat(Option.getOrNull(Option.map(state, s => s.sequence))),
+  Effect.map(state, shardState =>
+    SendEvents.heartbeat(
+      Option.getOrNull(Option.map(shardState, s => s.sequence)),
+    ),
   )
 
 const payloadOrReconnect = (
@@ -26,33 +26,30 @@ const payloadOrReconnect = (
   )
 
 export const send = (
-  hellos: Mailbox.ReadonlyMailbox<Discord.GatewayHelloData>,
-  acks: Mailbox.ReadonlyMailbox<void>,
+  hellos: Queue.Dequeue<Discord.GatewayHelloData>,
+  acks: Queue.Dequeue<void>,
   state: Effect.Effect<Option.Option<ShardState>>,
-  send: (p: DiscordWS.MessageSend) => Effect.Effect<void>,
+  sendMessage: (p: DiscordWS.MessageSend) => Effect.Effect<void>,
 ) =>
   Effect.flatMap(Ref.make(true), ackedRef => {
     const sendPayload = payloadOrReconnect(ackedRef, state).pipe(
-      Effect.zipLeft(Ref.set(ackedRef, false)),
-      Effect.flatMap(send),
+      Effect.tap(Ref.set(ackedRef, false)),
+      Effect.flatMap(sendMessage),
     )
 
     const heartbeats = EffectU.foreverSwitch(
-      Effect.zipLeft(hellos.take, Ref.set(ackedRef, true)),
-      p =>
-        Effect.schedule(
-          sendPayload,
-          Schedule.andThen(
-            Schedule.duration(
-              Duration.millis(p.heartbeat_interval * Math.random()),
-            ),
-            Schedule.spaced(Duration.millis(p.heartbeat_interval)),
-          ),
-        ),
+      Effect.tap(Queue.take(hellos), Ref.set(ackedRef, true)),
+      Effect.fnUntraced(function* (p) {
+        yield* Effect.sleep(p.heartbeat_interval * Math.random())
+        while (true) {
+          yield* sendPayload
+          yield* Effect.sleep(p.heartbeat_interval)
+        }
+      }),
     )
 
-    const run = acks.take.pipe(
-      Effect.zipLeft(Ref.set(ackedRef, true)),
+    const run = Queue.take(acks).pipe(
+      Effect.tap(Ref.set(ackedRef, true)),
       Effect.forever,
     )
 

package/src/DiscordGateway/Shard/identify.ts

@@ -1,9 +1,10 @@
 import * as Option from "effect/Option"
 import * as Effect from "effect/Effect"
-import * as SendEvents from "dfx/DiscordGateway/Shard/sendEvents"
-import type * as Discord from "dfx/types"
-import * as OS from "os"
-import type { ShardState } from "dfx/DiscordGateway/Shard/StateStore"
+import * as SendEvents from "./sendEvents.ts"
+import type * as Discord from "../../types.ts"
+import type { ShardState } from "./StateStore.ts"
+
+declare const process: { platform?: string | undefined } | undefined
 
 export interface Options {
   readonly token: string
@@ -17,7 +18,10 @@ const identify = ({ intents, presence, shard, token }: Options) =>
     token,
     intents,
     properties: {
-      os: OS.platform(),
+      os:
+        typeof process !== "undefined"
+          ? (process.platform ?? "unknown")
+          : "unknown",
       browser: "dfx",
       device: "dfx",
     },
@@ -40,6 +44,7 @@ export const identifyOrResume = (
     state,
     Option.match({
       onNone: () => identify(opts),
-      onSome: state => resume(opts.token, state.sessionId, state.sequence),
+      onSome: shardState =>
+        resume(opts.token, shardState.sessionId, shardState.sequence),
     }),
   )

package/src/DiscordGateway/Shard/sendEvents.ts

@@ -1,4 +1,4 @@
-import * as Discord from "dfx/types"
+import * as Discord from "../../types.ts"
 
 export const heartbeat = (
   d: Discord.GatewayHeartbeatData,

package/src/DiscordGateway/Shard/utils.ts

@@ -1,4 +1,4 @@
-import type * as Discord from "dfx/types"
+import type * as Discord from "../../types.ts"
 import * as Stream from "effect/Stream"
 
 export const opCode =