@lostgradient/cinder 0.9.0 → 0.12.0

package/dist/server/index.server-g5jgq3jp.js

@@ -0,0 +1,793 @@
+import {
+  Progress
+} from "./index.server-7g2pzksm.js";
+import {
+  Link
+} from "./index.server-2ta1a4ze.js";
+import {
+  Status_dot
+} from "./index.server-npxtkwjp.js";
+import {
+  Collapsible
+} from "./index.server-mvhf8b7g.js";
+import {
+  Badge
+} from "./index.server-thedzn9z.js";
+import {
+  classNames
+} from "./index.server-z7nvkz8v.js";
+
+// src/components/run-step-timeline/run-step-timeline.svelte
+import * as $2 from "svelte/internal/server";
+
+// src/components/run-step-timeline/run-step-branch-disclosure.svelte
+import * as $ from "svelte/internal/server";
+function Run_step_branch_disclosure($$renderer, $$props) {
+  let {
+    initialOpen,
+    triggerAriaLabel,
+    class: className,
+    trigger,
+    children
+  } = $$props;
+  let open = initialOpen;
+  let $$settled = true;
+  let $$inner_renderer;
+  function $$render_inner($$renderer2) {
+    Collapsible($$renderer2, {
+      trigger,
+      triggerAriaLabel,
+      class: className,
+      get open() {
+        return open;
+      },
+      set open($$value) {
+        open = $$value;
+        $$settled = false;
+      },
+      children: ($$renderer3) => {
+        children($$renderer3);
+        $$renderer3.push(`<!---->`);
+      },
+      $$slots: { default: true }
+    });
+  }
+  do {
+    $$settled = true;
+    $$inner_renderer = $$renderer.copy();
+    $$render_inner($$inner_renderer);
+  } while (!$$settled);
+  $$renderer.subsume($$inner_renderer);
+}
+
+// src/components/run-step-timeline/run-step-timeline.utilities.ts
+function relocateCompensationSteps(steps) {
+  return relocateSiblingItems(steps, (step) => step);
+}
+function relocateSiblingItems(items, getStep) {
+  if (!items.some((item) => getStep(item)?.compensates !== undefined))
+    return items;
+  const stepById = new Map;
+  for (const item of items) {
+    const step = getStep(item);
+    if (step !== undefined) {
+      stepById.set(step.id, step);
+    }
+  }
+  const canRelocate = (step) => {
+    const visited = new Set([step.id]);
+    let targetId = step.compensates;
+    while (targetId !== undefined) {
+      const target = stepById.get(targetId);
+      if (target === undefined || visited.has(targetId))
+        return false;
+      visited.add(targetId);
+      targetId = target.compensates;
+    }
+    return true;
+  };
+  const relocatable = new Set;
+  const compensationsByTarget = new Map;
+  for (const item of items) {
+    const step = getStep(item);
+    if (step === undefined || step.compensates === undefined || !canRelocate(step))
+      continue;
+    relocatable.add(step);
+    const compensations = compensationsByTarget.get(step.compensates) ?? [];
+    compensations.push(item);
+    compensationsByTarget.set(step.compensates, compensations);
+  }
+  const result = [];
+  const appendWithCompensations = (item) => {
+    result.push(item);
+    const step = getStep(item);
+    if (step === undefined)
+      return;
+    for (const compensation of compensationsByTarget.get(step.id) ?? []) {
+      appendWithCompensations(compensation);
+    }
+  };
+  for (const item of items) {
+    const step = getStep(item);
+    if (step === undefined || !relocatable.has(step))
+      appendWithCompensations(item);
+  }
+  return result;
+}
+function relocateCompensationEntries(entries) {
+  return relocateSiblingItems(entries, (entry) => isBranchGroup(entry) ? undefined : entry);
+}
+function isBranchGroup(entry) {
+  return "kind" in entry && entry.kind === "branch";
+}
+function statusDotStatus(status) {
+  switch (status) {
+    case "succeeded":
+      return "success";
+    case "failed":
+      return "danger";
+    case "running":
+      return "online";
+    case "retrying":
+      return "warning";
+    case "waiting_approval":
+      return "accent";
+    case "cancelled":
+      return "offline";
+    case "skipped":
+      return "neutral";
+    case "pending":
+      return "pending";
+  }
+}
+function statusLabel(status) {
+  switch (status) {
+    case "pending":
+      return "Pending";
+    case "running":
+      return "Running";
+    case "succeeded":
+      return "Succeeded";
+    case "failed":
+      return "Failed";
+    case "cancelled":
+      return "Cancelled";
+    case "skipped":
+      return "Skipped";
+    case "retrying":
+      return "Retrying";
+    case "waiting_approval":
+      return "Waiting approval";
+  }
+}
+function badgeVariant(status) {
+  switch (status) {
+    case "succeeded":
+      return "success";
+    case "failed":
+      return "danger";
+    case "running":
+      return "info";
+    case "retrying":
+      return "warning";
+    case "waiting_approval":
+      return "accent";
+    case "cancelled":
+      return "neutral";
+    case "skipped":
+      return "neutral";
+    case "pending":
+      return "neutral";
+  }
+}
+function isTerminal(status) {
+  return status === "succeeded" || status === "failed" || status === "cancelled" || status === "skipped";
+}
+function isCurrent(status) {
+  return status === "running" || status === "retrying" || status === "waiting_approval";
+}
+function hasProgress(step) {
+  return step.progress !== undefined && isCurrent(step.status);
+}
+function metadataItems(step) {
+  const items = [];
+  if (step.startTime !== undefined) {
+    items.push({ term: "Started", definition: step.startTime });
+  }
+  if (step.endTime !== undefined) {
+    items.push({ term: "Ended", definition: step.endTime });
+  }
+  if (step.duration !== undefined) {
+    items.push({ term: "Duration", definition: step.duration });
+  }
+  if (step.attemptCount !== undefined && step.attemptCount > 1) {
+    items.push({ term: "Attempts", definition: String(step.attemptCount) });
+  }
+  return items;
+}
+function actionsCountLabel(actionsCount) {
+  return actionsCount === 1 ? "1 action" : `${actionsCount} actions`;
+}
+function hiddenNestedStepLabel(hiddenStepCount) {
+  return hiddenStepCount === 1 ? "1 nested step hidden" : `${hiddenStepCount} nested steps hidden`;
+}
+function laneOutcomeLabel(outcome) {
+  switch (outcome) {
+    case "won":
+      return "Won";
+    case "lost":
+      return "Lost";
+    case "settled":
+      return "Settled";
+  }
+}
+function laneOutcomeBadgeVariant(outcome) {
+  switch (outcome) {
+    case "won":
+      return "success";
+    case "lost":
+      return "neutral";
+    case "settled":
+      return "info";
+  }
+}
+function branchOutcomeSummary(lanes) {
+  const counts = { won: 0, lost: 0, settled: 0, pending: 0 };
+  for (const lane of lanes) {
+    if (lane.outcome === undefined)
+      counts.pending += 1;
+    else
+      counts[lane.outcome] += 1;
+  }
+  const parts = [];
+  if (counts.won > 0)
+    parts.push(`${counts.won} won`);
+  if (counts.lost > 0)
+    parts.push(`${counts.lost} lost`);
+  if (counts.settled > 0)
+    parts.push(`${counts.settled} settled`);
+  if (counts.pending > 0) {
+    parts.push(counts.pending === 1 ? "1 lane racing" : `${counts.pending} lanes racing`);
+  }
+  return parts.length > 0 ? parts.join(", ") : "No lanes";
+}
+function branchGroupHasCurrentStep(group) {
+  const stack = group.lanes.flatMap((lane) => lane.steps);
+  while (stack.length > 0) {
+    const step = stack.pop();
+    if (step === undefined)
+      continue;
+    if (isCurrent(step.status))
+      return true;
+    if (step.children) {
+      for (const child of step.children)
+        stack.push(child);
+    }
+  }
+  return false;
+}
+function branchStartsCollapsed(laneCount, collapseThreshold, collapsed) {
+  if (collapsed !== undefined)
+    return collapsed;
+  const threshold = collapseThreshold !== undefined && Number.isInteger(collapseThreshold) && collapseThreshold > 0 ? collapseThreshold : 3;
+  return laneCount >= threshold;
+}
+function hasControlCharacter(value) {
+  for (let index = 0;index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code <= 31 || code === 127)
+      return true;
+  }
+  return false;
+}
+function safeStepLinkHref(href) {
+  const trimmedHref = href.trim();
+  if (trimmedHref === "")
+    return;
+  if (hasControlCharacter(trimmedHref))
+    return;
+  if (trimmedHref.includes("\\"))
+    return;
+  const leadingSeparators = trimmedHref.match(/^[\\/]+/)?.[0] ?? "";
+  if (leadingSeparators.length > 1)
+    return;
+  if (/^[A-Za-z][A-Za-z\d+.-]*:/.test(trimmedHref)) {
+    try {
+      const parsedUrl = new URL(trimmedHref);
+      return parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:" ? trimmedHref : undefined;
+    } catch {
+      return;
+    }
+  }
+  return trimmedHref;
+}
+
+// src/components/run-step-timeline/run-step-timeline.svelte
+function depthLimitItem($$renderer, row) {
+  $$renderer.push(`<li class="cinder-run-step-timeline__item" data-cinder-status="depth-limit"${$2.attr("data-cinder-depth", row.depth)}${$2.attr("data-cinder-path", row.pathKey)}${$2.attr("data-cinder-connector-after", row.connectorAfter)} data-cinder-depth-limit=""${$2.attr("aria-current", row.ariaCurrent ? "step" : undefined)}${$2.attr_style("", { "--_cinder-rst-depth": row.depth })}><div class="cinder-run-step-timeline__event"><span class="cinder-run-step-timeline__marker" aria-hidden="true" inert="">`);
+  Status_dot($$renderer, {
+    status: "neutral",
+    label: "Nested steps hidden",
+    showLabel: false,
+    size: "md"
+  });
+  $$renderer.push(`<!----></span> <div class="cinder-run-step-timeline__content"><div class="cinder-run-step-timeline__header"><span class="cinder-run-step-timeline__label">${$2.escape(hiddenNestedStepLabel(row.hiddenStepCount))}</span> `);
+  Badge($$renderer, {
+    class: "cinder-run-step-timeline__status",
+    variant: "neutral",
+    size: "xs",
+    "aria-label": "Status: Nested child steps hidden",
+    children: ($$renderer2) => {
+      $$renderer2.push(`<!---->Depth cap`);
+    },
+    $$slots: { default: true }
+  });
+  $$renderer.push(`<!----></div> <p class="cinder-run-step-timeline__body">Additional child-workflow steps are hidden because the timeline depth cap was reached.</p></div></div></li>`);
+}
+function Run_step_timeline($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const MAX_NESTED_STEP_DEPTH = 3;
+    let {
+      steps,
+      label,
+      class: className,
+      children,
+      "aria-label": ariaLabel,
+      "aria-labelledby": ariaLabelledby,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const resolvedAriaLabel = $2.derived(() => ariaLabelledby === undefined && ariaLabel === undefined ? label : ariaLabel);
+    const renderedEntries = $2.derived(() => flattenEntries(relocateCompensationEntries(steps)));
+    function isBranchGroup2(entry) {
+      return "kind" in entry && entry.kind === "branch";
+    }
+    function flattenEntries(entries) {
+      const result = [];
+      let stepRun = [];
+      const flushRun = () => {
+        if (stepRun.length === 0)
+          return;
+        result.push(...flattenSteps(stepRun, ""));
+        stepRun = [];
+      };
+      for (const entry of entries) {
+        if (isBranchGroup2(entry)) {
+          flushRun();
+          result.push({
+            kind: "branch",
+            group: entry,
+            pathKey: `%branch/${escapeStepPathSegment(entry.id)}`,
+            connectorAfter: "hidden"
+          });
+        } else {
+          stepRun.push(entry);
+        }
+      }
+      flushRun();
+      return applyGlobalRailConnectors(applyGlobalTopLevelCompensates(applyGlobalRailAriaCurrent(result)));
+    }
+    function applyGlobalTopLevelCompensates(rows) {
+      const topLevelLabelByPathKey = new Map;
+      for (const row of rows) {
+        if (row.kind === "step" && row.depth === 0) {
+          topLevelLabelByPathKey.set(row.pathKey, row.step.label);
+        }
+      }
+      return rows.map((row) => {
+        if (row.kind !== "step" || row.depth !== 0 || row.step.compensates === undefined)
+          return row;
+        return {
+          ...row,
+          compensatesLabel: resolveSiblingCompensatesLabel(row, topLevelLabelByPathKey)
+        };
+      });
+    }
+    function railRowDepth(row) {
+      return row.kind === "branch" ? 0 : row.depth;
+    }
+    function applyGlobalRailConnectors(rows) {
+      return rows.map((row, index) => {
+        const next = rows[index + 1];
+        const connectorAfter = next === undefined || railRowDepth(next) < railRowDepth(row) ? "hidden" : "visible";
+        return { ...row, connectorAfter };
+      });
+    }
+    function rowCurrentDepth(row) {
+      if (row.kind === "depth-limit")
+        return row.hiddenCurrent ? row.depth + 1 : -1;
+      if (row.kind === "step")
+        return isCurrent(row.step.status) ? row.depth : -1;
+      return -1;
+    }
+    function applyGlobalRailAriaCurrent(rows) {
+      let deepestRow;
+      let deepestDepth = -1;
+      for (const row of rows) {
+        const depth = rowCurrentDepth(row);
+        if (depth > deepestDepth) {
+          deepestDepth = depth;
+          deepestRow = row;
+        }
+      }
+      return rows.map((row) => row.kind === "branch" ? row : { ...row, ariaCurrent: row === deepestRow });
+    }
+    function flattenSteps(list, pathPrefix) {
+      const rows = [];
+      appendRunStepRows(rows, relocateCompensationSteps(list), 0, pathPrefix);
+      const currentRowIndex = deepestCurrentStepIndex(rows);
+      const labelByPathKey = new Map;
+      for (const row of rows) {
+        if (row.kind === "step")
+          labelByPathKey.set(row.pathKey, row.step.label);
+      }
+      return rows.map((row, index) => {
+        const next = rows[index + 1];
+        const connectorAfter = next === undefined || next.depth < row.depth ? "hidden" : "visible";
+        const ariaCurrent = index === currentRowIndex;
+        if (row.kind === "depth-limit") {
+          return { ...row, connectorAfter, ariaCurrent };
+        }
+        return {
+          ...row,
+          connectorAfter,
+          ariaCurrent,
+          compensatesLabel: resolveSiblingCompensatesLabel(row, labelByPathKey)
+        };
+      });
+    }
+    function resolveSiblingCompensatesLabel(row, labelByPathKey) {
+      if (row.step.compensates === undefined)
+        return;
+      const lastSeparator = row.pathKey.lastIndexOf("/");
+      const parentPrefix = lastSeparator === -1 ? "" : row.pathKey.slice(0, lastSeparator);
+      const siblingPathKey = nestedStepPathKey(parentPrefix, row.step.compensates);
+      if (siblingPathKey === row.pathKey)
+        return;
+      return labelByPathKey.get(siblingPathKey);
+    }
+    function appendRunStepRows(rows, list, depth, pathPrefix) {
+      for (const step of list) {
+        const pathKey = nestedStepPathKey(pathPrefix, step.id);
+        rows.push({ kind: "step", step, depth, pathKey });
+        if (step.children && step.children.length > 0) {
+          if (depth < MAX_NESTED_STEP_DEPTH) {
+            appendRunStepRows(rows, relocateCompensationSteps(step.children), depth + 1, pathKey);
+          } else {
+            const hiddenSummary = summarizeNestedRunSteps(step.children);
+            rows.push({
+              kind: "depth-limit",
+              depth,
+              pathKey: `${pathKey}/__cinder-depth-limit`,
+              hiddenStepCount: hiddenSummary.count,
+              hiddenCurrent: hiddenSummary.hasCurrent
+            });
+          }
+        }
+      }
+    }
+    function nestedStepPathKey(pathPrefix, stepId) {
+      const encodedStepId = escapeStepPathSegment(stepId);
+      return pathPrefix === "" ? encodedStepId : `${pathPrefix}/${encodedStepId}`;
+    }
+    function escapeStepPathSegment(stepId) {
+      return stepId.replaceAll("%", "%25").replaceAll("/", "%2F");
+    }
+    function summarizeNestedRunSteps(list) {
+      let count = 0;
+      let hasCurrent = false;
+      const stack = [...list];
+      while (stack.length > 0) {
+        const step = stack.pop();
+        if (step === undefined)
+          continue;
+        count += 1;
+        if (isCurrent(step.status))
+          hasCurrent = true;
+        const stepChildren = step.children;
+        if (stepChildren) {
+          for (let index = stepChildren.length - 1;index >= 0; index -= 1) {
+            const child = stepChildren[index];
+            if (child)
+              stack.push(child);
+          }
+        }
+      }
+      return { count, hasCurrent };
+    }
+    function deepestCurrentStepIndex(rows) {
+      let currentIndex = -1;
+      let currentDepth = -1;
+      rows.forEach((row, index) => {
+        const rowCurrentDepth2 = row.kind === "depth-limit" && row.hiddenCurrent ? row.depth + 1 : row.kind === "step" && isCurrent(row.step.status) ? row.depth : -1;
+        if (rowCurrentDepth2 > currentDepth) {
+          currentIndex = index;
+          currentDepth = rowCurrentDepth2;
+        }
+      });
+      return currentIndex;
+    }
+    function laneRows(lane) {
+      return flattenSteps(lane.steps, "");
+    }
+    function laneStateLabel(lane) {
+      return lane.outcome === undefined ? "racing" : laneOutcomeLabel(lane.outcome).toLowerCase();
+    }
+    function stepItem($$renderer3, row) {
+      const step = row.step;
+      const terminal = isTerminal(step.status);
+      const metadata = metadataItems(step);
+      $$renderer3.push(`<li class="cinder-run-step-timeline__item"${$2.attr("data-cinder-status", step.status)}${$2.attr("data-cinder-depth", row.depth)}${$2.attr("data-cinder-path", row.pathKey)}${$2.attr("data-cinder-terminal", terminal ? "" : undefined)}${$2.attr("data-cinder-rewound", step.rewound ? "" : undefined)}${$2.attr("data-cinder-compensation", row.compensatesLabel !== undefined ? "" : undefined)}${$2.attr("data-cinder-connector-after", row.connectorAfter)}${$2.attr("aria-current", row.ariaCurrent ? "step" : undefined)}${$2.attr_style("", { "--_cinder-rst-depth": row.depth })}><div class="cinder-run-step-timeline__event"><span class="cinder-run-step-timeline__marker" aria-hidden="true" inert="">`);
+      Status_dot($$renderer3, {
+        status: statusDotStatus(step.status),
+        label: statusLabel(step.status),
+        showLabel: false,
+        size: "md"
+      });
+      $$renderer3.push(`<!----></span> <div class="cinder-run-step-timeline__content"><div class="cinder-run-step-timeline__header"><span class="cinder-run-step-timeline__label">${$2.escape(step.label)}</span> `);
+      if (step.link) {
+        $$renderer3.push("<!--[0-->");
+        const safeLinkHref = safeStepLinkHref(step.link.href);
+        if (safeLinkHref) {
+          $$renderer3.push("<!--[0-->");
+          Link($$renderer3, {
+            href: safeLinkHref,
+            class: "cinder-run-step-timeline__link",
+            children: ($$renderer4) => {
+              $$renderer4.push(`<!---->${$2.escape(step.link.label)}`);
+            },
+            $$slots: { default: true }
+          });
+        } else {
+          $$renderer3.push("<!--[-1-->");
+          $$renderer3.push(`<span class="cinder-run-step-timeline__link cinder-run-step-timeline__link--unsafe">${$2.escape(step.link.label)}</span>`);
+        }
+        $$renderer3.push(`<!--]-->`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--> `);
+      Badge($$renderer3, {
+        class: "cinder-run-step-timeline__status",
+        variant: badgeVariant(step.status),
+        size: "xs",
+        "aria-label": `Status: ${statusLabel(step.status)}`,
+        children: ($$renderer4) => {
+          $$renderer4.push(`<!---->${$2.escape(statusLabel(step.status))}`);
+        },
+        $$slots: { default: true }
+      });
+      $$renderer3.push(`<!----> `);
+      if (step.rewound) {
+        $$renderer3.push("<!--[0-->");
+        Badge($$renderer3, {
+          class: "cinder-run-step-timeline__flag",
+          variant: "neutral",
+          size: "xs",
+          "aria-label": "State: rewound — speculatively executed, then unwound",
+          children: ($$renderer4) => {
+            $$renderer4.push(`<!---->Rewound`);
+          },
+          $$slots: { default: true }
+        });
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--> `);
+      if (row.compensatesLabel !== undefined) {
+        $$renderer3.push("<!--[0-->");
+        Badge($$renderer3, {
+          class: "cinder-run-step-timeline__flag",
+          variant: "warning",
+          size: "xs",
+          "aria-label": `Compensates ${row.compensatesLabel} — reverses the forward step`,
+          children: ($$renderer4) => {
+            $$renderer4.push(`<!---->Compensates ${$2.escape(row.compensatesLabel)}`);
+          },
+          $$slots: { default: true }
+        });
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--> `);
+      if (step.attemptCount !== undefined && step.attemptCount > 1) {
+        $$renderer3.push("<!--[0-->");
+        Badge($$renderer3, {
+          variant: "neutral",
+          size: "xs",
+          mono: true,
+          children: ($$renderer4) => {
+            $$renderer4.push(`<!---->attempt ${$2.escape(step.attemptCount)}`);
+          },
+          $$slots: { default: true }
+        });
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--> `);
+      if (step.actionsCount !== undefined && step.actionsCount > 0) {
+        $$renderer3.push("<!--[0-->");
+        Badge($$renderer3, {
+          variant: "neutral",
+          size: "xs",
+          mono: true,
+          children: ($$renderer4) => {
+            $$renderer4.push(`<!---->${$2.escape(actionsCountLabel(step.actionsCount))}`);
+          },
+          $$slots: { default: true }
+        });
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--></div> `);
+      if (hasProgress(step)) {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<div class="cinder-run-step-timeline__progress">`);
+        Progress($$renderer3, {
+          value: step.progress ?? 0,
+          max: step.progressMax ?? 100,
+          size: "sm",
+          ariaLabel: `${step.label} progress`
+        });
+        $$renderer3.push(`<!----></div>`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--> `);
+      if (metadata.length > 0) {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<dl class="cinder-run-step-timeline__meta"><!--[-->`);
+        const each_array = $2.ensure_array_like(metadata);
+        for (let $$index = 0, $$length = each_array.length;$$index < $$length; $$index++) {
+          let item = each_array[$$index];
+          $$renderer3.push(`<div class="cinder-run-step-timeline__meta-row"><dt class="cinder-run-step-timeline__meta-term">${$2.escape(item.term)}</dt> <dd class="cinder-run-step-timeline__meta-definition">${$2.escape(item.definition)}</dd></div>`);
+        }
+        $$renderer3.push(`<!--]--></dl>`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--> `);
+      if (step.details && step.details.length > 0) {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<div class="cinder-run-step-timeline__details"><!--[-->`);
+        const each_array_1 = $2.ensure_array_like(step.details);
+        for (let $$index_1 = 0, $$length = each_array_1.length;$$index_1 < $$length; $$index_1++) {
+          let detail = each_array_1[$$index_1];
+          Collapsible($$renderer3, {
+            trigger: detail.label,
+            children: ($$renderer4) => {
+              $$renderer4.push(`<pre class="cinder-run-step-timeline__detail-content">${$2.escape(detail.content)}</pre>`);
+            },
+            $$slots: { default: true }
+          });
+        }
+        $$renderer3.push(`<!--]--></div>`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--> `);
+      if (children) {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<div class="cinder-run-step-timeline__body">`);
+        children($$renderer3, step);
+        $$renderer3.push(`<!----></div>`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--></div></div></li>`);
+    }
+    function stepRail($$renderer3, rows) {
+      $$renderer3.push(`<!--[-->`);
+      const each_array_2 = $2.ensure_array_like(rows);
+      for (let $$index_2 = 0, $$length = each_array_2.length;$$index_2 < $$length; $$index_2++) {
+        let row = each_array_2[$$index_2];
+        if (row.kind === "depth-limit") {
+          $$renderer3.push("<!--[0-->");
+          depthLimitItem($$renderer3, row);
+        } else {
+          $$renderer3.push("<!--[-1-->");
+          stepItem($$renderer3, row);
+        }
+        $$renderer3.push(`<!--]-->`);
+      }
+      $$renderer3.push(`<!--]-->`);
+    }
+    $$renderer2.push(`<ol${$2.attributes({
+      ...rest,
+      class: $2.clsx(classNames("cinder-run-step-timeline", className)),
+      "aria-label": resolvedAriaLabel(),
+      "aria-labelledby": ariaLabelledby
+    })}><!--[-->`);
+    const each_array_3 = $2.ensure_array_like(renderedEntries());
+    for (let $$index_4 = 0, $$length = each_array_3.length;$$index_4 < $$length; $$index_4++) {
+      let entry = each_array_3[$$index_4];
+      if (entry.kind === "branch") {
+        $$renderer2.push("<!--[0-->");
+        const group = entry.group;
+        const summary = branchOutcomeSummary(group.lanes);
+        const initialOpen = !branchStartsCollapsed(group.lanes.length, group.collapseThreshold, group.collapsed) || group.collapsed === undefined && branchGroupHasCurrentStep(group);
+        $$renderer2.push(`<li class="cinder-run-step-timeline__item cinder-run-step-timeline__item--branch" data-cinder-status="branch" data-cinder-depth="0"${$2.attr("data-cinder-path", entry.pathKey)}${$2.attr("data-cinder-connector-after", entry.connectorAfter)}><div class="cinder-run-step-timeline__event"><span class="cinder-run-step-timeline__marker" aria-hidden="true" inert="">`);
+        Status_dot($$renderer2, {
+          status: "accent",
+          label: "Branch group",
+          showLabel: false,
+          size: "md"
+        });
+        $$renderer2.push(`<!----></span> <div class="cinder-run-step-timeline__content cinder-run-step-timeline__branch">`);
+        {
+          let trigger = function($$renderer3) {
+            $$renderer3.push(`<span class="cinder-run-step-timeline__branch-heading"><span class="cinder-run-step-timeline__label">${$2.escape(group.label)}</span> `);
+            Badge($$renderer3, {
+              variant: "accent",
+              size: "xs",
+              "aria-label": `Branch group outcome: ${summary}`,
+              children: ($$renderer4) => {
+                $$renderer4.push(`<!---->${$2.escape(summary)}`);
+              },
+              $$slots: { default: true }
+            });
+            $$renderer3.push(`<!----></span>`);
+          };
+          Run_step_branch_disclosure($$renderer2, {
+            initialOpen,
+            class: "cinder-run-step-timeline__branch-disclosure",
+            triggerAriaLabel: `Branch group: ${group.label}. ${summary}.`,
+            trigger,
+            children: ($$renderer3) => {
+              $$renderer3.push(`<ul class="cinder-run-step-timeline__lanes"${$2.attr("aria-label", `${group.label} branches`)}><!--[-->`);
+              const each_array_4 = $2.ensure_array_like(group.lanes);
+              for (let $$index_3 = 0, $$length2 = each_array_4.length;$$index_3 < $$length2; $$index_3++) {
+                let lane = each_array_4[$$index_3];
+                $$renderer3.push(`<li class="cinder-run-step-timeline__lane"${$2.attr("data-cinder-outcome", lane.outcome ?? "racing")}${$2.attr("aria-label", `Branch ${lane.label ?? lane.id}: ${laneStateLabel(lane)}`)}><div class="cinder-run-step-timeline__lane-header"><span class="cinder-run-step-timeline__lane-label">${$2.escape(lane.label ?? lane.id)}</span> `);
+                if (lane.outcome !== undefined) {
+                  $$renderer3.push("<!--[0-->");
+                  Badge($$renderer3, {
+                    variant: laneOutcomeBadgeVariant(lane.outcome),
+                    size: "xs",
+                    "aria-label": `Outcome: ${laneOutcomeLabel(lane.outcome)}`,
+                    children: ($$renderer4) => {
+                      $$renderer4.push(`<!---->${$2.escape(laneOutcomeLabel(lane.outcome))}`);
+                    },
+                    $$slots: { default: true }
+                  });
+                } else {
+                  $$renderer3.push("<!--[-1-->");
+                  Badge($$renderer3, {
+                    variant: "info",
+                    size: "xs",
+                    "aria-label": "Outcome: still racing",
+                    children: ($$renderer4) => {
+                      $$renderer4.push(`<!---->Racing`);
+                    },
+                    $$slots: { default: true }
+                  });
+                }
+                $$renderer3.push(`<!--]--></div> <ol class="cinder-run-step-timeline cinder-run-step-timeline__lane-steps"${$2.attr("aria-label", `${lane.label ?? lane.id} steps`)}>`);
+                stepRail($$renderer3, laneRows(lane));
+                $$renderer3.push(`<!----></ol></li>`);
+              }
+              $$renderer3.push(`<!--]--></ul>`);
+            },
+            $$slots: { trigger: true, default: true }
+          });
+        }
+        $$renderer2.push(`<!----></div></div></li>`);
+      } else if (entry.kind === "depth-limit") {
+        $$renderer2.push("<!--[1-->");
+        depthLimitItem($$renderer2, entry);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+        stepItem($$renderer2, entry);
+      }
+      $$renderer2.push(`<!--]-->`);
+    }
+    $$renderer2.push(`<!--]--></ol>`);
+  }, Run_step_timeline);
+}
+
+// src/components/run-step-timeline/index.ts
+var run_step_timeline_default = Run_step_timeline;
+export { Run_step_timeline, run_step_timeline_default };
+
+//# debugId=30B377135A5A317664756E2164756E21