@schlenkr/ragents 0.1.14 → 0.1.15

package/apps/server/src/ragents/run-script-tools.ts

@@ -0,0 +1,66 @@
+import { Type } from "typebox";
+import { defineRunFunction, defineToolAvailability, holdsUsable, type JsonValue, type PluginHost, type ToolContributor } from "@ragents/engine";
+import { toolDescriptorFrom } from "../plugin-support/agent-tool.js";
+import { runManagementToken, type RunManagement } from "./global-chat.js";
+
+const available = defineToolAvailability({
+  availability: "conditional",
+  availabilityDetail: "Only with the capability script.start, which the coordinator holds and passes to no agent it spawns.",
+  requiredCapabilities: ["script.start"],
+}, (actor) => actor.kind !== "human" && holdsUsable(actor, "script.start"));
+
+const listMetadata = {
+  name: "run_script_list",
+  label: "List run scripts",
+  description: "The run scripts of this profile that can join this run: entry, title, description, and whether each can start now or why not.",
+} as const;
+
+const startMetadata = {
+  name: "run_script_start",
+  label: "Start run script",
+  description: "Start a run script from run_script_list inside this run; returns its actor handle and which start of it this is.",
+  longDescription: "entry is the entry from run_script_list; input is the script's start value, if it takes one. The script joins the run "
+    + "without changing the primary actor; a repeated start reuses its actor. When it finishes a start, you receive its summary and result "
+    + "as a message; do not wait or poll for it in the same turn.",
+} as const;
+
+const listing = Type.Array(Type.Object({
+  entry: Type.String(),
+  title: Type.String(),
+  description: Type.String(),
+  available: Type.Boolean(),
+  reason: Type.Optional(Type.String()),
+}, { additionalProperties: false }));
+
+export const createRunScriptToolContributor = (management: () => RunManagement): ToolContributor => {
+  const list = defineRunFunction({
+    ...listMetadata,
+    schema: Type.Object({}, { additionalProperties: false }),
+    resultSchema: listing,
+    available,
+    run: ({ caller }) => management().scripts(caller.runId).map(({ id, ...script }) => ({ entry: id, ...script })),
+  });
+  const start = defineRunFunction({
+    ...startMetadata,
+    schema: Type.Object({
+      entry: Type.String({ minLength: 1, description: "The entry from run_script_list" }),
+      input: Type.Optional(Type.Unknown({ description: "Start value of the script; omit it for none" })),
+    }, { additionalProperties: false }),
+    resultSchema: Type.Object({ handle: Type.String(), count: Type.Integer({ minimum: 1 }) }, { additionalProperties: false }),
+    available,
+    run: async ({ caller }, _toolCallId, input) => {
+      const started = await management().startScript(caller.runId, input.entry, (input.input ?? null) as JsonValue | null, caller.actorId);
+      return { handle: started.handle, count: started.count };
+    },
+  });
+  return {
+    name: "ragents.run-scripts",
+    descriptors: [toolDescriptorFrom(listMetadata, available), toolDescriptorFrom(startMetadata, available)],
+    tools: () => [list, start],
+  };
+};
+
+/** The profile registers them once while composing; they act on the caller's own run. */
+export const registerRunScriptFunctions = (host: PluginHost): void => {
+  host.tools.register("ragents.runtime", [createRunScriptToolContributor(() => host.service(runManagementToken)())]);
+};

package/apps/server/src/ragents/session.ts

@@ -1,15 +1,14 @@
 import { randomUUID } from "node:crypto";
-import { mkdir, writeFile } from "node:fs/promises";
-import path from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { parseChatAttachments, type ChatAttachment, type ChatAttachmentInput, type ChatEvent, type ChatStartupStatus } from "quassel/events";
 import { attachmentContentPath } from "../api/contracts.js";
-import type { ChatSessionLike, ChatUser } from "../chat-handler.js";
+import type { ChatSessionLike, ChatUser, RunScriptListing, StartedScript } from "../chat-handler.js";
 import {
   assertJsonValue,
   attachmentInputKind,
   capabilityNames,
   DomainError,
+  firstHandCapabilities,
   isThinkingLevel,
   PluginStateProjection,
   resolveExecution,
@@ -25,7 +24,7 @@ import {
   type AgentExecution,
   type ModelSelection,
 } from "@ragents/engine";
-import type { ActorProgramsService } from "../plugin-support/actor-programs/service.js";
+import type { ActivatedActorProgram, ActorProgramsService } from "../plugin-support/actor-programs/service.js";
 import { modelLabel } from "../plugin-support/model-aliases.js";
 import type { StartOptionState } from "../plugin-support/start-options-contract.js";
 import type { Engine } from "./engine.js";
@@ -59,7 +58,7 @@ const coordinatorGrants = (): CapabilityGrant[] =>
   capabilityNames.map((capability) => ({
     capability,
     scope: { kind: "run" as const },
-    delegable: true,
+    delegable: !firstHandCapabilities.includes(capability),
   }));
 
 const primaryActorOf = (view: RunView) => view.primaryActorId
@@ -70,6 +69,9 @@ const messageOf = (error: unknown): string => error instanceof Error ? error.mes
 
 const userIdOf = (user: ChatUser | undefined): string | null => user?.id ?? null;
 
+const startValueOf = (input: unknown): JsonValue | null =>
+  input === undefined || input === null ? null : (assertJsonValue(input, "Start value of the run script"), input);
+
 /** Who starts a run, through which template, and which start options it fixes. */
 interface StartChoice {
   readonly userId: string | null;
@@ -83,6 +85,8 @@ const freeChoice = (userId: string | null): StartChoice => ({ userId, entry: nul
 /** A script template together with the package the host installs when it is clicked. */
 export type RunScriptStart = RunScriptPackage & { entry: PublicStartEntry };
 
+export type RunScriptPrograms = Pick<ActorProgramsService, "installScript" | "enqueueStart" | "isScriptActor">;
+
 export interface RunChatSessionOptions {
   engine: Engine;
   id: string;
@@ -99,7 +103,7 @@ export interface RunChatSessionOptions {
   started: (id: string, startEntry: SessionStartedContext["startEntry"]) => Promise<void>;
   scriptEntryFor: (entryId: string) => RunScriptStart | undefined;
   startEntryFor: (entryId: string) => PublicStartEntry | undefined;
-  actorPrograms: ActorProgramsService;
+  actorPrograms: RunScriptPrograms;
 }
 
 export class RunChatSession implements ChatSessionLike {
@@ -117,7 +121,7 @@ export class RunChatSession implements ChatSessionLike {
   readonly #started: (id: string, startEntry: SessionStartedContext["startEntry"]) => Promise<void>;
   readonly #scriptEntryFor: (entryId: string) => RunScriptStart | undefined;
   readonly #startEntryFor: (entryId: string) => PublicStartEntry | undefined;
-  readonly #actorPrograms: ActorProgramsService;
+  readonly #actorPrograms: RunScriptPrograms;
   readonly #events: ChatEvent[] = [];
   readonly #listeners = new Set<(event: ChatEvent) => void>();
   readonly #liveTurns = new Map<string, LiveTurn>();
@@ -127,6 +131,8 @@ export class RunChatSession implements ChatSessionLike {
   #primaryActorId: string | undefined;
   #activeLiveTurnId: string | undefined;
   #starting: Promise<void> | undefined;
+  #scriptQueue: Promise<unknown> = Promise.resolve();
+  readonly #scriptStarts = new Set<AbortController>();
   #startup: ChatStartupStatus | undefined;
   #startCancellation: AbortController | undefined;
   #unsubscribeJournal: (() => void) | undefined;
@@ -232,7 +238,7 @@ export class RunChatSession implements ChatSessionLike {
       const chosen = this.startLocked ? storedStartOption(state, optionId) : this.#startValues.get(optionId);
       if (chosen !== undefined && !isDeepStrictEqual(chosen, accepted)) {
         throw new DomainError("start-option-fixed", this.startLocked
-          ? `The template "${entry.title}" fixes the start option ${optionId}, but this run already has a different value there.`
+          ? `The template "${entry.title}" fixes the start option ${optionId} to ${JSON.stringify(accepted)}, but this run already has a different value there: ${JSON.stringify(chosen)}.`
           : `The template "${entry.title}" fixes the start option ${optionId}, but a different value is chosen. Undo the choice or start without this template.`, 409);
       }
       return [optionId, accepted] as const;
@@ -319,24 +325,47 @@ export class RunChatSession implements ChatSessionLike {
     return { attachment: this.#attachmentInfo(artifact), content };
   }
 
-  /** Starts the run through a script template: no message, the script's first turn builds the run. */
+  /** Starts a run script: in a new run its first turn builds the run, in a running run only an embeddable one joins it. */
   start(entryId: string, input: unknown, user?: ChatUser): void {
-    this.#track(() => this.#start(entryId, input, user));
+    void this.#track(() => this.#start(entryId, input, user));
+  }
+
+  /** startedBy is the actor that receives the script's result; without it, the owner. */
+  async startAndWait(entryId: string, input: unknown, user?: ChatUser, startedBy?: string): Promise<StartedScript> {
+    return this.#track(() => this.#start(entryId, input, user, startedBy));
+  }
+
+  /** The script templates among these entries, and whether each can start in this run now. */
+  runScripts(entries: readonly PublicStartEntry[], userId: string | null): RunScriptListing[] {
+    const started = this.#runStarted();
+    return entries.flatMap((entry) => {
+      const found = this.#scriptEntryFor(entry.id);
+      if (!found) return [];
+      const reason = !started ? undefined
+        : !found.embeddable ? "It starts only a new run; its RUN.md does not set embeddable: true."
+        : this.#optionConflict(found.entry, userId);
+      return [{ id: entry.id, title: entry.title, description: entry.description, available: reason === undefined, ...(reason ? { reason } : {}) }];
+    });
   }
 
-  async startAndWait(entryId: string, input: unknown, user?: ChatUser): Promise<void> {
-    await this.#track(() => this.#start(entryId, input, user));
+  #optionConflict(entry: PublicStartEntry, userId: string | null): string | undefined {
+    try {
+      this.#startChoice(entry, userId);
+      return undefined;
+    } catch (error) {
+      return messageOf(error);
+    }
   }
 
-  async startPackageAndWait(script: RunScriptStart, input: unknown, user?: ChatUser): Promise<void> {
-    await this.#track(() => this.#startPackage(() => script, input, user));
+  async startPackageAndWait(script: RunScriptStart, input: unknown, user?: ChatUser): Promise<StartedScript> {
+    return this.#track(() => this.#startPackage(() => script, input, user));
   }
 
-  #track(work: () => Promise<void>, reportError = true): Promise<void> {
+  #track<T>(work: () => Promise<T>, reportError = true): Promise<T> {
     if (this.#disposed) throw new Error("The run was deleted");
     this.#assertUsable(this.id);
     const operation = work();
-    const tracked = operation.catch((error: unknown) => {
+    const tracked = operation.then(() => undefined, (error: unknown) => {
       if (reportError && !this.#disposed) this.#emit({ kind: "system", text: `Error: ${messageOf(error)}` });
     });
     this.#pendingSends.add(tracked);
@@ -356,8 +385,9 @@ export class RunChatSession implements ChatSessionLike {
     if (this.#startCancellation && !this.#startCancellation.signal.aborted) {
       const message = "The start was cancelled by the operator.";
       this.#startCancellation.abort(new DomainError("run-start-aborted", message, 409));
-      this.#setStartup({ status: "failed", message });
+      if (this.#startup?.status === "preparing") this.#setStartup({ status: "failed", message });
     }
+    for (const controller of this.#scriptStarts) controller.abort(new DomainError("run-start-aborted", "The start was cancelled by the operator.", 409));
     try {
       if (this.#engine.journal.stateOf(this.id)) {
         await this.#engine.stopRun(this.id, {
@@ -386,6 +416,7 @@ export class RunChatSession implements ChatSessionLike {
     if (this.#engine.journal.stateOf(this.id)) throw new Error("The old journal must be removed before the conversation reset");
     this.#startCancellation?.abort(new Error("The start preparation was reset."));
     this.#startCancellation = undefined;
+    for (const controller of this.#scriptStarts) controller.abort(new Error("The start preparation was reset."));
     this.#startup = undefined;
     this.#unsubscribeJournal?.();
     this.#unsubscribeLive?.();
@@ -409,6 +440,7 @@ export class RunChatSession implements ChatSessionLike {
     this.#disposed = true;
     this.#startCancellation?.abort(new Error("The run was deleted"));
     this.#startCancellation = undefined;
+    for (const controller of this.#scriptStarts) controller.abort(new Error("The run was deleted"));
     this.#startup = undefined;
     this.#unsubscribeJournal?.();
     this.#unsubscribeLive?.();
@@ -581,32 +613,35 @@ export class RunChatSession implements ChatSessionLike {
     return this.#starting;
   }
 
-  async #start(entryId: string, input: unknown, user?: ChatUser): Promise<void> {
-    await this.#startPackage(() => {
+  #start(entryId: string, input: unknown, user?: ChatUser, startedBy?: string): Promise<StartedScript> {
+    return this.#startPackage(() => {
       const found = this.#scriptEntryFor(entryId);
       if (!found) throw new DomainError("entry-unknown", `The template ${entryId} is not a script template of this profile.`, 404);
       return found;
-    }, input, user);
+    }, input, user, startedBy);
   }
 
-  async #startPackage(resolve: () => RunScriptStart, input: unknown, user?: ChatUser): Promise<void> {
+  #runStarted(): boolean {
+    return this.startLocked && this.#engine.runtime.view(this.id).actors.some((actor) => actor.kind !== "human");
+  }
+
+  async #startPackage(resolve: () => RunScriptStart, input: unknown, user?: ChatUser, startedBy?: string): Promise<StartedScript> {
+    if (this.#runStarted()) return this.#startInRun(resolve(), input, user, startedBy);
     if (this.#starting) throw new DomainError("run-starting", "The run is being started.", 409);
-    if (this.startLocked && this.#engine.runtime.view(this.id).actors.some((actor) => actor.kind !== "human")) {
-      throw new DomainError("run-started", "The run is already running; a run script only starts a new run.", 409);
-    }
     const cancellation = new AbortController();
     this.#startCancellation = cancellation;
+    let started: StartedScript | undefined;
     const operation = this.#exclusiveStart(async () => {
       const { signal } = cancellation;
       try {
         signal.throwIfAborted();
         const found = resolve();
         const choice = this.#startChoice(found.entry, userIdOf(user));
-        const startValue: JsonValue | null = input === undefined || input === null ? null : (assertJsonValue(input, "Start value of the run script"), input);
+        const startValue = startValueOf(input);
         await this.#prepare(this.id, this.#emitSystem());
         signal.throwIfAborted();
         this.#assertUsable(this.id);
-        await this.#startWithScript(found, startValue, signal, user, choice);
+        started = await this.#startWithScript(found, startValue, signal, user, choice);
         signal.throwIfAborted();
         this.#setStartup(undefined);
       } catch (error) {
@@ -620,6 +655,41 @@ export class RunChatSession implements ChatSessionLike {
     });
     this.#setStartup({ status: "preparing", message: "Preparing run." });
     await operation;
+    if (!started) throw new Error("The run script start ended without a result");
+    return started;
+  }
+
+  /** Starts in a running run wait for each other; each checks what can refuse it before the run changes, and none touches the primary actor or the startup status. */
+  async #startInRun(found: RunScriptStart, input: unknown, user?: ChatUser, startedBy?: string): Promise<StartedScript> {
+    if (!found.embeddable) {
+      throw new DomainError("run-started", `The run is already running; the run script "${found.entry.title}" only starts a new run. A run script starts inside a running run only if its RUN.md sets embeddable: true.`, 409);
+    }
+    const startValue = startValueOf(input);
+    const cancellation = new AbortController();
+    this.#scriptStarts.add(cancellation);
+    const operation = this.#scriptQueue.then(async () => {
+      const { signal } = cancellation;
+      signal.throwIfAborted();
+      await this.#starting?.catch(() => undefined);
+      signal.throwIfAborted();
+      const choice = this.#startChoice(found.entry, userIdOf(user));
+      await this.#prepare(this.id, this.#emitSystem());
+      signal.throwIfAborted();
+      this.#assertUsable(this.id);
+      await this.#prepareWorkspace(this.id, this.#emitSystem());
+      signal.throwIfAborted();
+      this.#assertUsable(this.id);
+      const installed = await this.#installScript(found, signal);
+      signal.throwIfAborted();
+      this.#assertUsable(this.id);
+      return this.#enqueueStart(found, installed, startValue, choice, true, startedBy);
+    });
+    this.#scriptQueue = operation.catch(() => undefined);
+    try {
+      return await operation;
+    } finally {
+      this.#scriptStarts.delete(cancellation);
+    }
   }
 
   async #startRun(user: ChatUser | undefined, choice: StartChoice): Promise<void> {
@@ -632,8 +702,8 @@ export class RunChatSession implements ChatSessionLike {
     this.#assertUsable(this.id);
   }
 
-  async #startWithScript(found: RunScriptStart, input: JsonValue | null, signal: AbortSignal, user: ChatUser | undefined, choice: StartChoice): Promise<void> {
-    const { entry, ...script } = found;
+  async #startWithScript(found: RunScriptStart, input: JsonValue | null, signal: AbortSignal, user: ChatUser | undefined, choice: StartChoice): Promise<StartedScript> {
+    const { entry } = found;
     this.#createRunIfNeeded(this.#initialTitle ?? entry.title, user, choice);
     this.#assertUsable(this.id);
     this.#setStartup({ status: "preparing", message: "Preparing working directory." });
@@ -643,50 +713,40 @@ export class RunChatSession implements ChatSessionLike {
     this.#assertUsable(this.id);
     this.#setStartup({ status: "preparing", message: "Preparing UI." });
     signal.throwIfAborted();
-    await this.#copyPrograms(script.programs, signal);
-    signal.throwIfAborted();
-    const state = this.#engine.runtime.state(this.id);
-    const installed = await this.#actorPrograms.importPackage(
-      {actorId: state.ownerId, commandId: `run-script:${this.id}:${script.handle}`},
-      this.id, script.handle, script.files, signal, entry.id,
-    );
+    const installed = await this.#installScript(found, signal);
     signal.throwIfAborted();
     this.#assertUsable(this.id);
-    if (script.coordinator) this.#ensureCoordinatorAsPrimary(choice);
+    if (found.coordinator) this.#ensureCoordinatorAsPrimary(choice);
     else {
+      const state = this.#engine.runtime.state(this.id);
       this.#engine.runtime.selectPrimaryActor({actorId: state.ownerId, commandId: `run-script-primary:${this.id}`}, this.id, installed.actorId);
       this.#bind(installed.actorId);
     }
     await this.#started(this.id, choice.entry);
     this.#assertUsable(this.id);
-    const options = Object.fromEntries(this.#engine.startOptions.entries()
-      .map((option) => [option.option.id, this.#startValueOf(option, choice)]));
     signal.throwIfAborted();
-    this.#engine.runtime.enqueueInput(
-      { actorId: state.ownerId, commandId: `run-script-input:${this.id}:${script.handle}` },
-      this.id,
-      { actorId: installed.actorId, content: JSON.stringify({ input, options }) },
+    const started = this.#enqueueStart(found, installed, input, choice, false);
+    if (found.coordinator) this.#emit({ kind: "system", text: `The run script "${entry.title}" runs as @${installed.actorHandle} and sets up the run.` });
+    return started;
+  }
+
+  #installScript(found: RunScriptStart, signal: AbortSignal): Promise<ActivatedActorProgram> {
+    const { entry, handle, files, programs, sharedPrograms = [] } = found;
+    return this.#actorPrograms.installScript(
+      {actorId: this.#engine.runtime.state(this.id).ownerId, commandId: `run-script:${this.id}:${handle}:${randomUUID()}`},
+      this.id, {entryId: entry.id, handle, files, programs, sharedPrograms}, signal,
     );
-    if (script.coordinator) {
-      this.#emit({ kind: "system", text: `The run script "${entry.title}" runs as @${installed.actorHandle} and sets up the run.` });
-      return;
-    }
   }
 
-  async #copyPrograms(programs: RunScriptPackage["programs"], signal: AbortSignal): Promise<void> {
-    if (programs.length === 0) return;
-    const root = await this.#actorPrograms.workspaceDirectory(this.id);
-    for (const program of programs) {
-      signal.throwIfAborted();
-      const target = path.join(root, program.name);
-      await mkdir(target);
-      for (const file of program.files) {
-        signal.throwIfAborted();
-        const destination = path.join(target, file.path);
-        await mkdir(path.dirname(destination), {recursive: true});
-        await writeFile(destination, file.content, {flag: "wx"});
-      }
-    }
+  #enqueueStart(found: RunScriptStart, installed: ActivatedActorProgram, input: JsonValue | null, choice: StartChoice, embedded: boolean, startedBy?: string): StartedScript {
+    const ownerId = this.#engine.runtime.state(this.id).ownerId;
+    const options = Object.fromEntries(this.#engine.startOptions.entries()
+      .map((option) => [option.option.id, this.#startValueOf(option, choice)]));
+    const { count } = this.#actorPrograms.enqueueStart(
+      {actorId: ownerId, commandId: `run-script-input:${this.id}:${found.handle}:${randomUUID()}`},
+      this.id, found.handle, {content: JSON.stringify({ input, options }), embedded, startedBy: startedBy ?? ownerId},
+    );
+    return { actorId: installed.actorId, handle: installed.actorHandle, count };
   }
 
   #createRunIfNeeded(title: string, user: ChatUser | undefined, choice: StartChoice): void {
@@ -904,6 +964,8 @@ export class RunChatSession implements ChatSessionLike {
       primaryActorId,
       ownerId: this.#engine.runtime.state(this.id).ownerId,
       labelOf: (actorId) => this.#engine.runtime.state(this.id).actors.get(actorId)?.displayName,
+      scriptActorHandle: (actorId) => this.#actorPrograms.isScriptActor(this.id, actorId)
+        ? this.#engine.runtime.select(this.id, (state) => state.actors.get(actorId)?.handle) : undefined,
       turnOf: (turnId) => {
         const turn = this.#engine.runtime.state(this.id).turns.get(turnId);
         if (!turn) throw new Error(`The turn ${turnId} is missing from run ${this.id}`);

package/apps/web/dist/assets/{highlighted-body-KPVGNVTW-BslIwn_y.js → highlighted-body-KPVGNVTW-BwD4uYEe.js}

@@ -1 +1 @@
-import{r,S as d,E as p,j as E,c as f}from"./mermaid-HWGCJPDP-B1erZlFM.js";var j=({code:i,language:e,maxHeight:o,raw:a,className:u,startLine:m,lineNumbers:n,...h})=>{let{shikiTheme:l}=r.useContext(d),t=p(),[c,s]=r.useState(a);return r.useEffect(()=>{if(!t){s(a);return}let g=t.highlight({code:i,language:e,themes:l},x=>{s(x)});g&&s(g)},[i,e,l,t,a]),E.jsx(f,{className:u,language:e,lineNumbers:n,maxHeight:o,result:c,startLine:m,...h})};export{j as HighlightedCodeBlockBody};
+import{r,S as d,E as p,j as E,c as f}from"./mermaid-HWGCJPDP-CSCkaArr.js";var j=({code:i,language:e,maxHeight:o,raw:a,className:u,startLine:m,lineNumbers:n,...h})=>{let{shikiTheme:l}=r.useContext(d),t=p(),[c,s]=r.useState(a);return r.useEffect(()=>{if(!t){s(a);return}let g=t.highlight({code:i,language:e,themes:l},x=>{s(x)});g&&s(g)},[i,e,l,t,a]),E.jsx(f,{className:u,language:e,lineNumbers:n,maxHeight:o,result:c,startLine:m,...h})};export{j as HighlightedCodeBlockBody};

package/apps/web/dist/assets/{main-BUN8m8SW.js → main-KBrc5Q77.js}

@@ -1,4 +1,4 @@
-import{a as ue,r as s,j as e,D as fe,b as pe,d as ee,B as g,X as Le,M as Ie,C as xe,e as _e,f as Be,g as He,h as Ue,u as Fe,i as qe,k as Te,l as Ke,m as $e,A as We,n as Qe,o as Ve,U as Ge,P as Xe,W as Ye,R as Je,p as le,q as J,s as Ze,t as et,v as tt,w as st,x as nt,y as at,z as rt,Q as ot,F as it,G as lt}from"./mermaid-HWGCJPDP-B1erZlFM.js";/**
+import{a as ue,r as s,j as e,D as fe,b as pe,d as ee,B as g,X as Le,M as Ie,C as xe,e as _e,f as Be,g as He,h as Ue,u as Fe,i as qe,k as Te,l as Ke,m as $e,A as We,n as Qe,o as Ve,U as Ge,P as Xe,W as Ye,R as Je,p as le,q as J,s as Ze,t as et,v as tt,w as st,x as nt,y as at,z as rt,Q as ot,F as it,G as lt}from"./mermaid-HWGCJPDP-CSCkaArr.js";/**
  * @license lucide-react v1.46.0 - ISC
  *
  * This source code is licensed under the ISC license.