@rynx-ai/server 0.1.11-beta.37 → 0.1.11-beta.39

package/dist/server.js

@@ -5,6 +5,7 @@ import Router from "@koa/router";
 import { loadConfig, listAgentSpecs, loadAgentSpec, resolveSessionExecution, resolveRuntimeModel, ConversationRuntime, InMemorySessionBus, persistSessionEvent, } from "@rynx-ai/core";
 import { RunnerManager, FileCodexSessionStore, resolveCodexSessionStorePath, } from "@rynx-ai/runtime";
 import { createControlRouter, } from "./control-api.js";
+import { MachineSessionServiceFailure, MachineSessionServiceInputError, } from "./machine-session-service.js";
 import { attachEmulatorTouchWs } from "./emulator-touch-ws.js";
 import { attachTerminalWs } from "./terminal-ws.js";
 import { attachBrowserSurfaceWs } from "./browser-surface-ws.js";
@@ -29,25 +30,74 @@ export { attachDirectRuntimeBrowserInspectServer, DirectRuntimeBrowserInspectHos
 export { RemoteRuntimeDispatcher } from "./remote-runtime-dispatcher.js";
 export { createRunnerSessionTerminalHost, SessionTerminalOpenError, SessionTerminalStreamError, } from "./session-terminal-host.js";
 export { listRuntimeModels } from "@rynx-ai/runtime";
-/** Preserve one session's mirror order without serializing unrelated sessions. */
+/** Bound one mirror write at ten seconds. After that uncertainty boundary,
+ * later records may start instead
+ * of waiting forever behind a persistence call whose result is unknown. */
+const SESSION_MIRROR_STALL_TIMEOUT_MS = 10_000;
+class SessionMirrorAmbiguousError extends Error {
+    abandonToken;
+    mirrorClassification = "ambiguous";
+    constructor(sessionId, abandonToken) {
+        super(`Session mirror persistence did not settle before its response deadline: ${sessionId}`);
+        this.abandonToken = abandonToken;
+        this.name = "SessionMirrorAmbiguousError";
+    }
+}
+function preparedMirrorPersistence(persistence) {
+    if (typeof persistence === "object" &&
+        persistence !== null &&
+        "promise" in persistence)
+        return persistence;
+    return { promise: persistence };
+}
+/** Preserve one session's mirror order without serializing unrelated sessions.
+ * A timed-out operation is not cancelled: like an HTTP read timeout, it may
+ * still commit later. Its caller receives `ambiguous` and must not retry. */
 export class SessionMirrorQueue {
     persist;
+    stallTimeoutMs;
     tails = new Map();
-    constructor(persist) {
+    constructor(persist, stallTimeoutMs = SESSION_MIRROR_STALL_TIMEOUT_MS) {
         this.persist = persist;
+        this.stallTimeoutMs = stallTimeoutMs;
     }
     enqueue(sessionId, event) {
         const previous = this.tails.get(sessionId) ?? Promise.resolve();
-        const next = previous
+        const bounded = previous
             .catch(() => undefined)
-            .then(() => this.persist(sessionId, event));
-        this.tails.set(sessionId, next);
+            .then(() => {
+            // Prepare only when this record reaches the head of its Session lane.
+            // Starting either persistence or its deadline while an older record is
+            // still ahead would shorten queued records' attempt windows and allow a
+            // burst of them to time out concurrently.
+            const prepared = preparedMirrorPersistence(this.persist(sessionId, event));
+            let timer;
+            return new Promise((resolve, reject) => {
+                timer = setTimeout(() => {
+                    // A user echo claims one exact optimistic pending input while the
+                    // write starts. Retire it synchronously before rejecting this tail:
+                    // the next echo must never peek the same content or attachments.
+                    prepared.onAmbiguous?.();
+                    reject(new SessionMirrorAmbiguousError(sessionId, prepared.abandonToken));
+                }, this.stallTimeoutMs);
+                timer.unref?.();
+                void prepared.promise.then(resolve, reject);
+            }).finally(() => {
+                if (timer)
+                    clearTimeout(timer);
+            });
+        });
+        // The bounded result, not the potentially immortal persistence promise,
+        // gates the next record. `operation` remains observed by `bounded`, so a
+        // late rejection cannot become an unhandled promise rejection.
+        const tail = bounded.catch(() => undefined);
+        this.tails.set(sessionId, tail);
         const cleanup = () => {
-            if (this.tails.get(sessionId) === next)
+            if (this.tails.get(sessionId) === tail)
                 this.tails.delete(sessionId);
         };
-        void next.then(cleanup, cleanup);
-        return next;
+        void tail.then(cleanup, cleanup);
+        return bounded;
     }
 }
 /**
@@ -68,31 +118,57 @@ export function createSessionRuntimeServices(input) {
     });
     const sessionBus = new InMemorySessionBus();
     const sessionRuntimeIndex = new SessionRuntimeIndex();
-    const sessionMirrorQueue = new SessionMirrorQueue(async (sessionId, event) => {
-        const generatedImageFinalized = await finalizeGeneratedImageEvent(sessionId, event, input);
-        const pendingFinalized = resolvePendingInputEvent(sessionId, generatedImageFinalized, input.pendingInputs);
-        const finalized = pendingFinalized.event;
-        sessionRuntimeIndex.observe(sessionId, finalized);
-        await persistSessionEvent(sessionId, finalized, {
-            sessionLog: input.sessionLog,
-            sessionBus,
-            ...(input.onPendingInputPersisted
+    const sessionMirrorQueue = new SessionMirrorQueue((sessionId, event) => {
+        // Claim the exact pending projection synchronously when this record reaches
+        // the head of its Session lane. Its id remains stable even if persistence
+        // later times out or fails after the result becomes ambiguous.
+        const pendingResolved = resolvePendingInputEvent(sessionId, event, input.pendingInputs);
+        const pendingId = pendingResolved.pendingId;
+        const promise = (async () => {
+            const finalized = await finalizeGeneratedImageEvent(sessionId, pendingResolved.event, input);
+            try {
+                await persistSessionEvent(sessionId, finalized, {
+                    sessionLog: input.sessionLog,
+                    sessionBus,
+                    strictPersistence: true,
+                    ...(pendingId
+                        ? {
+                            onInputPersisted: async (persistedEvent) => {
+                                if (persistedEvent.clearedPendingId !== pendingId)
+                                    return;
+                                input.pendingInputs?.resolve(sessionId, pendingId);
+                                if (!input.onPendingInputPersisted || !pendingResolved.clientMessageId)
+                                    return;
+                                await input.onPendingInputPersisted({
+                                    sessionId,
+                                    pendingId: persistedEvent.clearedPendingId,
+                                    clientMessageId: pendingResolved.clientMessageId,
+                                    responseId: persistedEvent.item.responseId,
+                                    messageItemId: persistedEvent.item.id,
+                                });
+                            },
+                        }
+                        : {}),
+                });
+            }
+            catch (error) {
+                if (pendingId) {
+                    throw new PendingInputMirrorPersistenceError(error, pendingId);
+                }
+                throw error;
+            }
+            sessionRuntimeIndex.observe(sessionId, finalized);
+        })();
+        return {
+            promise,
+            ...(pendingId
                 ? {
-                    onInputPersisted: async (persistedEvent) => {
-                        if (!persistedEvent.clearedPendingId || !pendingFinalized.clientMessageId)
-                            return;
-                        await input.onPendingInputPersisted({
-                            sessionId,
-                            pendingId: persistedEvent.clearedPendingId,
-                            clientMessageId: pendingFinalized.clientMessageId,
-                            responseId: persistedEvent.item.responseId,
-                            messageItemId: persistedEvent.item.id,
-                        });
-                    },
+                    abandonToken: pendingId,
+                    onAmbiguous: () => input.pendingInputs?.resolve(sessionId, pendingId),
                 }
                 : {}),
-        });
-    });
+        };
+    }, input.mirrorStallTimeoutMs);
     const mirrorSessionEvent = (sessionId, event) => {
         return sessionMirrorQueue.enqueue(sessionId, event);
     };
@@ -104,8 +180,15 @@ export function createSessionRuntimeServices(input) {
     runnerManager.onMirror((sessionId, event) => {
         return mirrorSessionEvent(sessionId, event).catch((error) => {
             input.onMirrorError?.(error, sessionId);
+            throw error;
         });
     });
+    runnerManager.onMirrorAbandon((sessionId, pendingId) => {
+        input.pendingInputs?.resolve(sessionId, pendingId);
+    });
+    runnerManager.onMirrorSupersede((sessionId) => {
+        input.pendingInputs?.deleteSession(sessionId);
+    });
     return {
         sessionStore,
         runnerManager,
@@ -115,6 +198,20 @@ export function createSessionRuntimeServices(input) {
         publishSessionEvent: mirrorSessionEvent,
     };
 }
+class PendingInputMirrorPersistenceError extends Error {
+    abandonToken;
+    statusCode;
+    constructor(error, abandonToken) {
+        super(error instanceof Error ? error.message : String(error), { cause: error });
+        this.abandonToken = abandonToken;
+        this.name = "PendingInputMirrorPersistenceError";
+        if (typeof error === "object" &&
+            error !== null &&
+            typeof error.statusCode === "number") {
+            this.statusCode = error.statusCode;
+        }
+    }
+}
 /** Drain the oldest pending web input when the Provider transcript produces a
  * real user record. The transcript is the only durable writer; the returned id
  * lets clients replace the exact temporary bubble. */
@@ -122,10 +219,11 @@ function resolvePendingInputEvent(sessionId, event, pendingInputs) {
     if (event.type !== "session.input.consumed" ||
         event.item.type !== "message" ||
         event.item.data.role !== "user" ||
-        event.item.data.isMeta) {
+        event.item.data.isMeta ||
+        event.item.parentToolCallId !== undefined) {
         return { event };
     }
-    const pending = pendingInputs?.resolveOldest(sessionId);
+    const pending = pendingInputs?.peekOldest(sessionId);
     if (!pending)
         return { event };
     const fileParts = pending.content.filter((part) => part.type === "input_image" || part.type === "input_file");
@@ -138,6 +236,7 @@ function resolvePendingInputEvent(sessionId, event, pendingInputs) {
             ? [...fileParts, ...event.item.data.content]
             : event.item.data.content;
     return {
+        pendingId: pending.pendingId,
         clientMessageId: pending.clientMessageId,
         event: {
             ...event,
@@ -199,6 +298,14 @@ async function finalizeGeneratedImageEvent(sessionId, event, input) {
     }
     catch (error) {
         input.onMirrorError?.(error, sessionId);
+        // The source bytes are part of an ordinary durable delivery.
+        // Only deterministic validation/conflict failures may discard their
+        // preview; infrastructure and explicitly retryable resource failures must
+        // NACK so the child retries the exact image commit.
+        if (!(error instanceof MachineSessionServiceFailure) ||
+            error.retryable) {
+            throw error;
+        }
         return {
             ...event,
             item: {
@@ -421,6 +528,22 @@ export async function startServer({ config = loadConfig(), control, sessionLog,
             sourceSessionId: r.from,
             targetSessionId: r.to,
             kind: r.kind,
+        }).catch((error) => {
+            if (error instanceof MachineSessionServiceInputError) {
+                throw Object.assign(error, { statusCode: 400 });
+            }
+            if (error instanceof MachineSessionServiceFailure) {
+                // A mismatched pre-existing target is a deterministic payload conflict,
+                // not an HTTP-style concurrent 409. Surface it as permanent so the
+                // three-attempt permanent-error budget can stop the rotation lane.
+                const statusCode = error.code === "outcome_unknown"
+                    ? 503
+                    : error.code === "not_found"
+                        ? 404
+                        : 422;
+                throw Object.assign(error, { statusCode });
+            }
+            throw error;
         });
     });
     if (localMachineSessions) {

package/dist/session-pending-inputs.d.ts

@@ -13,6 +13,7 @@ export interface MachineSessionDrainedInput extends MachineSessionPendingInput {
 export interface MachineSessionPendingInputPort {
     record(sessionId: string, input: MachineSessionPendingInputRecord): string;
     resolve(sessionId: string, pendingId: string): void;
+    peekOldest(sessionId: string): MachineSessionDrainedInput | undefined;
     resolveOldest(sessionId: string): MachineSessionDrainedInput | undefined;
     findByClientMessageId(sessionId: string, clientMessageId: string): MachineSessionPendingInput | undefined;
     snapshotFor(sessionId: string): MachineSessionPendingInput[];
@@ -33,6 +34,7 @@ export declare class SessionPendingInputIndex implements MachineSessionPendingIn
     record(sessionId: string, input: MachineSessionPendingInputRecord): string;
     resolve(sessionId: string, pendingId: string): void;
     resolveOldest(sessionId: string): MachineSessionDrainedInput | undefined;
+    peekOldest(sessionId: string): MachineSessionDrainedInput | undefined;
     findByClientMessageId(sessionId: string, clientMessageId: string): MachineSessionPendingInput | undefined;
     snapshotFor(sessionId: string): MachineSessionPendingInput[];
     deleteSession(sessionId: string): void;

package/dist/session-pending-inputs.js

@@ -37,15 +37,18 @@ export class SessionPendingInputIndex {
             this.entries.delete(sessionId);
     }
     resolveOldest(sessionId) {
+        const input = this.peekOldest(sessionId);
+        if (input)
+            this.resolve(sessionId, input.pendingId);
+        return input;
+    }
+    peekOldest(sessionId) {
         this.evictStale(sessionId);
         const pending = this.entries.get(sessionId);
         const pendingId = pending?.keys().next().value;
         if (!pending || !pendingId)
             return undefined;
         const input = pending.get(pendingId);
-        pending.delete(pendingId);
-        if (pending.size === 0)
-            this.entries.delete(sessionId);
         return input ? cloneDrainedInput(input) : undefined;
     }
     findByClientMessageId(sessionId, clientMessageId) {

package/dist/session-runtime-index.d.ts

@@ -23,4 +23,5 @@ export declare class SessionRuntimeIndex {
     private hasRunningTurn;
     private statusAfterResponseTerminal;
     private retireStatusResponses;
+    private markResponseTerminal;
 }

package/dist/session-runtime-index.js

@@ -1,3 +1,4 @@
+const MAX_TERMINAL_RESPONSE_IDS = 2_000;
 /**
  * Process-local index of live Session state. Durable transcript items explain
  * history; this index says which historical requests still have a real runtime
@@ -10,18 +11,22 @@ export class SessionRuntimeIndex {
         const state = this.state(sessionId);
         switch (event.type) {
             case "response.created":
+                if (state.terminalResponseIds.has(event.responseId))
+                    return;
                 state.activeResponseIds.add(event.responseId);
                 state.status = "running";
                 state.statusKind = undefined;
                 state.backgroundTaskCount = undefined;
                 return;
             case "response.completed":
+                this.markResponseTerminal(state, event.responseId);
                 state.activeResponseIds.delete(event.responseId);
                 this.removeResponseInteractions(state, event.responseId);
                 state.status = this.statusAfterResponseTerminal(state);
                 state.statusKind = undefined;
                 return;
             case "response.failed":
+                this.markResponseTerminal(state, event.responseId);
                 state.activeResponseIds.delete(event.responseId);
                 this.removeResponseInteractions(state, event.responseId);
                 // Response failure is Turn-local. It must not poison a reusable Session.
@@ -29,6 +34,7 @@ export class SessionRuntimeIndex {
                 state.statusKind = undefined;
                 return;
             case "session.interrupted":
+                this.markResponseTerminal(state, event.responseId);
                 state.activeResponseIds.delete(event.responseId);
                 this.removeResponseInteractions(state, event.responseId);
                 state.status = this.statusAfterResponseTerminal(state);
@@ -44,6 +50,8 @@ export class SessionRuntimeIndex {
                     state.backgroundTaskCount = undefined;
                 }
                 if (event.status === "running") {
+                    if (event.responseId && state.terminalResponseIds.has(event.responseId))
+                        return;
                     if (event.responseId)
                         state.activeResponseIds.add(event.responseId);
                     state.status = "running";
@@ -58,7 +66,7 @@ export class SessionRuntimeIndex {
                     state.statusKind = undefined;
                     return;
                 }
-                this.retireStatusResponses(state);
+                this.retireStatusResponses(state, event.responseId);
                 if (event.status === "failed") {
                     state.status = "failed";
                 }
@@ -72,6 +80,8 @@ export class SessionRuntimeIndex {
                 return;
             }
             case "session.interaction.requested":
+                if (state.terminalResponseIds.has(event.responseId))
+                    return;
                 state.pendingInteractions.set(event.interaction.interactionId, {
                     responseId: event.responseId,
                     interaction: event.interaction,
@@ -132,6 +142,7 @@ export class SessionRuntimeIndex {
             state = {
                 status: "idle",
                 activeResponseIds: new Set(),
+                terminalResponseIds: new Set(),
                 pendingInteractions: new Map(),
             };
             this.sessions.set(sessionId, state);
@@ -152,13 +163,28 @@ export class SessionRuntimeIndex {
             return "running";
         return state.status === "failed" ? "failed" : "idle";
     }
-    retireStatusResponses(state) {
+    retireStatusResponses(state, responseId) {
         // session.status is Session-wide. Match reference implementation's
         // _session_active_response_cache: every idle/failed edge closes the one
         // in-flight native response projection, even when the edge happens to be
         // stamped with that response id. A late transcript event may still carry
         // the old id for grouping, but it cannot keep activity alive.
+        for (const activeResponseId of state.activeResponseIds) {
+            this.markResponseTerminal(state, activeResponseId);
+        }
+        if (responseId)
+            this.markResponseTerminal(state, responseId);
         state.activeResponseIds.clear();
         state.pendingInteractions.clear();
     }
+    markResponseTerminal(state, responseId) {
+        state.terminalResponseIds.delete(responseId);
+        state.terminalResponseIds.add(responseId);
+        while (state.terminalResponseIds.size > MAX_TERMINAL_RESPONSE_IDS) {
+            const oldest = state.terminalResponseIds.values().next().value;
+            if (oldest === undefined)
+                break;
+            state.terminalResponseIds.delete(oldest);
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/server",
-  "version": "0.1.11-beta.37",
+  "version": "0.1.11-beta.39",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -27,15 +27,15 @@
     "@koa/router": "^15.4.0",
     "koa": "^3.2.0",
     "ws": "^8.21.0",
-    "@rynx-ai/plugin-sdk": "0.1.11-beta.37",
-    "@rynx-ai/core": "0.1.11-beta.37",
-    "@rynx-ai/protocol": "0.1.11-beta.37",
-    "@rynx-ai/remote-runtime-e2ee": "0.1.11-beta.37",
-    "@rynx-ai/runtime": "0.1.11-beta.37"
+    "@rynx-ai/core": "0.1.11-beta.39",
+    "@rynx-ai/plugin-sdk": "0.1.11-beta.39",
+    "@rynx-ai/protocol": "0.1.11-beta.39",
+    "@rynx-ai/remote-runtime-e2ee": "0.1.11-beta.39",
+    "@rynx-ai/runtime": "0.1.11-beta.39"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1",
-    "@rynx-ai/control-web": "0.1.11-beta.37"
+    "@rynx-ai/control-web": "0.1.11-beta.39"
   },
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json && mkdir -p dist/control-web && cp -R ../control-web/dist/. dist/control-web/",

package/dist/control-web/assets/architecture-TIHT7OUA-BA6n-Dzl.js

@@ -1 +0,0 @@
-import"./chunk-KEIR6QF5-BICK3FdT.js";import{M as e}from"./mermaid-parser.core-pxV_1Fef.js";export{e as createArchitectureServices};

package/dist/control-web/assets/channel-CvSP6WIQ.js

@@ -1 +0,0 @@
-import{at as e,ot as t}from"./chunk-WYO6CB5R-Bbp0lWuA.js";var n=(n,r)=>t.lang.round(e.parse(n)[r]);export{n as t};

package/dist/control-web/assets/classDiagram-OUVF2IWQ-CbpSOtxx.js

@@ -1 +0,0 @@
-import{n as e}from"./chunk-Y2CYZVJY-DsF7k-Jl.js";import"./src-B6xuSHsQ.js";import"./chunk-WYO6CB5R-Bbp0lWuA.js";import"./chunk-ICXQ74PX-Jh1cDG2d.js";import"./chunk-HOUHSVGY-Cz-4R9wb.js";import"./chunk-Q4XR5HBZ-puXEgeqv.js";import"./chunk-7BUUIJ7U-Bb538aSH.js";import"./chunk-OGEWGWER-B3ysgOD5.js";import"./chunk-32BRIVSS-BfXRqSpF.js";import"./chunk-XXDRQBXY-DqAYeljN.js";import"./chunk-VR4S4FIN-DW_38atK.js";import"./chunk-C7G6YPKG-D0W6xHti.js";import"./chunk-ZGVPDNZ5-EJHunJJc.js";import"./chunk-52WLFC77-BeKggk68.js";import{i as t,n,r,t as i}from"./chunk-V7JOEXUC-C3tvTxnz.js";import"./markdown-streamdown-OYO-HVz6.js";var a={parser:n,get db(){return new i},renderer:r,styles:t,init:e(e=>{e.class||={},e.class.arrowMarkerAbsolute=e.arrowMarkerAbsolute},`init`)};export{a as diagram};

package/dist/control-web/assets/classDiagram-v2-EOCWNBFH-CbpSOtxx.js

@@ -1 +0,0 @@
-import{n as e}from"./chunk-Y2CYZVJY-DsF7k-Jl.js";import"./src-B6xuSHsQ.js";import"./chunk-WYO6CB5R-Bbp0lWuA.js";import"./chunk-ICXQ74PX-Jh1cDG2d.js";import"./chunk-HOUHSVGY-Cz-4R9wb.js";import"./chunk-Q4XR5HBZ-puXEgeqv.js";import"./chunk-7BUUIJ7U-Bb538aSH.js";import"./chunk-OGEWGWER-B3ysgOD5.js";import"./chunk-32BRIVSS-BfXRqSpF.js";import"./chunk-XXDRQBXY-DqAYeljN.js";import"./chunk-VR4S4FIN-DW_38atK.js";import"./chunk-C7G6YPKG-D0W6xHti.js";import"./chunk-ZGVPDNZ5-EJHunJJc.js";import"./chunk-52WLFC77-BeKggk68.js";import{i as t,n,r,t as i}from"./chunk-V7JOEXUC-C3tvTxnz.js";import"./markdown-streamdown-OYO-HVz6.js";var a={parser:n,get db(){return new i},renderer:r,styles:t,init:e(e=>{e.class||={},e.class.arrowMarkerAbsolute=e.arrowMarkerAbsolute},`init`)};export{a as diagram};

package/dist/control-web/assets/eventmodeling-45OFAUF4-B4JspsqG.js

@@ -1 +0,0 @@
-import"./chunk-KEIR6QF5-BICK3FdT.js";import{O as e}from"./mermaid-parser.core-pxV_1Fef.js";export{e as createEventModelingServices};

package/dist/control-web/assets/flowDiagram-23GEKE2U-Ium-zrch.js

@@ -1 +0,0 @@
-import"./src-B6xuSHsQ.js";import"./chunk-WYO6CB5R-Bbp0lWuA.js";import"./chunk-ICXQ74PX-Jh1cDG2d.js";import"./chunk-HOUHSVGY-Cz-4R9wb.js";import"./chunk-Q4XR5HBZ-puXEgeqv.js";import"./chunk-7BUUIJ7U-Bb538aSH.js";import"./chunk-OGEWGWER-B3ysgOD5.js";import"./chunk-32BRIVSS-BfXRqSpF.js";import"./chunk-XXDRQBXY-DqAYeljN.js";import"./chunk-VR4S4FIN-DW_38atK.js";import"./chunk-C7G6YPKG-D0W6xHti.js";import"./chunk-ZGVPDNZ5-EJHunJJc.js";import"./chunk-52WLFC77-BeKggk68.js";import{n as e}from"./chunk-PUDLZKDR-CcXYtnKN.js";import"./markdown-streamdown-OYO-HVz6.js";export{e as diagram};

package/dist/control-web/assets/katex-BSYj5LXs.js

@@ -1 +0,0 @@
-import{_ as e}from"./markdown-streamdown-OYO-HVz6.js";export{e as default};

package/dist/control-web/assets/mermaid-GHXKKRXX-BybKptJt.js

@@ -1 +0,0 @@
-import{i as e}from"./markdown-streamdown-OYO-HVz6.js";export{e as Mermaid};

package/dist/control-web/assets/railroad-abnf-AHOZXSZD-C6gyeMKO.js

@@ -1 +0,0 @@
-import"./chunk-KEIR6QF5-BICK3FdT.js";import{m as e}from"./mermaid-parser.core-pxV_1Fef.js";export{e as createRailroadAbnfServices};

package/dist/control-web/assets/railroad-ebnf-EBAXGLYW-CTnsShXg.js

@@ -1 +0,0 @@
-import"./chunk-KEIR6QF5-BICK3FdT.js";import{f as e}from"./mermaid-parser.core-pxV_1Fef.js";export{e as createRailroadEbnfServices};

package/dist/control-web/assets/railroad-peg-LSFZ7HO6-NgilCakK.js

@@ -1 +0,0 @@
-import"./chunk-KEIR6QF5-BICK3FdT.js";import{u as e}from"./mermaid-parser.core-pxV_1Fef.js";export{e as createRailroadPegServices};

package/dist/control-web/assets/stateDiagram-v2-6OUMAXLB-CsJT1Rvc.js

@@ -1 +0,0 @@
-import{n as e}from"./chunk-Y2CYZVJY-DsF7k-Jl.js";import"./src-B6xuSHsQ.js";import"./chunk-WYO6CB5R-Bbp0lWuA.js";import"./chunk-ICXQ74PX-Jh1cDG2d.js";import"./chunk-HOUHSVGY-Cz-4R9wb.js";import"./chunk-Q4XR5HBZ-puXEgeqv.js";import"./chunk-7BUUIJ7U-Bb538aSH.js";import"./chunk-OGEWGWER-B3ysgOD5.js";import"./chunk-32BRIVSS-BfXRqSpF.js";import"./chunk-XXDRQBXY-DqAYeljN.js";import"./chunk-VR4S4FIN-DW_38atK.js";import"./chunk-C7G6YPKG-D0W6xHti.js";import"./chunk-ZGVPDNZ5-EJHunJJc.js";import"./chunk-52WLFC77-BeKggk68.js";import{i as t,n,r,t as i}from"./chunk-EX3LRPZG-D-s3PHl_.js";import"./markdown-streamdown-OYO-HVz6.js";var a={parser:n,get db(){return new i(2)},renderer:r,styles:t,init:e(e=>{e.state||={},e.state.arrowMarkerAbsolute=e.arrowMarkerAbsolute},`init`)};export{a as diagram};

package/dist/control-web/assets/swimlanesDiagram-G3AALYLV-CzaTMmXS.js

@@ -1,8 +0,0 @@
-import{n as e}from"./chunk-Y2CYZVJY-DsF7k-Jl.js";import"./src-B6xuSHsQ.js";import"./chunk-WYO6CB5R-Bbp0lWuA.js";import"./chunk-ICXQ74PX-Jh1cDG2d.js";import"./chunk-HOUHSVGY-Cz-4R9wb.js";import"./chunk-Q4XR5HBZ-puXEgeqv.js";import"./chunk-7BUUIJ7U-Bb538aSH.js";import"./chunk-OGEWGWER-B3ysgOD5.js";import"./chunk-32BRIVSS-BfXRqSpF.js";import"./chunk-XXDRQBXY-DqAYeljN.js";import"./chunk-VR4S4FIN-DW_38atK.js";import"./chunk-C7G6YPKG-D0W6xHti.js";import"./chunk-ZGVPDNZ5-EJHunJJc.js";import"./chunk-52WLFC77-BeKggk68.js";import{r as t,t as n}from"./chunk-PUDLZKDR-CcXYtnKN.js";import"./markdown-streamdown-OYO-HVz6.js";var r=n({defaultLayout:`swimlane`,styles:e(e=>`${t(e)}
-  .swimlane.cluster rect {
-    stroke: ${e.clusterBorder} !important;
-  }
-  [data-look="neo"].cluster rect {
-    filter: none;
-  }
-`,`getStyles`)});export{r as diagram};