liminal 0.5.3 → 0.5.5

package/Agent.ts

@@ -1,28 +1,26 @@
-import { Fiber, type FiberInfo } from "./Fiber.ts"
+import { Context } from "./Context.ts"
+import { run } from "./run.ts"
 import type { Rune, RuneKey } from "./Rune.ts"
 import type { Runic } from "./Runic.ts"
+import { Fiber } from "./state/Fiber.ts"
+import { Globals } from "./state/Globals.ts"
 
 export interface Agent<out T, out E> extends PromiseLike<T> {
   T: T
   E: E
 }
 
-export function Agent<Y extends Rune, T>(runic: Runic<Y, T>, config?: AgentConfig<Y, T>): Agent<T, Rune.E<Y>> {
+export function Agent<Y extends Rune, T>(
+  runic: Runic<Y, T>,
+  globals?: Partial<Globals<Y[RuneKey]>>,
+): Agent<T, Rune.E<Y>> {
   return {
     then(onfulfilled, onrejected) {
-      const root = Fiber({
-        globals: {
-          handler: config?.handler ?? (() => {}),
-        },
-        runic,
-        signal: config?.signal,
-      })
-      return root.run().then(onfulfilled, onrejected)
+      const context = new Context([
+        [Globals.make, Globals.make(globals)],
+        [Fiber.make, Fiber.make()],
+      ])
+      return Context.storage.run(context, () => run(runic).then(onfulfilled, onrejected))
     },
   } satisfies Omit<Agent<T, Rune.E<Y>>, "E" | "T"> as never
 }
-
-export interface AgentConfig<Y extends Rune, _T> {
-  handler: (event: Y[RuneKey], info: FiberInfo) => void
-  signal?: AbortSignal
-}

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # liminal
 
+## 0.5.5
+
+### Patch Changes
+
+- 43afd27: Fixing misc. bugs and refactoring context management.
+
+## 0.5.4
+
+### Patch Changes
+
+- 284adab: Reintroduce AI SDK adapter and begin simplifying runic execution.
+- Updated dependencies [284adab]
+  - liminal-schema@0.0.2
+  - liminal-util@0.0.2
+
 ## 0.5.3
 
 ### Patch Changes

package/Context.ts

@@ -0,0 +1,44 @@
+import { assert } from "liminal-util"
+import { AsyncLocalStorage } from "node:async_hooks"
+
+export class Context extends Map<StateFactory, unknown> {
+  static storage: AsyncLocalStorage<Context> = new AsyncLocalStorage<Context>()
+
+  static make(context?: Context): Context {
+    const instance = new Context()
+    if (context) {
+      for (const [key, value] of context.entries()) {
+        instance.set(key, key(value))
+      }
+    }
+    return instance
+  }
+
+  static unwrap(): Context {
+    const context = this.storage.getStore()
+    assert(context)
+    return context
+  }
+
+  static get<T>(factory: StateFactory<T>): T | undefined {
+    return this.unwrap().get(factory) as never
+  }
+
+  static getAssert<T>(factory: StateFactory<T>): T {
+    const value = this.get(factory)
+    assert(value)
+    return value
+  }
+
+  static getOrInit<T>(factory: StateFactory<T>): T {
+    let context = this.unwrap()
+    let instance = context.get(factory)
+    if (!instance) {
+      instance = factory()
+      context.set(factory, instance)
+    }
+    return instance as never
+  }
+}
+
+export type StateFactory<T = any> = (instance?: T) => T

package/EventBase.ts

@@ -0,0 +1,26 @@
+import { inspect, type InspectOptions } from "node:util"
+
+export interface EventBase<B extends symbol = symbol, K extends string = string> {
+  readonly brand: B
+  readonly type: K
+}
+
+export function EventBase<B extends symbol, K extends string>(brand: B, type: K) {
+  return class implements EventBase<B, K> {
+    readonly brand = brand
+    readonly type = type
+
+    // Allows us to circumvent a false positive ts error related to private symbols.
+    // https://github.com/microsoft/TypeScript/issues/58496
+    static {
+      Object.defineProperties(this.prototype, {
+        [inspect.custom]: {
+          value(depth: number, options: InspectOptions) {
+            const { brand: _0, type: _1, ...rest } = this
+            return `${this.constructor.name} ` + inspect(rest, { ...options, depth })
+          },
+        },
+      })
+    }
+  }
+}

package/Globals.ts

@@ -3,7 +3,7 @@ export interface Globals {
 }
 
 export interface EventInfo {
-  fiber: number
+  // fiber: number
   timestamp: number
   // group
   // depth

package/L/L.ts

@@ -5,9 +5,6 @@ export * from "./assistant.ts"
 export * from "./branch.ts"
 export * from "./emit.ts"
 export * from "./fork.ts"
-export * from "./join.ts"
 export * from "./model.ts"
-export * from "./self.ts"
-export * from "./state.ts"
 export * from "./system.ts"
 export * from "./user.ts"

package/L/_infer.ts

@@ -1,35 +1,39 @@
-import type { SchemaRoot } from "liminal-schema"
+import type { SchemaObject } from "liminal-schema"
 import { assert } from "liminal-util"
-import { type InferenceRequested, type Inferred, type LEvent, LEventTag } from "../LEvent.ts"
+import { Context } from "../Context.ts"
+import { InferenceRequested, Inferred, type LEvent } from "../LEvent.ts"
 import type { Rune } from "../Rune.ts"
-import { Counter } from "../state/Counter.ts"
 import { MessageRegistry } from "../state/MessageRegistry.ts"
 import { ModelRegistry } from "../state/ModelRegistry.ts"
 import { emit } from "./emit.ts"
 import { rune } from "./rune.ts"
-import { state } from "./state.ts"
 
-export function* _infer(schema?: SchemaRoot): Generator<Rune<LEvent>, string> {
-  const [modelRegistry, { messages }, counter] = yield* state(
-    ModelRegistry,
-    MessageRegistry,
-    InferenceRequestCounter,
-  )
+export function* _infer(schema?: SchemaObject): Generator<Rune<LEvent>, string> {
+  const modelRegistry = Context.getOrInit(ModelRegistry.make)
   const model = modelRegistry.peek()
   assert(model)
+  const messageRegistry = Context.getOrInit(MessageRegistry.make)
+  const counter = Context.getOrInit(InferenceRequestCounter)
   const requestId = counter.next()
-  yield* emit<InferenceRequested>({
-    [LEventTag]: "inference_requested",
-    ...schema && { schema },
-    requestId,
-  })
-  const inference = yield* rune(() => model.resolve(messages, schema))
-  yield* emit<Inferred>({
-    [LEventTag]: "inferred",
-    inference,
-    requestId,
-  })
+  yield* emit(new InferenceRequested(requestId, schema))
+  const inference = yield* rune(() => model.resolve(messageRegistry.messages, schema))
+  yield* emit(new Inferred(requestId, inference))
   return inference
 }
 
-class InferenceRequestCounter extends Counter {}
+function InferenceRequestCounter(instance?: Counter) {
+  return {
+    count: instance?.count ?? 0,
+    next() {
+      return this.count++
+    },
+    clone() {
+      return InferenceRequestCounter(this)
+    },
+  }
+}
+
+interface Counter {
+  count: number
+  next(): number
+}

package/L/_message.ts

@@ -1,18 +1,15 @@
-import { type LEvent, LEventTag, type MessageAppended } from "../LEvent.ts"
+import { Context } from "../Context.ts"
+import { type LEvent, MessageAppended } from "../LEvent.ts"
 import type { ContentPart, Message, MessageRole } from "../Message.ts"
 import type { Rune } from "../Rune.ts"
 import { MessageRegistry } from "../state/MessageRegistry.ts"
 import { emit } from "./emit.ts"
-import { state } from "./state.ts"
 
 export interface _message extends Generator<Rune<LEvent>, void> {}
 
 export function* _message(role: MessageRole, content: Array<ContentPart>): _message {
-  const [messageRegistry] = yield* state(MessageRegistry)
+  const messageRegistry = Context.getOrInit(MessageRegistry.make)
   const message: Message = { role, content }
-  yield* emit<MessageAppended>({
-    [LEventTag]: "message_appended",
-    message,
-  })
+  yield* emit(new MessageAppended(message))
   messageRegistry.append(message)
 }

package/L/assistant.ts

@@ -1,7 +1,4 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec"
-import { type LType, toJSONSchema } from "liminal-schema"
-import type { json } from "liminal-util"
-import { LiminalAssertionError } from "liminal-util"
+import { type LType, toJSONSchema, validate } from "liminal-schema"
 import type { LEvent } from "../LEvent.ts"
 import type { Rune } from "../Rune.ts"
 import { _infer } from "./_infer.ts"
@@ -18,11 +15,7 @@ export const assistant: assistant = Object.assign(
     const inference = yield* _infer(schema)
     yield* _message("assistant", [{ part: inference }])
     const input = JSON.parse(inference)
-    const result = yield* rune(() => (type as StandardSchemaV1<json.ValueObject, T>)["~standard"].validate(input))
-    if (result.issues) {
-      throw new LiminalAssertionError(JSON.stringify(result.issues, null, 2))
-    }
-    return result.value
+    return yield* rune(() => validate(type, input))
   },
   {
     *[Symbol.iterator]() {

package/L/branch.ts

@@ -1,10 +1,9 @@
-import { Fiber } from "../Fiber.ts"
+import { Context } from "../Context.ts"
+import { run } from "../run.ts"
 import { type Rune } from "../Rune.ts"
 import type { Runic } from "../Runic.ts"
-import { all } from "./all.ts"
-import { fork } from "./fork.ts"
-import { join } from "./join.ts"
-import { self } from "./self.ts"
+import { Fiber } from "../state/Fiber.ts"
+import { rune } from "./rune.ts"
 
 export interface branch<Y extends Rune, T> extends Generator<Y, T> {}
 
@@ -16,30 +15,23 @@ export function branch<XR extends Record<keyof any, Runic>>(
   runics: XR,
 ): branch<Runic.Y<XR[keyof XR]> | Rune<never>, { [K in keyof XR]: Runic.T<XR[K]> }>
 export function* branch(value: Runic | Array<Runic> | Record<keyof any, Runic>): branch<Rune, any> {
-  const parent = yield* self
-  const { globals, state } = parent
+  const parent = Context.get(Fiber.make)
   if (Array.isArray(value)) {
-    const fibers = value.map((runic) =>
-      Fiber({
-        globals,
-        parent,
-        runic,
-        state: state.clone(),
-      })
-    )
-    return yield* join(yield* all(...fibers))
+    const runners = value.map((runic) => {
+      const context = Context.make(Context.unwrap())
+      context.set(Fiber.make, new Fiber(parent))
+      return () => run(runic, context)
+    })
+    return yield* rune(() => Promise.all(runners.map((runner) => runner())))
   } else if (typeof value === "object") {
-    const fibers = Object.values(value).map((runic) =>
-      Fiber({
-        globals,
-        parent,
-        runic,
-        state: state.clone(),
-      })
-    )
-    const resolved = yield* join(yield* all(...fibers))
-    return Object.fromEntries(Object.keys(value).map((key, i) => [key, resolved[i]]))
+    const runners = Object.entries(value).map(([key, runic]) => {
+      const context = Context.make(Context.unwrap())
+      context.set(Fiber.make, new Fiber(parent))
+      return async () => [key, await run(runic, context)]
+    })
+    return yield* rune(() => Promise.all(runners.map((runner) => runner())).then(Object.fromEntries))
   }
-  const fiber = yield* fork(typeof value === "function" ? value() : value, state.clone())
-  return yield* join(fiber)
+  const context = Context.make(Context.unwrap())
+  context.set(Fiber.make, new Fiber(parent))
+  return yield* rune(() => run(typeof value === "function" ? value() : value, context))
 }

package/L/emit.ts

@@ -1,11 +1,16 @@
 import type { EnsureNarrow } from "liminal-util"
+import { Context } from "../Context.ts"
 import type { Rune } from "../Rune.ts"
-import { rune } from "./rune.ts"
+import { Fiber } from "../state/Fiber.ts"
+import { Globals } from "../state/Globals.ts"
 
 export interface emit<E> extends Generator<Rune<E>, void> {}
 
 export function* emit<const E>(event: EnsureNarrow<E>): emit<E> {
-  yield* rune((fiber) => {
-    fiber.handler(event)
-  })<E>()
+  const globals = Context.getAssert(Globals.make)
+  const fiber = Context.getAssert(Fiber.make)
+  globals.handler?.(event, {
+    fiber: fiber.index,
+    timestamp: Date.now(),
+  })
 }

package/L/fork.ts

@@ -1,18 +1,20 @@
-import { Fiber } from "../Fiber.ts"
-import type { Rune } from "../Rune.ts"
-import type { Runic } from "../Runic.ts"
-import type { StateMap } from "../state/StateMap.ts"
-import { rune } from "./rune.ts"
+// import type { FiberConfig } from "../Fiber.ts"
+// import type { Rune } from "../Rune.ts"
+// import type { Runic } from "../Runic.ts"
+// import { runic as runic_ } from "./runic.ts"
+// import { self } from "./self.ts"
 
-export interface fork<Y extends Rune, T> extends Generator<Rune<never> | Y, Fiber<T>> {}
+// export interface fork<Y extends Rune, T> extends Generator<Rune<any> | Y, FiberConfig<T>> {}
 
-export function* fork<Y extends Rune, T>(runic: Runic<Y, T>, state?: StateMap): fork<Y, T> {
-  return yield* rune((parent) =>
-    Fiber({
-      globals: parent.globals,
-      parent,
-      runic,
-      state: state?.clone(),
-    })
-  )
-}
+// export function* fork<Y extends Rune, T>(runic: Runic<Y, T>): fork<Y, T> {
+//   const parent = yield* self
+//   const { globals, state, signal } = parent
+//   const controller = new AbortController()
+//   const fiberConfig: FiberConfig = {
+//     T: null!,
+//     globals,
+//     signal: controller.signal,
+//     state: state?.clone(),
+//   }
+//   return (yield* runic_(runic, fiberConfig)) as never
+// }

package/L/model.ts

@@ -1,11 +1,11 @@
+import { Context } from "../Context.ts"
 import type { Model } from "../Model.ts"
 import type { Rune } from "../Rune.ts"
 import { ModelRegistry } from "../state/ModelRegistry.ts"
-import { state } from "./state.ts"
 
 export interface model extends Generator<Rune<never>, void> {}
 
 export function* model(model: Model): model {
-  const [modelRegistry] = yield* state(ModelRegistry)
+  const modelRegistry = Context.getOrInit(ModelRegistry.make)
   modelRegistry.register(model)
 }

package/L/rune.ts

@@ -1,11 +1,10 @@
-import type { Fiber } from "../Fiber.ts"
 import { type Rune, RuneKey } from "../Rune.ts"
 
 export interface rune<T> extends Iterable<Rune<never>, T> {
   <E>(): Generator<Rune<E>, T>
 }
 
-export function rune<R>(source: (fiber: Fiber) => R): rune<Awaited<R>> {
+export function rune<R>(source: () => R): rune<Awaited<R>> {
   return Object.assign(
     function*<E>(): Generator<Rune<E>, Awaited<R>> {
       return yield Object.assign(source, { [RuneKey]: {} as never })

package/LEvent.ts

@@ -1,35 +1,48 @@
-import type { SchemaRoot } from "liminal-schema"
+import type { SchemaObject } from "liminal-schema"
+import { EventBase } from "./EventBase.ts"
 import type { Message } from "./Message.ts"
 
 export type LEvent = InferenceRequested | Inferred | MessageAppended | FiberCreated | FiberStarted | FiberResolved
 
-export interface InferenceRequested extends LEventBase<"inference_requested"> {
-  requestId: number
-  schema?: SchemaRoot
-}
+export const LEventTag: unique symbol = Symbol.for("liminal/LEvent")
+export type LEventTag = typeof LEventTag
 
-export interface Inferred extends LEventBase<"inferred"> {
-  requestId: number
-  inference: string
+export class InferenceRequested extends EventBase(LEventTag, "inference_requested") {
+  declare schema?: SchemaObject
+  constructor(
+    readonly requestId: number,
+    schema?: SchemaObject | undefined,
+  ) {
+    super()
+    if (schema) {
+      this.schema = schema
+    }
+  }
 }
 
-export interface MessageAppended extends LEventBase<"message_appended"> {
-  message: Message
+export class Inferred extends EventBase(LEventTag, "inferred") {
+  constructor(
+    readonly requestId: number,
+    readonly inference: string,
+  ) {
+    super()
+  }
 }
 
-export interface FiberCreated extends LEventBase<"fiber_created"> {}
-export interface FiberStarted extends LEventBase<"fiber_started"> {}
-export interface FiberResolved extends LEventBase<"fiber_resolved"> {
-  value: any
+export class MessageAppended extends EventBase(LEventTag, "message_appended") {
+  constructor(readonly message: Message) {
+    super()
+  }
 }
 
-interface LEventBase<K extends string> {
-  [LEventTag]: K
+export class FiberCreated extends EventBase(LEventTag, "fiber_created") {}
+export class FiberStarted extends EventBase(LEventTag, "fiber_started") {}
+export class FiberResolved extends EventBase(LEventTag, "fiber_resolved") {
+  constructor(readonly value: any) {
+    super()
+  }
 }
 
-export const LEventTag: unique symbol = Symbol.for("liminal/LEvent")
-export type LEventTag = typeof LEventTag
-
 export function isLEvent(value: unknown): value is LEvent {
   return typeof value === "object" && value !== null && LEventTag in value
 }

package/Rune.ts

@@ -1,7 +1,5 @@
-import type { Fiber } from "./Fiber.ts"
-
 export interface Rune<out E = any> {
-  (fiber: Fiber): any
+  (): any
   [RuneKey]: E
 }
 

package/dist/Agent.d.ts

@@ -1,12 +1,8 @@
-import { type FiberInfo } from "./Fiber.ts";
 import type { Rune, RuneKey } from "./Rune.ts";
 import type { Runic } from "./Runic.ts";
+import { Globals } from "./state/Globals.ts";
 export interface Agent<out T, out E> extends PromiseLike<T> {
     T: T;
     E: E;
 }
-export declare function Agent<Y extends Rune, T>(runic: Runic<Y, T>, config?: AgentConfig<Y, T>): Agent<T, Rune.E<Y>>;
-export interface AgentConfig<Y extends Rune, _T> {
-    handler: (event: Y[RuneKey], info: FiberInfo) => void;
-    signal?: AbortSignal;
-}
+export declare function Agent<Y extends Rune, T>(runic: Runic<Y, T>, globals?: Partial<Globals<Y[RuneKey]>>): Agent<T, Rune.E<Y>>;

package/dist/Agent.js

@@ -1,15 +1,15 @@
-import { Fiber } from "./Fiber.js";
-export function Agent(runic, config) {
+import { Context } from "./Context.js";
+import { run } from "./run.js";
+import { Fiber } from "./state/Fiber.js";
+import { Globals } from "./state/Globals.js";
+export function Agent(runic, globals) {
     return {
         then(onfulfilled, onrejected) {
-            const root = Fiber({
-                globals: {
-                    handler: config?.handler ?? (() => { }),
-                },
-                runic,
-                signal: config?.signal,
-            });
-            return root.run().then(onfulfilled, onrejected);
+            const context = new Context([
+                [Globals.make, Globals.make(globals)],
+                [Fiber.make, Fiber.make()],
+            ]);
+            return Context.storage.run(context, () => run(runic).then(onfulfilled, onrejected));
         },
     };
 }

package/dist/Agent.js.map

@@ -1 +1 @@
-{"version":3,"file":"Agent.js","sourceRoot":"","sources":["../Agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAkB,MAAM,YAAY,CAAA;AASlD,MAAM,UAAU,KAAK,CAAoB,KAAkB,EAAE,MAA0B;IACrF,OAAO;QACL,IAAI,CAAC,WAAW,EAAE,UAAU;YAC1B,MAAM,IAAI,GAAG,KAAK,CAAC;gBACjB,OAAO,EAAE;oBACP,OAAO,EAAE,MAAM,EAAE,OAAO,IAAI,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC;iBACvC;gBACD,KAAK;gBACL,MAAM,EAAE,MAAM,EAAE,MAAM;aACvB,CAAC,CAAA;YACF,OAAO,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,CAAA;QACjD,CAAC;KACsD,CAAA;AAC3D,CAAC"}
+{"version":3,"file":"Agent.js","sourceRoot":"","sources":["../Agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAG9B,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAO5C,MAAM,UAAU,KAAK,CACnB,KAAkB,EAClB,OAAsC;IAEtC,OAAO;QACL,IAAI,CAAC,WAAW,EAAE,UAAU;YAC1B,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC;gBAC1B,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBACrC,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC;aAC3B,CAAC,CAAA;YACF,OAAO,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC,CAAA;QACrF,CAAC;KACsD,CAAA;AAC3D,CAAC"}

package/dist/Context.d.ts

@@ -0,0 +1,10 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+export declare class Context extends Map<StateFactory, unknown> {
+    static storage: AsyncLocalStorage<Context>;
+    static make(context?: Context): Context;
+    static unwrap(): Context;
+    static get<T>(factory: StateFactory<T>): T | undefined;
+    static getAssert<T>(factory: StateFactory<T>): T;
+    static getOrInit<T>(factory: StateFactory<T>): T;
+}
+export type StateFactory<T = any> = (instance?: T) => T;

package/dist/Context.js

@@ -0,0 +1,37 @@
+import { assert } from "liminal-util";
+import { AsyncLocalStorage } from "node:async_hooks";
+export class Context extends Map {
+    static storage = new AsyncLocalStorage();
+    static make(context) {
+        const instance = new Context();
+        if (context) {
+            for (const [key, value] of context.entries()) {
+                instance.set(key, key(value));
+            }
+        }
+        return instance;
+    }
+    static unwrap() {
+        const context = this.storage.getStore();
+        assert(context);
+        return context;
+    }
+    static get(factory) {
+        return this.unwrap().get(factory);
+    }
+    static getAssert(factory) {
+        const value = this.get(factory);
+        assert(value);
+        return value;
+    }
+    static getOrInit(factory) {
+        let context = this.unwrap();
+        let instance = context.get(factory);
+        if (!instance) {
+            instance = factory();
+            context.set(factory, instance);
+        }
+        return instance;
+    }
+}
+//# sourceMappingURL=Context.js.map

package/dist/Context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Context.js","sourceRoot":"","sources":["../Context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AACrC,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAEpD,MAAM,OAAO,OAAQ,SAAQ,GAA0B;IACrD,MAAM,CAAC,OAAO,GAA+B,IAAI,iBAAiB,EAAW,CAAA;IAE7E,MAAM,CAAC,IAAI,CAAC,OAAiB;QAC3B,MAAM,QAAQ,GAAG,IAAI,OAAO,EAAE,CAAA;QAC9B,IAAI,OAAO,EAAE,CAAC;YACZ,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC;gBAC7C,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,CAAA;YAC/B,CAAC;QACH,CAAC;QACD,OAAO,QAAQ,CAAA;IACjB,CAAC;IAED,MAAM,CAAC,MAAM;QACX,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAA;QACvC,MAAM,CAAC,OAAO,CAAC,CAAA;QACf,OAAO,OAAO,CAAA;IAChB,CAAC;IAED,MAAM,CAAC,GAAG,CAAI,OAAwB;QACpC,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,OAAO,CAAU,CAAA;IAC5C,CAAC;IAED,MAAM,CAAC,SAAS,CAAI,OAAwB;QAC1C,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;QAC/B,MAAM,CAAC,KAAK,CAAC,CAAA;QACb,OAAO,KAAK,CAAA;IACd,CAAC;IAED,MAAM,CAAC,SAAS,CAAI,OAAwB;QAC1C,IAAI,OAAO,GAAG,IAAI,CAAC,MAAM,EAAE,CAAA;QAC3B,IAAI,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;QACnC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,QAAQ,GAAG,OAAO,EAAE,CAAA;YACpB,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;QAChC,CAAC;QACD,OAAO,QAAiB,CAAA;IAC1B,CAAC"}

package/dist/EventBase.d.ts

@@ -0,0 +1,10 @@
+export interface EventBase<B extends symbol = symbol, K extends string = string> {
+    readonly brand: B;
+    readonly type: K;
+}
+export declare function EventBase<B extends symbol, K extends string>(brand: B, type: K): {
+    new (): {
+        readonly brand: B;
+        readonly type: K;
+    };
+};

package/dist/EventBase.js

@@ -0,0 +1,20 @@
+import { inspect } from "node:util";
+export function EventBase(brand, type) {
+    return class {
+        brand = brand;
+        type = type;
+        // Allows us to circumvent a false positive ts error related to private symbols.
+        // https://github.com/microsoft/TypeScript/issues/58496
+        static {
+            Object.defineProperties(this.prototype, {
+                [inspect.custom]: {
+                    value(depth, options) {
+                        const { brand: _0, type: _1, ...rest } = this;
+                        return `${this.constructor.name} ` + inspect(rest, { ...options, depth });
+                    },
+                },
+            });
+        }
+    };
+}
+//# sourceMappingURL=EventBase.js.map

package/dist/EventBase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventBase.js","sourceRoot":"","sources":["../EventBase.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAuB,MAAM,WAAW,CAAA;AAOxD,MAAM,UAAU,SAAS,CAAqC,KAAQ,EAAE,IAAO;IAC7E,OAAO;QACI,KAAK,GAAG,KAAK,CAAA;QACb,IAAI,GAAG,IAAI,CAAA;QAEpB,gFAAgF;QAChF,uDAAuD;QACvD;YACE,MAAM,CAAC,gBAAgB,CAAC,IAAI,CAAC,SAAS,EAAE;gBACtC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;oBAChB,KAAK,CAAC,KAAa,EAAE,OAAuB;wBAC1C,MAAM,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,IAAI,EAAE,GAAG,IAAI,CAAA;wBAC7C,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,GAAG,GAAG,OAAO,CAAC,IAAI,EAAE,EAAE,GAAG,OAAO,EAAE,KAAK,EAAE,CAAC,CAAA;oBAC3E,CAAC;iBACF;aACF,CAAC,CAAA;QACJ,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/Globals.d.ts

@@ -2,6 +2,5 @@ export interface Globals {
     handler<E = any>(event: E, info: EventInfo): void;
 }
 export interface EventInfo {
-    fiber: number;
     timestamp: number;
 }