liminal 0.5.1 → 0.5.3

package/actions/enableTool.ts

@@ -1,75 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec"
-import { Action } from "../Action.ts"
-import type { Actor } from "../Actor.ts"
-import type { ToolCalled } from "../events/ToolCalled.ts"
-import type { ToolEnabled } from "../events/ToolEnabled.ts"
-import type { Spec } from "../Spec.ts"
-import { Tool, type ToolImplementation, type ToolResult } from "../Tool.ts"
-import type { JSONKey } from "../util/JSONKey.ts"
-import type { JSONObject } from "../util/JSONObject.ts"
-import { JSONSchemaMemo } from "../util/JSONSchemaMemo.ts"
-import type { PromiseOr } from "../util/PromiseOr.ts"
-import { disableTool } from "./disableTool.ts"
-
-export function enableTool<K extends JSONKey, A>(
-  key: K,
-  description: string,
-  params: StandardSchemaV1<JSONObject, A>,
-  implementation: (params: A) => PromiseOr<ToolResult>,
-): Generator<
-  Action<
-    "enable_tool",
-    Spec.Make<{
-      Event: ToolEnabled<K> | ToolCalled<K, A>
-    }>
-  >,
-  Generator<disableTool<K>, void>
->
-export function enableTool<
-  K extends JSONKey,
-  A,
-  Y extends Action,
-  T extends ToolResult,
->(
-  key: K,
-  description: string,
-  params: StandardSchemaV1<JSONObject, A>,
-  implementation: (params: A) => Actor<Y, T>,
-): Generator<
-  Action<
-    "enable_tool",
-    Spec.Make<{
-      Event: ToolEnabled<K> | ToolCalled<K, A>
-      Child: [K, Y[""]]
-      Entry: Y[""]["Entry"]
-      Value: T
-    }>
-  >,
-  Generator<disableTool<K>, void>
->
-export function* enableTool(
-  key: JSONKey,
-  description: string,
-  params: StandardSchemaV1<JSONObject, any>,
-  implementation: ToolImplementation,
-): Generator<Action<"enable_tool">, Generator<Action<"disable_tool">, void>> {
-  return yield Action("enable_tool", async (scope) => {
-    scope.event({
-      type: "tool_enabled",
-      description,
-      schema: await JSONSchemaMemo(params),
-      tool: key,
-    })
-    const tool = Tool({
-      toolKey: key,
-      description,
-      params,
-      implementation,
-    })
-    return {
-      ...scope,
-      tools: new Set([...scope.tools, tool]),
-      nextArg: disableTool(tool),
-    }
-  })
-}

package/actions/enableTool.type-test.ts

@@ -1,118 +0,0 @@
-import type { AssertTrue, IsExact } from "conditional-type-checks"
-import type { ActorLike } from "../Actor.ts"
-import type { Emitted } from "../events/Emitted.ts"
-import type { ToolCalled } from "../events/ToolCalled.ts"
-import type { ToolDisabled } from "../events/ToolDisabled.ts"
-import type { ToolEnabled } from "../events/ToolEnabled.ts"
-import * as L from "../L.ts"
-import { ActorAssertions } from "../testing/ActorAssertions.ts"
-import { emit } from "./emit.ts"
-import { enableTool } from "./enableTool.ts"
-
-type P = typeof P["T"]
-const P = L.object({
-  a: L.string,
-  b: L.string,
-})
-
-const arrowTool = L.enableTool("Tool", "", P, (params) => {
-  type _ = [AssertTrue<IsExact<typeof params, P>>]
-})
-
-ActorAssertions(arrowTool).assertSpec<{
-  Event:
-    | ToolEnabled<"Tool">
-    | ToolCalled<"Tool", {
-      a: string
-      b: string
-    }>
-  Child: never
-  Throw: never
-  Entry: never
-  Value: never
-}>()
-
-function* _0() {
-  const detach = yield* arrowTool
-  ActorAssertions(detach).assertSpec<{
-    Event: ToolDisabled<"Tool">
-    Child: never
-    Throw: never
-    Entry: never
-    Value: never
-  }>()
-}
-
-const genTool = enableTool("tool-key", "", P, function*(params) {
-  type _ = [AssertTrue<IsExact<typeof params, P>>]
-  yield* emit("Test")
-  return ""
-})
-
-ActorAssertions(genTool).assertSpec<{
-  Event:
-    | ToolEnabled<"tool-key">
-    | ToolCalled<"tool-key", {
-      a: string
-      b: string
-    }>
-  Child: ["tool-key", {
-    Event: Emitted<"Test">
-    Child: never
-    Throw: never
-    Entry: never
-    Value: never
-  }]
-  Throw: never
-  Entry: never
-  Value: string
-}>()
-
-function* parent() {
-  yield* L.enableTool("parent-tool", "", P, () => {})
-  yield* L.branch("fork-key", {
-    *"arm-key"() {
-      yield* arrowTool
-    },
-  })
-}
-
-type g = typeof parent extends ActorLike<infer Y> ? Y[""] : never
-
-ActorAssertions(parent).assertSpec<
-  {
-    Event:
-      | ToolEnabled<"parent-tool">
-      | ToolCalled<"parent-tool", {
-        a: string
-        b: string
-      }>
-    Child: never
-    Throw: never
-    Entry: never
-    Value: never
-  } | {
-    Event: never
-    Child: ["fork-key", {
-      Event: never
-      Child: ["arm-key", {
-        Event:
-          | ToolEnabled<"Tool">
-          | ToolCalled<"Tool", {
-            a: string
-            b: string
-          }>
-        Child: never
-        Throw: never
-        Entry: never
-        Value: never
-      }]
-      Throw: never
-      Entry: never
-      Value: void
-    }]
-    Throw: never
-    Entry: never
-    Value: never
-  }
->()

package/actions/getScope.ts

@@ -1,11 +0,0 @@
-import { Action } from "../Action.ts"
-import type { Scope } from "../Scope.ts"
-
-export interface getScope extends Action<"get_scope", never> {}
-
-export function* getScope(): Generator<getScope, Scope> {
-  return yield Action("get_scope", (scope) => ({
-    ...scope,
-    nextArg: scope,
-  }))
-}

package/actions/getSignal.ts

@@ -1,10 +0,0 @@
-import { Action } from "../Action.ts"
-
-export interface getSignal extends Action<"get_signal", never> {}
-
-export function* getSignal(): Generator<getSignal, AbortSignal> {
-  return yield (Action("get_signal", (scope) => ({
-    ...scope,
-    nextArg: scope.controller.signal,
-  })))
-}

package/actions/getTools.ts

@@ -1,11 +0,0 @@
-import { Action } from "../Action.ts"
-import type { Tool } from "../Tool.ts"
-
-export interface getTools extends Action<"get_tools", never> {}
-
-export function* getTools(): Generator<getTools, Set<Tool>> {
-  return yield Action("get_tools", (scope) => ({
-    ...scope,
-    nextArg: scope.tools,
-  }))
-}

package/actions/infer.ts

@@ -1,37 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec"
-import { Action } from "../Action.ts"
-import type { InferenceRequested } from "../events/InferenceRequested.ts"
-import type { Inferred } from "../events/Inferred.ts"
-import type { Spec } from "../Spec.ts"
-import type { JSONObject } from "../util/JSONObject.ts"
-import type { JSONValue } from "../util/JSONValue.ts"
-
-export { infer_ as infer }
-
-interface infer_<_T> extends
-  Action<
-    "infer",
-    Spec.Make<{
-      Event: InferenceRequested | Inferred
-    }>
-  >
-{}
-
-function* infer_<T extends JSONValue = string>(type?: StandardSchemaV1<JSONObject, T>): Generator<infer_<T>, T> {
-  return yield Action("infer", async (scope) => {
-    scope.event({
-      type: "inference_requested",
-    })
-    const model = scope.languageModels.values().next().value!
-    scope = await scope.reduce(model.infer(type))
-    scope.event({
-      type: "inferred",
-      value: scope.value,
-    })
-    return {
-      ...scope,
-      nextArg: scope.value,
-    }
-  })
-}
-Object.defineProperty(infer_, "name", { value: "infer" })

package/actions/pushModel.ts

@@ -1,32 +0,0 @@
-import { Action } from "../Action.ts"
-import type { ModelPushed } from "../events/ModelPushed.ts"
-import type { Model, ModelType } from "../Model.ts"
-import type { Spec } from "../Spec.ts"
-import type { JSONKey } from "../util/JSONKey.ts"
-import { applyToModels } from "./actions_common/updateModels.ts"
-import { removeModel } from "./removeModel.ts"
-
-export interface pushModel<K extends JSONKey, M extends ModelType>
-  extends Action<"remove_model", Spec.Make<{ Event: ModelPushed<K, M> }>>
-{}
-
-export function* pushModel<K extends JSONKey, M extends Model>(
-  modelKey: K,
-  model: M,
-): Generator<pushModel<K, M["type"]>, Generator<removeModel<K, M["type"]>, void>> {
-  return yield Action("remove_model", (scope) => {
-    scope.event({
-      type: "model_pushed",
-      modelKey,
-      modelType: model.type,
-    })
-    return {
-      ...scope,
-      ...applyToModels(scope, model, (models) => {
-        models.add(model)
-        return models
-      }),
-      nextArg: removeModel(modelKey, model),
-    }
-  })
-}

package/actions/removeMessage.ts

@@ -1,22 +0,0 @@
-import { Action } from "../Action.ts"
-import type { MessageRemoved } from "../events/MessageRemoved.ts"
-import type { Message } from "../Message.ts"
-import type { Spec } from "../Spec.ts"
-
-export interface removeMessage extends Action<"remove_message", Spec.Make<{ Event: MessageRemoved }>> {}
-
-export function* removeMessage(message: Message): Generator<removeMessage, void> {
-  yield Action("remove_message", (scope) => {
-    scope.event({
-      type: "message_removed",
-      message,
-    })
-    const messages = new Set(scope.messages)
-    messages.delete(message)
-    return {
-      ...scope,
-      nextArg: message,
-      messages,
-    }
-  })
-}

package/actions/removeModel.ts

@@ -1,31 +0,0 @@
-import { Action } from "../Action.ts"
-import type { ModelRemoved } from "../events/ModelRemoved.ts"
-import type { Model, ModelType } from "../Model.ts"
-import type { Spec } from "../Spec.ts"
-import type { JSONKey } from "../util/JSONKey.ts"
-import { applyToModels } from "./actions_common/updateModels.ts"
-
-export interface removeModel<K extends JSONKey, M extends ModelType>
-  extends Action<"remove_model", Spec.Make<{ Event: ModelRemoved<K, M> }>>
-{}
-
-export function* removeModel<K extends JSONKey, M extends Model>(
-  modelKey: K,
-  model: M,
-): Generator<removeModel<K, M["type"]>, void> {
-  yield Action("remove_model", (scope) => {
-    scope.event({
-      type: "model_removed",
-      modelKey,
-      modelType: model.type,
-    })
-    return {
-      ...scope,
-      ...applyToModels(scope, model, (models) => {
-        models.delete(model)
-        return models
-      }),
-      nextArg: undefined,
-    }
-  })
-}

package/actions/setMessages.ts

@@ -1,66 +0,0 @@
-import { Action } from "../Action.ts"
-import type { Actor } from "../Actor.ts"
-import type { MessagesSet } from "../events/MessagesSet.ts"
-import type { Message } from "../Message.ts"
-import type { Spec } from "../Spec.ts"
-import { isPropertyKey } from "../util/isPropertyKey.ts"
-import type { JSONKey } from "../util/JSONKey.ts"
-import type { PromiseOr } from "../util/PromiseOr.ts"
-
-export function setMessages(
-  setter: (messages: Array<Message>) => PromiseOr<Array<Message>>,
-): Generator<
-  Action<
-    "set_messages",
-    Spec.Make<{
-      Event: MessagesSet
-    }>
-  >,
-  Array<Message>
->
-export function setMessages<K extends JSONKey, Y extends Action>(
-  key: K,
-  setter: (messages: Array<Message>) => Actor<Y, Array<Message>>,
-): Generator<
-  Action<
-    "set_messages",
-    Spec.Make<{
-      Event: MessagesSet
-      Child: [K, Y[""]]
-      Entry: Y[""]["Entry"]
-      Value: Array<Message>
-    }>
-  >,
-  Array<Message>
->
-export function* setMessages(
-  setterOrKey: JSONKey | ((messages: Array<Message>) => PromiseOr<Array<Message>>),
-  maybeSetter?: (messages: Array<Message>) => Actor<Action, Array<Message>>,
-): Generator<Action<"set_messages">, Array<Message>> {
-  return yield Action("set_messages", async (scope) => {
-    if (isPropertyKey(setterOrKey)) {
-      const setterScope = scope.fork("set_messages", [setterOrKey])
-      const reduced = await setterScope.reduce(maybeSetter!([...scope.messages]))
-      const { value } = reduced
-      setterScope.event({
-        type: "returned",
-        value,
-      })
-      setterScope.event({
-        type: "messages_set",
-        messages: value,
-      })
-      return {
-        ...scope,
-        messages: value,
-        nextArg: scope.messages,
-      }
-    }
-    const messages = await setterOrKey([...scope.messages])
-    return {
-      ...scope,
-      messages,
-      nextArg: scope.messages,
-    }
-  })
-}

package/actions/throw.ts

@@ -1,18 +0,0 @@
-import { Action } from "../Action.ts"
-import type { Spec } from "../Spec.ts"
-import type { EnsureNarrow } from "../util/EnsureNarrow.ts"
-
-export { throw_ as throw }
-
-interface throw_<V> extends Action<"throw", Spec.Make<{ Throw: V }>> {}
-
-function* throw_<V>(value: V, ...[_error]: EnsureNarrow<V>): Generator<throw_<V>, never> {
-  return (yield Action("throw", (scope) => {
-    return {
-      ...scope,
-      thrown: value,
-      nextArg: undefined,
-    }
-  })) as never
-}
-Object.defineProperty(throw_, "name", { value: "throw" })

package/cli/WriteHandler.ts

@@ -1,35 +0,0 @@
-import { mkdir, writeFile } from "node:fs/promises"
-import { type ParsedPath, relative, resolve } from "node:path"
-import type { EventResolved } from "../events/EventResolved.ts"
-
-export async function WriteHandler({
-  stateDir,
-  parsedPath,
-  configDir,
-  startTime,
-}: {
-  stateDir: string
-  execId: string | undefined
-  parsedPath: ParsedPath
-  startTime: number
-  configDir: string
-}): Promise<(event: EventResolved) => Promise<void>> {
-  const destDir = resolve(stateDir, relative(configDir, parsedPath.dir), parsedPath.name, startTime.toString())
-  let ensureDir: undefined | PromiseWithResolvers<void>
-  let i = 0
-  return async (event) => {
-    if (!ensureDir) {
-      ensureDir = Promise.withResolvers()
-      ;(async () => {
-        try {
-          await mkdir(destDir, { recursive: true })
-        } catch (_e: unknown) {}
-        ensureDir.resolve()
-      })()
-    }
-    await ensureDir.promise
-    const key = `${i++}__${event.scope.join("__")}__${event.type}.json`
-    const destPath = resolve(destDir, key)
-    await writeFile(destPath, JSON.stringify(event, null, 2), "utf-8")
-  }
-}

package/cli/cli_common.ts

@@ -1,3 +0,0 @@
-export interface CliCtx {
-  ctl: AbortController
-}

package/cli/runExec.ts

@@ -1,68 +0,0 @@
-import { dirname, isAbsolute, parse, resolve } from "node:path"
-import { parseArgs, type ParseArgsConfig } from "node:util"
-import { type Actor, type EventResolved, Exec, L, type LEvent, type LiminalConfig } from "../index.ts"
-import type { CliCtx } from "./cli_common.ts"
-import { WriteHandler } from "./WriteHandler.ts"
-
-const options = {
-  config: {
-    type: "string",
-    default: "liminal.ts",
-    short: "c",
-  },
-  execId: {
-    type: "string",
-    short: "i",
-  },
-} satisfies ParseArgsConfig["options"]
-
-export async function runExec(ctx: CliCtx, args: Array<string>) {
-  let {
-    values: {
-      config: configPath,
-      execId,
-    },
-    positionals,
-  } = parseArgs({
-    args,
-    strict: true,
-    allowPositionals: true,
-    options,
-  })
-  const configPathResolved = resolve(configPath)
-  const configDir = dirname(configPathResolved)
-  const config = await import(configPathResolved).then(({ default: default_ }) => default_ as LiminalConfig)
-  const actorPathInitial = L.string.assert(positionals[0])
-  let actorPathResolved: string
-  if (isAbsolute(actorPathInitial)) {
-    actorPathResolved = actorPathInitial
-  } else {
-    actorPathResolved = resolve(configDir, ...config.actors ? [config.actors] : [], actorPathInitial)
-  }
-  if (!actorPathResolved.endsWith(".ts")) {
-    actorPathResolved = `${actorPathResolved}.ts`
-  }
-  const parsedPath = parse(actorPathResolved)
-  const actorLike = await import(actorPathResolved).then(({ default: default_ }) => default_ as () => Actor)
-  const startTime = Date.now()
-  const writeHandlerOrNoop = config.write
-    ? await WriteHandler({
-      configDir,
-      parsedPath,
-      execId,
-      startTime,
-      stateDir: typeof config.write === "string" ? config.write : ".liminal",
-    })
-    : undefined
-  const printHandlerOrNoop = config.silent ? undefined : (event: EventResolved) => console.log(event)
-  const exec = Exec(actorLike, {
-    default: config.default,
-    args: config.args!,
-  })
-  await exec((event) => {
-    printHandlerOrNoop?.(event)
-    writeHandlerOrNoop?.(event)
-  }, {
-    signal: ctx.ctl.signal,
-  })
-}

package/dist/Action.d.ts

@@ -1,15 +0,0 @@
-import type { Scope } from "./Scope.ts";
-import type { Spec } from "./Spec.ts";
-import type { PromiseOr } from "./util/PromiseOr.ts";
-export interface Action<K extends string = string, S extends Spec = Spec> {
-    "": S;
-    type: K;
-    [ActionKey]: true;
-    trace: string;
-    reducer(this: this, scope: Scope): PromiseOr<Scope>;
-}
-export type ActionReducer<K extends string, S extends Spec> = (this: Action<K, S>, scope: Scope) => PromiseOr<Scope>;
-export declare function Action<K extends string, S extends Spec>(type: K, reducer: ActionReducer<K, S>): Action<K, S>;
-export type ActionKey = typeof ActionKey;
-export declare const ActionKey: unique symbol;
-export declare function isAction(value: unknown): value is Action;

package/dist/Action.js

@@ -1,13 +0,0 @@
-export function Action(type, reducer) {
-    return {
-        type,
-        [ActionKey]: true,
-        trace: new Error().stack,
-        reducer,
-    };
-}
-export const ActionKey = Symbol("Liminal/Action");
-export function isAction(value) {
-    return typeof value === "object" && value !== null && ActionKey in value;
-}
-//# sourceMappingURL=Action.js.map

package/dist/Action.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Action.js","sourceRoot":"","sources":["../Action.ts"],"names":[],"mappings":"AAcA,MAAM,UAAU,MAAM,CAAmC,IAAO,EAAE,OAA4B;IAC5F,OAAQ;QACN,IAAI;QACJ,CAAC,SAAS,CAAC,EAAE,IAAI;QACjB,KAAK,EAAE,IAAI,KAAK,EAAE,CAAC,KAAM;QACzB,OAAO;KACmC,CAAA;AAC9C,CAAC;AAGD,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAA;AAEjD,MAAM,UAAU,QAAQ,CAAC,KAAc;IACrC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,SAAS,IAAI,KAAK,CAAA;AAC1E,CAAC"}

package/dist/Actor.d.ts

@@ -1,14 +0,0 @@
-import type { Action } from "./Action.ts";
-import type { DeferredOr } from "./util/DeferredOr.ts";
-import type { IteratorLike } from "./util/IteratorLike.ts";
-import type { JSONKey } from "./util/JSONKey.ts";
-export type Actor<Y extends Action = Action, R = any> = IteratorLike<Y, R>;
-export type ActorLike<Y extends Action = Action, R = any> = DeferredOr<Actor<Y, R>>;
-export type ActorLikeY<A extends ActorLike> = A extends ActorLike<infer Y> ? Y : never;
-export type ActorLikeT<A extends ActorLike> = A extends ActorLike<Action, infer T> ? T : never;
-export type ActorLikes = ActorLikeArray | ActorLikeRecord;
-export type ActorLikeArray = Array<ActorLike>;
-export type ActorLikeRecord = Record<JSONKey, ActorLike>;
-export type ActorLikesT<A extends ActorLikes> = {
-    -readonly [K in keyof A]: A[K] extends ActorLike<Action, infer T> ? T : never;
-} & {};

package/dist/Actor.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=Actor.js.map

package/dist/Actor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Actor.js","sourceRoot":"","sources":["../Actor.ts"],"names":[],"mappings":""}

package/dist/Exec.d.ts

@@ -1,27 +0,0 @@
-import type { Action } from "./Action.ts";
-import type { Actor } from "./Actor.ts";
-import type { EventHandler } from "./events/EventHandler.ts";
-import type { EventResolved, ExtractEventResolved } from "./events/EventResolved.ts";
-import type { LanguageModel } from "./Model.ts";
-import type { FromEntries } from "./util/FromEntries.ts";
-import type { JSONKey } from "./util/JSONKey.ts";
-export interface Exec<Y extends Action = Action, T = any> {
-    (handler?: EventHandler<Extract<ExtractEventResolved<Y[""]> & {}, EventResolved>>, options?: ExecOptions): Promise<T>;
-}
-export interface ExecConfig {
-    default: LanguageModel;
-    args?: Record<JSONKey, any>;
-}
-export interface ExecOptions {
-    signal?: AbortSignal;
-}
-export type ExtractExecConfig<Y extends Action> = {
-    default: LanguageModel;
-} & ([
-    Y[""]["Entry"]
-] extends [never] ? {
-    args?: undefined;
-} : {
-    args: FromEntries<Y[""]["Entry"]>;
-});
-export declare function Exec<Y extends Action, T>(createActor: () => Actor<Y, T>, config: ExtractExecConfig<Y>): Exec<Y, T>;

package/dist/Exec.js

@@ -1,22 +0,0 @@
-import { RootScope } from "./Scope.js";
-export function Exec(createActor, config) {
-    // TODO: consider `Result` type.
-    return async (handler, options) => {
-        let scope = RootScope(config.default, config.args, handler, options?.signal);
-        scope = await scope.reduce(createActor());
-        const { signal: { aborted, reason } } = scope.controller;
-        if (aborted) {
-            scope.event({
-                type: "aborted",
-                reason,
-            });
-            throw reason;
-        }
-        scope.event({
-            type: "returned",
-            value: scope.value,
-        });
-        return scope.value;
-    };
-}
-//# sourceMappingURL=Exec.js.map

package/dist/Exec.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Exec.js","sourceRoot":"","sources":["../Exec.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAc,MAAM,YAAY,CAAA;AAmClD,MAAM,UAAU,IAAI,CAClB,WAA8B,EAC9B,MAA4B;IAE5B,gCAAgC;IAChC,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE;QAChC,IAAI,KAAK,GAAU,SAAS,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,EAAE,OAAgB,EAAE,OAAO,EAAE,MAAM,CAAC,CAAA;QAC5F,KAAK,GAAG,MAAM,KAAK,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAA;QACzC,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,GAAG,KAAK,CAAC,UAAU,CAAA;QACxD,IAAI,OAAO,EAAE,CAAC;YACZ,KAAK,CAAC,KAAK,CAAC;gBACV,IAAI,EAAE,SAAS;gBACf,MAAM;aACP,CAAC,CAAA;YACF,MAAM,MAAM,CAAA;QACd,CAAC;QACD,KAAK,CAAC,KAAK,CAAC;YACV,IAAI,EAAE,UAAU;YAChB,KAAK,EAAE,KAAK,CAAC,KAAK;SACnB,CAAC,CAAA;QACF,OAAO,KAAK,CAAC,KAAK,CAAA;IACpB,CAAC,CAAA;AACH,CAAC"}