liminal 0.5.16 → 0.6.0

package/Schema.ts

@@ -1,185 +0,0 @@
-import { subtle } from "node:crypto"
-import { LiminalAssertionError as LE } from "./LiminalAssertionError.ts"
-
-export type Schema<T = any> = SchemaType<T> | SchemaAnyOf<T>
-
-export type SchemaType<T = any> =
-  | SchemaNull<T>
-  | SchemaBoolean<T>
-  | SchemaInteger<T>
-  | SchemaNumber<T>
-  | SchemaString<T>
-  | SchemaArray<T>
-  | SchemaObject<T>
-
-export interface SchemaNull<T = any> extends SchemaTypeBase<"null", T> {}
-
-export interface SchemaBoolean<T = any> extends SchemaTypeBase<"boolean", T> {}
-
-export interface SchemaInteger<T = any> extends SchemaTypeBase<"integer", T> {}
-
-export interface SchemaNumber<T = any> extends SchemaTypeBase<"number", T> {}
-
-export interface SchemaString<T = any> extends SchemaTypeBase<"string", T> {
-  enum?: Array<string>
-  const?: string
-}
-
-export interface SchemaArray<T = any> extends SchemaTypeBase<"array", T> {
-  items: Schema
-}
-
-export interface SchemaObject<T = any> extends SchemaTypeBase<"object", T> {
-  properties: Record<string, Schema>
-  required: Array<string>
-  additionalProperties: false
-}
-
-interface SchemaTypeBase<K extends SchemaTypeName, T> extends SchemaBase<T> {
-  type: K
-  anyOf?: never
-}
-
-export type SchemaTypeName = "null" | "boolean" | "integer" | "number" | "string" | "array" | "object"
-
-export interface SchemaAnyOf<T = any> extends SchemaBase<T> {
-  type?: never
-  anyOf: Array<Schema>
-}
-
-export interface SchemaBase<T> {
-  T: T
-  description?: string
-}
-
-export namespace Schema {
-  const ids = new WeakMap<Schema, Record<string, string>>()
-  const schemas = new WeakMap<WeakKey, Schema>()
-  const validators = new WeakMap<Schema, (value: unknown) => unknown>()
-
-  export function compile<T>(key: WeakKey, {
-    schema: schema_,
-    validate,
-  }: {
-    schema(): unknown
-    validate(value: unknown): T
-  }) {
-    let schema = schemas.get(key)
-    if (!schema) {
-      schema = Schema.validate(schema_())
-      schemas.set(key, schema)
-    }
-    validators.set(schema, validate)
-    return schema
-  }
-
-  export function validateValue<T>(schema: Schema<T>, value: unknown): T {
-    const validator = validators.get(schema)
-    LE.assert(validator)
-    return validator(value) as never
-  }
-
-  export async function id(schema: Schema, description?: string): Promise<string> {
-    description = description ?? ""
-    if (!ids.has(schema)) {
-      ids.set(schema, {})
-    }
-    const schemaIds = ids.get(schema)!
-    let id = schemaIds[description]
-    if (!id) {
-      const content = `${description}_${JSON.stringify(schema)}`
-      const bytes = new Uint8Array(await subtle.digest("SHA-256", new TextEncoder().encode(content)))
-      let binary = ""
-      for (const b of bytes) binary += String.fromCharCode(b)
-      id = btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "")
-      schemaIds[description] = id
-    }
-    return id
-  }
-
-  export function wrap(schema: Schema): SchemaObject {
-    return {
-      type: "object",
-      properties: { value: schema },
-      additionalProperties: false,
-      required: ["value"],
-    } satisfies Omit<SchemaObject, "T"> as never
-  }
-
-  export function validate(value: unknown): Schema {
-    LE.assert(typeof value === "object")
-    LE.assert(value !== null)
-    if ("anyOf" in value) {
-      LE.assert(Array.isArray(value.anyOf))
-      return {
-        anyOf: value.anyOf.map(validate),
-      } satisfies Omit<SchemaAnyOf, "T"> as never
-    } else {
-      if ("enum" in value) {
-        LE.assert(Array.isArray(value.enum))
-        LE.assert(!("const" in value))
-        value.enum.forEach((v) => LE.assert(typeof v === "string"))
-        return {
-          type: "string",
-          enum: value.enum,
-        } satisfies Omit<SchemaString, "T"> as never
-      } else if ("const" in value) {
-        LE.assert(typeof value.const === "string")
-        return {
-          type: "string",
-          const: value.const,
-        } satisfies Omit<SchemaString, "T"> as never
-      } else if ("type" in value) {
-        LE.assert("type" in value)
-        LE.assert(typeof value.type === "string")
-        LE.assert(SCHEMA_TYPE_NAMES[value.type])
-        switch (value.type) {
-          case "null":
-          case "boolean":
-          case "integer":
-          case "number": {
-            break
-          }
-          case "string": {
-            if ("const" in value) {
-              LE.assert(typeof value.const === "string")
-            }
-            break
-          }
-          case "array": {
-            LE.assert("items" in value)
-            return {
-              type: "array",
-              items: validate(value.items),
-            } satisfies Omit<SchemaArray, "T"> as never
-          }
-          case "object": {
-            LE.assert("properties" in value)
-            LE.assert(typeof value.properties === "object")
-            const { properties } = value
-            LE.assert(properties !== null)
-            return {
-              type: "object",
-              properties: Object.fromEntries(
-                Object.entries(properties).map(([key, value]) => [key, validate(value)]),
-              ),
-              required: Object.keys(properties),
-              additionalProperties: false,
-            } satisfies Omit<SchemaObject, "T"> as never
-          }
-        }
-      }
-    }
-    return value as Schema
-  }
-}
-
-const SCHEMA_TYPE_NAMES: Record<string, boolean> = {
-  null: true,
-  boolean: true,
-  integer: true,
-  number: true,
-  string: true,
-  array: true,
-  object: true,
-} satisfies Record<SchemaTypeName, true>

package/Strand.ts

@@ -1,284 +0,0 @@
-import { Context } from "./Context.ts"
-import { Definition } from "./Definition.ts"
-import { StrandRejectedError } from "./errors.ts"
-import { continuation } from "./L/continuation.ts"
-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) {
-    this.#definition = definition
-    this.depth = (config?.parent?.depth ?? -1) + 1
-    const { parent, context, signal: configSignal } = config ?? {}
-    if (parent) {
-      this.parent = parent
-      this.#attachSignal(parent.signal, () => ({
-        type: "parent_aborted",
-        reason: parent.signal.reason,
-      }))
-    }
-    if (configSignal) {
-      this.#attachSignal(configSignal, () => ({
-        type: "config_signal_aborted",
-        reason: configSignal.reason,
-      }))
-    }
-    if (context) {
-      this.context = context
-      const { handler } = context
-      if (handler) {
-        this.#handle = (function(this: Strand, event: any) {
-          try {
-            handler.call(this, event)
-          } catch (exception) {
-            this.#setTerminalStatus({
-              type: "handler_exception_thrown",
-              exception,
-            })
-          }
-        }).bind(this)
-        this.#handle(new StrandStatusChanged(this.status))
-      }
-    } else {
-      this.context = Context()
-    }
-  }
-
-  #setStatus(status: StrandStatus<T>): void {
-    this.status = status
-    this.#handle?.(new StrandStatusChanged(this.status))
-  }
-
-  #setTerminalStatus = (status: StrandStatus.Rejected | StrandStatus.Resolved<T>): void => {
-    this.#setStatus(status)
-    this.#controller.abort(this.status)
-  }
-
-  #attachSignal(
-    signal: AbortSignal,
-    getStatus: () => StrandStatus.Rejected.ConfigSignalAborted | StrandStatus.Rejected.ParentAborted,
-  ): void {
-    const f = () => {
-      this.#setTerminalStatus(getStatus())
-    }
-    if (signal.aborted) {
-      return f()
-    }
-    signal.addEventListener("abort", f, { once: true })
-    this.#controller.signal.addEventListener(
-      "abort",
-      () => {
-        signal.removeEventListener("abort", f)
-      },
-      { once: true },
-    )
-  }
-
-  then<TResult1 = T, TResult2 = never>(
-    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null,
-    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null,
-  ): PromiseLike<TResult1 | TResult2> {
-    if (this.status.type !== "untouched") {
-      return this.#replay(this.status).then(onfulfilled, onrejected)
-    }
-    let resolve: (value: T) => void = undefined!
-    let reject: (reason?: unknown) => void = undefined!
-    const promise = new Promise<T>((resolve_, reject_) => {
-      resolve = resolve_
-      reject = reject_
-    })
-    this.status = {
-      type: "pending",
-      promise,
-      resolve,
-      reject,
-    }
-    this.#handle?.(new StrandStatusChanged(this.status))
-    const iterator = Definition.unwrap(this.#definition)
-    let nextArg: unknown
-    queueMicrotask(async () => {
-      try {
-        let current = await iterator.next()
-        while (!current.done) {
-          const rune = current.value
-          const { instruction: value } = rune
-          switch (value.kind) {
-            case "reflect": {
-              nextArg = this
-              break
-            }
-            case "continue": {
-              nextArg = await value.f()
-              break
-            }
-            case "emit": {
-              this.#handle?.(value.event)
-              nextArg = undefined
-              break
-            }
-            case "create_child": {
-              nextArg = await new Strand(value.definition, {
-                parent: this,
-                context: value.context ?? this.context.clone(),
-              }).then()
-              break
-            }
-          }
-          switch (this.status.type) {
-            case "config_signal_aborted":
-            case "parent_aborted":
-            case "continuation_exception_thrown":
-            case "handler_exception_thrown": {
-              try {
-                await iterator.return?.(undefined)
-              } catch (exception) {}
-              return Promise.reject(new StrandRejectedError(this.status))
-            }
-          }
-          current = await iterator.next(nextArg)
-        }
-        const { value } = current
-        this.#setTerminalStatus({
-          type: "resolved",
-          value,
-        })
-        resolve(value)
-      } catch (exception) {
-        this.#setTerminalStatus({
-          type: "continuation_exception_thrown",
-          exception,
-        })
-        reject(exception)
-      }
-    })
-    return promise.then(onfulfilled, onrejected)
-  }
-
-  *[Symbol.iterator](): Generator<Y, T> {
-    return yield* continuation("run_strand", () => this.then()) as any
-  }
-
-  #replay(status: Exclude<StrandStatus, StrandStatus.Untouched>): Promise<T> {
-    switch (status.type) {
-      case "config_signal_aborted":
-      case "parent_aborted":
-      case "continuation_exception_thrown":
-      // case "model_error":
-      case "handler_exception_thrown": {
-        return Promise.reject(new StrandRejectedError(status))
-      }
-      case "resolved": {
-        return Promise.resolve(status.value)
-      }
-      case "pending": {
-        return status.promise
-      }
-    }
-  }
-
-  static {
-    attachCustomInspect(this, ({ index, parent }) => ({ index, ...parent && { parent } }))
-  }
-}
-
-export type StrandStatus<T = any> =
-  | StrandStatus.Untouched
-  | StrandStatus.Pending<T>
-  | StrandStatus.Resolved<T>
-  | StrandStatus.Rejected
-export namespace StrandStatus {
-  export interface Untouched {
-    type: "untouched"
-  }
-
-  export interface Pending<T> {
-    type: "pending"
-    promise: Promise<T>
-    resolve: (value: T) => void
-    reject: (reason?: unknown) => void
-  }
-
-  export interface Resolved<T> {
-    type: "resolved"
-    value: T
-  }
-
-  export type Rejected =
-    | Rejected.ConfigSignalAborted
-    | Rejected.ParentAborted
-    | Rejected.ContinuationExceptionThrown
-    | Rejected.HandlerExceptionThrown
-  // | Rejected.ModelError
-  export namespace Rejected {
-    export interface ConfigSignalAborted {
-      type: "config_signal_aborted"
-      reason: unknown
-    }
-    export interface ParentAborted {
-      type: "parent_aborted"
-      reason: unknown
-    }
-    export interface ContinuationExceptionThrown {
-      type: "continuation_exception_thrown"
-      exception: unknown
-    }
-    export interface HandlerExceptionThrown {
-      type: "handler_exception_thrown"
-      exception: unknown
-    }
-    // export interface ModelError {
-    //   type: "model_error"
-    //   model: string
-    //   error: unknown
-    // }
-  }
-}

package/Tool.ts

@@ -1,26 +0,0 @@
-import { Schema } from "./Schema.ts"
-import type { JSONValue } from "./util/JSONValue.ts"
-
-export class Tool {
-  static async make<T extends JSONValue>(
-    description: string,
-    schema: Schema<T>,
-    f: (arg: T) => JSONValue | Promise<JSONValue>,
-  ) {
-    return new Tool(
-      await Schema.id(schema, description),
-      description,
-      schema,
-      async (arg) => {
-        return await f(await Schema.validateValue(schema, arg))
-      },
-    )
-  }
-
-  constructor(
-    readonly name: string,
-    readonly description: string,
-    readonly parameterSchema: Schema,
-    readonly f: (arg: any) => JSONValue | Promise<JSONValue>,
-  ) {}
-}

package/TypeAdapter.ts

@@ -1,3 +0,0 @@
-import { LiminalAssertionError } from "./LiminalAssertionError.ts"
-import { Schema } from "./Schema.ts"
-import type { JSONValueObject } from "./util/JSONValue.ts"

package/dist/Adapter.d.ts

@@ -1,18 +0,0 @@
-import type { Message } from "./Message.ts";
-import type { SchemaObject } from "./Schema.ts";
-import type { Tool } from "./Tool.ts";
-export declare class Adapter {
-    readonly name: string;
-    readonly seal: (envelope: Envelope) => SealedEnvelope;
-    constructor(name: string, seal: (envelope: Envelope) => SealedEnvelope);
-}
-export interface Envelope {
-    messages: Array<Message>;
-    schema?: SchemaObject | undefined;
-    signal: AbortSignal;
-    tools?: Set<Tool> | undefined;
-}
-export interface SealedEnvelope {
-    resolve: () => Promise<string>;
-    stream: () => ReadableStream<string>;
-}

package/dist/Adapter.js

@@ -1,13 +0,0 @@
-import { attachCustomInspect } from "./util/attachCustomInspect.js";
-export class Adapter {
-    name;
-    seal;
-    constructor(name, seal) {
-        this.name = name;
-        this.seal = seal;
-    }
-    static {
-        attachCustomInspect(this, ({ name }) => ({ name }));
-    }
-}
-//# sourceMappingURL=Adapter.js.map

package/dist/Adapter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Adapter.js","sourceRoot":"","sources":["../Adapter.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAA;AAEnE,MAAM,OAAO,OAAO;IAEP;IACA;IAFX,YACW,IAAY,EACZ,IAA4C;QAD5C,SAAI,GAAJ,IAAI,CAAQ;QACZ,SAAI,GAAJ,IAAI,CAAwC;IACpD,CAAC;IAEJ;QACE,mBAAmB,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAA;IACrD,CAAC;CACF"}

package/dist/AdapterRegistry.d.ts

@@ -1,27 +0,0 @@
-import type { Adapter } from "./Adapter.ts";
-/**
- * An intrusive doubly-linked list for storing `Model`s.
- * Provides efficient insertion, removal, and lookups.
- */
-export declare class AdapterRegistry {
-    head?: ModelRegistryNode | undefined;
-    tail?: ModelRegistryNode | undefined;
-    /** Returns the most recently registered model */
-    peek(): Adapter | undefined;
-    /** Ensure */
-    ensure(): Adapter;
-    /**
-     * Registers a new model and returns the created node
-     * @param value The model to register
-     */
-    register(value: Adapter): ModelRegistryNode;
-    /** Remove a model from the registry. */
-    remove(node: ModelRegistryNode): void;
-    /** Creates a deep copy of this registry. */
-    clone(): AdapterRegistry;
-}
-export interface ModelRegistryNode {
-    prev: ModelRegistryNode | undefined;
-    adapter: Adapter;
-    next?: ModelRegistryNode | undefined;
-}

package/dist/AdapterRegistry.js

@@ -1,62 +0,0 @@
-import { LiminalAssertionError } from "./LiminalAssertionError.js";
-/**
- * An intrusive doubly-linked list for storing `Model`s.
- * Provides efficient insertion, removal, and lookups.
- */
-export class AdapterRegistry {
-    /** Returns the most recently registered model */
-    peek() {
-        return this.tail?.adapter;
-    }
-    /** Ensure */
-    ensure() {
-        LiminalAssertionError.assert(this.tail, "No conversation adapter registered. Use `L.focus` to focus a conversation adapter.");
-        return this.tail.adapter;
-    }
-    /**
-     * Registers a new model and returns the created node
-     * @param value The model to register
-     */
-    register(value) {
-        const node = {
-            prev: this.tail,
-            adapter: value,
-        };
-        if (this.tail) {
-            this.tail.next = node;
-        }
-        else {
-            this.head = node;
-        }
-        this.tail = node;
-        return node;
-    }
-    /** Remove a model from the registry. */
-    remove(node) {
-        if (node.prev) {
-            node.prev.next = node.next;
-        }
-        if (node.next) {
-            node.next.prev = node.prev;
-        }
-        if (node === this.head) {
-            this.head = node.next;
-        }
-        if (node === this.tail) {
-            this.tail = node.prev;
-        }
-        node.prev = undefined;
-        delete node.next;
-    }
-    /** Creates a deep copy of this registry. */
-    clone() {
-        const instance = new AdapterRegistry();
-        for (let node = this.head; node; node = node.next) {
-            if (node.adapter) {
-                instance.register(node.adapter);
-            }
-        }
-        return instance;
-    }
-}
-//# sourceMappingURL=AdapterRegistry.js.map

package/dist/AdapterRegistry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AdapterRegistry.js","sourceRoot":"","sources":["../AdapterRegistry.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AAElE;;;GAGG;AACH,MAAM,OAAO,eAAe;IAI1B,iDAAiD;IACjD,IAAI;QACF,OAAO,IAAI,CAAC,IAAI,EAAE,OAAO,CAAA;IAC3B,CAAC;IAED,aAAa;IACb,MAAM;QACJ,qBAAqB,CAAC,MAAM,CAC1B,IAAI,CAAC,IAAI,EACT,oFAAoF,CACrF,CAAA;QACD,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAA;IAC1B,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,KAAc;QACrB,MAAM,IAAI,GAAsB;YAC9B,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,OAAO,EAAE,KAAK;SACf,CAAA;QACD,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YACd,IAAI,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QACvB,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAClB,CAAC;QACD,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,OAAO,IAAI,CAAA;IACb,CAAC;IAED,wCAAwC;IACxC,MAAM,CAAC,IAAuB;QAC5B,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YACd,IAAI,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAA;QAC5B,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YACd,IAAI,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAA;QAC5B,CAAC;QACD,IAAI,IAAI,KAAK,IAAI,CAAC,IAAI,EAAE,CAAC;YACvB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAA;QACvB,CAAC;QACD,IAAI,IAAI,KAAK,IAAI,CAAC,IAAI,EAAE,CAAC;YACvB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAA;QACvB,CAAC;QACD,IAAI,CAAC,IAAI,GAAG,SAAS,CAAA;QACrB,OAAO,IAAI,CAAC,IAAI,CAAA;IAClB,CAAC;IAED,4CAA4C;IAC5C,KAAK;QACH,MAAM,QAAQ,GAAG,IAAI,eAAe,EAAE,CAAA;QACtC,KAAK,IAAI,IAAI,GAAG,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;YAClD,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;gBACjB,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;YACjC,CAAC;QACH,CAAC;QACD,OAAO,QAAQ,CAAA;IACjB,CAAC;CACF"}

package/dist/Config.d.ts

@@ -1,12 +0,0 @@
-import { AdapterRegistry } from "./AdapterRegistry.ts";
-import type { Message } from "./Message.ts";
-import type { Rune } from "./Rune.ts";
-import type { Strand } from "./Strand.ts";
-import type { Tool } from "./Tool.ts";
-export interface Config<Y extends Rune<any> = Rune<any>, T = any> {
-    handler?: ((this: Strand<Y, T>, event: Rune.E<Y>) => void) | undefined;
-    models?: AdapterRegistry | undefined;
-    messages?: Array<Message>;
-    tools?: Set<Tool> | undefined;
-    signal?: AbortSignal | undefined;
-}

package/dist/Config.js

@@ -1,2 +0,0 @@
-import { AdapterRegistry } from "./AdapterRegistry.js";
-//# sourceMappingURL=Config.js.map

package/dist/Config.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Config.js","sourceRoot":"","sources":["../Config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA"}

package/dist/Definition.d.ts

@@ -1,24 +0,0 @@
-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 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>;
-}