liminal 0.5.14 → 0.5.15

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # liminal
 
+## 0.5.15
+
+### Patch Changes
+
+- 9c276c3: Fix message list cloning, add streaming to ollama adapter.
+
 ## 0.5.14
 
 ### Patch Changes

package/Context.ts

@@ -3,22 +3,39 @@ import type { Message } from "./Message.ts"
 import { ModelRegistry } from "./ModelRegistry.ts"
 import type { Tool } from "./Tool.ts"
 
+/**
+ * Context represents the execution environment for a Strand.
+ *
+ * It holds all the stateful components needed during strand execution:
+ * - Message history.
+ * - Event handler for processing events.
+ * - Model registry for tracking available language models.
+ * - Available tools for model-driven function calling.
+ */
 export interface Context {
+  /** Event handler for processing events during strand execution. */
   readonly handler: Handler | undefined
+  /** Registry of available models for inference. */
   readonly models: ModelRegistry
+  /** Accumulated message history. */
   readonly messages: Array<Message>
+  /** Set of tools available to the models. */
   readonly tools: Set<Tool>
-
+  /** Creates a copy of the current `Context` for child strands. */
   clone(): Context
 }
 
+/**
+ * Factory function to create a new Context.
+ * @param context Optional base context from which to initialize.
+ * @returns A newly created Context.
+ */
 export function Context(context?: Omit<Context, "clone">): Context {
   return {
     handler: context?.handler,
-    models: context?.models.clone() ?? new ModelRegistry(),
-    messages: [],
+    models: context?.models?.clone() ?? new ModelRegistry(),
+    messages: [...(context?.messages ?? [])],
     tools: new Set(context?.tools),
-
     clone(): Context {
       return {
         handler: this.handler,

package/Definition.ts

@@ -1,22 +1,38 @@
 import type { Rune } from "./Rune.ts"
 
 export type RuneIterator<Y extends Rune<any> = Rune<any>, T = any> = Iterator<Y, T> | AsyncIterator<Y, T>
+
 export type RuneIterable<Y extends Rune<any> = Rune<any>, T = any> = Iterable<Y, T> | AsyncIterable<Y, T>
+
 export type Definition<Y extends Rune<any> = Rune<any>, T = any> = RuneIterable<Y, T> | (() => RuneIterable<Y, T>)
 
 export namespace Definition {
+  /** Extracts the Rune type from a Definition. */
   export type Y<X extends Definition> = X extends RuneIterable<infer Y> ? Y
     : X extends () => RuneIterable<infer Y> ? Y
     : X extends RuneIterator<infer Y> ? Y
     : never
 
+  /** Extracts the result type from a Definition. */
   export type T<X extends Definition> = X extends RuneIterable<Rune<any>, infer T> ? T
     : X extends () => RuneIterable<Rune<any>, infer T> ? T
     : X extends RuneIterator<Rune<any>, infer T> ? T
     : never
 
+  /** Extracts the event type from a Definition. */
   export type E<X extends Definition> = Rune.E<Y<X>>
 
+  /**
+   * Converts a Definition into a RuneIterator.
+   *
+   * This function handles all the different forms a Definition can take:
+   * - Synchronous iterables
+   * - Asynchronous iterables
+   * - Factory functions returning iterables
+   *
+   * @param definition The definition to unwrap.
+   * @returns A RuneIterator ready for consumption.
+   */
   export function unwrap<Y extends Rune<any>, T>(definition: Definition<Y, T>): RuneIterator<Y, T> {
     if (Symbol.iterator in definition) {
       return definition[Symbol.iterator]()

package/L/L.ts

@@ -1,7 +1,6 @@
 export * from "./all.ts"
 export * from "./assistant.ts"
 export * from "./catch.ts"
-export * from "./context.ts"
 export * from "./continuation.ts"
 export * from "./emit.ts"
 export * from "./infer.ts"

package/L/all.ts

@@ -6,6 +6,10 @@ import { Strand } from "../Strand.ts"
 import { continuation } from "./continuation.ts"
 import { reflect } from "./reflect.ts"
 
+/**
+ * Runs multiple definitions in parallel and collects their results.
+ * Can be used with an array or object of definitions.
+ */
 export function all<A extends Array<Definition>>(
   definitions: A,
   context?: Context,

package/L/assistant.ts

@@ -4,6 +4,10 @@ import { Schema } from "../Schema.ts"
 import { infer } from "./infer.ts"
 import { message } from "./message.ts"
 
+/**
+ * Produces an assistant message when yielded. Can be called with a schema
+ * for structured output. Otherwise produces a string.
+ */
 export interface assistant extends Iterable<Rune<LEvent>, string> {
   <T>(schema: Schema<T>): Generator<Rune<LEvent>, T>
 }

package/L/catch.ts

@@ -7,6 +7,10 @@ import { reflect } from "./reflect.ts"
 
 export { catch_ as catch }
 
+/**
+ * Error handling utility that catches exceptions from running a definition.
+ * Returns a result object indicating whether the operation succeeded or failed.
+ */
 function* catch_<Y extends Rune<any>, T>(
   definition: Definition<Y, T>,
 ): Generator<Rune<LEvent> | Rune<Y>, CatchResult<T>> {

package/L/continuation.ts

@@ -1,11 +1,12 @@
 import type { LEvent } from "../LEvent.ts"
 import { Rune, RuneKey } from "../Rune.ts"
 
+/** Yields a continuation rune that executes a function and passes its result to the next iteration. */
 export function* continuation<R>(debug: string, f: () => R): Generator<Rune<LEvent>, Awaited<R>> {
   return yield {
     [RuneKey]: true,
-    value: {
-      kind: "continuation",
+    instruction: {
+      kind: "continue",
       debug,
       f,
     },

package/L/emit.ts

@@ -1,11 +1,15 @@
 import { Rune, RuneKey } from "../Rune.ts"
 import type { EnsureNarrow } from "../util/EnsureNarrow.ts"
 
+/**
+ * Emits an event to be supplied to handlers.
+ * Used for broadcasting state changes and triggering side effects.
+ */
 export function* emit<E>(event: EnsureNarrow<E>): Generator<Rune<E>, void> {
   return yield {
     [RuneKey]: true,
-    value: {
-      kind: "event",
+    instruction: {
+      kind: "emit",
       event,
     },
   }

package/L/infer.ts

@@ -6,22 +6,28 @@ import { continuation } from "./continuation.ts"
 import { emit } from "./emit.ts"
 import { reflect } from "./reflect.ts"
 
+/**
+ * Requests an inference from the current model, optionally with a schema.
+ * Emits inference-related events and returns the model's response as a string.
+ */
 export function* infer(schema?: Schema): Generator<Rune<LEvent>, string> {
   const { context: { models, messages }, signal } = yield* reflect
   const model = models.peek()
   LiminalAssertionError.assert(model)
   const requestId = crypto.randomUUID()
   yield* emit(new InferenceRequested(requestId, schema))
-  let inference = yield* continuation("infer", () =>
-    model.seal({
-      messages,
-      ...schema && {
-        schema: schema.type === "object"
-          ? schema
-          : Schema.wrap(schema),
-      },
-      signal,
-    }).resolve())
+  let inference = yield* continuation(
+    "infer",
+    model
+      .seal({
+        messages,
+        ...schema && {
+          schema: schema.type === "object" ? schema : Schema.wrap(schema),
+        },
+        signal,
+      })
+      .resolve,
+  )
   if (schema?.type && schema.type !== "object") {
     inference = JSON.stringify(JSON.parse(inference).value)
   }

package/L/message.ts

@@ -4,6 +4,10 @@ import type { Rune } from "../Rune.ts"
 import { emit } from "./emit.ts"
 import { reflect } from "./reflect.ts"
 
+/**
+ * Adds a new message to the current context's message list.
+ * Emits a message append event to observers.
+ */
 export function* message(role: MessageRole, content: Array<Content>): Generator<Rune<LEvent>, void> {
   const { context: { messages } } = yield* reflect
   const message: Message = { role, parts: content }

package/L/model.ts

@@ -5,6 +5,10 @@ import type { Rune } from "../Rune.ts"
 import { emit } from "./emit.ts"
 import { reflect } from "./reflect.ts"
 
+/**
+ * Registers a model in the current context and emits a model registration event.
+ * Returns the registered model instance.
+ */
 export function* model(model: Model): Generator<Rune<LEvent>, Model> {
   const { context: { models } } = yield* reflect
   models.register(model)

package/L/reflect.ts

@@ -2,11 +2,12 @@ import type { LEvent } from "../LEvent.ts"
 import { Rune, RuneKey } from "../Rune.ts"
 import type { Strand } from "../Strand.ts"
 
+/** Returns the current strand instance, providing access to context and parent information. */
 export const reflect: Iterable<Rune<LEvent>, Strand> = {
   *[Symbol.iterator]() {
     return yield {
       [RuneKey]: true,
-      value: { kind: "reflect" },
+      instruction: { kind: "reflect" },
     }
   },
 }

package/L/run.ts

@@ -7,6 +7,7 @@ import type { Rune } from "../Rune.ts"
 import { Strand } from "../Strand.ts"
 import type { Tool } from "../Tool.ts"
 
+/** Configuration options for running a definition. */
 export interface RunConfig<Y extends Rune<any>> {
   handler?: Handler<Y> | undefined
   models?: ModelRegistry | undefined

package/L/strand.ts

@@ -3,14 +3,18 @@ import type { Definition } from "../Definition.ts"
 import type { LEvent } from "../LEvent.ts"
 import { type Rune, RuneKey } from "../Rune.ts"
 
+/**
+ * Creates a child strand that executes a definition.
+ * Optionally specify the context. Otherwise the current context is inherited.
+ */
 export function* strand<Y extends Rune<any>, T>(
   definition: Definition<Y, T>,
   context?: Context,
 ): Generator<Rune<LEvent>, T> {
   return yield {
     [RuneKey]: true,
-    value: {
-      kind: "child",
+    instruction: {
+      kind: "create_child",
       definition,
       context,
     },

package/L/stream.ts

@@ -5,6 +5,7 @@ import { continuation } from "./continuation.ts"
 import { emit } from "./emit.ts"
 import { reflect } from "./reflect.ts"
 
+/** Creates a readable stream of content from the current model. */
 export const stream: Iterable<Rune<LEvent>, ReadableStream<string>> = {
   *[Symbol.iterator]() {
     const { context: { models, messages }, signal } = yield* reflect
@@ -12,6 +13,6 @@ export const stream: Iterable<Rune<LEvent>, ReadableStream<string>> = {
     LiminalAssertionError.assert(model)
     const requestId = crypto.randomUUID()
     yield* emit(new InferenceRequested(requestId))
-    return yield* continuation("stream", () => model.seal({ messages, signal }).stream())
+    return yield* continuation("stream", model.seal({ messages, signal }).stream)
   },
 }

package/Model.ts

@@ -5,12 +5,12 @@ import { attachCustomInspect } from "./util/attachCustomInspect.ts"
 
 export class Model {
   constructor(
-    readonly vendor: string,
+    readonly client: string,
     readonly seal: (envelope: Envelope) => SealedEnvelope,
   ) {}
 
   static {
-    attachCustomInspect(this, ({ vendor }) => ({ vendor }))
+    attachCustomInspect(this, ({ client }) => ({ client }))
   }
 }
 
@@ -22,6 +22,6 @@ export interface Envelope {
 }
 
 export interface SealedEnvelope {
-  resolve(): Promise<string>
-  stream(): ReadableStream<string>
+  resolve: () => Promise<string>
+  stream: () => ReadableStream<string>
 }

package/ModelRegistry.ts

@@ -1,14 +1,22 @@
 import type { Model } from "./Model.ts"
 
-/** An intrusive list for storing `Model`s. */
+/**
+ * An intrusive doubly-linked list for storing `Model`s.
+ * Provides efficient insertion, removal, and lookups.
+ */
 export class ModelRegistry {
   declare head?: ModelRegistryNode | undefined
   declare tail?: ModelRegistryNode | undefined
 
+  /** Returns the most recently registered model */
   peek() {
     return this.tail?.model
   }
 
+  /**
+   * Registers a new model and returns the created node
+   * @param value The model to register
+   */
   register(value: Model): ModelRegistryNode {
     const node: ModelRegistryNode = {
       prev: this.tail,
@@ -23,6 +31,7 @@ export class ModelRegistry {
     return node
   }
 
+  /** Remove a model from the registry. */
   remove(node: ModelRegistryNode) {
     if (node.prev) {
       node.prev.next = node.next
@@ -36,13 +45,17 @@ export class ModelRegistry {
     if (node === this.tail) {
       this.tail = node.prev
     }
-    node.prev = node.next = undefined
+    node.prev = undefined
+    delete node.next
   }
 
+  /** Creates a deep copy of this registry. */
   clone() {
     const instance = new ModelRegistry()
     for (let node = this.head; node; node = node.next) {
-      instance.register(node.model)
+      if (node.model) {
+        instance.register(node.model)
+      }
     }
     return instance
   }

package/Rune.ts

@@ -1,31 +1,60 @@
 import type { Context } from "./Context.ts"
 import type { Definition } from "./Definition.ts"
 
+/**
+ * `Rune` represents a computational unit within a Strand execution.
+ * It is a specialized protocol for expressing different kinds of operations
+ * that can be yielded from generator functions to control message state
+ * and concurrency within the Liminal runtime.
+ * @template E The event type this Rune can handle
+ */
 export interface Rune<E> {
   [RuneKey]: true
-  value: {
-    kind: "continuation"
+  instruction: RuneInstruction<E>
+}
+
+export type RuneInstruction<E> =
+  | RuneInstruction.Continue
+  | RuneInstruction.Emit<E>
+  | RuneInstruction.Reflect
+  | RuneInstruction.CreateChild
+export namespace RuneInstruction {
+  /** Tells the runtime to call this function and and pass the result to the next iteration. */
+  export interface Continue {
+    kind: "continue"
     debug: string
     f: () => any
-  } | {
-    kind: "event"
+  }
+
+  /** Dispatch an event to the registered handler. */
+  export interface Emit<E> {
+    kind: "emit"
     event: E
-  } | {
+  }
+
+  /** Tells the runtime to provide a reference to the current strand */
+  export interface Reflect {
     kind: "reflect"
-  } | {
-    kind: "child"
+  }
+
+  /** Creates a nested execution context with its own definition. */
+  export interface CreateChild {
+    kind: "create_child"
     definition: Definition
     context?: Context | undefined
   }
 }
 
 export namespace Rune {
+  /** Extract the event type from a Rune type. */
   export type E<X extends Rune<any>> = X extends Rune<infer E> ? E : never
 
+  /** Type guard to check if a value is a Rune. */
   export function is(value: unknown): value is Rune<any> {
     return typeof value === "object" && value !== null && RuneKey in value
   }
 }
 
+/** Symbol used to identify Rune objects. */
 export const RuneKey: unique symbol = Symbol.for("liminal/RuneKey")
 export type RuneKey = typeof RuneKey

package/Strand.ts

@@ -6,26 +6,53 @@ import { StrandStatusChanged } from "./LEvent.ts"
 import type { Rune } from "./Rune.ts"
 import { attachCustomInspect } from "./util/attachCustomInspect.ts"
 
+/** Configuration options for creating a new Strand. */
 export interface StrandConfig {
+  /** Optional parent strand that this strand will be a child of */
   parent?: Strand | undefined
+  /** Optional context for the strand execution */
   context?: Context | undefined
+  /** Optional abort signal that can be used to cancel strand execution */
   signal?: AbortSignal | undefined
 }
 
 let nextIndex: number = 0
 
+/**
+ * A "Strand" is the core unit of execution in Liminal.
+ *
+ * It represents a suspendable computation that can yield Runes to control conversation state.
+ * Strands implement both the Iterable and PromiseLike interfaces to enable both
+ * running (via awaiting) and joining to parent strands (via yielding).
+ *
+ * Strands maintain their own state and can be hierarchically organized with parent-child
+ * relationships. Child strands are bound to their parents, ensuring consistent
+ * cancellation behavior.
+ *
+ * @template Y The type of Runes this Strand can yield.
+ * @template T The result type of the Strand.
+ */
 export class Strand<Y extends Rune<any> = Rune<any>, T = any> implements Iterable<Y, T>, PromiseLike<T> {
   declare T: T
   declare Y: Y
 
+  /** Controls abort signal propagation. */
   readonly #controller: AbortController = new AbortController()
+  /** Signal that can be used to detect when this strand is aborted. */
   readonly signal: AbortSignal = this.#controller.signal
+  /** Optional event handler function. */
   #handle?: ((this: Strand, event: any) => void) | undefined
+  /** The definition (usually via generator function) that powers this strand. */
   #definition: Definition<Y, T>
+  /** Current status of the strand (untouched, pending, resolved, rejected) */
   status: StrandStatus<T> = { type: "untouched" }
+  /** Unique identifier for this strand. */
   readonly index: number = nextIndex++
+  /** Nesting depth in the strand hierarchy. */
   readonly depth: number
+  /** The parent strand or undefined. */
   declare readonly parent?: Strand
+  /** The conversation state with which the strand operates. */
   readonly context: Context
 
   constructor(definition: Definition<Y, T>, config: StrandConfig) {
@@ -123,22 +150,22 @@ export class Strand<Y extends Rune<any> = Rune<any>, T = any> implements Iterabl
         let current = await iterator.next()
         while (!current.done) {
           const rune = current.value
-          const { value } = rune
+          const { instruction: value } = rune
           switch (value.kind) {
             case "reflect": {
               nextArg = this
               break
             }
-            case "continuation": {
+            case "continue": {
               nextArg = await value.f()
               break
             }
-            case "event": {
+            case "emit": {
               this.#handle?.(value.event)
               nextArg = undefined
               break
             }
-            case "child": {
+            case "create_child": {
               nextArg = await new Strand(value.definition, {
                 parent: this,
                 context: value.context ?? this.context.clone(),
@@ -185,6 +212,7 @@ export class Strand<Y extends Rune<any> = Rune<any>, T = any> implements Iterabl
       case "config_signal_aborted":
       case "parent_aborted":
       case "continuation_exception_thrown":
+      // case "model_error":
       case "handler_exception_thrown": {
         return Promise.reject(new StrandRejectedError(status))
       }
@@ -230,8 +258,6 @@ export namespace StrandStatus {
     | Rejected.ContinuationExceptionThrown
     | Rejected.HandlerExceptionThrown
   // | Rejected.ModelError
-  // | Rejected.ValidationError
-  // | Rejected.Timeout
   export namespace Rejected {
     export interface ConfigSignalAborted {
       type: "config_signal_aborted"
@@ -249,5 +275,10 @@ export namespace StrandStatus {
       type: "handler_exception_thrown"
       exception: unknown
     }
+    // export interface ModelError {
+    //   type: "model_error"
+    //   model: string
+    //   error: unknown
+    // }
   }
 }

package/dist/Context.d.ts

@@ -2,11 +2,30 @@ import type { Handler } from "./Handler.ts";
 import type { Message } from "./Message.ts";
 import { ModelRegistry } from "./ModelRegistry.ts";
 import type { Tool } from "./Tool.ts";
+/**
+ * Context represents the execution environment for a Strand.
+ *
+ * It holds all the stateful components needed during strand execution:
+ * - Message history.
+ * - Event handler for processing events.
+ * - Model registry for tracking available language models.
+ * - Available tools for model-driven function calling.
+ */
 export interface Context {
+    /** Event handler for processing events during strand execution. */
     readonly handler: Handler | undefined;
+    /** Registry of available models for inference. */
     readonly models: ModelRegistry;
+    /** Accumulated message history. */
     readonly messages: Array<Message>;
+    /** Set of tools available to the models. */
     readonly tools: Set<Tool>;
+    /** Creates a copy of the current `Context` for child strands. */
     clone(): Context;
 }
+/**
+ * Factory function to create a new Context.
+ * @param context Optional base context from which to initialize.
+ * @returns A newly created Context.
+ */
 export declare function Context(context?: Omit<Context, "clone">): Context;

package/dist/Context.js

@@ -1,9 +1,14 @@
 import { ModelRegistry } from "./ModelRegistry.js";
+/**
+ * Factory function to create a new Context.
+ * @param context Optional base context from which to initialize.
+ * @returns A newly created Context.
+ */
 export function Context(context) {
     return {
         handler: context?.handler,
-        models: context?.models.clone() ?? new ModelRegistry(),
-        messages: [],
+        models: context?.models?.clone() ?? new ModelRegistry(),
+        messages: [...(context?.messages ?? [])],
         tools: new Set(context?.tools),
         clone() {
             return {

package/dist/Context.js.map

@@ -1 +1 @@
-{"version":3,"file":"Context.js","sourceRoot":"","sources":["../Context.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAYlD,MAAM,UAAU,OAAO,CAAC,OAAgC;IACtD,OAAO;QACL,OAAO,EAAE,OAAO,EAAE,OAAO;QACzB,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,KAAK,EAAE,IAAI,IAAI,aAAa,EAAE;QACtD,QAAQ,EAAE,EAAE;QACZ,KAAK,EAAE,IAAI,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC;QAE9B,KAAK;YACH,OAAO;gBACL,OAAO,EAAE,IAAI,CAAC,OAAO;gBACrB,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE;gBAC3B,QAAQ,EAAE,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC;gBAC5B,KAAK,EAAE,IAAI,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC;gBAC1B,KAAK,EAAE,IAAI,CAAC,KAAK;aAClB,CAAA;QACH,CAAC;KACF,CAAA;AACH,CAAC"}
+{"version":3,"file":"Context.js","sourceRoot":"","sources":["../Context.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAyBlD;;;;GAIG;AACH,MAAM,UAAU,OAAO,CAAC,OAAgC;IACtD,OAAO;QACL,OAAO,EAAE,OAAO,EAAE,OAAO;QACzB,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,IAAI,aAAa,EAAE;QACvD,QAAQ,EAAE,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC;QACxC,KAAK,EAAE,IAAI,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC;QAC9B,KAAK;YACH,OAAO;gBACL,OAAO,EAAE,IAAI,CAAC,OAAO;gBACrB,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE;gBAC3B,QAAQ,EAAE,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC;gBAC5B,KAAK,EAAE,IAAI,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC;gBAC1B,KAAK,EAAE,IAAI,CAAC,KAAK;aAClB,CAAA;QACH,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/Definition.d.ts

@@ -3,8 +3,22 @@ export type RuneIterator<Y extends Rune<any> = Rune<any>, T = any> = Iterator<Y,
 export type RuneIterable<Y extends Rune<any> = Rune<any>, T = any> = Iterable<Y, T> | AsyncIterable<Y, T>;
 export type Definition<Y extends Rune<any> = Rune<any>, T = any> = RuneIterable<Y, T> | (() => RuneIterable<Y, T>);
 export declare namespace Definition {
+    /** Extracts the Rune type from a Definition. */
     type Y<X extends Definition> = X extends RuneIterable<infer Y> ? Y : X extends () => RuneIterable<infer Y> ? Y : X extends RuneIterator<infer Y> ? Y : never;
+    /** Extracts the result type from a Definition. */
     type T<X extends Definition> = X extends RuneIterable<Rune<any>, infer T> ? T : X extends () => RuneIterable<Rune<any>, infer T> ? T : X extends RuneIterator<Rune<any>, infer T> ? T : never;
+    /** Extracts the event type from a Definition. */
     type E<X extends Definition> = Rune.E<Y<X>>;
+    /**
+     * Converts a Definition into a RuneIterator.
+     *
+     * This function handles all the different forms a Definition can take:
+     * - Synchronous iterables
+     * - Asynchronous iterables
+     * - Factory functions returning iterables
+     *
+     * @param definition The definition to unwrap.
+     * @returns A RuneIterator ready for consumption.
+     */
     function unwrap<Y extends Rune<any>, T>(definition: Definition<Y, T>): RuneIterator<Y, T>;
 }

package/dist/Definition.js

@@ -1,5 +1,16 @@
 export var Definition;
 (function (Definition) {
+    /**
+     * Converts a Definition into a RuneIterator.
+     *
+     * This function handles all the different forms a Definition can take:
+     * - Synchronous iterables
+     * - Asynchronous iterables
+     * - Factory functions returning iterables
+     *
+     * @param definition The definition to unwrap.
+     * @returns A RuneIterator ready for consumption.
+     */
     function unwrap(definition) {
         if (Symbol.iterator in definition) {
             return definition[Symbol.iterator]();

package/dist/Definition.js.map

@@ -1 +1 @@
-{"version":3,"file":"Definition.js","sourceRoot":"","sources":["../Definition.ts"],"names":[],"mappings":"AAMA,MAAM,KAAW,UAAU,CAyB1B;AAzBD,WAAiB,UAAU;IAazB,SAAgB,MAAM,CAAyB,UAA4B;QACzE,IAAI,MAAM,CAAC,QAAQ,IAAI,UAAU,EAAE,CAAC;YAClC,OAAO,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAA;QACtC,CAAC;aAAM,IAAI,MAAM,CAAC,aAAa,IAAI,UAAU,EAAE,CAAC;YAC9C,OAAO,UAAU,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAA;QAC3C,CAAC;QACD,MAAM,QAAQ,GAAG,UAAU,EAAE,CAAA;QAC7B,IAAI,MAAM,CAAC,QAAQ,IAAI,QAAQ,EAAE,CAAC;YAChC,OAAO,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAA;QACpC,CAAC;QACD,OAAO,QAAQ,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAA;IACzC,CAAC;IAXe,iBAAM,SAWrB,CAAA;AACH,CAAC,EAzBgB,UAAU,KAAV,UAAU,QAyB1B"}
+{"version":3,"file":"Definition.js","sourceRoot":"","sources":["../Definition.ts"],"names":[],"mappings":"AAQA,MAAM,KAAW,UAAU,CAuC1B;AAvCD,WAAiB,UAAU;IAgBzB;;;;;;;;;;OAUG;IACH,SAAgB,MAAM,CAAyB,UAA4B;QACzE,IAAI,MAAM,CAAC,QAAQ,IAAI,UAAU,EAAE,CAAC;YAClC,OAAO,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAA;QACtC,CAAC;aAAM,IAAI,MAAM,CAAC,aAAa,IAAI,UAAU,EAAE,CAAC;YAC9C,OAAO,UAAU,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAA;QAC3C,CAAC;QACD,MAAM,QAAQ,GAAG,UAAU,EAAE,CAAA;QAC7B,IAAI,MAAM,CAAC,QAAQ,IAAI,QAAQ,EAAE,CAAC;YAChC,OAAO,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAA;QACpC,CAAC;QACD,OAAO,QAAQ,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAA;IACzC,CAAC;IAXe,iBAAM,SAWrB,CAAA;AACH,CAAC,EAvCgB,UAAU,KAAV,UAAU,QAuC1B"}