@hachej/boring-deck 0.1.20

package/dist/front/index.js

@@ -0,0 +1,1159 @@
+// src/front/index.tsx
+import {
+  WorkspaceFilesProvider,
+  useHasWorkspaceFilesProvider
+} from "@hachej/boring-workspace";
+import { definePlugin } from "@hachej/boring-workspace/plugin";
+
+// src/shared/constants.ts
+var DECK_PLUGIN_ID = "deck";
+var DECK_PANEL_ID = "deck";
+var DECK_LABEL = "Deck";
+var DECK_PATH_PREFIX = "deck/";
+
+// src/shared/path.ts
+function normalizeDeckPath(path) {
+  const trimmed = path.trim().replace(/\\/g, "/");
+  const noLeadingDot = trimmed.replace(/^\.\//, "");
+  return noLeadingDot.replace(/\/+/g, "/");
+}
+function isDeckMarkdownPath(path, pathPrefix = "deck/") {
+  const normalized = normalizeDeckPath(path);
+  const normalizedPathPrefix = normalizeDeckPath(pathPrefix);
+  const normalizedPrefix = normalizedPathPrefix.endsWith("/") ? normalizedPathPrefix : `${normalizedPathPrefix}/`;
+  if (!normalized.endsWith(".md")) return false;
+  if (normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized)) return false;
+  if (normalized.split("/").some((segment) => segment === "..")) return false;
+  return normalized.startsWith(normalizedPrefix);
+}
+
+// src/shared/parser.ts
+var TITLE_RX = /^##\s+title:\s*(.+)$/i;
+var YAML_TITLE_RX = /^title:\s*(.+)$/i;
+var YAML_KV_RX = /^[A-Za-z][\w-]*:\s*.*$/;
+var FENCE_RX = /^(```|~~~)/;
+var WIDGET_OPEN = "{{";
+var WIDGET_CLOSE = "}}";
+var WIDGET_NAME_RX = /^[A-Za-z][\w-]*$/;
+var ATTR_KEY_RX = /^[A-Za-z][\w-]*$/;
+function splitSlides(input) {
+  const slides = [];
+  let current = [];
+  let fenceMarker = null;
+  for (const line of input.split("\n")) {
+    const trimmed = line.trim();
+    const fence = FENCE_RX.exec(trimmed);
+    if (fence) {
+      if (fenceMarker === fence[1]) fenceMarker = null;
+      else if (fenceMarker === null) fenceMarker = fence[1];
+    }
+    if (fenceMarker === null && trimmed === "---") {
+      slides.push(current.join("\n").trim());
+      current = [];
+      continue;
+    }
+    current.push(line);
+  }
+  slides.push(current.join("\n").trim());
+  const nonEmpty = slides.filter((slide) => slide.length > 0);
+  if (nonEmpty.length > 0) return nonEmpty;
+  return [""];
+}
+function parseWidgetAttrs(raw) {
+  const parsed = tryParseWidgetAttrs(raw);
+  if (parsed == null) throw new Error(`Malformed widget attrs: ${raw}`);
+  return parsed;
+}
+function parseDeckMarkdown(input) {
+  const lines = input.split("\n");
+  let start = 0;
+  while (start < lines.length && lines[start].trim() === "") start += 1;
+  let title = stripYamlFrontmatter(lines, start);
+  while (start < lines.length && lines[start].trim() === "") start += 1;
+  if (!title && lines[start]?.trim() === "---") {
+    lines.splice(start, 1);
+  }
+  let sawFence = false;
+  for (let i = 0; i < lines.length; i += 1) {
+    const trimmed = lines[i].trim();
+    if (FENCE_RX.test(trimmed)) sawFence = !sawFence;
+    if (!sawFence && trimmed === "---") break;
+    const match = TITLE_RX.exec(trimmed);
+    if (match) {
+      title = title ?? stripQuotes(match[1].trim());
+      lines.splice(i, 1);
+      if (lines[i]?.trim() === "") lines.splice(i, 1);
+      break;
+    }
+  }
+  const slides = splitSlides(lines.join("\n")).map((raw, index, all) => ({
+    index,
+    raw,
+    segments: tokenize(raw, index, all.length)
+  }));
+  return title ? { title, slides } : { slides };
+}
+function stripYamlFrontmatter(lines, start) {
+  if (lines[start]?.trim() !== "---") return void 0;
+  let end = -1;
+  for (let i = start + 1; i < lines.length; i += 1) {
+    if (lines[i].trim() === "---") {
+      end = i;
+      break;
+    }
+  }
+  if (end === -1) return void 0;
+  const fields = lines.slice(start + 1, end);
+  if (fields.length === 0 || !fields.every((line) => YAML_KV_RX.test(line.trim()))) return void 0;
+  const titleLine = fields.find((line) => YAML_TITLE_RX.test(line.trim()));
+  const title = titleLine?.trim().match(YAML_TITLE_RX)?.[1]?.trim();
+  lines.splice(start, end - start + 1);
+  while (start < lines.length && lines[start]?.trim() === "") lines.splice(start, 1);
+  return title ? stripQuotes(title) : void 0;
+}
+function tokenize(markdown, slideIndex, slideCount) {
+  const segments = [];
+  const lines = markdown.split("\n");
+  let fenceMarker = null;
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    const line = lines[lineIndex];
+    const trimmed = line.trim();
+    const fence = FENCE_RX.exec(trimmed);
+    if (fence) {
+      if (fenceMarker === fence[1]) fenceMarker = null;
+      else if (fenceMarker === null) fenceMarker = fence[1];
+      pushMarkdown(segments, line);
+      if (lineIndex < lines.length - 1) pushMarkdown(segments, "\n");
+      continue;
+    }
+    if (fenceMarker) {
+      pushMarkdown(segments, line);
+      if (lineIndex < lines.length - 1) pushMarkdown(segments, "\n");
+      continue;
+    }
+    for (const segment of tokenizeLine(line, slideIndex, slideCount)) {
+      if (segment.type === "markdown") pushMarkdown(segments, segment.text);
+      else segments.push(segment);
+    }
+    if (lineIndex < lines.length - 1) pushMarkdown(segments, "\n");
+  }
+  return segments.length > 0 ? segments : [{ type: "markdown", text: "" }];
+}
+function tokenizeLine(line, _slideIndex, _slideCount) {
+  const segments = [];
+  let markdown = "";
+  let i = 0;
+  while (i < line.length) {
+    if (line[i] === "`") {
+      const tickCount = countRepeated(line, i, "`");
+      const close = line.indexOf("`".repeat(tickCount), i + tickCount);
+      if (close === -1) {
+        markdown += line.slice(i);
+        break;
+      }
+      markdown += line.slice(i, close + tickCount);
+      i = close + tickCount;
+      continue;
+    }
+    if (line.startsWith(WIDGET_OPEN, i)) {
+      const close = line.indexOf(WIDGET_CLOSE, i + WIDGET_OPEN.length);
+      if (close === -1) {
+        markdown += line.slice(i);
+        break;
+      }
+      const raw = line.slice(i, close + WIDGET_CLOSE.length);
+      const parsed = parseWidget(raw, line);
+      if (!parsed) {
+        markdown += raw;
+        i = close + WIDGET_CLOSE.length;
+        continue;
+      }
+      if (markdown) {
+        segments.push({ type: "markdown", text: markdown });
+        markdown = "";
+      }
+      segments.push(parsed);
+      i = close + WIDGET_CLOSE.length;
+      continue;
+    }
+    markdown += line[i];
+    i += 1;
+  }
+  if (markdown) segments.push({ type: "markdown", text: markdown });
+  return segments;
+}
+function parseWidget(raw, line) {
+  const inner = raw.slice(WIDGET_OPEN.length, -WIDGET_CLOSE.length).trim();
+  if (!inner) return null;
+  const firstSpace = inner.search(/\s/);
+  const name = firstSpace === -1 ? inner : inner.slice(0, firstSpace);
+  const attrsRaw = firstSpace === -1 ? "" : inner.slice(firstSpace).trim();
+  if (!WIDGET_NAME_RX.test(name)) return null;
+  let attrs;
+  try {
+    attrs = attrsRaw ? parseWidgetAttrs(attrsRaw) : {};
+  } catch {
+    return null;
+  }
+  return {
+    type: "widget",
+    name,
+    attrs,
+    raw,
+    position: line.trim() === raw.trim() ? "block" : "inline"
+  };
+}
+function tryParseWidgetAttrs(raw) {
+  const attrs = {};
+  let i = 0;
+  while (i < raw.length) {
+    while (i < raw.length && /\s/.test(raw[i])) i += 1;
+    if (i >= raw.length) break;
+    const keyStart = i;
+    while (i < raw.length && /[A-Za-z0-9_-]/.test(raw[i])) i += 1;
+    const key = raw.slice(keyStart, i);
+    if (!ATTR_KEY_RX.test(key)) return null;
+    while (i < raw.length && /\s/.test(raw[i])) i += 1;
+    if (raw[i] !== "=") return null;
+    i += 1;
+    while (i < raw.length && /\s/.test(raw[i])) i += 1;
+    if (raw[i] !== '"') return null;
+    i += 1;
+    let value = "";
+    let closed = false;
+    while (i < raw.length) {
+      const char = raw[i];
+      if (char === "\\") {
+        const next = raw[i + 1];
+        if (next === void 0) return null;
+        value += next;
+        i += 2;
+        continue;
+      }
+      if (char === '"') {
+        i += 1;
+        closed = true;
+        break;
+      }
+      value += char;
+      i += 1;
+    }
+    if (!closed) return null;
+    attrs[key] = value;
+  }
+  while (i < raw.length && /\s/.test(raw[i])) i += 1;
+  if (i !== raw.length) return null;
+  return attrs;
+}
+function pushMarkdown(segments, text) {
+  if (text.length === 0) return;
+  const last = segments[segments.length - 1];
+  if (last?.type === "markdown") last.text += text;
+  else segments.push({ type: "markdown", text });
+}
+function stripQuotes(value) {
+  return value.replace(/^['"]|['"]$/g, "");
+}
+function countRepeated(value, start, needle) {
+  let count = 0;
+  while (value[start + count] === needle) count += 1;
+  return count;
+}
+
+// src/front/DeckPane.tsx
+import {
+  cn as cn2,
+  MarkdownEditor,
+  useFilePane,
+  useFullPagePanelHref,
+  useIsFullPagePanel
+} from "@hachej/boring-workspace";
+import { Button as Button2 } from "@hachej/boring-ui-kit";
+import { ExternalLink } from "lucide-react";
+import { Fragment, useEffect, useMemo, useState } from "react";
+import ReactMarkdown from "react-markdown";
+import remarkGfm from "remark-gfm";
+
+// src/front/components.tsx
+import { cn } from "@hachej/boring-workspace";
+import { Button, SegmentedControl, SegmentedControlItem, Separator } from "@hachej/boring-ui-kit";
+import { ChevronLeft, ChevronRight, Maximize2, Minimize2 } from "lucide-react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function DeckScaffoldState({ children }) {
+  return /* @__PURE__ */ jsx("div", { className: "p-4 text-sm text-muted-foreground", children });
+}
+function DeckErrorState({ title, description }) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: "flex min-h-0 flex-1 items-center justify-center p-6",
+      "data-testid": "deck-error-state",
+      children: /* @__PURE__ */ jsxs("div", { className: "max-w-lg rounded-xl border border-destructive/20 bg-destructive/5 p-4 text-sm", children: [
+        /* @__PURE__ */ jsx("div", { className: "font-medium text-foreground", children: title }),
+        /* @__PURE__ */ jsx("div", { className: "mt-1 text-muted-foreground", children: description })
+      ] })
+    }
+  );
+}
+function DeckShell({ children, theme, presentMode = false }) {
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn(
+        "deck-root flex min-h-0 flex-1 flex-col bg-background text-foreground",
+        presentMode && "min-h-screen bg-background",
+        theme?.className
+      ),
+      "data-testid": presentMode ? "deck-shell-present" : "deck-shell-read",
+      children: [
+        children,
+        /* @__PURE__ */ jsx("style", { children: `
+        .deck-root { --deck-accent: oklch(0.62 0.14 65); }
+        .dark .deck-root { --deck-accent: oklch(0.76 0.16 68); }
+        .deck-slide-frame-shell {
+          animation: deck-slide-enter 240ms cubic-bezier(0.22, 1, 0.36, 1);
+        }
+        @keyframes deck-slide-enter {
+          from { opacity: 0; transform: translateY(6px); }
+          to { opacity: 1; transform: translateY(0); }
+        }
+        @media (prefers-reduced-motion: reduce) {
+          .deck-slide-frame-shell { animation: none; }
+        }
+      ` })
+      ]
+    }
+  );
+}
+function DeckSlideFrame({ children, theme }) {
+  const aspectRatio = theme?.aspectRatio === "4:3" ? "4 / 3" : "16 / 9";
+  return /* @__PURE__ */ jsx("div", { className: "flex min-h-0 flex-1 items-center justify-center p-3 sm:p-6", children: /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cn(
+        "deck-slide-frame-shell flex w-full max-w-6xl overflow-hidden rounded-2xl border border-border/70 bg-card shadow-[0_1px_0_oklch(from_var(--foreground)_l_c_h/0.04),0_24px_60px_-30px_oklch(from_var(--foreground)_l_c_h/0.45)]",
+        theme?.slideClassName
+      ),
+      "data-testid": "deck-slide-frame",
+      style: { aspectRatio },
+      children: /* @__PURE__ */ jsx("div", { className: "min-h-0 min-w-0 flex-1 overflow-auto p-6 sm:p-10", children })
+    }
+  ) });
+}
+function DeckToolbar({
+  title,
+  path,
+  mode,
+  onModeChange,
+  presentMode,
+  slideIndex,
+  slideCount,
+  onTogglePresentMode,
+  actions
+}) {
+  return /* @__PURE__ */ jsxs("header", { className: "flex items-center justify-between gap-3 border-b border-border/60 bg-background/60 px-4 py-2 backdrop-blur-[2px]", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex min-w-0 items-baseline gap-3", children: [
+      /* @__PURE__ */ jsx("span", { className: "font-mono text-[10px] uppercase tracking-[0.22em] text-[color:var(--deck-accent)]", children: "Deck" }),
+      /* @__PURE__ */ jsx("span", { className: "truncate text-[13px] font-medium tracking-tight text-foreground", children: title || "Deck" }),
+      path ? /* @__PURE__ */ jsx("span", { className: "hidden truncate font-mono text-[11px] text-muted-foreground/70 sm:inline", children: path }) : null
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "flex shrink-0 items-center gap-2", children: [
+      onModeChange ? /* @__PURE__ */ jsx(SegmentedControl, { "aria-label": "Deck mode", className: "bg-background", children: ["read", "edit"].map((nextMode) => /* @__PURE__ */ jsx(
+        SegmentedControlItem,
+        {
+          type: "button",
+          selected: mode === nextMode,
+          onClick: () => onModeChange(nextMode),
+          "aria-pressed": mode === nextMode,
+          className: "px-2.5 py-1 text-[11px]",
+          "data-testid": nextMode === "read" ? "deck-mode-read" : "deck-mode-edit",
+          children: nextMode === "read" ? "Read" : "Edit"
+        },
+        nextMode
+      )) }) : null,
+      actions,
+      slideCount > 0 ? /* @__PURE__ */ jsxs("span", { className: "hidden font-mono text-[11px] tabular-nums tracking-tight text-muted-foreground sm:inline", children: [
+        "Slide ",
+        slideIndex + 1,
+        " of ",
+        slideCount
+      ] }) : null,
+      onTogglePresentMode ? /* @__PURE__ */ jsx(
+        Button,
+        {
+          type: "button",
+          variant: "ghost",
+          size: "icon-xs",
+          onClick: onTogglePresentMode,
+          "aria-label": presentMode ? "Exit present mode" : "Present",
+          title: presentMode ? "Exit present mode" : "Present",
+          "data-testid": "deck-toggle-present",
+          children: presentMode ? /* @__PURE__ */ jsx(Minimize2, { className: "size-3.5" }) : /* @__PURE__ */ jsx(Maximize2, { className: "size-3.5" })
+        }
+      ) : null
+    ] })
+  ] });
+}
+function DeckSlideRail({
+  slideIndex,
+  slideCount,
+  canGoPrevious,
+  canGoNext,
+  onPrevious,
+  onNext,
+  onSelect
+}) {
+  if (slideCount <= 1) return null;
+  return /* @__PURE__ */ jsxs("footer", { className: "flex shrink-0 items-center gap-3 border-t border-border/60 bg-background/60 px-4 py-2", children: [
+    /* @__PURE__ */ jsxs(
+      Button,
+      {
+        type: "button",
+        variant: "ghost",
+        size: "xs",
+        onClick: onPrevious,
+        disabled: !canGoPrevious,
+        "aria-label": "Previous slide",
+        "data-testid": "deck-prev",
+        children: [
+          /* @__PURE__ */ jsx(ChevronLeft, { className: "size-3.5" }),
+          "Prev"
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs("div", { className: "flex flex-1 items-center justify-center gap-2.5", children: [
+      /* @__PURE__ */ jsx("span", { className: "font-mono text-[11px] tabular-nums tracking-tight text-foreground", children: String(slideIndex + 1).padStart(2, "0") }),
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          role: "group",
+          "aria-label": "Slide navigation",
+          className: "flex max-w-[60%] flex-1 items-center gap-0.5 overflow-x-auto",
+          children: Array.from({ length: slideCount }, (_, index) => {
+            const isActive = index === slideIndex;
+            const label = `Slide ${index + 1}`;
+            return /* @__PURE__ */ jsxs(
+              Button,
+              {
+                type: "button",
+                variant: "ghost",
+                size: "icon-xs",
+                "aria-current": isActive ? "true" : void 0,
+                "aria-label": label,
+                onClick: () => onSelect?.(index),
+                className: "group flex flex-1 min-w-[28px] max-w-[56px] cursor-pointer items-center justify-center px-0.5 py-2.5",
+                children: [
+                  /* @__PURE__ */ jsx("span", { className: "sr-only", children: label }),
+                  /* @__PURE__ */ jsx(
+                    "span",
+                    {
+                      "aria-hidden": true,
+                      className: cn(
+                        "block h-1 w-full rounded-full transition-colors",
+                        isActive ? "bg-[color:var(--deck-accent)]" : "bg-border group-hover:bg-muted-foreground/40 group-focus-visible:bg-muted-foreground/40"
+                      )
+                    }
+                  )
+                ]
+              },
+              index
+            );
+          })
+        }
+      ),
+      /* @__PURE__ */ jsx("span", { className: "font-mono text-[11px] tabular-nums tracking-tight text-muted-foreground", children: String(slideCount).padStart(2, "0") })
+    ] }),
+    /* @__PURE__ */ jsx(Separator, { orientation: "vertical", className: "!h-5" }),
+    /* @__PURE__ */ jsxs(
+      Button,
+      {
+        type: "button",
+        variant: "ghost",
+        size: "xs",
+        onClick: onNext,
+        disabled: !canGoNext,
+        "aria-label": "Next slide",
+        "data-testid": "deck-next",
+        children: [
+          "Next",
+          /* @__PURE__ */ jsx(ChevronRight, { className: "size-3.5" })
+        ]
+      }
+    )
+  ] });
+}
+function DeckNotice({
+  title,
+  description,
+  actions,
+  tone = "warning",
+  testId
+}) {
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn(
+        "mx-3 mt-3 rounded-xl border p-3 text-sm",
+        tone === "error" ? "border-destructive/20 bg-destructive/5" : "border-amber-500/20 bg-amber-500/5"
+      ),
+      "data-testid": testId,
+      children: [
+        /* @__PURE__ */ jsx("div", { className: "font-medium text-foreground", children: title }),
+        /* @__PURE__ */ jsx("div", { className: "mt-1 text-muted-foreground", children: description }),
+        actions ? /* @__PURE__ */ jsx("div", { className: "mt-3 flex items-center gap-2", children: actions }) : null
+      ]
+    }
+  );
+}
+
+// src/front/widgets.tsx
+import { Component } from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function validateDeckWidgets(widgets) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const widget of widgets) {
+    if (seen.has(widget.name)) {
+      throw new Error(`Duplicate deck widget name: ${widget.name}`);
+    }
+    seen.add(widget.name);
+  }
+  return widgets;
+}
+function indexDeckWidgets(widgets) {
+  const indexed = /* @__PURE__ */ new Map();
+  for (const widget of validateDeckWidgets(widgets)) indexed.set(widget.name, widget);
+  return {
+    get(name) {
+      return indexed.get(name);
+    },
+    entries() {
+      return indexed.entries();
+    }
+  };
+}
+function DeckWidgetSlot({ segment, widgets, context }) {
+  const widget = widgets.get(segment.name);
+  if (!widget) {
+    return /* @__PURE__ */ jsx2(DeckWidgetPlaceholder, { name: segment.name, position: segment.position, reason: "Unknown widget" });
+  }
+  const display = widget.display ?? segment.position;
+  try {
+    const attrs = widget.parse ? widget.parse(segment.attrs) : segment.attrs;
+    return /* @__PURE__ */ jsx2(DeckWidgetErrorBoundary, { name: segment.name, position: display, children: /* @__PURE__ */ jsx2(DeckWidgetFrame, { position: display, children: widget.render({ attrs, rawAttrs: segment.attrs, context }) }) });
+  } catch (error) {
+    return /* @__PURE__ */ jsx2(
+      DeckWidgetPlaceholder,
+      {
+        name: segment.name,
+        position: display,
+        reason: error instanceof Error ? error.message : "Widget failed"
+      }
+    );
+  }
+}
+function DeckWidgetFrame({ position, children }) {
+  if (position === "inline") {
+    return /* @__PURE__ */ jsx2("span", { "data-testid": "deck-widget-inline", children });
+  }
+  return /* @__PURE__ */ jsx2("div", { "data-testid": "deck-widget-block", children });
+}
+function DeckWidgetPlaceholder({
+  name,
+  position,
+  reason
+}) {
+  const content = /* @__PURE__ */ jsxs2("span", { className: "text-xs text-muted-foreground", "data-testid": "deck-widget-placeholder", children: [
+    reason,
+    ": ",
+    name
+  ] });
+  return position === "inline" ? /* @__PURE__ */ jsx2("span", { children: content }) : /* @__PURE__ */ jsx2("div", { children: content });
+}
+var DeckWidgetErrorBoundary = class extends Component {
+  state = { error: null };
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(_error, _info) {
+  }
+  componentDidUpdate(prevProps) {
+    if (this.state.error && prevProps.children !== this.props.children) {
+      this.setState({ error: null });
+    }
+  }
+  render() {
+    if (this.state.error) {
+      return /* @__PURE__ */ jsx2(
+        DeckWidgetPlaceholder,
+        {
+          name: this.props.name,
+          position: this.props.position,
+          reason: this.state.error.message || "Widget failed"
+        }
+      );
+    }
+    return this.props.children;
+  }
+};
+
+// src/front/DeckPane.tsx
+import { Fragment as Fragment2, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var DEFAULT_SCAFFOLD_CONTENT = `# Deck scaffold
+
+Deck rendering shell is ready.`;
+function useDeckKeyboardNavigation({
+  enabled,
+  canGoPrevious,
+  canGoNext,
+  onPrevious,
+  onNext
+}) {
+  useEffect(() => {
+    if (!enabled) return;
+    const onKeyDown = (event) => {
+      if (event.metaKey || event.ctrlKey || event.altKey) return;
+      const target = event.target;
+      if (target && (target.tagName === "INPUT" || target.tagName === "TEXTAREA" || target.isContentEditable)) {
+        return;
+      }
+      if ((event.key === "ArrowRight" || event.key === "PageDown") && canGoNext) {
+        event.preventDefault();
+        onNext();
+        return;
+      }
+      if ((event.key === "ArrowLeft" || event.key === "PageUp") && canGoPrevious) {
+        event.preventDefault();
+        onPrevious();
+      }
+    };
+    window.addEventListener("keydown", onKeyDown);
+    return () => window.removeEventListener("keydown", onKeyDown);
+  }, [enabled, canGoNext, canGoPrevious, onNext, onPrevious]);
+}
+function DeckPane(props) {
+  if (props.content === void 0 && props.params?.path) {
+    return /* @__PURE__ */ jsx3(FileBackedDeckPane, { ...props });
+  }
+  return /* @__PURE__ */ jsx3(
+    DeckRenderedPane,
+    {
+      ...props,
+      content: props.content ?? DEFAULT_SCAFFOLD_CONTENT,
+      initialMode: props.initialMode === "edit" ? "read" : props.initialMode ?? "read"
+    }
+  );
+}
+function DeckRenderedPane({
+  params,
+  content,
+  pathPrefix = "deck/",
+  theme,
+  widgets = [],
+  onError,
+  initialMode = "read"
+}) {
+  const isFullPagePanel = useIsFullPagePanel();
+  const resolvedInitialMode = isFullPagePanel ? "present" : initialMode;
+  const [mode, setMode] = useState(resolvedInitialMode);
+  const [slideIndex, setSlideIndex] = useState(0);
+  const indexedWidgets = useMemo(() => indexDeckWidgets(widgets), [widgets]);
+  const parsed = useMemo(() => parseDeckContent(content, params?.path), [content, params?.path]);
+  useEffect(() => {
+    if (!parsed.ok) onError?.(parsed.error);
+  }, [onError, parsed]);
+  useEffect(() => {
+    setMode(resolvedInitialMode);
+  }, [resolvedInitialMode]);
+  useEffect(() => {
+    setSlideIndex(0);
+  }, [content, params?.path]);
+  if (!content) {
+    return /* @__PURE__ */ jsx3(DeckShell, { theme, presentMode: mode === "present", children: /* @__PURE__ */ jsxs3(DeckScaffoldState, { children: [
+      "Deck shell for ",
+      pathPrefix,
+      params?.path ? ` (${params.path})` : ""
+    ] }) });
+  }
+  if (!parsed.ok) {
+    return /* @__PURE__ */ jsx3(DeckShell, { theme, presentMode: mode === "present", children: /* @__PURE__ */ jsx3(DeckErrorState, { title: "Failed to render deck", description: parsed.error.message }) });
+  }
+  const slides = parsed.deck.slides;
+  const safeIndex = Math.min(Math.max(slideIndex, 0), Math.max(slides.length - 1, 0));
+  const currentSlide = slides[safeIndex];
+  const title = parsed.deck.title ?? params?.path ?? "Deck";
+  const presentMode = mode === "present";
+  const hidePresentationControls = shouldHidePresentationControls({
+    isFullPagePanel,
+    params,
+    presentMode
+  });
+  useDeckKeyboardNavigation({
+    enabled: true,
+    canGoPrevious: safeIndex > 0,
+    canGoNext: safeIndex < slides.length - 1,
+    onPrevious: () => setSlideIndex((current) => Math.max(current - 1, 0)),
+    onNext: () => setSlideIndex((current) => Math.min(current + 1, slides.length - 1))
+  });
+  return /* @__PURE__ */ jsxs3(DeckShell, { theme, presentMode, children: [
+    !hidePresentationControls ? /* @__PURE__ */ jsx3(
+      DeckToolbar,
+      {
+        title,
+        path: params?.path,
+        presentMode,
+        slideIndex: safeIndex,
+        slideCount: slides.length,
+        onTogglePresentMode: () => setMode((current) => current === "present" ? "read" : "present")
+      }
+    ) : null,
+    /* @__PURE__ */ jsx3(DeckSlideFrame, { theme, children: /* @__PURE__ */ jsx3(
+      "article",
+      {
+        className: cn2("prose prose-slate max-w-none dark:prose-invert", presentMode && "text-base"),
+        "data-testid": "deck-slide-content",
+        children: /* @__PURE__ */ jsx3(
+          DeckSlideContent,
+          {
+            slide: currentSlide,
+            slideCount: slides.length,
+            path: params?.path,
+            mode,
+            widgets: indexedWidgets
+          }
+        )
+      }
+    ) }),
+    !hidePresentationControls ? /* @__PURE__ */ jsx3(
+      DeckSlideRail,
+      {
+        slideIndex: safeIndex,
+        slideCount: slides.length,
+        canGoPrevious: safeIndex > 0,
+        canGoNext: safeIndex < slides.length - 1,
+        onPrevious: () => setSlideIndex((current) => Math.max(current - 1, 0)),
+        onNext: () => setSlideIndex((current) => Math.min(current + 1, slides.length - 1)),
+        onSelect: setSlideIndex
+      }
+    ) : null
+  ] });
+}
+function FileBackedDeckPane({
+  params,
+  api,
+  theme,
+  widgets = [],
+  onError,
+  initialMode = "read",
+  getPresentHref
+}) {
+  const path = params?.path ?? "";
+  const hasSelectedPath = /\S/.test(path);
+  const isFullPagePanel = useIsFullPagePanel();
+  const resolvedInitialMode = isFullPagePanel ? "present" : initialMode;
+  const [mode, setMode] = useState(resolvedInitialMode);
+  const [slideIndex, setSlideIndex] = useState(0);
+  const indexedWidgets = useMemo(() => indexDeckWidgets(widgets), [widgets]);
+  const {
+    content,
+    conflict,
+    error,
+    fileName,
+    isLoading,
+    onOverwrite,
+    onReloadFromServer,
+    setContent,
+    tabTitle
+  } = useFilePane({ path, panelId: api?.id });
+  const parsed = useMemo(() => content == null ? null : parseDeckContent(content, path), [content, path]);
+  useEffect(() => {
+    if (error) {
+      onError?.({
+        type: "storage",
+        path,
+        message: error.message,
+        cause: error
+      });
+    }
+  }, [error, onError, path]);
+  useEffect(() => {
+    if (conflict) {
+      onError?.({
+        type: "conflict",
+        path,
+        message: conflict.message,
+        cause: conflict
+      });
+    }
+  }, [conflict, onError, path]);
+  useEffect(() => {
+    if (parsed && !parsed.ok) onError?.(parsed.error);
+  }, [onError, parsed]);
+  useEffect(() => {
+    setMode(resolvedInitialMode);
+  }, [resolvedInitialMode]);
+  useEffect(() => {
+    setSlideIndex(0);
+  }, [content, path]);
+  useEffect(() => {
+    if (api && tabTitle) {
+      api.setTitle(tabTitle);
+    }
+  }, [api, tabTitle]);
+  const deck = parsed && parsed.ok ? parsed.deck : null;
+  const fallbackContent = content ?? "";
+  const slides = deck?.slides ?? [{ index: 0, raw: fallbackContent, segments: [{ type: "markdown", text: fallbackContent }] }];
+  const slideCount = slides.length;
+  const safeIndex = Math.min(Math.max(slideIndex, 0), Math.max(slideCount - 1, 0));
+  const currentSlide = slides[safeIndex];
+  const title = deck?.title ?? fileName ?? path;
+  const canNavigateSlides = mode !== "edit";
+  const fullPageHref = useFullPagePanelHref({
+    componentId: DECK_PANEL_ID,
+    params: path ? { path } : void 0
+  });
+  const presentHref = isFullPagePanel ? null : path ? getPresentHref?.(path) ?? fullPageHref : null;
+  const hidePresentationControls = shouldHidePresentationControls({
+    isFullPagePanel,
+    params,
+    presentMode: mode === "present"
+  });
+  useDeckKeyboardNavigation({
+    enabled: hasSelectedPath && !error && content != null && mode !== "edit",
+    canGoPrevious: safeIndex > 0,
+    canGoNext: safeIndex < slideCount - 1,
+    onPrevious: () => setSlideIndex((current) => Math.max(current - 1, 0)),
+    onNext: () => setSlideIndex((current) => Math.min(current + 1, slideCount - 1))
+  });
+  if (!hasSelectedPath) {
+    return /* @__PURE__ */ jsx3(DeckShell, { theme, children: /* @__PURE__ */ jsx3(DeckScaffoldState, { children: "No deck file selected." }) });
+  }
+  if (isLoading && content == null) {
+    return /* @__PURE__ */ jsx3(DeckShell, { theme, children: /* @__PURE__ */ jsx3(DeckScaffoldState, { children: "Loading deck\u2026" }) });
+  }
+  if (error || content == null) {
+    return /* @__PURE__ */ jsx3(DeckShell, { theme, children: /* @__PURE__ */ jsx3(DeckErrorState, { title: "Failed to load deck", description: error?.message ?? "Preview unavailable." }) });
+  }
+  return /* @__PURE__ */ jsxs3(DeckShell, { theme, presentMode: mode === "present", children: [
+    !hidePresentationControls ? /* @__PURE__ */ jsx3(
+      DeckToolbar,
+      {
+        title,
+        path,
+        mode: mode === "present" ? "read" : mode,
+        onModeChange: isFullPagePanel ? void 0 : setMode,
+        presentMode: mode === "present",
+        slideIndex: safeIndex,
+        slideCount,
+        onTogglePresentMode: mode === "edit" ? void 0 : () => setMode((current) => current === "present" ? "read" : "present"),
+        actions: /* @__PURE__ */ jsx3(Fragment2, { children: presentHref ? /* @__PURE__ */ jsx3(
+          Button2,
+          {
+            variant: "ghost",
+            size: "icon-xs",
+            asChild: true,
+            "aria-label": "Open in new tab",
+            title: "Open deck in new tab",
+            children: /* @__PURE__ */ jsx3("a", { href: presentHref, target: "_blank", rel: "noopener noreferrer", "data-testid": "deck-open-present", children: /* @__PURE__ */ jsx3(ExternalLink, { className: "size-3.5" }) })
+          }
+        ) : null })
+      }
+    ) : null,
+    conflict ? /* @__PURE__ */ jsx3(
+      DeckNotice,
+      {
+        title: "Deck changed on disk",
+        description: "Choose whether to reload the server version or overwrite it with your current draft.",
+        testId: "deck-conflict-notice",
+        actions: /* @__PURE__ */ jsxs3(Fragment2, { children: [
+          /* @__PURE__ */ jsx3(
+            Button2,
+            {
+              type: "button",
+              variant: "outline",
+              size: "xs",
+              onClick: () => void onReloadFromServer(),
+              "data-testid": "deck-reload",
+              children: "Reload"
+            }
+          ),
+          /* @__PURE__ */ jsx3(
+            Button2,
+            {
+              type: "button",
+              variant: "outline",
+              size: "xs",
+              onClick: () => void onOverwrite(),
+              "data-testid": "deck-overwrite",
+              children: "Overwrite"
+            }
+          )
+        ] })
+      }
+    ) : null,
+    mode === "edit" ? /* @__PURE__ */ jsxs3("div", { className: "min-h-0 flex-1 overflow-hidden", "data-testid": "deck-edit-mode", children: [
+      parsed && !parsed.ok ? /* @__PURE__ */ jsx3(
+        DeckNotice,
+        {
+          title: "Deck markdown has parse errors",
+          description: parsed.error.message,
+          tone: "error",
+          testId: "deck-parse-notice"
+        }
+      ) : null,
+      /* @__PURE__ */ jsx3(
+        MarkdownEditor,
+        {
+          content,
+          onChange: setContent,
+          documentPath: path,
+          className: "min-h-0 h-full"
+        }
+      )
+    ] }) : parsed && !parsed.ok ? /* @__PURE__ */ jsx3(DeckErrorState, { title: "Failed to render deck", description: parsed.error.message }) : /* @__PURE__ */ jsx3(DeckSlideFrame, { theme, children: /* @__PURE__ */ jsx3(
+      "article",
+      {
+        className: cn2("prose prose-slate max-w-none dark:prose-invert", mode === "present" && "text-base"),
+        "data-testid": "deck-slide-content",
+        children: /* @__PURE__ */ jsx3(
+          DeckSlideContent,
+          {
+            slide: currentSlide,
+            slideCount,
+            path,
+            mode: mode === "present" ? "present" : "read",
+            widgets: indexedWidgets
+          }
+        )
+      }
+    ) }),
+    mode !== "edit" && !hidePresentationControls ? /* @__PURE__ */ jsx3(
+      DeckSlideRail,
+      {
+        slideIndex: safeIndex,
+        slideCount,
+        canGoPrevious: canNavigateSlides && safeIndex > 0,
+        canGoNext: canNavigateSlides && safeIndex < slideCount - 1,
+        onPrevious: () => setSlideIndex((current) => Math.max(current - 1, 0)),
+        onNext: () => setSlideIndex((current) => Math.min(current + 1, slideCount - 1)),
+        onSelect: setSlideIndex
+      }
+    ) : null
+  ] });
+}
+function shouldHidePresentationControls({
+  isFullPagePanel,
+  params,
+  presentMode
+}) {
+  if (!presentMode) return false;
+  if (params?.showControls === true || params?.controls === "visible") return false;
+  if (params?.showControls === false || params?.controls === "hidden") return true;
+  return isFullPagePanel;
+}
+function DeckSlideContent({ slide, slideCount, path, mode, widgets }) {
+  const blocks = [];
+  let inlineRun = [];
+  const flushInlineRun = () => {
+    if (inlineRun.length === 0) return;
+    blocks.push(/* @__PURE__ */ jsx3("p", { children: inlineRun }, `inline-run-${slide.index}-${blocks.length}`));
+    inlineRun = [];
+  };
+  slide.segments.forEach((segment, index) => {
+    const context = {
+      path,
+      slideIndex: slide.index,
+      slideCount,
+      mode
+    };
+    if (segment.type === "markdown") {
+      if (isInlineCompatibleMarkdown(segment.text)) {
+        inlineRun.push(
+          /* @__PURE__ */ jsx3(InlineMarkdownSegment, { text: segment.text }, `inline-markdown-${slide.index}-${index}`)
+        );
+        return;
+      }
+      flushInlineRun();
+      blocks.push(/* @__PURE__ */ jsx3(MarkdownSegment, { text: segment.text }, `markdown-${slide.index}-${index}`));
+      return;
+    }
+    const widget = widgets.get(segment.name);
+    const display = widget?.display ?? segment.position;
+    if (display === "inline") {
+      inlineRun.push(
+        /* @__PURE__ */ jsx3(
+          DeckWidgetSlot,
+          {
+            segment,
+            widgets,
+            context
+          },
+          `widget-${slide.index}-${index}`
+        )
+      );
+      return;
+    }
+    flushInlineRun();
+    blocks.push(
+      /* @__PURE__ */ jsx3(
+        DeckWidgetSlot,
+        {
+          segment,
+          widgets,
+          context
+        },
+        `widget-${slide.index}-${index}`
+      )
+    );
+  });
+  flushInlineRun();
+  return /* @__PURE__ */ jsx3("div", { className: "space-y-4", "data-testid": `deck-slide-${slide.index}`, children: blocks });
+}
+function MarkdownSegment({ text }) {
+  return /* @__PURE__ */ jsx3(ReactMarkdown, { remarkPlugins: [remarkGfm], children: text });
+}
+function InlineMarkdownSegment({ text }) {
+  return /* @__PURE__ */ jsx3("span", { className: "whitespace-pre-wrap", children: /* @__PURE__ */ jsx3(
+    ReactMarkdown,
+    {
+      remarkPlugins: [remarkGfm],
+      components: {
+        p: ({ children }) => /* @__PURE__ */ jsx3(Fragment, { children })
+      },
+      children: text
+    }
+  ) });
+}
+function isInlineCompatibleMarkdown(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return false;
+  if (trimmed.includes("\n\n")) return false;
+  return !/^(#{1,6}\s|[-*+]\s|\d+\.\s|>|```|~~~|\|)|^---$/m.test(trimmed);
+}
+function parseDeckContent(content, path) {
+  try {
+    return { ok: true, deck: parseDeckMarkdown(content) };
+  } catch (cause) {
+    return {
+      ok: false,
+      error: {
+        type: "parse",
+        path,
+        message: cause instanceof Error ? cause.message : "Failed to parse deck",
+        cause
+      }
+    };
+  }
+}
+
+// src/front/StandaloneDeckRoute.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+function StandaloneDeckRoute({ path, content, theme, widgets, onError, getPresentHref }) {
+  return /* @__PURE__ */ jsx4("div", { className: "min-h-screen bg-background text-foreground", children: /* @__PURE__ */ jsx4(
+    DeckPane,
+    {
+      params: path ? { path } : {},
+      content,
+      theme,
+      widgets,
+      onError,
+      getPresentHref,
+      initialMode: "present"
+    }
+  ) });
+}
+
+// src/front/surfaceResolver.ts
+import { WORKSPACE_OPEN_PATH_SURFACE_KIND } from "@hachej/boring-workspace/plugin";
+function basename(path) {
+  const normalized = normalizeDeckPath(path);
+  return normalized.split("/").pop() ?? path;
+}
+function createDeckSurfaceResolver(pathPrefix) {
+  const normalizedPrefix = normalizeDeckPath(pathPrefix);
+  return {
+    id: "deck.open-path",
+    kind: WORKSPACE_OPEN_PATH_SURFACE_KIND,
+    source: "app",
+    resolve: (request) => {
+      if (request.kind !== WORKSPACE_OPEN_PATH_SURFACE_KIND) return null;
+      const target = normalizeDeckPath(request.target);
+      if (!isDeckMarkdownPath(target, normalizedPrefix)) return null;
+      return {
+        component: DECK_PANEL_ID,
+        title: basename(target),
+        params: { path: target },
+        score: 100
+      };
+    }
+  };
+}
+var deckSurfaceResolver = createDeckSurfaceResolver("deck/");
+
+// src/front/index.tsx
+import { Fragment as Fragment3, jsx as jsx5 } from "react/jsx-runtime";
+function DeckFilesProvider({
+  apiBaseUrl,
+  authHeaders,
+  onAuthError,
+  apiTimeout,
+  children
+}) {
+  const hasWorkspaceFilesProvider = useHasWorkspaceFilesProvider();
+  if (hasWorkspaceFilesProvider) {
+    return /* @__PURE__ */ jsx5(Fragment3, { children });
+  }
+  return /* @__PURE__ */ jsx5(
+    WorkspaceFilesProvider,
+    {
+      apiBaseUrl,
+      authHeaders,
+      onAuthError,
+      timeout: apiTimeout,
+      children
+    }
+  );
+}
+function createDeckPlugin(options = {}) {
+  const pathPrefix = normalizeDeckPath(options.pathPrefix ?? DECK_PATH_PREFIX);
+  validateDeckWidgets(options.widgets ?? []);
+  return definePlugin({
+    id: DECK_PLUGIN_ID,
+    label: DECK_LABEL,
+    providers: [
+      {
+        id: "deck-files",
+        component: DeckFilesProvider
+      }
+    ],
+    panels: [
+      {
+        id: DECK_PANEL_ID,
+        label: DECK_LABEL,
+        component: (props) => /* @__PURE__ */ jsx5(
+          DeckPane,
+          {
+            ...props,
+            pathPrefix,
+            theme: options.theme,
+            widgets: options.widgets,
+            onError: options.onError
+          }
+        ),
+        placement: "center",
+        source: "app",
+        supportsFullPage: true
+      }
+    ],
+    surfaceResolvers: [createDeckSurfaceResolver(pathPrefix)]
+  });
+}
+var deckPlugin = createDeckPlugin({ pathPrefix: DECK_PATH_PREFIX });
+var front_default = deckPlugin;
+export {
+  DeckPane,
+  StandaloneDeckRoute,
+  createDeckPlugin,
+  createDeckSurfaceResolver,
+  deckSurfaceResolver,
+  front_default as default
+};