liminal 0.5.5 → 0.5.6

package/Agent.ts

@@ -1,9 +1,18 @@
 import { Context } from "./Context.ts"
-import { run } from "./run.ts"
-import type { Rune, RuneKey } from "./Rune.ts"
+import { Fiber } from "./Fiber.ts"
+import { HandlerContext } from "./Handler.ts"
+import { MessageRegistry, MessageRegistryContext } from "./MessageRegistry.ts"
+import { ModelRegistry, ModelRegistryContext } from "./ModelRegistry.ts"
+import type { Rune } from "./Rune.ts"
 import type { Runic } from "./Runic.ts"
-import { Fiber } from "./state/Fiber.ts"
-import { Globals } from "./state/Globals.ts"
+import type { RuntimeEvent } from "./RuntimeEvent.ts"
+
+export interface AgentConfig<E> {
+  handler?: ((event: RuntimeEvent<E>) => void) | undefined
+  models?: ModelRegistry
+  messages?: MessageRegistry
+  signal?: AbortSignal | undefined
+}
 
 export interface Agent<out T, out E> extends PromiseLike<T> {
   T: T
@@ -12,15 +21,16 @@ export interface Agent<out T, out E> extends PromiseLike<T> {
 
 export function Agent<Y extends Rune, T>(
   runic: Runic<Y, T>,
-  globals?: Partial<Globals<Y[RuneKey]>>,
+  config?: AgentConfig<Rune.E<Y>>,
 ): Agent<T, Rune.E<Y>> {
   return {
     then(onfulfilled, onrejected) {
-      const context = new Context([
-        [Globals.make, Globals.make(globals)],
-        [Fiber.make, Fiber.make()],
+      const rootCtx = new Context([
+        [HandlerContext, config?.handler],
+        [ModelRegistryContext, config?.models ?? new ModelRegistry()],
+        [MessageRegistryContext, config?.messages ?? new MessageRegistry()],
       ])
-      return Context.storage.run(context, () => run(runic).then(onfulfilled, onrejected))
+      return rootCtx.run(() => Fiber(runic).resolve().then(onfulfilled, onrejected))
     },
   } satisfies Omit<Agent<T, Rune.E<Y>>, "E" | "T"> as never
 }

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # liminal
 
+## 0.5.6
+
+### Patch Changes
+
+- f79205e: Include fiber information in the event type supplied to user-specified handlers. Continue reworking runtime implementation.
+
 ## 0.5.5
 
 ### Patch Changes

package/Context.ts

@@ -1,44 +1,52 @@
 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
-  }
+const storage = new AsyncLocalStorage<Context>()
 
-  static unwrap(): Context {
-    const context = this.storage.getStore()
+export class Context extends Map<ContextHandle, unknown> {
+  static ensure(): Context {
+    const context = storage.getStore()
     assert(context)
     return context
   }
 
-  static get<T>(factory: StateFactory<T>): T | undefined {
-    return this.unwrap().get(factory) as never
+  get<V>(context: ContextHandle<V>): V | undefined {
+    return super.get(context) as never
+  }
+
+  getOrInit<V>(context: ContextHandle<V>, init: () => V): V {
+    if (this.has(context)) {
+      return this.get(context) as V
+    }
+    const instance = init()
+    this.set(context, instance)
+    return instance
   }
 
-  static getAssert<T>(factory: StateFactory<T>): T {
-    const value = this.get(factory)
-    assert(value)
-    return value
+  set<V>(context: ContextHandle<V>, value: V): this {
+    super.set(context, value)
+    return this
   }
 
-  static getOrInit<T>(factory: StateFactory<T>): T {
-    let context = this.unwrap()
-    let instance = context.get(factory)
-    if (!instance) {
-      instance = factory()
-      context.set(factory, instance)
+  run<R>(callback: () => R): R {
+    return storage.run(this, callback)
+  }
+
+  clone(overrides?: Iterable<[ContextHandle, unknown]>): Context {
+    const context = new Context(overrides)
+    for (const [handle, value] of this.entries()) {
+      if (!context.has(handle)) {
+        context.set(handle, handle.clone?.(value) ?? value)
+      }
     }
-    return instance as never
+    return context
   }
 }
 
-export type StateFactory<T = any> = (instance?: T) => T
+export type ContextHandle<V = any> = {
+  clone?: ((value: V) => V) | undefined
+}
+
+export function ContextHandle<V>(clone?: (value: V) => V): ContextHandle<V> {
+  return { clone }
+}

package/Fiber.ts

@@ -0,0 +1,54 @@
+import { Context } from "./Context.ts"
+import type { Rune } from "./Rune.ts"
+import { Runic } from "./Runic.ts"
+
+export interface FiberInfo {
+  readonly index: number
+  readonly parent?: FiberInfo
+}
+
+let nextIndex = 0
+
+export interface Fiber<T = any> {
+  parent?: Fiber | undefined
+  info: FiberInfo
+  resolve(): Promise<T>
+}
+
+export function Fiber<T = any>(runic: Runic<Rune, T>, parent?: Fiber): Fiber<T> {
+  let index = nextIndex++
+  let pending: Promise<T> | undefined
+  const context = Context.ensure()
+  return {
+    parent,
+    info: {
+      index,
+      ...parent && { parent: parent.info },
+    },
+    resolve,
+  }
+
+  function resolve(this: Fiber<T>): Promise<T> {
+    if (!pending) {
+      const { promise, resolve, reject } = Promise.withResolvers<T>()
+      pending = promise
+      const iterator = Runic.unwrap(runic)
+      let nextArg: unknown
+      context.run(async () => {
+        try {
+          let current = await iterator.next()
+          while (!current.done) {
+            const rune = current.value
+            nextArg = await rune(this)
+            current = await iterator.next(nextArg)
+          }
+          const { value } = current
+          resolve(value)
+        } catch (error) {
+          reject(error)
+        }
+      })
+    }
+    return pending
+  }
+}

package/Handler.ts

@@ -0,0 +1,6 @@
+import { ContextHandle } from "./Context.ts"
+import type { RuntimeEvent } from "./RuntimeEvent.ts"
+
+export type Handler<E = any> = [(event: RuntimeEvent<E>) => void][0]
+
+export const HandlerContext: ContextHandle<Handler | undefined> = ContextHandle()

package/L/L.ts

@@ -4,7 +4,6 @@ export * from "./_message.ts"
 export * from "./assistant.ts"
 export * from "./branch.ts"
 export * from "./emit.ts"
-export * from "./fork.ts"
 export * from "./model.ts"
 export * from "./system.ts"
 export * from "./user.ts"

package/L/_infer.ts

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

package/L/_message.ts

@@ -1,14 +1,17 @@
+import { assert } from "liminal-util"
 import { Context } from "../Context.ts"
 import { type LEvent, MessageAppended } from "../LEvent.ts"
 import type { ContentPart, Message, MessageRole } from "../Message.ts"
+import { MessageRegistryContext } from "../MessageRegistry.ts"
 import type { Rune } from "../Rune.ts"
-import { MessageRegistry } from "../state/MessageRegistry.ts"
 import { emit } from "./emit.ts"
 
 export interface _message extends Generator<Rune<LEvent>, void> {}
 
 export function* _message(role: MessageRole, content: Array<ContentPart>): _message {
-  const messageRegistry = Context.getOrInit(MessageRegistry.make)
+  const context = Context.ensure()
+  const messageRegistry = context.get(MessageRegistryContext)
+  assert(messageRegistry)
   const message: Message = { role, content }
   yield* emit(new MessageAppended(message))
   messageRegistry.append(message)

package/L/branch.ts

@@ -1,8 +1,7 @@
 import { Context } from "../Context.ts"
-import { run } from "../run.ts"
+import { Fiber } from "../Fiber.ts"
 import { type Rune } from "../Rune.ts"
 import type { Runic } from "../Runic.ts"
-import { Fiber } from "../state/Fiber.ts"
 import { rune } from "./rune.ts"
 
 export interface branch<Y extends Rune, T> extends Generator<Y, T> {}
@@ -15,23 +14,20 @@ 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 = Context.get(Fiber.make)
+  const context = Context.ensure()
+  const parent = yield* rune((fiber) => fiber)
   if (Array.isArray(value)) {
-    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())))
+    const fibers = value.map((runic) => context.clone().run(() => Fiber(runic, parent)))
+    return yield* rune(() => Promise.all(fibers.map(({ resolve }) => resolve())))
   } else if (typeof value === "object") {
-    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 entries = Object.entries(value)
+    const fibers = entries.map(([_key, runic]) => context.clone().run(() => Fiber(runic, parent)))
+    return yield* rune(() =>
+      Promise
+        .all(fibers.map(({ resolve }, i) => resolve().then((value) => [entries[i]![0], value])))
+        .then(Object.fromEntries)
+    )
   }
-  const context = Context.make(Context.unwrap())
-  context.set(Fiber.make, new Fiber(parent))
-  return yield* rune(() => run(typeof value === "function" ? value() : value, context))
+  const fiber = context.clone().run(() => Fiber(typeof value === "function" ? value() : value, parent))
+  return yield* rune(() => fiber.resolve())
 }

package/L/emit.ts

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

package/L/model.ts

@@ -1,11 +1,17 @@
+import { assert } from "liminal-util"
 import { Context } from "../Context.ts"
+import { ModelRegistered } from "../LEvent.ts"
 import type { Model } from "../Model.ts"
+import { ModelRegistryContext } from "../ModelRegistry.ts"
 import type { Rune } from "../Rune.ts"
-import { ModelRegistry } from "../state/ModelRegistry.ts"
+import { emit } from "./emit.ts"
 
-export interface model extends Generator<Rune<never>, void> {}
+export interface model extends Generator<Rune<ModelRegistered>, void> {}
 
 export function* model(model: Model): model {
-  const modelRegistry = Context.getOrInit(ModelRegistry.make)
-  modelRegistry.register(model)
+  const context = Context.ensure()
+  const registry = context.get(ModelRegistryContext)
+  assert(registry)
+  registry.register(model)
+  yield* emit(new ModelRegistered(model))
 }

package/L/rune.ts

@@ -1,10 +1,11 @@
+import { 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: () => R): rune<Awaited<R>> {
+export function rune<R>(source: (fiber: Fiber) => 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,12 +1,26 @@
 import type { SchemaObject } from "liminal-schema"
 import { EventBase } from "./EventBase.ts"
 import type { Message } from "./Message.ts"
+import type { Model } from "./Model.ts"
 
-export type LEvent = InferenceRequested | Inferred | MessageAppended | FiberCreated | FiberStarted | FiberResolved
+export type LEvent =
+  | FiberCreated
+  | FiberResolved
+  | FiberStarted
+  | InferenceRequested
+  | Inferred
+  | MessageAppended
+  | ModelRegistered
 
 export const LEventTag: unique symbol = Symbol.for("liminal/LEvent")
 export type LEventTag = typeof LEventTag
 
+export class ModelRegistered extends EventBase(LEventTag, "model_registered") {
+  constructor(readonly model: Model) {
+    super()
+  }
+}
+
 export class InferenceRequested extends EventBase(LEventTag, "inference_requested") {
   declare schema?: SchemaObject
   constructor(

package/MessageRegistry.ts

@@ -0,0 +1,21 @@
+import { ContextHandle } from "./Context.ts"
+import type { Message } from "./Message.ts"
+
+export class MessageRegistry {
+  messages: Array<Message>
+  constructor(messages?: Array<Message>) {
+    this.messages = messages ?? []
+  }
+
+  append(message: Message): void {
+    this.messages.push(message)
+  }
+
+  clone(): MessageRegistry {
+    return new MessageRegistry([...this.messages])
+  }
+}
+
+export const MessageRegistryContext: ContextHandle<MessageRegistry> = ContextHandle(({ messages }) =>
+  new MessageRegistry([...messages])
+)

package/{state/ModelRegistry.ts → ModelRegistry.ts}

@@ -1,21 +1,20 @@
-import type { Model } from "../Model.ts"
+import { ContextHandle } from "./Context.ts"
+import type { Model } from "./Model.ts"
 
 /** An intrusive list for storing `Model`s. */
 export class ModelRegistry {
-  static make(modelRegistry?: ModelRegistry) {
-    const instance = new ModelRegistry()
-    if (modelRegistry) {
-      for (let node = modelRegistry.head; node; node = node.next) {
-        instance.register(node.model)
+  declare head?: ModelRegistryNode | undefined
+  declare tail?: ModelRegistryNode | undefined
+
+  constructor(models?: Array<Model>) {
+    if (models) {
+      for (const model of models) {
+        this.register(model)
       }
     }
-    return instance
   }
 
-  declare head?: ModelRegistryNode | undefined
-  declare tail?: ModelRegistryNode | undefined
-
-  peek(): Model | undefined {
+  peek() {
     return this.tail?.model
   }
 
@@ -33,7 +32,7 @@ export class ModelRegistry {
     return node
   }
 
-  remove(node: ModelRegistryNode): void {
+  remove(node: ModelRegistryNode) {
     if (node.prev) {
       node.prev.next = node.next
     }
@@ -55,3 +54,11 @@ export interface ModelRegistryNode {
   model: Model
   next?: ModelRegistryNode | undefined
 }
+
+export const ModelRegistryContext: ContextHandle<ModelRegistry> = ContextHandle(({ head }) => {
+  const instance = new ModelRegistry()
+  for (let node = head; node; node = node.next) {
+    instance.register(node.model)
+  }
+  return instance
+})

package/Rune.ts

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

package/Runic.ts

@@ -1,11 +1,19 @@
 import type { Rune } from "./Rune.ts"
 
 export type RuneIterator<Y extends Rune = Rune, T = any> = Iterator<Y, T> | AsyncIterator<Y, T>
-export type RuneIterable<Y extends Rune, T> = Iterable<Y, T> | AsyncIterable<Y, T>
+export type RuneIterable<Y extends Rune = Rune, T = any> = Iterable<Y, T> | AsyncIterable<Y, T>
 export type Runic<Y extends Rune = Rune, T = any> = RuneIterable<Y, T> | (() => RuneIterable<Y, T>)
+
 export namespace Runic {
-  export type Y<R extends Runic> = R extends Runic<infer Y> ? Y : never
-  export type T<R extends Runic> = R extends Runic<Rune, infer T> ? T : never
+  export type Y<X extends Runic> = X extends RuneIterable<infer Y> ? Y
+    : X extends () => RuneIterable<infer Y> ? Y
+    : X extends RuneIterator<infer Y> ? Y
+    : never
+
+  export type T<X extends Runic> = X extends RuneIterable<Rune, infer T> ? T
+    : X extends () => RuneIterable<Rune, infer T> ? T
+    : X extends RuneIterator<Rune, infer T> ? T
+    : never
 
   export function unwrap<Y extends Rune, T>(runic: Runic<Y, T>): RuneIterator<Y, T> {
     if (Symbol.iterator in runic) {

package/RuntimeEvent.ts

@@ -0,0 +1,6 @@
+import type { Fiber, FiberInfo } from "./Fiber.ts"
+
+export interface RuntimeEvent<E> extends FiberInfo {
+  readonly parent?: FiberInfo
+  readonly event: E
+}

package/dist/Agent.d.ts

@@ -1,8 +1,16 @@
-import type { Rune, RuneKey } from "./Rune.ts";
+import { MessageRegistry } from "./MessageRegistry.ts";
+import { ModelRegistry } from "./ModelRegistry.ts";
+import type { Rune } from "./Rune.ts";
 import type { Runic } from "./Runic.ts";
-import { Globals } from "./state/Globals.ts";
+import type { RuntimeEvent } from "./RuntimeEvent.ts";
+export interface AgentConfig<E> {
+    handler?: ((event: RuntimeEvent<E>) => void) | undefined;
+    models?: ModelRegistry;
+    messages?: MessageRegistry;
+    signal?: AbortSignal | undefined;
+}
 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>, globals?: Partial<Globals<Y[RuneKey]>>): Agent<T, Rune.E<Y>>;
+export declare function Agent<Y extends Rune, T>(runic: Runic<Y, T>, config?: AgentConfig<Rune.E<Y>>): Agent<T, Rune.E<Y>>;

package/dist/Agent.js

@@ -1,15 +1,17 @@
 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) {
+import { Fiber } from "./Fiber.js";
+import { HandlerContext } from "./Handler.js";
+import { MessageRegistry, MessageRegistryContext } from "./MessageRegistry.js";
+import { ModelRegistry, ModelRegistryContext } from "./ModelRegistry.js";
+export function Agent(runic, config) {
     return {
         then(onfulfilled, onrejected) {
-            const context = new Context([
-                [Globals.make, Globals.make(globals)],
-                [Fiber.make, Fiber.make()],
+            const rootCtx = new Context([
+                [HandlerContext, config?.handler],
+                [ModelRegistryContext, config?.models ?? new ModelRegistry()],
+                [MessageRegistryContext, config?.messages ?? new MessageRegistry()],
             ]);
-            return Context.storage.run(context, () => run(runic).then(onfulfilled, onrejected));
+            return rootCtx.run(() => Fiber(runic).resolve().then(onfulfilled, onrejected));
         },
     };
 }

package/dist/Agent.js.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"Agent.js","sourceRoot":"","sources":["../Agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAA;AAC9E,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAiBxE,MAAM,UAAU,KAAK,CACnB,KAAkB,EAClB,MAA+B;IAE/B,OAAO;QACL,IAAI,CAAC,WAAW,EAAE,UAAU;YAC1B,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC;gBAC1B,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,CAAC;gBACjC,CAAC,oBAAoB,EAAE,MAAM,EAAE,MAAM,IAAI,IAAI,aAAa,EAAE,CAAC;gBAC7D,CAAC,sBAAsB,EAAE,MAAM,EAAE,QAAQ,IAAI,IAAI,eAAe,EAAE,CAAC;aACpE,CAAC,CAAA;YACF,OAAO,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC,CAAA;QAChF,CAAC;KACsD,CAAA;AAC3D,CAAC"}

package/dist/Context.d.ts

@@ -1,10 +1,12 @@
-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 declare class Context extends Map<ContextHandle, unknown> {
+    static ensure(): Context;
+    get<V>(context: ContextHandle<V>): V | undefined;
+    getOrInit<V>(context: ContextHandle<V>, init: () => V): V;
+    set<V>(context: ContextHandle<V>, value: V): this;
+    run<R>(callback: () => R): R;
+    clone(overrides?: Iterable<[ContextHandle, unknown]>): Context;
 }
-export type StateFactory<T = any> = (instance?: T) => T;
+export type ContextHandle<V = any> = {
+    clone?: ((value: V) => V) | undefined;
+};
+export declare function ContextHandle<V>(clone?: (value: V) => V): ContextHandle<V>;