@tea-agent/loop-agent 0.43.0-next.16 → 0.43.0-next.18

package/dist/worker/task-spec/validate.js

@@ -245,7 +245,10 @@ function checkPathBoundaries(taskSpec, errors, warnings) {
     const pathErrors = errors.slice(start).filter((error) => error.layer === "path-boundary");
     if (pathErrors.length === 0)
         return "ok";
-    return toFailure(pathErrors[0]);
+    const [firstPathError] = pathErrors;
+    if (firstPathError === undefined)
+        return "ok";
+    return toFailure(firstPathError);
 }
 function checkVerifyCommands(taskSpec, errors) {
     if (!VERIFY_OPTIONAL_TYPES.has(taskSpec.type) &&

package/dist/workflows/dag/decision-envelope.js

@@ -386,6 +386,8 @@ export function parseDagDecisionCommandArgs(mode, args) {
     let nodeId;
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];
+        if (arg === undefined)
+            break;
         if (arg === "--run-id") {
             runId = args[++i];
             continue;

package/dist/workflows/dag/dynamic-runtime/shared.js

@@ -31,13 +31,13 @@ export function getNodeOutputAsJson(state, nodeId) {
 export function normalizeVerdictCandidateLine(value) {
     const trimmed = String(value).trim();
     const emphasized = trimmed.match(/^(?:`{1,3}|\*{1,3})\s*(VERDICT:[^`*]+?)\s*(?:`{1,3}|\*{1,3})$/);
-    const line = (emphasized ? emphasized[1] : trimmed).trim();
+    const line = (emphasized?.[1] ?? trimmed).trim();
     // Canonicalize the colon separator and trailing sentence punctuation so
     // "VERDICT:pass", "VERDICT:  pass", or "VERDICT: pass." match the declared
     // enum lines without accepting free-text verdicts. Conflicting verdicts
     // still canonicalize to distinct enum lines and remain fail-closed.
     const verdictMatch = line.match(/^VERDICT:\s*(pass|request-revision)\s*[.!?。！？]*$/i);
-    if (verdictMatch)
+    if (verdictMatch?.[1])
         return `VERDICT: ${verdictMatch[1].toLowerCase()}`;
     return line;
 }

package/dist/workflows/dag/frontend-verification-trace.js

@@ -170,6 +170,8 @@ export function extractFrontendTestTitles(content) {
     }
     for (let index = 0; index < tokens.length; index += 1) {
         const token = tokens[index];
+        if (token === undefined)
+            continue;
         if (token?.type !== "identifier" ||
             !["describe", "it", "test"].includes(token.value) ||
             (tokens[index - 1]?.type === "punctuation" &&
@@ -183,15 +185,16 @@ export function extractFrontendTestTitles(content) {
         while (tokens[cursor]?.type === "punctuation" &&
             tokens[cursor]?.value === "." &&
             tokens[cursor + 1]?.type === "identifier") {
-            if (tokens[cursor + 1]?.type === "identifier" &&
-                configurationModifiers.has(tokens[cursor + 1].value)) {
+            const modifier = tokens[cursor + 1];
+            if (modifier === undefined)
+                break;
+            if (configurationModifiers.has(modifier.value)) {
                 hasConfigurationModifier = true;
-                if (["runIf", "skipIf"].includes(tokens[cursor + 1].value)) {
-                    conditionalModifier = tokens[cursor + 1].value;
+                if (["runIf", "skipIf"].includes(modifier.value)) {
+                    conditionalModifier = modifier.value;
                 }
             }
-            if (tokens[cursor + 1]?.type === "identifier" &&
-                nonExecutingModifiers.has(tokens[cursor + 1].value)) {
+            if (nonExecutingModifiers.has(modifier.value)) {
                 hasNonExecutingModifier = true;
             }
             cursor += 2;
@@ -221,9 +224,10 @@ export function extractFrontendTestTitles(content) {
             index = closingParenIndex(cursor) ?? tokens.length;
             continue;
         }
-        if (tokens[cursor + 1]?.type !== "string")
+        const titleToken = tokens[cursor + 1];
+        if (titleToken?.type !== "string")
             continue;
-        titles.push(tokens[cursor + 1].value);
+        titles.push(titleToken.value);
     }
     return titles;
 }
@@ -326,9 +330,9 @@ export async function evaluateVerificationTargets(input) {
 export function verificationSymbolMatchesContent(symbol, content) {
     if (symbol.trim().toLowerCase() === "all describe blocks")
         return content.includes("describe(");
+    const separatorHead = symbol.split(/[（(]/, 1)[0];
     const symbols = symbol.includes(" / ")
-        ? symbol
-            .split(/[（(]/, 1)[0]
+        ? (separatorHead ?? symbol)
             .split("/")
             .map((item) => item.trim())
             .filter(Boolean)

package/dist/workflows/dag/init-hybrid.js

@@ -814,7 +814,7 @@ export function extractSuccessCriteria(requirementMarkdown, taskId) {
     const criteria = [];
     const sectionMatch = requirementMarkdown.match(SUCCESS_CRITERIA_SECTION);
     if (sectionMatch) {
-        for (const line of sectionMatch[2].split("\n")) {
+        for (const line of (sectionMatch[2] ?? "").split("\n")) {
             const trimmed = line.replace(/^[-*]\s*\[[ xX]\]\s*/, "").trim();
             if (trimmed.startsWith("-") || trimmed.startsWith("*")) {
                 criteria.push(trimmed.replace(/^[-*]\s*/, "").trim());
@@ -1020,6 +1020,82 @@ function extractFrontendVerifyCommandsFromMarkdown(input) {
     }
     return { staticCommands, behaviorCommands };
 }
+/**
+ * Resolve the static verification commands the frontend DAG will freeze.
+ *
+ * The frontend contract is "the implementation must be statically verifiable -
+ * never a no-op". It used to mean exactly `npm run build`, which made the whole
+ * run fail at the verify node (8 of 11) for any project that legitimately has no
+ * build step: a zero-dependency Node app, a static-site repo, a plain-ESM
+ * browser module. The failure landed *after* `frontend-implement-pi` had already
+ * delivered correct, test-passing work, so the run reported failure for a project
+ * shape that was never going to pass. That is a meaningless failure and a
+ * gratuitous loss of trust, not a safety property.
+ *
+ * Order, keeping every choice a real check:
+ *   1. `npm run build` when the project defines it - unchanged for every project
+ *      that already worked.
+ *   2. static commands the task declared via `--verify`. These were already being
+ *      classified onto the static lane and then discarded, so an operator who
+ *      declared `--verify typecheck:npm run typecheck` was silently ignored.
+ *   3. the project's own `typecheck` / `check` script.
+ *   4. otherwise the historical `npm run build` is kept. That still fails at the
+ *      verify node, exactly as before this change - it is deliberately NOT a new
+ *      generation-time error. Introducing one would turn a late failure into an
+ *      early one for projects that never declared static verification, which is
+ *      more failure, not less; the operator can still declare one via `--verify`.
+ *
+ * Lint is deliberately never chosen: the frontend topology hard-codes
+ * `lintShellCommands = []` so existing lint debt stays outside this workflow, and
+ * auto-selecting a lint script would turn that debt into a fresh failure.
+ */
+const FRONTEND_STATIC_SCRIPT_PREFERENCE = ["typecheck", "check"];
+async function resolveFrontendStaticCommands(input) {
+    let scripts = {};
+    try {
+        const manifest = JSON.parse(await readFile(path.join(input.repoRoot, "package.json"), "utf8"));
+        scripts = manifest.scripts ?? {};
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const hasScript = (name) => {
+        const script = scripts[name];
+        return typeof script === "string" && script.trim() !== "";
+    };
+    if (hasScript("build")) {
+        return [
+            {
+                label: "build",
+                args: ["bash", "-lc", "npm run build"],
+                cwd: input.repoRoot,
+            },
+        ];
+    }
+    if (input.explicitStatic.length > 0)
+        return input.explicitStatic;
+    for (const name of FRONTEND_STATIC_SCRIPT_PREFERENCE) {
+        if (!hasScript(name))
+            continue;
+        return [
+            {
+                label: name,
+                args: ["bash", "-lc", `npm run ${name}`],
+                cwd: input.repoRoot,
+            },
+        ];
+    }
+    // Nothing static is discoverable: keep the historical command rather than
+    // inventing a new failure. See the doc comment above for why.
+    return [
+        {
+            label: "build",
+            args: ["bash", "-lc", "npm run build"],
+            cwd: input.repoRoot,
+        },
+    ];
+}
 /** Reuse the project's test entrypoint; never install a runner for an untested project. */
 async function resolveFrontendExistingTests(sources) {
     const repoRoot = sources.repoRoot ?? process.cwd();
@@ -1425,7 +1501,7 @@ function isFullSuiteVerifyCommand(command) {
             (rest.length === 2 && rest[0] === "run" && rest[1] === "test"));
     }
     if (["bash", "sh"].includes(executable) && rest.length === 1) {
-        return /(?:^|\/)scripts\/(?:ci|check-repo)\.sh$/i.test(rest[0].replace(/\\/g, "/"));
+        return /(?:^|\/)scripts\/(?:ci|check-repo)\.sh$/i.test((rest[0] ?? "").replace(/\\/g, "/"));
     }
     return (rest.length === 0 &&
         /(?:^|\/)scripts\/(?:ci|check-repo)\.sh$/i.test((args[index] ?? "").replace(/\\/g, "/")));
@@ -2597,11 +2673,27 @@ function resolveFrontendMockContextBlock(sources) {
         parts.push("Implement the selected Mock strategy within authorized paths and keep production-default-off isolation. Mock behavior verification is deferred to frontend-test; it is not an implementation gate.");
     }
     if (mode === "not-required") {
-        parts.push("Generation-time evidence does not require Mock. The assessment must still use contract/scout evidence: select not-needed when Mock is intentionally skipped, or select a safe Mock strategy if project evidence supports one.");
+        // The assessment sentence is deliberately split: every branch keeps the
+        // "select not-needed when Mock is intentionally skipped" guidance, because
+        // that is the correct action in both cases, and only the permissive
+        // "or select a safe Mock strategy if project evidence supports one" tail is
+        // withheld when the allow-list is frozen.
+        //
+        // Emitting both was a direct instruction conflict, and it cost a whole
+        // frontend run (dogfood R2): the model resolved it the permissive way, the
+        // typed tool accepted ten `native` records with ok:true, and the
+        // design-policy shell rejected the contract ~90s later, killing 8
+        // downstream nodes. The fix belongs here - stop contradicting ourselves -
+        // rather than in extra enforcement that would leave the model guessing.
+        const mockAssessment = "Generation-time evidence does not require Mock. The assessment must still use contract/scout evidence: select not-needed when Mock is intentionally skipped";
         if (frontendMockStrategyMustBeNotNeeded(sources)) {
+            parts.push(`${mockAssessment}.`);
             parts.push('Auto mode has no confirmed project Mock capability. The structured contract must set mockApi.strategy to "not-needed". Keep the real request path as the default, record any unproved backend behavior as Real Integration Gap, and do not add Mock files or dependencies within this run.');
             parts.push('HARD CONSTRAINT (frozen at generation time): this DAG allows only mockApi.strategy "not-needed"; the prewrite gate rejects any other strategy. If project governance (openspec / ai_workspace / decision records, e.g. a DEC rule requiring native) demands Mock-backed verification, that is a generation-time contract gap, not a plan-revision defect: confirm the project Mock capability and policy: "required" in task.json and regenerate the DAG.');
         }
+        else {
+            parts.push(`${mockAssessment}, or select a safe Mock strategy if project evidence supports one.`);
+        }
     }
     if (mode === "blocked") {
         parts.push("Mock contract is blocked. The DAG must stop before any write node executes.");
@@ -3125,7 +3217,7 @@ async function buildFrontendHybridDagFromTask(sources) {
         "Frontend planning must consume the read-only Mock assessment strategy produced after scouting; MOCK_STRATEGY: blocked must not pass the deterministic Mock contract gate.",
         "Mock implementations must preserve the real request path as the default, require explicit test/dev activation, and never rely on commenting out the real request.",
         "Mock-backed behavior evidence proves only the documented frontend contract, never real API integration.",
-        "frontend-implementation requires npm run build and existing affected unit tests. Update affected tests with the implementation; do not install a test framework when absent. Broader browser/visual testing may be deferred; build success is never test success.",
+        "frontend-implementation requires the frozen static verification command and existing affected unit tests. Update affected tests with the implementation; do not install a test framework when absent. Broader browser/visual testing may be deferred; static-verification success is never test success.",
         "Frontend closeout renders only from committed facts; a weak status (failed / not-run / baseline-debt / mock-backed / pending) can never be rewritten into a stronger one (passed / real-integrated).",
         `Frontend risk classification: ${frontendRisk.selectedRisk} — ${frontendRisk.reason}`,
         frontendRisk.forceFullGates
@@ -3141,13 +3233,15 @@ async function buildFrontendHybridDagFromTask(sources) {
                 : "Mock contract is blocked by deterministic generation-time Mock safety constraints.";
         return buildBlockedFrontendMockDag(frontendSources, readOnlyPaths, forbiddenPaths, globalConstraints, blockedReason);
     }
-    // Build is mandatory; existing or explicitly declared tests remain required.
-    // Keep a real failing command when build is unavailable; never use a no-op.
-    const buildCommands = [{
-            label: "build",
-            args: ["bash", "-lc", "npm run build"],
-            cwd: sources.repoRoot ?? process.cwd(),
-        }];
+    // Static verification is mandatory; existing or explicitly declared tests remain
+    // required. Never use a no-op - but never freeze a command the project cannot run
+    // either. See resolveFrontendStaticCommands for why `npm run build` is not the
+    // only acceptable answer.
+    const explicitFrontendCommands = buildExplicitFrontendVerifyCommands(sources.taskConfig, sources.repoRoot ?? process.cwd());
+    const buildCommands = await resolveFrontendStaticCommands({
+        repoRoot: sources.repoRoot ?? process.cwd(),
+        explicitStatic: explicitFrontendCommands.staticCommands,
+    });
     const staticShellCommands = buildVerifyShellCommands({
         repoRoot: sources.repoRoot ?? process.cwd(), commands: buildCommands, fallbackCommands: [],
     });

package/dist/workflows/dag/interrupt-request.js

@@ -454,6 +454,8 @@ export function parseDagRequestInterruptArgs(args) {
     for (let i = 0; i < args.length; i += 1) {
         const cursor = { value: i };
         const arg = args[i];
+        if (arg === undefined)
+            break;
         const runIdValue = readFlag(args, cursor, "run-id");
         if (runIdValue !== undefined) {
             runId = runIdValue;

package/dist/workflows/dag/lifecycle.js

@@ -684,6 +684,8 @@ export function parseDagStatusArgs(args) {
     let runId;
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];
+        if (arg === undefined)
+            break;
         if (arg === "--run-id") {
             runId = args[++i];
             continue;
@@ -712,6 +714,8 @@ export function parseDagDoctorArgs(args) {
     let markdown = false;
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];
+        if (arg === undefined)
+            break;
         if (arg === "--run-id") {
             runId = args[++i];
             if (!runId || runId.startsWith("-")) {

package/dist/workflows/dag/node-execution.js

@@ -1075,6 +1075,8 @@ function validateRepairArtifactGateBeforeShell(input) {
     if (!gate)
         return;
     const upstream = input.state.nodes[gate.fromNodeId];
+    if (!upstream)
+        return;
     const parsed = parseSupervisorRepairArtifact(upstream);
     if (!parsed.ok) {
         throw new Error(`repair artifact gate failed: ${parsed.reason}`);

package/dist/workflows/dag/reconcile-run.js

@@ -7,6 +7,8 @@ export function parseDagReconcileRunArgs(args) {
     let reason;
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
+        if (arg === undefined)
+            break;
         if (arg === "--run-id")
             runId = args[++index];
         else if (arg.startsWith("--run-id="))

package/dist/workflows/dag/repair-artifact.js

@@ -330,7 +330,9 @@ export function resolveRepairTaskForGate(input) {
     }
     const candidates = directDownstream.filter(isGovernedRepairWriter);
     if (candidates.length === 1) {
-        return { ok: true, repairTask: candidates[0] };
+        const [onlyCandidate] = candidates;
+        if (onlyCandidate)
+            return { ok: true, repairTask: onlyCandidate };
     }
     const candidateIds = directDownstream.map((task) => task.id).join(", ") || "none";
     if (candidates.length === 0) {

package/dist/workflows/dag/report.js

@@ -449,6 +449,8 @@ export async function buildDagRunReportEntry(input) {
         const rankNodes = input.state.ranks[rank] ?? [];
         for (let order = 0; order < rankNodes.length; order += 1) {
             const nodeId = rankNodes[order];
+            if (nodeId === undefined)
+                continue;
             const node = input.state.nodes[nodeId];
             if (!node)
                 continue;

package/dist/workflows/dag/rerun-task.js

@@ -26,6 +26,8 @@ export function parseDagRerunTaskArgs(args) {
     let recoveryOperationId;
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
+        if (arg === undefined)
+            break;
         if (arg === "--run-id")
             parentRunId = args[++index];
         else if (arg.startsWith("--run-id="))

package/dist/workflows/dag/types.js

@@ -192,6 +192,25 @@ export const dagJsonArtifactGateSchema = z.object({
 const dagFrontendNodeIdSchema = z
     .string()
     .regex(/^[a-z][a-z0-9-]*$/, "frontend node id must be kebab-case");
+/**
+ * Requirement id accepted in a generated DAG's `requiredRequirementIds`.
+ *
+ * These ids are lifted verbatim from the task requirement ledger, which mirrors
+ * whatever the PRD wrote. A PRD that writes `AC1` (no hyphen) therefore yields an
+ * id this schema rejects, and `dagSpecSchema.parse` surfaces zod's raw issue array
+ * - so the operator saw only `"message": "Invalid"` plus a JSON pointer and had no
+ * way to learn the constraint. The message below carries it into that error.
+ *
+ * This is deliberately a fail-closed check, not a normalizer: `AC1` is
+ * canonicalized to `AC-1` upstream by `normalizeAcceptanceId` in the semantic
+ * intake, so every workflow reads the same ids. What remains here is the guard
+ * for genuinely malformed input - and because `dagSpecSchema.parse` surfaces
+ * zod's raw issue array, the message below is what makes that guard
+ * self-explanatory instead of `"message": "Invalid"` plus a JSON pointer.
+ */
+const dagRequirementIdSchema = z
+    .string()
+    .regex(/^(?:REQ|BR|AC)-[A-Z0-9]+(?:-[A-Z0-9]+)*$/, 'requirement id must be "<REQ|BR|AC>-<SEGMENT>" with a hyphen after the prefix (e.g. AC-1, AC-FE-001, REQ-SRC-ABC123); ids come verbatim from the task requirement ledger, so a PRD writing "AC1" must write "AC-1"');
 const openspecCandidatePathSchema = z
     .string()
     .refine((candidate) => !candidate.includes("\\") &&
@@ -210,9 +229,7 @@ export const dagFrontendPrewriteGateSchema = z.object({
     planFallbackFromNodeIds: z.array(dagFrontendNodeIdSchema).default([]),
     reviewFromNodeId: dagFrontendNodeIdSchema,
     reviewFallbackFromNodeIds: z.array(dagFrontendNodeIdSchema).default([]),
-    requiredRequirementIds: z
-        .array(z.string().regex(/^(?:REQ|BR|AC)-[A-Z0-9]+(?:-[A-Z0-9]+)*$/))
-        .default([]),
+    requiredRequirementIds: z.array(dagRequirementIdSchema).default([]),
     allowedMockStrategies: z
         .array(z.enum(["native", "browser-intercept", "request-adapter", "not-needed"]))
         .min(1),
@@ -422,9 +439,7 @@ export const dagFrontendDesignPolicySchema = z
     .object({
     schemaVersion: z.literal(1),
     planFromNodeId: dagFrontendNodeIdSchema,
-    requiredRequirementIds: z
-        .array(z.string().regex(/^(?:REQ|BR|AC)-[A-Z0-9]+(?:-[A-Z0-9]+)*$/))
-        .default([]),
+    requiredRequirementIds: z.array(dagRequirementIdSchema).default([]),
     allowedMockStrategies: z
         .array(z.enum(["native", "browser-intercept", "request-adapter", "not-needed"]))
         .min(1),

package/dist/workflows/dag/validate.js

@@ -222,6 +222,8 @@ function validateRepairArtifactGateConfig(task, spec, issues) {
         return;
     }
     const hardVerify = hardVerifyCandidates[0];
+    if (!hardVerify)
+        return;
     const descendantIds = new Set();
     const queue = [hardVerify.id];
     while (queue.length > 0) {
@@ -411,6 +413,8 @@ function validateSameRankWriteSetConflicts(spec, ranks, issues) {
             for (let j = i + 1; j < exclusiveWriters.length; j += 1) {
                 const left = exclusiveWriters[i];
                 const right = exclusiveWriters[j];
+                if (!left || !right)
+                    continue;
                 const leftSet = left.writeSet ?? [];
                 const rightSet = right.writeSet ?? [];
                 for (const leftEntry of leftSet) {

package/docs/governance/README.md

@@ -10,6 +10,7 @@
 - [`harness-methodology-tdd.md`](harness-methodology-tdd.md)：测试先行的方法与边界。
 - [`harness-methodology-verification.md`](harness-methodology-verification.md)：如何用新鲜命令结果支持完成声明。
 - [`harness-methodology-debugging.md`](harness-methodology-debugging.md)：系统化定位故障，不用猜测代替证据。
+- [`defect-ledger.md`](defect-ledger.md)：真实缺陷台账与优先级规则——治理目标先从真故障选，再看代理指标排名。
 - [`document-review-policy.md`](document-review-policy.md)：文档 freshness、`reviewTier` 与 `lastReviewed` 更新边界。
 - [`lightweight-github-collaboration.md`](lightweight-github-collaboration.md)：短分支、简短 PR、CI 与 Squash Merge 的轻量协作规则。
 - [`研发模式.md`](研发模式.md)：Feature 团队推进、交付和知识回写方法论。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.43.0-next.16",
+  "version": "0.43.0-next.18",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",
@@ -84,6 +84,7 @@
     "katex": "^0.16.47",
     "mermaid": "^11.16.1",
     "node-pty": "^1.2.0-beta.15",
+    "playwright-core": "^1.63.0",
     "rehype-highlight": "^7.0.2",
     "rehype-katex": "^7.0.1",
     "remark-math": "^6.0.0",
@@ -103,6 +104,7 @@
     "@types/react-dom": "^19.1.6",
     "@types/semver": "^7.7.1",
     "@vitest/coverage-v8": "^4.1.11",
+    "fast-check": "^4.10.0",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
     "react-markdown": "^10.1.0",

package/dist/worker/console/static/assets/channel-BxdTlb_5.js

@@ -1 +0,0 @@
-import{ag as o,ah as n}from"./mermaid.core-CQA4Nzmo.js";const t=(a,r)=>o.lang.round(n.parse(a)[r]);export{t as c};

package/dist/worker/console/static/assets/classDiagram-JCYQIIEL-_ByA1Nf8.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-GF5L2VYU-D9UA7hUb.js";import{_ as i}from"./mermaid.core-CQA4Nzmo.js";import"./chunk-5VM5RSS4-DGdvrNm8.js";import"./chunk-XXDRQBXY-CScR6mDD.js";import"./chunk-KBJHAD2P-BmuEOIh7.js";import"./chunk-2GRJ4B5K-CoviemSL.js";import"./index-wXlQohNs.js";var n={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{n as diagram};

package/dist/worker/console/static/assets/classDiagram-v2-OCEON4UE-_ByA1Nf8.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-GF5L2VYU-D9UA7hUb.js";import{_ as i}from"./mermaid.core-CQA4Nzmo.js";import"./chunk-5VM5RSS4-DGdvrNm8.js";import"./chunk-XXDRQBXY-CScR6mDD.js";import"./chunk-KBJHAD2P-BmuEOIh7.js";import"./chunk-2GRJ4B5K-CoviemSL.js";import"./index-wXlQohNs.js";var n={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{n as diagram};

package/dist/worker/console/static/assets/stateDiagram-v2-UEYNNEHI-nLgMZ0D3.js

@@ -1 +0,0 @@
-import{s as r,b as e,a,S as s}from"./chunk-5RXB4S5H-BsG2pmdQ.js";import{_ as i}from"./mermaid.core-CQA4Nzmo.js";import"./chunk-XXDRQBXY-CScR6mDD.js";import"./chunk-KBJHAD2P-BmuEOIh7.js";import"./chunk-2GRJ4B5K-CoviemSL.js";import"./index-wXlQohNs.js";var u={parser:a,get db(){return new s(2)},renderer:e,styles:r,init:i(t=>{t.state||(t.state={}),t.state.arrowMarkerAbsolute=t.arrowMarkerAbsolute},"init")};export{u as diagram};

package/dist/worker/console/static/assets/swimlanesDiagram-ULZ7WXOC-BcYqTady.js

@@ -1,8 +0,0 @@
-import{c as r,s as e}from"./flowDiagram-UKHOOZJN-BHIRvRr3.js";import{_ as a}from"./mermaid.core-CQA4Nzmo.js";import"./chunk-5VM5RSS4-DGdvrNm8.js";import"./chunk-XXDRQBXY-CScR6mDD.js";import"./chunk-KBJHAD2P-BmuEOIh7.js";import"./chunk-2GRJ4B5K-CoviemSL.js";import"./channel-BxdTlb_5.js";import"./index-wXlQohNs.js";var o=a(t=>`${e(t)}
-  .swimlane.cluster rect {
-    stroke: ${t.clusterBorder} !important;
-  }
-  [data-look="neo"].cluster rect {
-    filter: none;
-  }
-`,"getStyles"),s=o,n=r({defaultLayout:"swimlane",styles:s});export{n as diagram};