liminal 0.5.7 → 0.5.9

package/Agent.ts

@@ -5,11 +5,13 @@ 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 { ToolRegistry, ToolRegistryContext } from "./ToolRegistry.ts"
 
-export interface AgentConfig<E> {
-  handler?: ((this: Fiber, event: E) => void) | undefined
+export interface AgentConfig<T, E> {
+  handler?: ((this: Fiber<T>, event: E) => void) | undefined
   models?: ModelRegistry
   messages?: MessageRegistry
+  tools?: ToolRegistry
   signal?: AbortSignal | undefined
 }
 
@@ -20,16 +22,17 @@ export interface Agent<out T, out E> extends PromiseLike<T> {
 
 export function Agent<Y extends Rune, T>(
   runic: Runic<Y, T>,
-  config?: AgentConfig<Rune.E<Y>>,
+  config?: AgentConfig<T, Rune.E<Y>>,
 ): Agent<T, Rune.E<Y>> {
   return {
     then(onfulfilled, onrejected) {
-      const rootCtx = new Context([
+      return new Context([
         [HandlerContext, config?.handler],
         [ModelRegistryContext, config?.models ?? new ModelRegistry()],
         [MessageRegistryContext, config?.messages ?? new MessageRegistry()],
+        [ToolRegistryContext, config?.tools ?? new ToolRegistry()],
       ])
-      return rootCtx.run(() => new Fiber(runic).resolve().then(onfulfilled, onrejected))
+        .run(() => new Fiber(runic).resolution().then(onfulfilled, onrejected))
     },
   } satisfies Omit<Agent<T, Rune.E<Y>>, "E" | "T"> as never
 }

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # liminal
 
+## 0.5.9
+
+### Patch Changes
+
+- dbd5e93: Reintroduced tools and various examples.
+
+## 0.5.8
+
+### Patch Changes
+
+- 23a24ae: Reintroduce L.catch and clean up parts of the generator runtime.
+- f2f360c: Continue to clean up the generator runtime internals.
+- Updated dependencies [23a24ae]
+- Updated dependencies [f2f360c]
+  - liminal-schema@0.0.3
+  - liminal-util@0.0.4
+
 ## 0.5.7
 
 ### Patch Changes

package/Context.ts

@@ -14,15 +14,6 @@ export class Context extends Map<ContextHandle, unknown> {
     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
-  }
-
   set<V>(context: ContextHandle<V>, value: V): this {
     super.set(context, value)
     return this
@@ -44,7 +35,7 @@ export class Context extends Map<ContextHandle, unknown> {
 }
 
 export type ContextHandle<V = any> = {
-  clone?: ((value: V) => V) | undefined
+  clone: ((value: V) => V) | undefined
 }
 
 export function ContextHandle<V>(clone?: (value: V) => V): ContextHandle<V> {

package/Fiber.ts

@@ -3,41 +3,108 @@ import { Context } from "./Context.ts"
 import type { Rune } from "./Rune.ts"
 import { Runic } from "./Runic.ts"
 
-let nextIndex = 0
+export type FiberStatus<T> = {
+  type: "untouched"
+} | {
+  type: "pending"
+  self: AbortSignal
+  promise: Promise<T>
+} | {
+  type: "aborted"
+  reason: unknown
+} | {
+  type: "resolved"
+  value: T
+} | {
+  type: "rejected"
+  exception: unknown
+}
 
 export class Fiber<T = any> {
-  readonly index = nextIndex++
+  static nextIndex: number = 0
+
+  declare T: T
+  readonly index: number = Fiber.nextIndex++
+
+  #runic: Runic<Rune, T>
   declare readonly parent?: Fiber
-  context = Context.ensure()
-  pending: Promise<T> | undefined
-  constructor(readonly runic: Runic<Rune, T>, parent?: Fiber) {
+  #context: Context = Context.ensure()
+
+  signal: AbortSignal
+  either: AbortSignal
+  abort: (reason?: any) => void
+
+  status: FiberStatus<T> = { type: "untouched" }
+
+  constructor(runic: Runic<Rune, T>, parent?: Fiber) {
+    this.#runic = runic
     if (parent) {
       this.parent = parent
     }
+    const controller = new AbortController()
+    this.signal = controller.signal
+    this.either = AbortSignal.any([
+      ...this.parent?.signal ? [this.parent.signal] : [],
+      this.signal,
+    ])
+    this.abort = controller.abort.bind(controller)
   }
 
-  resolve(this: Fiber<T>): Promise<T> {
-    if (!this.pending) {
-      const { promise, resolve, reject } = Promise.withResolvers<T>()
-      this.pending = promise
-      const iterator = Runic.unwrap(this.runic)
-      let nextArg: unknown
-      this.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)
+  fork<T>(runic: Runic<Rune, T>): Fiber<T> {
+    return new Fiber(runic, this)
+  }
+
+  resolution(this: Fiber<T>): Promise<T> {
+    const { status, abort } = this
+    switch (status.type) {
+      case "untouched": {
+        const { promise, resolve, reject } = Promise.withResolvers<T>()
+        this.status = {
+          type: "pending",
+          self: this.signal,
+          promise,
         }
-      })
+        const iterator = Runic.unwrap(this.#runic)
+        let nextArg: unknown
+        this.#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
+            this.status = {
+              type: "resolved",
+              value,
+            }
+            abort()
+            resolve(value)
+          } catch (exception) {
+            this.status = {
+              type: "rejected",
+              exception,
+            }
+            abort(exception)
+            reject(exception)
+          }
+        })
+        return promise
+      }
+      case "pending": {
+        return status.promise
+      }
+      case "resolved": {
+        return Promise.resolve(status.value)
+      }
+      case "rejected": {
+        return Promise.reject(status.exception)
+      }
+      case "aborted": {
+        return Promise.reject(status.reason)
+      }
     }
-    return this.pending
   }
 
   static {

package/L/L.ts

@@ -3,6 +3,7 @@ export * from "./_infer.ts"
 export * from "./_message.ts"
 export * from "./assistant.ts"
 export * from "./branch.ts"
+export * from "./catch.ts"
 export * from "./emit.ts"
 export * from "./model.ts"
 export * from "./system.ts"

package/L/_infer.ts

@@ -1,6 +1,6 @@
 import type { SchemaObject } from "liminal-schema"
 import { assert } from "liminal-util"
-import { Context, ContextHandle } from "../Context.ts"
+import { Context } from "../Context.ts"
 import { InferenceRequested, Inferred, type LEvent } from "../LEvent.ts"
 import { MessageRegistryContext } from "../MessageRegistry.ts"
 import { ModelRegistryContext } from "../ModelRegistry.ts"
@@ -14,20 +14,18 @@ export function* _infer(schema?: SchemaObject): Generator<Rune<LEvent>, string>
   assert(modelRegistry)
   const model = modelRegistry.peek()
   assert(model)
-  const requestId = context.getOrInit(InferenceRequestCounterContext, () => new InferenceRequestCounter()).next()
+  const requestId = InferenceCounter.next()
   yield* emit(new InferenceRequested(requestId, schema))
   const messageRegistry = context.get(MessageRegistryContext)
   assert(messageRegistry)
-  const inference = yield* rune(() => model.resolve(messageRegistry.messages, schema))
+  const inference = yield* rune(() => model.resolve(messageRegistry.messages, schema), "infer")
   yield* emit(new Inferred(requestId, inference))
   return inference
 }
 
-class InferenceRequestCounter {
-  count: number = 0
-  next(): number {
+class InferenceCounter {
+  static count: number = 0
+  static next(): number {
     return this.count++
   }
 }
-
-const InferenceRequestCounterContext: ContextHandle<InferenceRequestCounter> = ContextHandle()

package/L/assistant.ts

@@ -6,7 +6,7 @@ import { _message } from "./_message.ts"
 import { rune } from "./rune.ts"
 
 export interface assistant extends Iterable<Rune<LEvent>, string> {
-  <T>(schema: LType<T>): Generator<Rune<LEvent>, T>
+  <T>(type: LType<T>): Generator<Rune<LEvent>, T>
 }
 
 export const assistant: assistant = Object.assign(
@@ -15,7 +15,7 @@ export const assistant: assistant = Object.assign(
     const inference = yield* _infer(schema)
     yield* _message("assistant", [{ part: inference }])
     const input = JSON.parse(inference)
-    return yield* rune(() => validate(type, input))
+    return yield* rune(() => validate(type, input), "validate_assistant_message")
   },
   {
     *[Symbol.iterator]() {

package/L/branch.ts

@@ -1,5 +1,4 @@
 import { Context } from "../Context.ts"
-import { Fiber } from "../Fiber.ts"
 import { type Rune } from "../Rune.ts"
 import type { Runic } from "../Runic.ts"
 import { rune } from "./rune.ts"
@@ -15,15 +14,20 @@ export function branch<XR extends Record<keyof any, Runic>>(
 ): 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 context = Context.ensure()
-  const parent = yield* rune((fiber) => fiber)
+  const parent = yield* rune
   if (Array.isArray(value)) {
-    const fibers = value.map((runic) => context.clone().run(() => new Fiber(runic, parent)))
-    return yield* rune(() => Promise.all(fibers.map((fiber) => fiber.resolve())))
+    const fibers = value.map((runic) => context.clone().run(() => parent.fork(runic)))
+    return yield* rune(() => Promise.all(fibers.map((fiber) => fiber.resolution())), "branch")
   } else if (typeof value === "object") {
-    const entries = Object.entries(value)
-    const fibers = entries.map(([_key, runic]) => context.clone().run(() => new Fiber(runic, parent)))
-    return yield* rune(() => Promise.all(fibers.map((fiber) => fiber.resolve())).then(Object.fromEntries))
+    const fibers = Object.values(value).map((runic) => context.clone().run(() => parent.fork(runic)))
+    return yield* rune(async () => {
+      const keys = Object.keys(value)
+      return await Promise
+        .all(fibers.map((fiber) => fiber.resolution()))
+        .then((resolved) => resolved.map((value, i) => [keys[i], value]))
+        .then(Object.fromEntries)
+    }, "branch")
   }
-  const fiber = context.clone().run(() => new Fiber(typeof value === "function" ? value() : value, parent))
-  return yield* rune(() => fiber.resolve())
+  const fiber = context.clone().run(() => parent.fork(typeof value === "function" ? value() : value))
+  return yield* rune(() => fiber.resolution(), "branch")
 }

package/L/catch.ts

@@ -0,0 +1,23 @@
+import type { Rune } from "../Rune.ts"
+import type { Runic } from "../Runic.ts"
+import { rune } from "./rune.ts"
+
+export { catch_ as catch }
+function* catch_<Y extends Rune, T>(runic: Runic<Y, T>): Generator<Rune<Y>, CatchResult<T>> {
+  return yield* rune(async (fiber) => {
+    try {
+      return { resolved: await fiber.fork(runic).resolution() }
+    } catch (exception: unknown) {
+      return { rejected: exception }
+    }
+  }, "catch")
+}
+Object.defineProperty(catch_, "name", { value: "catch" })
+
+export type CatchResult<T> = {
+  resolved: T
+  rejected?: never
+} | {
+  resolved?: never
+  rejected: unknown
+}

package/L/emit.ts

@@ -9,6 +9,6 @@ export interface emit<E> extends Generator<Rune<E>, void> {}
 export function* emit<const E>(event: EnsureNarrow<E>): emit<E> {
   const context = Context.ensure()
   const handler = context.get(HandlerContext)
-  const fiber = yield* rune((fiber) => fiber)
+  const fiber = yield* rune
   handler?.call(fiber, event)
 }

package/L/rune.ts

@@ -1,19 +1,30 @@
 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 interface rune extends Iterable<Rune<never>, Fiber> {
+  <R>(source: (fiber: Fiber) => R, debug?: string): Iterable<Rune<never>, Awaited<R>> & {
+    <E>(): Generator<Rune<E>, 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 })
-    },
-    {
-      *[Symbol.iterator](): Generator<Rune<never>, Awaited<R>> {
-        return yield Object.assign(source, { [RuneKey]: {} as never })
+export const rune: rune = Object.assign(
+  function<R>(source: (fiber: Fiber) => R, debug?: string) {
+    return Object.assign(
+      function*<E>(): Generator<Rune<E>, Awaited<R>> {
+        return yield Object.assign(source, { [RuneKey]: true, debug } as never)
       },
+      {
+        *[Symbol.iterator](): Generator<Rune<never>, Awaited<R>> {
+          return yield Object.assign(source, { [RuneKey]: true, debug } as never)
+        },
+      },
+    )
+  },
+  {
+    *[Symbol.iterator](): Generator<Rune<never>, Fiber> {
+      return yield Object.assign((fiber: Fiber) => fiber, {
+        [RuneKey]: true,
+        debug: "get_current_fiber",
+      } as never)
     },
-  )
-}
+  },
+)

package/LEvent.ts

@@ -58,5 +58,5 @@ export class FiberResolved extends EventBase(LEventTag, "fiber_resolved") {
 }
 
 export function isLEvent(value: unknown): value is LEvent {
-  return typeof value === "object" && value !== null && LEventTag in value
+  return typeof value === "object" && value !== null && "brand" in value && value.brand === LEventTag
 }

package/Model.ts

@@ -1,13 +1,14 @@
 import type { Schema } from "liminal-schema"
+import { attachCustomInspect } from "liminal-util"
 import type { Message } from "./Message.ts"
 
-export interface Model {
-  resolve(messages: Array<Message>, schema?: Schema): Promise<string>
-}
+export class Model {
+  constructor(
+    readonly vendor: string,
+    readonly resolve: (messages: Array<Message>, schema?: Schema) => Promise<string>,
+  ) {}
 
-// export interface ModelCapabilities {
-//   readonly url: boolean
-//   readonly mimes: Set<string>
-//   readonly reasoning: boolean
-//   readonly structures: boolean
-// }
+  static {
+    attachCustomInspect(this, ({ vendor }) => ({ vendor }))
+  }
+}

package/ModelRegistry.ts

@@ -6,14 +6,6 @@ export class ModelRegistry {
   declare head?: ModelRegistryNode | undefined
   declare tail?: ModelRegistryNode | undefined
 
-  constructor(models?: Array<Model>) {
-    if (models) {
-      for (const model of models) {
-        this.register(model)
-      }
-    }
-  }
-
   peek() {
     return this.tail?.model
   }

package/Rune.ts

@@ -1,12 +1,14 @@
 import type { Fiber } from "./Fiber.ts"
 
 export interface Rune<out E = any> {
+  E: E
   (fiber: Fiber): any
-  [RuneKey]: E
+  [RuneKey]: true
+  debug?: string
 }
 
 export declare namespace Rune {
-  export type E<X extends Rune> = X[RuneKey]
+  export type E<X extends Rune> = X["E"]
 }
 
 export const RuneKey: unique symbol = Symbol.for("liminal/Rune")

package/Tool.ts

@@ -0,0 +1,31 @@
+import { type LType, type SchemaObject, toJSONSchema, validate, type Value, type ValueObject } from "liminal-schema"
+import { subtle } from "node:crypto"
+
+export class Tool {
+  static async make<T extends ValueObject>(
+    description: string,
+    type: LType<T>,
+    f: (arg: T) => Value | Promise<Value>,
+  ) {
+    const encoder = new TextEncoder()
+    const schema = toJSONSchema(type)
+    const buffer = await subtle.digest("SHA-256", encoder.encode(description + "\n\n" + JSON.stringify(schema)))
+    const bytes = new Uint8Array(buffer)
+    let binary = ""
+    for (const b of bytes) binary += String.fromCharCode(b)
+    const base64 = btoa(binary)
+      .replace(/\+/g, "-")
+      .replace(/\//g, "_")
+      .replace(/=+$/, "")
+    return new Tool(base64, description, schema, async (arg) => {
+      return await f(await validate(type, arg) as never)
+    })
+  }
+
+  constructor(
+    readonly name: string,
+    readonly description: string,
+    readonly parameterSchema: SchemaObject,
+    readonly f: (arg: any) => Value | Promise<Value>,
+  ) {}
+}

package/ToolRegistry.ts

@@ -0,0 +1,5 @@
+import { ContextHandle } from "liminal"
+import type { Tool } from "./Tool"
+
+export class ToolRegistry extends Set<Tool> {}
+export const ToolRegistryContext: ContextHandle<ToolRegistry> = ContextHandle()

package/dist/Agent.d.ts

@@ -3,14 +3,16 @@ import { MessageRegistry } from "./MessageRegistry.ts";
 import { ModelRegistry } from "./ModelRegistry.ts";
 import type { Rune } from "./Rune.ts";
 import type { Runic } from "./Runic.ts";
-export interface AgentConfig<E> {
-    handler?: ((this: Fiber, event: E) => void) | undefined;
+import { ToolRegistry } from "./ToolRegistry.ts";
+export interface AgentConfig<T, E> {
+    handler?: ((this: Fiber<T>, event: E) => void) | undefined;
     models?: ModelRegistry;
     messages?: MessageRegistry;
+    tools?: ToolRegistry;
     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>, config?: AgentConfig<Rune.E<Y>>): Agent<T, Rune.E<Y>>;
+export declare function Agent<Y extends Rune, T>(runic: Runic<Y, T>, config?: AgentConfig<T, Rune.E<Y>>): Agent<T, Rune.E<Y>>;

package/dist/Agent.js

@@ -3,15 +3,17 @@ import { Fiber } from "./Fiber.js";
 import { HandlerContext } from "./Handler.js";
 import { MessageRegistry, MessageRegistryContext } from "./MessageRegistry.js";
 import { ModelRegistry, ModelRegistryContext } from "./ModelRegistry.js";
+import { ToolRegistry, ToolRegistryContext } from "./ToolRegistry.js";
 export function Agent(runic, config) {
     return {
         then(onfulfilled, onrejected) {
-            const rootCtx = new Context([
+            return new Context([
                 [HandlerContext, config?.handler],
                 [ModelRegistryContext, config?.models ?? new ModelRegistry()],
                 [MessageRegistryContext, config?.messages ?? new MessageRegistry()],
-            ]);
-            return rootCtx.run(() => new Fiber(runic).resolve().then(onfulfilled, onrejected));
+                [ToolRegistryContext, config?.tools ?? new ToolRegistry()],
+            ])
+                .run(() => new Fiber(runic).resolution().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,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;AAgBxE,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,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC,CAAA;QACpF,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;AAGxE,OAAO,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AAerE,MAAM,UAAU,KAAK,CACnB,KAAkB,EAClB,MAAkC;IAElC,OAAO;QACL,IAAI,CAAC,WAAW,EAAE,UAAU;YAC1B,OAAO,IAAI,OAAO,CAAC;gBACjB,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;gBACnE,CAAC,mBAAmB,EAAE,MAAM,EAAE,KAAK,IAAI,IAAI,YAAY,EAAE,CAAC;aAC3D,CAAC;iBACC,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,UAAU,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC,CAAA;QAC3E,CAAC;KACsD,CAAA;AAC3D,CAAC"}

package/dist/Context.d.ts

@@ -1,12 +1,11 @@
 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 ContextHandle<V = any> = {
-    clone?: ((value: V) => V) | undefined;
+    clone: ((value: V) => V) | undefined;
 };
 export declare function ContextHandle<V>(clone?: (value: V) => V): ContextHandle<V>;

package/dist/Context.js

@@ -10,14 +10,6 @@ export class Context extends Map {
     get(context) {
         return super.get(context);
     }
-    getOrInit(context, init) {
-        if (this.has(context)) {
-            return this.get(context);
-        }
-        const instance = init();
-        this.set(context, instance);
-        return instance;
-    }
     set(context, value) {
         super.set(context, value);
         return this;

package/dist/Context.js.map

@@ -1 +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,GAAG,IAAI,iBAAiB,EAAW,CAAA;AAEhD,MAAM,OAAO,OAAQ,SAAQ,GAA2B;IACtD,MAAM,CAAC,MAAM;QACX,MAAM,OAAO,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAA;QAClC,MAAM,CAAC,OAAO,CAAC,CAAA;QACf,OAAO,OAAO,CAAA;IAChB,CAAC;IAED,GAAG,CAAI,OAAyB;QAC9B,OAAO,KAAK,CAAC,GAAG,CAAC,OAAO,CAAU,CAAA;IACpC,CAAC;IAED,SAAS,CAAI,OAAyB,EAAE,IAAa;QACnD,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;YACtB,OAAO,IAAI,CAAC,GAAG,CAAC,OAAO,CAAM,CAAA;QAC/B,CAAC;QACD,MAAM,QAAQ,GAAG,IAAI,EAAE,CAAA;QACvB,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;QAC3B,OAAO,QAAQ,CAAA;IACjB,CAAC;IAED,GAAG,CAAI,OAAyB,EAAE,KAAQ;QACxC,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;QACzB,OAAO,IAAI,CAAA;IACb,CAAC;IAED,GAAG,CAAI,QAAiB;QACtB,OAAO,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAA;IACpC,CAAC;IAED,KAAK,CAAC,SAA8C;QAClD,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,SAAS,CAAC,CAAA;QACtC,KAAK,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;YAC7C,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;gBACzB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,CAAA;YACrD,CAAC;QACH,CAAC;QACD,OAAO,OAAO,CAAA;IAChB,CAAC;CACF;AAMD,MAAM,UAAU,aAAa,CAAI,KAAuB;IACtD,OAAO,EAAE,KAAK,EAAE,CAAA;AAClB,CAAC"}
+{"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,GAAG,IAAI,iBAAiB,EAAW,CAAA;AAEhD,MAAM,OAAO,OAAQ,SAAQ,GAA2B;IACtD,MAAM,CAAC,MAAM;QACX,MAAM,OAAO,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAA;QAClC,MAAM,CAAC,OAAO,CAAC,CAAA;QACf,OAAO,OAAO,CAAA;IAChB,CAAC;IAED,GAAG,CAAI,OAAyB;QAC9B,OAAO,KAAK,CAAC,GAAG,CAAC,OAAO,CAAU,CAAA;IACpC,CAAC;IAED,GAAG,CAAI,OAAyB,EAAE,KAAQ;QACxC,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;QACzB,OAAO,IAAI,CAAA;IACb,CAAC;IAED,GAAG,CAAI,QAAiB;QACtB,OAAO,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAA;IACpC,CAAC;IAED,KAAK,CAAC,SAA8C;QAClD,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,SAAS,CAAC,CAAA;QACtC,KAAK,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;YAC7C,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;gBACzB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,CAAA;YACrD,CAAC;QACH,CAAC;QACD,OAAO,OAAO,CAAA;IAChB,CAAC;CACF;AAMD,MAAM,UAAU,aAAa,CAAI,KAAuB;IACtD,OAAO,EAAE,KAAK,EAAE,CAAA;AAClB,CAAC"}

package/dist/Fiber.d.ts

@@ -1,12 +1,32 @@
-import { Context } from "./Context.ts";
 import type { Rune } from "./Rune.ts";
 import { Runic } from "./Runic.ts";
+export type FiberStatus<T> = {
+    type: "untouched";
+} | {
+    type: "pending";
+    self: AbortSignal;
+    promise: Promise<T>;
+} | {
+    type: "aborted";
+    reason: unknown;
+} | {
+    type: "resolved";
+    value: T;
+} | {
+    type: "rejected";
+    exception: unknown;
+};
 export declare class Fiber<T = any> {
-    readonly runic: Runic<Rune, T>;
+    #private;
+    static nextIndex: number;
+    T: T;
     readonly index: number;
     readonly parent?: Fiber;
-    context: Context;
-    pending: Promise<T> | undefined;
+    signal: AbortSignal;
+    either: AbortSignal;
+    abort: (reason?: any) => void;
+    status: FiberStatus<T>;
     constructor(runic: Runic<Rune, T>, parent?: Fiber);
-    resolve(this: Fiber<T>): Promise<T>;
+    fork<T>(runic: Runic<Rune, T>): Fiber<T>;
+    resolution(this: Fiber<T>): Promise<T>;
 }