liminal 0.5.17 → 0.6.0

package/dist/user.d.ts

@@ -0,0 +1,6 @@
+import { Effect } from "effect";
+import { Handler, MessagesRef } from "./Context.ts";
+export declare const user: {
+    (template: TemplateStringsArray, ...substitutions: Array<unknown>): Effect.Effect<void, never, MessagesRef | Handler>;
+    (message: string): Effect.Effect<void, never, MessagesRef | Handler>;
+};

package/dist/user.js

@@ -0,0 +1,18 @@
+import { AiInput } from "@effect/ai";
+import { Effect, Ref } from "effect";
+import { _emit } from "./_emit.js";
+import { Handler, MessagesRef } from "./Context.js";
+import { MessageAppended } from "./LEvent.js";
+import { isTemplateStringsArray } from "./util/isTemplateStringsArray.js";
+export const user = Effect.fn(function* (e0, ...eRest) {
+    const message = new AiInput.UserMessage({
+        parts: [
+            new AiInput.TextPart({
+                text: isTemplateStringsArray(e0) ? String.raw({ raw: e0 }, ...eRest) : e0,
+            }),
+        ],
+    });
+    yield* _emit(new MessageAppended({ message }));
+    yield* Ref.update(yield* MessagesRef, (messages) => [...messages, message]);
+});
+//# sourceMappingURL=user.js.map

package/dist/user.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.js","sourceRoot":"","sources":["../user.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AACpC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAA;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAA;AAEzE,MAAM,CAAC,MAAM,IAAI,GAMb,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAC,EAAE,EAAE,GAAG,KAAK;IAClC,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,WAAW,CAAC;QACtC,KAAK,EAAE;YACL,IAAI,OAAO,CAAC,QAAQ,CAAC;gBACnB,IAAI,EAAE,sBAAsB,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE;aAC1E,CAAC;SACH;KACF,CAAC,CAAA;IACF,KAAK,CAAC,CAAC,KAAK,CAAC,IAAI,eAAe,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,CAAA;IAC9C,KAAK,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,GAAG,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAA;AAC7E,CAAC,CAAU,CAAA"}

package/dist/util/JSONValue.d.ts

@@ -1,7 +1,4 @@
 export type JSONValue = null | boolean | number | string | JSONValueArray | JSONValueObject;
-export declare namespace JSONValue {
-    function assert(value: unknown, visited?: Set<object>): asserts value is JSONValue;
-}
 export type JSONValueArray = Array<JSONValue>;
 export type JSONValueObject = {
     [key: string]: JSONValue;

package/dist/util/JSONValue.js

@@ -1,32 +1,2 @@
-import { LiminalAssertionError } from "liminal";
-export var JSONValue;
-(function (JSONValue) {
-    function assert(value, visited = new Set()) {
-        if (value === null)
-            return;
-        const t = typeof value;
-        if (typeof value !== "object") {
-            LiminalAssertionError.assert(t === "string" || t === "number" || t === "boolean");
-            return;
-        }
-        LiminalAssertionError.assert(!visited.has(value));
-        visited.add(value);
-        try {
-            if (Array.isArray(value)) {
-                for (let i = 0; i < value.length; i++) {
-                    assert(value[i], new Set(visited));
-                }
-            }
-            else {
-                for (const key in value) {
-                    assert(value[key], new Set(visited));
-                }
-            }
-        }
-        finally {
-            visited.delete(value);
-        }
-    }
-    JSONValue.assert = assert;
-})(JSONValue || (JSONValue = {}));
+export {};
 //# sourceMappingURL=JSONValue.js.map

package/dist/util/JSONValue.js.map

@@ -1 +1 @@
-{"version":3,"file":"JSONValue.js","sourceRoot":"","sources":["../../util/JSONValue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAG/C,MAAM,KAAW,SAAS,CA2BzB;AA3BD,WAAiB,SAAS;IACxB,SAAgB,MAAM,CACpB,KAAc,EACd,UAAuB,IAAI,GAAG,EAAU;QAExC,IAAI,KAAK,KAAK,IAAI;YAAE,OAAM;QAC1B,MAAM,CAAC,GAAG,OAAO,KAAK,CAAA;QACtB,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC9B,qBAAqB,CAAC,MAAM,CAAC,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,SAAS,CAAC,CAAA;YACjF,OAAM;QACR,CAAC;QACD,qBAAqB,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAA;QACjD,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;QAClB,IAAI,CAAC;YACH,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;gBACzB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBACtC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC,CAAA;gBACpC,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,KAAK,MAAM,GAAG,IAAI,KAAK,EAAE,CAAC;oBACxB,MAAM,CAAC,KAAK,CAAC,GAAY,CAAC,EAAE,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC,CAAA;gBAC/C,CAAC;YACH,CAAC;QACH,CAAC;gBAAS,CAAC;YACT,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;QACvB,CAAC;IACH,CAAC;IAzBe,gBAAM,SAyBrB,CAAA;AACH,CAAC,EA3BgB,SAAS,KAAT,SAAS,QA2BzB"}
+{"version":3,"file":"JSONValue.js","sourceRoot":"","sources":["../../util/JSONValue.ts"],"names":[],"mappings":""}

package/index.ts

@@ -1,15 +1,4 @@
-export * from "./Adapter.ts"
-export * from "./AdapterRegistry.ts"
-export * from "./Config.ts"
 export * from "./Context.ts"
-export * from "./Definition.ts"
-export * from "./EventBase.ts"
-export * as L from "./L/L.ts"
+export * as L from "./L.ts"
 export * from "./LEvent.ts"
-export * from "./LiminalAssertionError.ts"
-export * from "./Message.ts"
-export * from "./Rune.ts"
-export * from "./Schema.ts"
-export * from "./Strand.ts"
-export * from "./Tool.ts"
-export * from "./TypeAdapter.ts"
+export * from "./strand.ts"

package/messages.ts

@@ -0,0 +1,5 @@
+import type { AiInput } from "@effect/ai"
+import { Effect, Ref } from "effect"
+import { MessagesRef } from "./Context.ts"
+
+export const messages: Effect.Effect<Array<AiInput.Message>, never, MessagesRef> = Effect.flatMap(MessagesRef, Ref.get)

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.5.17",
+  "version": "0.6.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -15,7 +15,8 @@
   "exports": {
     ".": "./dist/index.js"
   },
-  "devDependencies": {
-    "conditional-type-checks": "^1.0.6"
+  "peerDependencies": {
+    "@effect/ai": "^0.18.2",
+    "effect": "^3.16.3"
   }
 }

package/set.ts

@@ -0,0 +1,10 @@
+import type { AiInput } from "@effect/ai"
+import { Effect, Ref } from "effect"
+import { MessagesRef } from "./Context.ts"
+
+export const set = Effect.fn(function*(messages: Iterable<AiInput.Message>) {
+  const messagesRef = yield* MessagesRef
+  const previous = yield* Ref.get(messagesRef)
+  yield* Ref.set(messagesRef, [...messages])
+  return previous
+})

package/strand.ts

@@ -0,0 +1,38 @@
+import type { AiInput, AiTool, AiToolkit } from "@effect/ai"
+import { Effect, Option, Ref } from "effect"
+import { Handler, MessagesRef, System, Toolkit } from "./Context.ts"
+import { LEvent } from "./LEvent.ts"
+
+export interface StrandOptions<E, R, in out T extends AiTool.Any> {
+  /** The system prompt. */
+  system?: string | undefined
+  /** The initial list of AI input messages. */
+  messages?: Iterable<AiInput.Message> | undefined
+  /** The liminal event handler. */
+  handler?: ((event: LEvent) => Effect.Effect<any, E, R>) | undefined
+  /** The tools to use for by strand. */
+  tools?: AiToolkit.AiToolkit<T> | undefined
+}
+
+/** Create an isolated clone of the current conversation to provide for an effect. */
+export const strand: <HE = never, HR = never, T extends AiTool.Any = never>(
+  options?: StrandOptions<HE, HR, T>,
+) => <A, E, R>(
+  effect: Effect.Effect<A, E, R>,
+) => Effect.Effect<A, E | HE, Exclude<R, MessagesRef | System | Handler> | T> = (options) => (effect) =>
+  Effect.gen(function*() {
+    const messagesRef = options?.messages
+      ? Ref.unsafeMake([...options.messages])
+      : yield* Option.match(yield* Effect.serviceOption(MessagesRef), {
+        *onSome(ref) {
+          return Ref.unsafeMake([...yield* Ref.get(ref)])
+        },
+        onNone: () => Ref.make([] as Array<AiInput.Message>),
+      })
+    return yield* (effect.pipe(
+      Effect.provideService(MessagesRef, messagesRef),
+      Effect.provideService(System, options?.system),
+      Effect.provideService(Handler, options?.handler),
+      Effect.provideService(Toolkit, options?.tools),
+    ))
+  }) as never // TODO

package/todo.test.ts

@@ -0,0 +1,3 @@
+import { it } from "vitest"
+
+it("works", () => {})

package/user.ts

@@ -0,0 +1,24 @@
+import { AiInput } from "@effect/ai"
+import { Effect, Ref } from "effect"
+import { _emit } from "./_emit.ts"
+import { Handler, MessagesRef } from "./Context.ts"
+import { MessageAppended } from "./LEvent.ts"
+import { isTemplateStringsArray } from "./util/isTemplateStringsArray.ts"
+
+export const user: {
+  (
+    template: TemplateStringsArray,
+    ...substitutions: Array<unknown>
+  ): Effect.Effect<void, never, MessagesRef | Handler>
+  (message: string): Effect.Effect<void, never, MessagesRef | Handler>
+} = Effect.fn(function*(e0, ...eRest) {
+  const message = new AiInput.UserMessage({
+    parts: [
+      new AiInput.TextPart({
+        text: isTemplateStringsArray(e0) ? String.raw({ raw: e0 }, ...eRest) : e0,
+      }),
+    ],
+  })
+  yield* _emit(new MessageAppended({ message }))
+  yield* Ref.update(yield* MessagesRef, (messages) => [...messages, message])
+}) as never

package/util/JSONValue.ts

@@ -1,34 +1,4 @@
-import { LiminalAssertionError } from "liminal"
-
 export type JSONValue = null | boolean | number | string | JSONValueArray | JSONValueObject
-export namespace JSONValue {
-  export function assert(
-    value: unknown,
-    visited: Set<object> = new Set<object>(),
-  ): asserts value is JSONValue {
-    if (value === null) return
-    const t = typeof value
-    if (typeof value !== "object") {
-      LiminalAssertionError.assert(t === "string" || t === "number" || t === "boolean")
-      return
-    }
-    LiminalAssertionError.assert(!visited.has(value))
-    visited.add(value)
-    try {
-      if (Array.isArray(value)) {
-        for (let i = 0; i < value.length; i++) {
-          assert(value[i], new Set(visited))
-        }
-      } else {
-        for (const key in value) {
-          assert(value[key as never], new Set(visited))
-        }
-      }
-    } finally {
-      visited.delete(value)
-    }
-  }
-}
 
 export type JSONValueArray = Array<JSONValue>
 

package/Adapter.ts

@@ -1,27 +0,0 @@
-import type { Message } from "./Message.ts"
-import type { SchemaObject } from "./Schema.ts"
-import type { Tool } from "./Tool.ts"
-import { attachCustomInspect } from "./util/attachCustomInspect.ts"
-
-export class Adapter {
-  constructor(
-    readonly name: string,
-    readonly seal: (envelope: Envelope) => SealedEnvelope,
-  ) {}
-
-  static {
-    attachCustomInspect(this, ({ name }) => ({ name }))
-  }
-}
-
-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/AdapterRegistry.ts

@@ -1,78 +0,0 @@
-import type { Adapter } from "./Adapter.ts"
-import { LiminalAssertionError } from "./LiminalAssertionError.ts"
-
-/**
- * An intrusive doubly-linked list for storing `Adapter`s.
- * Provides efficient insertion, removal, and lookups.
- */
-export class AdapterRegistry {
-  declare head?: ModelRegistryNode | undefined
-  declare tail?: ModelRegistryNode | undefined
-
-  /** Returns the most recently registered adapter */
-  peek() {
-    return this.tail?.adapter
-  }
-
-  /** Ensure */
-  ensure(): Adapter {
-    LiminalAssertionError.assert(
-      this.tail,
-      "No conversation adapter registered. Use `L.focus` to focus a conversation adapter.",
-    )
-    return this.tail.adapter
-  }
-
-  /**
-   * Registers a new adapter and returns the created node
-   * @param value The adapter to register
-   */
-  register(value: Adapter): ModelRegistryNode {
-    const node: ModelRegistryNode = {
-      prev: this.tail,
-      adapter: value,
-    }
-    if (this.tail) {
-      this.tail.next = node
-    } else {
-      this.head = node
-    }
-    this.tail = node
-    return node
-  }
-
-  /** Remove a adapter from the registry. */
-  remove(node: ModelRegistryNode) {
-    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
-  }
-}
-
-export interface ModelRegistryNode {
-  prev: ModelRegistryNode | undefined
-  adapter: Adapter
-  next?: ModelRegistryNode | undefined
-}

package/Config.ts

@@ -1,13 +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/Definition.ts

@@ -1,48 +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 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]()
-    } else if (Symbol.asyncIterator in definition) {
-      return definition[Symbol.asyncIterator]()
-    }
-    const iterable = definition()
-    if (Symbol.iterator in iterable) {
-      return iterable[Symbol.iterator]()
-    }
-    return iterable[Symbol.asyncIterator]()
-  }
-}

package/EventBase.ts

@@ -1,23 +0,0 @@
-import { attachCustomInspect } from "./util/attachCustomInspect.ts"
-
-export interface EventBase<B extends symbol = symbol, K extends string = string> {
-  readonly brand: B
-  readonly type: K
-}
-
-export function EventBase<B extends symbol, K extends string>(brand: B, type: K) {
-  return class implements EventBase<B, K> {
-    static is<T>(this: new(...args: any) => T, value: unknown): value is T {
-      return typeof value === "object" && value !== null
-        && "brand" in value && value.brand === brand
-        && "type" in value && value.type === type
-    }
-
-    readonly brand = brand
-    readonly type = type
-
-    static {
-      attachCustomInspect(this, ({ brand: _0, type: _1, ...rest }) => rest)
-    }
-  }
-}

package/Handler.ts

@@ -1,4 +0,0 @@
-import type { Rune } from "./Rune.ts"
-import type { Strand } from "./Strand.ts"
-
-export type Handler<Y extends Rune<any> = Rune<any>> = (this: Strand, event: Rune.E<Y>) => void

package/L/L.ts

@@ -1,24 +0,0 @@
-export * from "./all.ts"
-export * from "./assistant.ts"
-export * from "./catch.ts"
-export * from "./continuation.ts"
-export * from "./emit.ts"
-export * from "./focus.ts"
-export * from "./infer.ts"
-export * from "./message.ts"
-export * from "./reflect.ts"
-export * from "./run.ts"
-export * from "./schema/anyOf.ts"
-export * from "./schema/array.ts"
-export * from "./schema/boolean.ts"
-export * from "./schema/const.ts"
-export * from "./schema/enum.ts"
-export * from "./schema/integer.ts"
-export * from "./schema/null.ts"
-export * from "./schema/number"
-export * from "./schema/object.ts"
-export * from "./schema/string.ts"
-export * from "./strand.ts"
-export * from "./stream.ts"
-export * from "./system.ts"
-export * from "./user.ts"

package/L/all.ts

@@ -1,39 +0,0 @@
-import type { Context } from "../Context.ts"
-import { Definition } from "../Definition.ts"
-import type { LEvent } from "../LEvent.ts"
-import type { Rune } from "../Rune.ts"
-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,
-): Generator<Rune<LEvent> | Definition.Y<A[number]>, { [I in keyof A]: Definition.T<A[I]> }>
-export function all<A extends Record<keyof any, Definition>>(
-  definitions: A,
-  context?: Context,
-): Generator<Rune<LEvent> | Definition.Y<A[keyof A]>, { [K in keyof A]: Definition.T<A[K]> }>
-export function* all<A extends Array<Definition> | Record<keyof any, Definition>>(
-  definitions: A,
-  context?: Context,
-): Generator<Rune<any>, any> { // TODO: although it's somewhat irrelevant, type this
-  const parent = yield* reflect
-  const strands: Array<Strand> = []
-  for (const definition of Array.isArray(definitions) ? definitions : Object.values(definitions)) {
-    strands.push(
-      new Strand(definition, {
-        parent,
-        context: context?.clone() ?? parent.context.clone(),
-      }),
-    )
-  }
-  const results = yield* continuation("all", () => Promise.all(strands))
-  if (Array.isArray(strands)) return results
-  const keys = Object.keys(strands)
-  return Object.fromEntries(results.map((result, i) => [keys[i], result]))
-}

package/L/assistant.ts

@@ -1,28 +0,0 @@
-import type { LEvent } from "../LEvent.ts"
-import type { Rune } from "../Rune.ts"
-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>
-}
-
-export const assistant: assistant = Object.assign(
-  function* assistant<T>(schema: Schema<T>): Generator<Rune<LEvent>, T> {
-    const inference = yield* infer(schema)
-    yield* message("assistant", [{ part: inference }])
-    return JSON.parse(inference)
-  },
-  {
-    *[Symbol.iterator]() {
-      const inference = yield* infer()
-      yield* message("assistant", [{ part: inference }])
-      return inference
-    },
-  },
-)

package/L/catch.ts

@@ -1,38 +0,0 @@
-import type { Definition } from "../Definition.ts"
-import type { LEvent } from "../LEvent.ts"
-import type { Rune } from "../Rune.ts"
-import { Strand } from "../Strand.ts"
-import { continuation } from "./continuation.ts"
-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>> {
-  const parent = yield* reflect
-  return yield* continuation("catch", async () => {
-    try {
-      const resolved = await new Strand(definition, {
-        parent,
-        context: parent.context.clone(),
-      }).then()
-      return { resolved }
-    } catch (exception: unknown) {
-      return { rejected: exception }
-    }
-  })
-}
-Object.defineProperty(catch_, "name", { value: "catch" })
-
-export type CatchResult<T> = {
-  resolved: T
-  rejected?: never
-} | {
-  resolved?: never
-  rejected: unknown
-}

package/L/continuation.ts

@@ -1,14 +0,0 @@
-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,
-    instruction: {
-      kind: "continue",
-      debug,
-      f,
-    },
-  }
-}

package/L/emit.ts

@@ -1,16 +0,0 @@
-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,
-    instruction: {
-      kind: "emit",
-      event,
-    },
-  }
-}

package/L/focus.ts

@@ -1,17 +0,0 @@
-import type { Adapter } from "../Adapter.ts"
-import type { LEvent } from "../LEvent.ts"
-import { AdapterFocused } from "../LEvent.ts"
-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* focus(adapter: Adapter): Generator<Rune<LEvent>, Adapter> {
-  const { context: { adapters } } = yield* reflect
-  adapters.register(adapter)
-  yield* emit(new AdapterFocused(adapter))
-  return adapter
-}

package/L/infer.ts

@@ -1,34 +0,0 @@
-import { InferenceRequested, Inferred, type LEvent } from "../LEvent.ts"
-import type { Rune } from "../Rune.ts"
-import { Schema } from "../Schema.ts"
-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: { adapters: models, messages }, signal } = yield* reflect
-  const model = models.ensure()
-  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,
-  )
-  if (schema?.type && schema.type !== "object") {
-    inference = JSON.stringify(JSON.parse(inference).value)
-  }
-  yield* emit(new Inferred(requestId, inference))
-  return inference
-}