rename bus

packages/opencode/src/bus/bus-event.ts

@@ -0,0 +1,43 @@
+import z from "zod"
+import type { ZodType } from "zod"
+import { Log } from "../util/log"
+
+export namespace BusEvent {
+  const log = Log.create({ service: "event" })
+
+  export type Definition = ReturnType<typeof define>
+
+  const registry = new Map<string, Definition>()
+
+  export function define<Type extends string, Properties extends ZodType>(type: Type, properties: Properties) {
+    const result = {
+      type,
+      properties,
+    }
+    registry.set(type, result)
+    return result
+  }
+
+  export function payloads() {
+    return z
+      .discriminatedUnion(
+        "type",
+        registry
+          .entries()
+          .map(([type, def]) => {
+            return z
+              .object({
+                type: z.literal(type),
+                properties: def.properties,
+              })
+              .meta({
+                ref: "Event" + "." + def.type,
+              })
+          })
+          .toArray() as any,
+      )
+      .meta({
+        ref: "Event",
+      })
+  }
+}

packages/opencode/src/bus/index.ts

@@ -1,7 +1,7 @@
 import z from "zod"
-import type { ZodType } from "zod"
 import { Log } from "../util/log"
 import { Instance } from "../project/instance"
+import { BusEvent } from "./bus-event"
 import { GlobalBus } from "./global"
 
 export namespace Bus {
@@ -9,10 +9,6 @@ export namespace Bus {
   type Subscription = (event: any) => void
   const disposedEventType = "server.instance.disposed"
 
-  export type EventDefinition = ReturnType<typeof event>
-
-  const registry = new Map<string, EventDefinition>()
-
   const state = Instance.state(
     () => {
       const subscriptions = new Map<any, Subscription[]>()
@@ -36,46 +32,14 @@ export namespace Bus {
     },
   )
 
-  export function event<Type extends string, Properties extends ZodType>(type: Type, properties: Properties) {
-    const result = {
-      type,
-      properties,
-    }
-    registry.set(type, result)
-    return result
-  }
-
-  export const InstanceDisposed = event(
+  export const InstanceDisposed = BusEvent.define(
     disposedEventType,
     z.object({
       directory: z.string(),
     }),
   )
 
-  export function payloads() {
-    return z
-      .discriminatedUnion(
-        "type",
-        registry
-          .entries()
-          .map(([type, def]) => {
-            return z
-              .object({
-                type: z.literal(type),
-                properties: def.properties,
-              })
-              .meta({
-                ref: "Event" + "." + def.type,
-              })
-          })
-          .toArray() as any,
-      )
-      .meta({
-        ref: "Event",
-      })
-  }
-
-  export async function publish<Definition extends EventDefinition>(
+  export async function publish<Definition extends BusEvent.Definition>(
     def: Definition,
     properties: z.output<Definition["properties"]>,
   ) {
@@ -100,14 +64,14 @@ export namespace Bus {
     return Promise.all(pending)
   }
 
-  export function subscribe<Definition extends EventDefinition>(
+  export function subscribe<Definition extends BusEvent.Definition>(
     def: Definition,
     callback: (event: { type: Definition["type"]; properties: z.infer<Definition["properties"]> }) => void,
   ) {
     return raw(def.type, callback)
   }
 
-  export function once<Definition extends EventDefinition>(
+  export function once<Definition extends BusEvent.Definition>(
     def: Definition,
     callback: (event: {
       type: Definition["type"]