@tea-agent/loop-agent 0.1.0-fe-test.0

package/dist/worker/console/security.js

@@ -0,0 +1,170 @@
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { isLoopbackHost } from "./loopback.js";
+export const BOOT_CAPABILITY_COOKIE = "loop_console_capability";
+/** Custom mutation confirmation header (design §9). JS-readable; not the HttpOnly boot cookie. */
+export const CONFIRMATION_TOKEN_HEADER = "x-loop-console-confirmation";
+/** Issue per-process unguessable boot capability + confirmation tokens. */
+export function issueBootCapabilityToken() {
+    const value = randomBytes(32).toString("base64url");
+    const confirmationToken = randomBytes(32).toString("base64url");
+    const setCookieHeader = [
+        `${BOOT_CAPABILITY_COOKIE}=${value}`,
+        "HttpOnly",
+        "SameSite=Strict",
+        "Path=/",
+    ].join("; ");
+    return { value, setCookieHeader, confirmationToken };
+}
+/** Inject confirmation token into HTML so the SPA can send the mutation header. */
+export function injectConfirmationTokenScript(html, confirmationToken) {
+    const source = typeof html === "string" ? html : html.toString("utf8");
+    const script = `<script>window.__CONSOLE_CONFIRMATION_TOKEN__=${JSON.stringify(confirmationToken)};</script>`;
+    if (source.includes("</head>")) {
+        return Buffer.from(source.replace("</head>", `${script}</head>`), "utf8");
+    }
+    if (source.includes("</body>")) {
+        return Buffer.from(source.replace("</body>", `${script}</body>`), "utf8");
+    }
+    return Buffer.from(`${source}\n${script}`, "utf8");
+}
+export function parseCookieHeader(header, name) {
+    if (!header)
+        return undefined;
+    for (const part of header.split(";")) {
+        const trimmed = part.trim();
+        const eq = trimmed.indexOf("=");
+        if (eq <= 0)
+            continue;
+        const key = trimmed.slice(0, eq).trim();
+        if (key === name) {
+            return trimmed.slice(eq + 1).trim();
+        }
+    }
+    return undefined;
+}
+function safeEqualToken(a, b) {
+    const left = Buffer.from(a);
+    const right = Buffer.from(b);
+    if (left.length !== right.length)
+        return false;
+    return timingSafeEqual(left, right);
+}
+/**
+ * Minimum mutation challenge (design §9):
+ * cookie boot token AND custom confirmation header/token + Host/Origin checks +
+ * Sec-Fetch-Site not cross-site.
+ */
+/**
+ * Loopback origin equivalence: a Console bound to a loopback host accepts
+ * page Origins that resolve to the same loopback server — localhost,
+ * 127.0.0.1 and [::1] on the SAME port are interchangeable aliases (browsers
+ * treat them as distinct sites, so a third-party page can never spoof one).
+ * This keeps bookmarks / autocomplete on `localhost:port` working against a
+ * Console bound to `127.0.0.1:port` (and vice versa).
+ */
+function loopbackOriginMatches(origin, consoleOrigin) {
+    if (origin === consoleOrigin)
+        return true;
+    const parseLoopback = (value) => {
+        const match = /^http:\/\/(localhost|127\.0\.0\.1|\[::1\])(:\d+)?$/i.exec(value);
+        return match ? `${match[1].toLowerCase()}${match[2] ?? ""}` : null;
+    };
+    const originKey = parseLoopback(origin);
+    const consoleKey = parseLoopback(consoleOrigin);
+    return originKey !== null && consoleKey !== null && originKey === consoleKey;
+}
+export function evaluateMutationGate(req, ctx) {
+    const cookieToken = parseCookieHeader(req.headers.cookie, BOOT_CAPABILITY_COOKIE);
+    if (!cookieToken) {
+        return {
+            status: 403,
+            code: "missing-capability-token",
+            message: "mutation requires boot capability cookie",
+        };
+    }
+    if (!safeEqualToken(cookieToken, ctx.bootToken)) {
+        return {
+            status: 403,
+            code: "invalid-capability-token",
+            message: "invalid boot capability token",
+        };
+    }
+    const headerRaw = req.headers[CONFIRMATION_TOKEN_HEADER];
+    const confirmationHeader = typeof headerRaw === "string"
+        ? headerRaw.trim()
+        : Array.isArray(headerRaw)
+            ? (headerRaw[0] ?? "").trim()
+            : "";
+    if (!confirmationHeader) {
+        return {
+            status: 403,
+            code: "missing-confirmation-token",
+            message: "mutation requires confirmation header token",
+        };
+    }
+    if (!safeEqualToken(confirmationHeader, ctx.confirmationToken)) {
+        return {
+            status: 403,
+            code: "invalid-confirmation-token",
+            message: "invalid confirmation header token",
+        };
+    }
+    const hostHeader = req.headers.host ?? "";
+    const hostOnly = hostHeader.split(":")[0] ?? "";
+    if (ctx.allowNonLoopbackAccess) {
+        if (!hostHeader.trim()) {
+            return {
+                status: 403,
+                code: "host-not-loopback",
+                message: "Host header is required for non-loopback Console binds",
+            };
+        }
+    }
+    else if (!isLoopbackHost(hostOnly)) {
+        return {
+            status: 403,
+            code: "host-not-loopback",
+            message: `Host is not loopback: ${hostHeader}`,
+        };
+    }
+    const origin = req.headers.origin;
+    if (ctx.allowNonLoopbackAccess) {
+        const expectedFromHost = hostHeader.trim()
+            ? `http://${hostHeader.trim()}`
+            : "";
+        const originOk = typeof origin === "string" &&
+            origin.length > 0 &&
+            (origin === ctx.consoleOrigin ||
+                (Boolean(expectedFromHost) && origin === expectedFromHost));
+        if (!originOk) {
+            return {
+                status: 403,
+                code: "origin-mismatch",
+                message: "Origin does not match Console access URL",
+            };
+        }
+    }
+    else if (typeof origin !== "string" ||
+        origin.length === 0 ||
+        !loopbackOriginMatches(origin, ctx.consoleOrigin)) {
+        return {
+            status: 403,
+            code: "origin-mismatch",
+            message: "Origin does not match Console origin",
+        };
+    }
+    const secFetchSite = req.headers["sec-fetch-site"];
+    if (typeof secFetchSite === "string" &&
+        secFetchSite.toLowerCase() === "cross-site") {
+        return {
+            status: 403,
+            code: "cross-site-fetch",
+            message: "Sec-Fetch-Site cross-site is not allowed for mutations",
+        };
+    }
+    return undefined;
+}
+export function isMutationMethod(method) {
+    const m = (method ?? "GET").toUpperCase();
+    return m === "POST" || m === "PUT" || m === "PATCH" || m === "DELETE";
+}

package/dist/worker/console/server.js

@@ -0,0 +1,357 @@
+import { randomBytes } from "node:crypto";
+import { existsSync } from "node:fs";
+import { createServer } from "node:http";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { LoopAgentClient } from "../loop-agent/loop-agent-client.js";
+import { DAG_ABSOLUTE_MAX_WALL_CLOCK_MS } from "../../shared/timeout-policy.js";
+import { openConsoleAppData } from "./app-data.js";
+import { DagConfirmationStore } from "./dag-confirmation.js";
+import { DagExecutionReceiptStore } from "./dag-execution-receipt.js";
+import { DraftStore } from "./draft-store.js";
+import { AssessmentStore } from "./interview/assessment.js";
+import { InterviewSessionStore } from "./interview/session.js";
+import { isLoopbackHost } from "./loopback.js";
+import { ChatSessionStore } from "./chat/session-store.js";
+import { createChatEventStore, createChatOperationLinker, } from "./chat/chat-event-store.js";
+import { createChatTurnExecutionRegistry } from "./chat/turn-execution-registry.js";
+import { ConsolePiRuntime } from "./chat/pi-runtime.js";
+import { handleChatRequest } from "./chat/routes.js";
+import { createOperationEventStore, } from "./operation-sse.js";
+import { OperationStore } from "./operation-store.js";
+import { probePiReadiness, } from "./pi-readiness.js";
+import { handleConsoleHealthRequest, handleConsoleOperatorRequest, sendJson, serveConsoleStatic, } from "./routes.js";
+import { issueBootCapabilityToken } from "./security.js";
+import { resolveSiblingLoopAgentBin } from "./sibling-controller.js";
+import { NightAuxTicker } from "./night-aux-ticker.js";
+import { deriveObserveRouteCapabilities } from "../observe/health.js";
+import { createObserveRouteContext, defaultObserveStaticDir, handleMatchedObserveRoute, matchObserveGetRoute, ROUTES, serveObserveStatic, } from "../observe/routes.js";
+/**
+ * Default hard timeout for the Console-owned LoopAgentClient.
+ *
+ * Console task-nav operations (`dag execute`, `task advance --approve-gate`,
+ * etc.) spawn a long-lived sibling runner via the operation runner. The
+ * worker client hard-kills children after `defaultTimeoutMs` (default 120s),
+ * which is far below multi-node DAG wall clocks and leaves `state.json`
+ * stuck in `running` with no error. Align with shared `DAG_ABSOLUTE_MAX_WALL_CLOCK_MS`
+ * (4h) so the client is a safety net, not a false deadline.
+ */
+export const DEFAULT_CONSOLE_CLIENT_TIMEOUT_MS = DAG_ABSOLUTE_MAX_WALL_CLOCK_MS;
+/**
+ * Resolve the Console LoopAgentClient default timeout.
+ * `0` disables the client hard timeout (DAG kernel owns wall clock).
+ */
+export function resolveConsoleDefaultTimeoutMs(override) {
+    if (override === undefined) {
+        return DEFAULT_CONSOLE_CLIENT_TIMEOUT_MS;
+    }
+    if (!Number.isFinite(override) || override < 0) {
+        throw new Error(`console serve: invalid defaultTimeoutMs ${String(override)} (expected >= 0)`);
+    }
+    return override;
+}
+/** Built static assets live next to the compiled server under dist/worker/console/static. */
+export function defaultConsoleStaticDir(fromFileUrl = import.meta.url) {
+    return path.join(path.dirname(fileURLToPath(fromFileUrl)), "static");
+}
+/**
+ * Create Loop Operator Console HTTP server.
+ * Default bind is loopback; non-loopback hosts warn and stay allowed for LAN,
+ * matching Observe serve (mutations still require cookie + confirmation + Origin).
+ */
+export async function createConsoleServer(options) {
+    const host = options.host ?? "127.0.0.1";
+    const loopbackBind = isLoopbackHost(host);
+    if (!loopbackBind) {
+        process.stderr.write(`console: binding non-loopback host ${host} (Operator mutations enabled; no network auth — expose only on trusted networks)\n`);
+    }
+    const repoRoot = path.resolve(options.repoRoot);
+    const port = options.port ?? 8790;
+    const debug = options.debug === true;
+    const keepAliveTimeoutMs = options.keepAliveTimeoutMs ?? 65_000;
+    const staticDir = options.staticDir ?? defaultConsoleStaticDir();
+    const inspectStaticDir = options.inspectStaticDir ?? defaultObserveStaticDir();
+    const observeRouteContext = createObserveRouteContext(repoRoot, {
+        staticDir: inspectStaticDir,
+    });
+    const bootToken = issueBootCapabilityToken();
+    const operatorSessionId = `sess_${randomBytes(16).toString("hex")}`;
+    const appData = openConsoleAppData({
+        repoRoot,
+        appDataRoot: options.appDataRoot,
+    });
+    const operations = new OperationStore(appData);
+    const events = createOperationEventStore({
+        persistenceDir: path.join(appData.operations, "events"),
+    });
+    const drafts = new DraftStore(appData);
+    const confirmations = new DagConfirmationStore(appData, bootToken.confirmationToken);
+    const dagExecutionReceipts = new DagExecutionReceiptStore(appData);
+    const interviews = new InterviewSessionStore(appData);
+    const assessments = new AssessmentStore(appData);
+    const readiness = await probePiReadiness({
+        override: options.piReadinessProbe,
+        repoRoot,
+    });
+    let readinessCache = readiness;
+    const artifactRoot = path.join(appData.root, "client-artifacts", appData.fingerprint);
+    const client = options.createClient?.(artifactRoot) ??
+        new LoopAgentClient({
+            loopAgentBin: resolveSiblingLoopAgentBin(),
+            artifactRoot,
+            resolveIdentity: true,
+            // See DEFAULT_CONSOLE_CLIENT_TIMEOUT_MS: dag execute / task advance
+            // must not inherit the 120s worker-command default.
+            defaultTimeoutMs: resolveConsoleDefaultTimeoutMs(options.defaultTimeoutMs),
+        });
+    if (!options.skipReconcile) {
+        await operations.reconcileOnBoot();
+    }
+    const getReadiness = () => readinessCache;
+    const refreshReadiness = async () => {
+        readinessCache = await probePiReadiness({
+            override: options.piReadinessProbe,
+            repoRoot,
+        });
+        actionContext.readiness = readinessCache;
+        return readinessCache;
+    };
+    const actionContext = {
+        repoRoot,
+        appData,
+        operatorSessionId,
+        client,
+        operations,
+        events,
+        drafts,
+        confirmations,
+        dagExecutionReceipts,
+        humanGateSecret: bootToken.confirmationToken,
+        interviews,
+        assessments,
+        readiness: readinessCache,
+        getReadiness,
+        refreshReadiness,
+        observeBaseUrl: options.observeBaseUrl,
+        fetchImpl: options.fetchImpl,
+        getConsoleOrigin: () => `http://${boundHost}:${boundPort}`,
+    };
+    let boundHost = host;
+    let boundPort = port;
+    const getConsoleOrigin = () => `http://${boundHost}:${boundPort}`;
+    // Phase 4: General Operator Chat runtime. The actionContext is forwarded so
+    // custom-tool execute() calls dispatch into the operator action layer (Gate 3).
+    // Chat session dir is dedicated (app-data/chat-sessions), NOT user default.
+    const chatStore = new ChatSessionStore(appData);
+    // M5.1: every Console boot owns a fresh event-log generation. A browser
+    // reconnecting with an old SSE cursor must reconcile from snapshot rather
+    // than silently consume a different process' event namespace.
+    const chatEventEpoch = randomBytes(12).toString("hex");
+    const chatEvents = createChatEventStore({ appData, epoch: chatEventEpoch });
+    const chatTurnExecutions = createChatTurnExecutionRegistry();
+    const chatOperationLinker = createChatOperationLinker({
+        chatEvents,
+        operations,
+        operationEvents: events,
+    });
+    const chatRuntime = new ConsolePiRuntime({
+        cwd: repoRoot,
+        sessionDir: appData.chatSessions,
+        resourcePreferencesPath: appData.resourcePreferences,
+        actionContext,
+    });
+    // chatRouteDeps is a plain object literal — it cannot throw. The previous
+    // try/catch was dead code that created a false "handled failure" impression.
+    // If a future field can throw, scope it explicitly instead of wrapping the
+    // literal.
+    const chatRouteDeps = {
+        runtime: chatRuntime,
+        store: chatStore,
+        events: chatEvents,
+        turnExecutions: chatTurnExecutions,
+        operationLinker: chatOperationLinker,
+        appData,
+        bootToken,
+        getConsoleOrigin,
+        allowNonLoopbackAccess: !loopbackBind,
+    };
+    const nightAuxTicker = new NightAuxTicker({
+        repoRoot,
+        client,
+    });
+    const routeContext = {
+        repoRoot,
+        staticDir,
+        bootToken,
+        getConsoleOrigin,
+        allowNonLoopbackAccess: !loopbackBind,
+        inspect: {
+            ready: existsSync(path.join(inspectStaticDir, "index.html")),
+            routeCapabilities: deriveObserveRouteCapabilities(ROUTES),
+        },
+        operator: {
+            actionContext,
+            operations,
+            events,
+            getReadiness,
+            chat: chatRouteDeps,
+            nightAuxTicker,
+        },
+    };
+    return new Promise((resolve, reject) => {
+        const server = createServer((req, res) => {
+            const startedAt = Date.now();
+            if (debug) {
+                let logged = false;
+                const onceLog = (note) => {
+                    if (logged)
+                        return;
+                    logged = true;
+                    logConsoleRequest(req, res, startedAt, note);
+                };
+                res.on("finish", () => onceLog());
+                res.on("close", () => {
+                    if (!res.writableFinished)
+                        onceLog("aborted");
+                });
+            }
+            void dispatch(req, res).catch((error) => {
+                if (!res.headersSent) {
+                    const payload = JSON.stringify({
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                    res.writeHead(500, {
+                        "Content-Type": "application/json",
+                        "Content-Length": Buffer.byteLength(payload),
+                    });
+                    res.end(payload);
+                }
+            });
+        });
+        server.keepAliveTimeout = keepAliveTimeoutMs;
+        server.headersTimeout = keepAliveTimeoutMs + 5_000;
+        server.requestTimeout = 0;
+        server.on("connection", (socket) => {
+            socket.on("error", () => {
+                // Ignore client resets while retaining one listener per connection.
+            });
+        });
+        server.on("clientError", (err, socket) => {
+            if (debug) {
+                process.stderr.write(`[console] ${new Date().toISOString()} clientError ${err.message}\n`);
+            }
+            if (!socket.destroyed) {
+                socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
+            }
+        });
+        async function dispatch(req, res) {
+            // Refresh readiness pointer on each request surface
+            actionContext.readiness = getReadiness();
+            const method = (req.method ?? "GET").toUpperCase();
+            const pathname = decodeURIComponent(new URL(req.url ?? "/", "http://localhost").pathname);
+            if (method === "GET" && pathname === "/api/health") {
+                await handleConsoleHealthRequest(req, res, routeContext);
+                return;
+            }
+            if (pathname.startsWith("/api/operator/v1/") ||
+                pathname.startsWith("/api/session/")) {
+                // Phase 4: General Operator Chat routes (mounted under chat/).
+                if (pathname.startsWith("/api/operator/v1/chat/") ||
+                    pathname.startsWith("/api/operator/v1/pi/")) {
+                    await handleChatRequest(req, res, chatRouteDeps, pathname);
+                    return;
+                }
+                await handleConsoleOperatorRequest(req, res, routeContext);
+                return;
+            }
+            if (method === "GET" && pathname.startsWith("/api/")) {
+                const match = matchObserveGetRoute(pathname);
+                if (match) {
+                    await handleMatchedObserveRoute(req, res, match, observeRouteContext);
+                    return;
+                }
+            }
+            if (pathname.startsWith("/inspect")) {
+                await serveObserveStatic(req, res, inspectStaticDir, {
+                    urlPrefix: "/inspect",
+                });
+                return;
+            }
+            if (pathname.startsWith("/api/")) {
+                sendJson(res, 404, { error: "Not found" });
+                return;
+            }
+            await serveConsoleStatic(req, res, routeContext);
+        }
+        server.on("error", reject);
+        server.listen(port, host, () => {
+            const addr = server.address();
+            if (!addr || typeof addr === "string") {
+                reject(new Error("Failed to get console server address"));
+                return;
+            }
+            boundHost = host;
+            boundPort = addr.port;
+            const url = `http://${host}:${addr.port}`;
+            if (debug) {
+                process.stderr.write(`[console] debug logging enabled; keepAliveTimeout=${keepAliveTimeoutMs}ms\n`);
+            }
+            process.stderr.write(`[console] Loop Operator Console listening on ${url}${loopbackBind
+                ? " (loopback)"
+                : " (non-loopback; trusted networks only)"}\n`);
+            resolve({
+                url,
+                host,
+                port: addr.port,
+                appData,
+                operations,
+                events,
+                getReadiness,
+                operatorSessionId,
+                close: () => new Promise((closeResolve, closeReject) => {
+                    // Dispose all Chat Pi sessions BEFORE closing the HTTP server so
+                    // no prompt is left executing and no session/SDK state/file handle
+                    // leaks across Console restarts (regression: close() previously
+                    // only closed the socket, leaving ConsolePiRuntime sessions live).
+                    try {
+                        chatOperationLinker.dispose();
+                        chatRuntime.disposeAll();
+                        nightAuxTicker.dispose();
+                    }
+                    catch (error) {
+                        // Best-effort: surface but do not block the HTTP close.
+                        process.stderr.write(`[console] chatRuntime.disposeAll() failed during close: ${error instanceof Error ? error.message : String(error)}\n`);
+                    }
+                    server.close((err) => (err ? closeReject(err) : closeResolve()));
+                }),
+            });
+        });
+    });
+}
+function requestSource(req) {
+    const forwarded = req.headers["x-forwarded-for"];
+    if (typeof forwarded === "string" && forwarded.trim()) {
+        return forwarded.split(",")[0]?.trim() || forwarded.trim();
+    }
+    if (Array.isArray(forwarded) && forwarded[0]) {
+        return forwarded[0].split(",")[0]?.trim() || forwarded[0];
+    }
+    const realIp = req.headers["x-real-ip"];
+    if (typeof realIp === "string" && realIp.trim()) {
+        return realIp.trim();
+    }
+    return req.socket.remoteAddress ?? "-";
+}
+function logConsoleRequest(req, res, startedAt, note) {
+    const ms = Date.now() - startedAt;
+    const ua = String(req.headers["user-agent"] ?? "-").slice(0, 120);
+    const suffix = note ? ` ${note}` : "";
+    process.stderr.write(`[console] ${new Date().toISOString()} ${req.method ?? "?"} ${req.url ?? "/"} ${res.statusCode} ${ms}ms from=${requestSource(req)} ua=${JSON.stringify(ua)}${suffix}\n`);
+}
+/** Test helper: replace readiness report in-process. */
+export function setConsoleReadinessForTests(server, report) {
+    if (!server.getReadiness)
+        return;
+    // Mutate via closure replacement is not available; tests should inject probe at create.
+    void report;
+}

package/dist/worker/console/sibling-controller.js

@@ -0,0 +1,33 @@
+import { existsSync, realpathSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { findPackageRoot } from "../../shared/package-metadata.js";
+/** Resolve an absolute sibling package bin; never fall back to PATH. */
+function resolveSiblingBin(name, fromFileUrl) {
+    const startDir = path.dirname(fileURLToPath(fromFileUrl));
+    const packageRoot = findPackageRoot(startDir);
+    if (!packageRoot) {
+        throw new Error(`console sibling controller: cannot locate package root from console module`);
+    }
+    const candidate = path.join(packageRoot, "bin", name);
+    if (!existsSync(candidate)) {
+        throw new Error(`console sibling controller: missing sibling bin at ${candidate}`);
+    }
+    return realpathSync(candidate);
+}
+/** Resolve the absolute sibling `bin/loop-agent.js` for this package install. */
+export function resolveSiblingLoopAgentBin(fromFileUrl = import.meta.url) {
+    return resolveSiblingBin("loop-agent.js", fromFileUrl);
+}
+/** Resolve the absolute sibling `bin/agent-worker.js` for this package install. */
+export function resolveSiblingAgentWorkerBin(fromFileUrl = import.meta.url) {
+    return resolveSiblingBin("agent-worker.js", fromFileUrl);
+}
+export function resolvePackageRootFromConsole(fromFileUrl = import.meta.url) {
+    const startDir = path.dirname(fileURLToPath(fromFileUrl));
+    const packageRoot = findPackageRoot(startDir);
+    if (!packageRoot) {
+        throw new Error("console: cannot locate package root");
+    }
+    return packageRoot;
+}

package/dist/worker/console/static/assets/abnfDiagram-N423BO3Z-BmOEx0gA.js

@@ -0,0 +1 @@
+import{g as p,r as u,d as a}from"./chunk-6Q2QTUOP-D_A5_5QL.js";import{p as f}from"./chunk-JWPE2WC7-UYGvEP4l.js";import{_ as n,l as o}from"./mermaid.core-BjuFPRqa.js";import{M as c,b as d}from"./cynefin-VYW2F7L2--PcyL34A.js";import"./index-DkCrqaYg.js";var v=d().RailroadAbnf.parser.LangiumParser,i=n(e=>{const r=e.alternatives.map(g);return r.length===1?r[0]:{type:"choice",alternatives:r}},"transformAlternation"),g=n(e=>{const r=e.elements.map(y);return r.length===1?r[0]:{type:"sequence",elements:r}},"transformConcatenation"),b=n(e=>{if(e.includes("*")){const[t,s]=e.split("*"),l=t?parseInt(t,10):0,m=s?parseInt(s,10):1/0;return{min:l,max:m}}const r=parseInt(e,10);return{min:r,max:r}},"parseRepeat"),y=n(e=>{const r=A(e.primary);if(!e.repeat)return r;const{min:t,max:s}=b(e.repeat);return t===0&&s===1?{type:"optional",element:r}:{type:"repetition",element:r,min:t,max:s}},"transformElement"),A=n(e=>{switch(e.$type){case"AbnfStringLiteral":return{type:"terminal",value:e.value};case"AbnfNumVal":return{type:"terminal",value:e.value};case"AbnfRuleName":return{type:"nonterminal",name:e.name};case"AbnfGroup":return i(e.element);case"AbnfOptionalGroup":return{type:"optional",element:i(e.element)};default:throw new Error(`Unsupported ABNF primary node: ${e.$type}`)}},"transformPrimary"),P=n(e=>({name:e.name,definition:i(e.definition)}),"transformRule"),h=n(e=>{f(e,a),e.title&&a.setTitle(e.title),e.rules.map(r=>a.addRule(P(r)))},"populateDb"),R={parse:n(e=>{a.clear(),o.debug("[ABNF Parser] Starting Langium parse");const r=v.parse(e);if(r.lexerErrors.length>0||r.parserErrors.length>0)throw new c(r);const t=r.value;o.debug("[ABNF Parser] Parsed rules:",t.rules.length),h(t),o.debug("[ABNF Parser] Parse complete")},"parse"),parser:{yy:a}},B={parser:R,db:a,renderer:u,styles:p};export{B as diagram};

package/dist/worker/console/static/assets/arc-BGiVVe8b.js

@@ -0,0 +1 @@
+import{Y as ln,$ as an,a0 as F,a1 as q,a2 as j,a3 as un,a4 as y,a5 as tn,a6 as J,a7 as _,a8 as rn,a9 as o,aa as on,ab as sn,ac as fn}from"./mermaid.core-BjuFPRqa.js";function cn(l){return l.innerRadius}function yn(l){return l.outerRadius}function gn(l){return l.startAngle}function dn(l){return l.endAngle}function mn(l){return l&&l.padAngle}function pn(l,h,I,D,v,A,z,a){var O=I-l,i=D-h,n=z-v,d=a-A,u=d*O-n*i;if(!(u*u<y))return u=(n*(h-A)-d*(l-v))/u,[l+u*O,h+u*i]}function U(l,h,I,D,v,A,z){var a=l-I,O=h-D,i=(z?A:-A)/J(a*a+O*O),n=i*O,d=-i*a,u=l+n,s=h+d,f=I+n,c=D+d,B=(u+f)/2,t=(s+c)/2,m=f-u,g=c-s,R=m*m+g*g,T=v-A,P=u*c-f*s,S=(g<0?-1:1)*J(on(0,T*T*R-P*P)),Y=(P*g-m*S)/R,$=(-P*m-g*S)/R,w=(P*g+m*S)/R,p=(-P*m+g*S)/R,x=Y-B,e=$-t,r=w-B,C=p-t;return x*x+e*e>r*r+C*C&&(Y=w,$=p),{cx:Y,cy:$,x01:-n,y01:-d,x11:Y*(v/T-1),y11:$*(v/T-1)}}function hn(){var l=cn,h=yn,I=j(0),D=null,v=gn,A=dn,z=mn,a=null,O=ln(i);function i(){var n,d,u=+l.apply(this,arguments),s=+h.apply(this,arguments),f=v.apply(this,arguments)-un,c=A.apply(this,arguments)-un,B=rn(c-f),t=c>f;if(a||(a=n=O()),s<u&&(d=s,s=u,u=d),!(s>y))a.moveTo(0,0);else if(B>tn-y)a.moveTo(s*F(f),s*q(f)),a.arc(0,0,s,f,c,!t),u>y&&(a.moveTo(u*F(c),u*q(c)),a.arc(0,0,u,c,f,t));else{var m=f,g=c,R=f,T=c,P=B,S=B,Y=z.apply(this,arguments)/2,$=Y>y&&(D?+D.apply(this,arguments):J(u*u+s*s)),w=_(rn(s-u)/2,+I.apply(this,arguments)),p=w,x=w,e,r;if($>y){var C=sn($/u*q(Y)),K=sn($/s*q(Y));(P-=C*2)>y?(C*=t?1:-1,R+=C,T-=C):(P=0,R=T=(f+c)/2),(S-=K*2)>y?(K*=t?1:-1,m+=K,g-=K):(S=0,m=g=(f+c)/2)}var G=s*F(m),H=s*q(m),L=u*F(T),M=u*q(T);if(w>y){var N=s*F(g),Q=s*q(g),V=u*F(R),W=u*q(R),E;if(B<an)if(E=pn(G,H,V,W,N,Q,L,M)){var X=G-E[0],Z=H-E[1],b=N-E[0],k=Q-E[1],nn=1/q(fn((X*b+Z*k)/(J(X*X+Z*Z)*J(b*b+k*k)))/2),en=J(E[0]*E[0]+E[1]*E[1]);p=_(w,(u-en)/(nn-1)),x=_(w,(s-en)/(nn+1))}else p=x=0}S>y?x>y?(e=U(V,W,G,H,s,x,t),r=U(N,Q,L,M,s,x,t),a.moveTo(e.cx+e.x01,e.cy+e.y01),x<w?a.arc(e.cx,e.cy,x,o(e.y01,e.x01),o(r.y01,r.x01),!t):(a.arc(e.cx,e.cy,x,o(e.y01,e.x01),o(e.y11,e.x11),!t),a.arc(0,0,s,o(e.cy+e.y11,e.cx+e.x11),o(r.cy+r.y11,r.cx+r.x11),!t),a.arc(r.cx,r.cy,x,o(r.y11,r.x11),o(r.y01,r.x01),!t))):(a.moveTo(G,H),a.arc(0,0,s,m,g,!t)):a.moveTo(G,H),!(u>y)||!(P>y)?a.lineTo(L,M):p>y?(e=U(L,M,N,Q,u,-p,t),r=U(G,H,V,W,u,-p,t),a.lineTo(e.cx+e.x01,e.cy+e.y01),p<w?a.arc(e.cx,e.cy,p,o(e.y01,e.x01),o(r.y01,r.x01),!t):(a.arc(e.cx,e.cy,p,o(e.y01,e.x01),o(e.y11,e.x11),!t),a.arc(0,0,u,o(e.cy+e.y11,e.cx+e.x11),o(r.cy+r.y11,r.cx+r.x11),t),a.arc(r.cx,r.cy,p,o(r.y11,r.x11),o(r.y01,r.x01),!t))):a.arc(0,0,u,T,R,t)}if(a.closePath(),n)return a=null,n+""||null}return i.centroid=function(){var n=(+l.apply(this,arguments)+ +h.apply(this,arguments))/2,d=(+v.apply(this,arguments)+ +A.apply(this,arguments))/2-an/2;return[F(d)*n,q(d)*n]},i.innerRadius=function(n){return arguments.length?(l=typeof n=="function"?n:j(+n),i):l},i.outerRadius=function(n){return arguments.length?(h=typeof n=="function"?n:j(+n),i):h},i.cornerRadius=function(n){return arguments.length?(I=typeof n=="function"?n:j(+n),i):I},i.padRadius=function(n){return arguments.length?(D=n==null?null:typeof n=="function"?n:j(+n),i):D},i.startAngle=function(n){return arguments.length?(v=typeof n=="function"?n:j(+n),i):v},i.endAngle=function(n){return arguments.length?(A=typeof n=="function"?n:j(+n),i):A},i.padAngle=function(n){return arguments.length?(z=typeof n=="function"?n:j(+n),i):z},i.context=function(n){return arguments.length?(a=n??null,i):a},i}export{hn as d};