@ampless/admin 0.2.0-alpha.8 → 1.0.0-alpha.27

package/dist/chunk-G4CF5ZWV.js

@@ -0,0 +1,1319 @@
+'use client';
+import {
+  ImageUploadDialog,
+  getMediaProcessingDefaults
+} from "./chunk-CTGFMK2J.js";
+import {
+  publicMediaUrl
+} from "./chunk-2ITWLRYF.js";
+import {
+  useT
+} from "./chunk-Q66BLMNJ.js";
+
+// src/lib/upload.ts
+import { uploadData } from "aws-amplify/storage";
+import { processImage } from "ampless/media";
+function sanitizeName(name) {
+  return name.replace(/[\x00-\x1f\x7f]/g, "").replace(/[\\/:*?"<>|]/g, "_").replace(/\s+/g, "_").replace(/^\.+/, "_").slice(0, 200) || "upload";
+}
+async function uploadProcessedImage(file, options) {
+  const processed = await processImage(file, options);
+  const safeName = sanitizeName(processed.suggestedName);
+  const now = /* @__PURE__ */ new Date();
+  const yyyy = now.getFullYear();
+  const mm = String(now.getMonth() + 1).padStart(2, "0");
+  const path = `public/media/${yyyy}/${mm}/${Date.now()}-${safeName}`;
+  await uploadData({
+    path,
+    data: processed.blob,
+    options: { contentType: processed.mime }
+  }).result;
+  return { path, url: publicMediaUrl(path) };
+}
+
+// src/components/media-picker.tsx
+import { useEffect, useRef, useState } from "react";
+import { list } from "aws-amplify/storage";
+import { Upload } from "lucide-react";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger,
+  Button
+} from "@ampless/runtime/ui";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function MediaPicker({ trigger, onSelect }) {
+  const t = useT();
+  const [open, setOpen] = useState(false);
+  const [items, setItems] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [pendingUpload, setPendingUpload] = useState(null);
+  const [uploading, setUploading] = useState(false);
+  const fileInputRef = useRef(null);
+  useEffect(() => {
+    if (!open) return;
+    let cancelled = false;
+    setLoading(true);
+    setError(null);
+    list({ path: "public/media/" }).then((result) => {
+      if (cancelled) return;
+      setItems(result.items.map((i) => i.path));
+    }).catch((err) => {
+      if (!cancelled) setError(err instanceof Error ? err.message : String(err));
+    }).finally(() => {
+      if (!cancelled) setLoading(false);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [open]);
+  function handlePick(path) {
+    onSelect(publicMediaUrl(path));
+    setOpen(false);
+  }
+  function handleFileSelected(e) {
+    const file = e.target.files?.[0];
+    e.target.value = "";
+    if (!file) return;
+    setPendingUpload(file);
+  }
+  async function handleUploadConfirm(file, options) {
+    setUploading(true);
+    setError(null);
+    try {
+      const { url } = await uploadProcessedImage(file, options);
+      onSelect(url);
+      setPendingUpload(null);
+      setOpen(false);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setUploading(false);
+    }
+  }
+  const pickerOpen = open && !pendingUpload;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs(Dialog, { open: pickerOpen, onOpenChange: (next) => setOpen(next), children: [
+      /* @__PURE__ */ jsx(DialogTrigger, { asChild: true, onClick: () => setOpen(true), children: trigger }),
+      /* @__PURE__ */ jsxs(DialogContent, { children: [
+        /* @__PURE__ */ jsx(DialogHeader, { children: /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between gap-4", children: [
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx(DialogTitle, { children: t("mediaPicker.title") }),
+            /* @__PURE__ */ jsx(DialogDescription, { children: t("mediaPicker.description") })
+          ] }),
+          /* @__PURE__ */ jsxs(
+            Button,
+            {
+              type: "button",
+              variant: "outline",
+              size: "sm",
+              onClick: () => fileInputRef.current?.click(),
+              children: [
+                /* @__PURE__ */ jsx(Upload, { className: "mr-2 h-3 w-3" }),
+                t("mediaPicker.uploadNew")
+              ]
+            }
+          )
+        ] }) }),
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            ref: fileInputRef,
+            type: "file",
+            accept: "image/*",
+            className: "hidden",
+            onChange: handleFileSelected
+          }
+        ),
+        loading && /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground", children: t("common.loading") }),
+        error && /* @__PURE__ */ jsx("p", { className: "text-sm text-destructive", children: error }),
+        !loading && items.length === 0 && /* @__PURE__ */ jsxs("p", { className: "text-sm text-muted-foreground", children: [
+          t("mediaPicker.empty"),
+          " ",
+          t("mediaPicker.emptyHint", { action: t("mediaPicker.emptyAction") })
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: "grid max-h-[60vh] grid-cols-3 gap-3 overflow-auto sm:grid-cols-4", children: items.map((path) => /* @__PURE__ */ jsxs(
+          "button",
+          {
+            type: "button",
+            onClick: () => handlePick(path),
+            className: "group overflow-hidden rounded-md border transition hover:border-primary",
+            children: [
+              /* @__PURE__ */ jsx(
+                "img",
+                {
+                  src: publicMediaUrl(path),
+                  alt: path,
+                  className: "aspect-square w-full object-cover"
+                }
+              ),
+              /* @__PURE__ */ jsx("div", { className: "truncate p-1 text-xs text-muted-foreground", children: path.split("/").pop() })
+            ]
+          },
+          path
+        )) })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(
+      ImageUploadDialog,
+      {
+        file: pendingUpload,
+        remaining: pendingUpload ? 1 : 0,
+        busy: uploading,
+        defaults: getMediaProcessingDefaults(),
+        onConfirm: handleUploadConfirm,
+        onSkip: () => setPendingUpload(null),
+        onCancel: () => setPendingUpload(null)
+      }
+    )
+  ] });
+}
+
+// src/components/post-form.tsx
+import { useRef as useRef3, useState as useState4 } from "react";
+import { useRouter } from "next/navigation";
+import { Image as ImageIcon3 } from "lucide-react";
+import {
+  createPost,
+  updatePost,
+  deletePost,
+  formatDate
+} from "ampless";
+import {
+  renderBody,
+  tiptapToHtml,
+  tiptapToMarkdown,
+  markdownToHtml,
+  htmlToMarkdown
+} from "@ampless/runtime";
+import { Button as Button6, Input, Label, Textarea } from "@ampless/runtime/ui";
+
+// src/editor/tiptap-editor.tsx
+import { useEditor, EditorContent } from "@tiptap/react";
+import StarterKit from "@tiptap/starter-kit";
+import Link from "@tiptap/extension-link";
+import Image from "@tiptap/extension-image";
+import { Table } from "@tiptap/extension-table";
+import { TableRow } from "@tiptap/extension-table-row";
+import { TableHeader } from "@tiptap/extension-table-header";
+import { TableCell } from "@tiptap/extension-table-cell";
+import { TaskList } from "@tiptap/extension-task-list";
+import { TaskItem } from "@tiptap/extension-task-item";
+import { Underline as Underline2 } from "@tiptap/extension-underline";
+import { Highlight } from "@tiptap/extension-highlight";
+import { TextAlign } from "@tiptap/extension-text-align";
+
+// src/editor/toolbar.tsx
+import {
+  Bold,
+  Italic,
+  Underline,
+  Strikethrough,
+  Highlighter,
+  Heading1,
+  Heading2,
+  List,
+  ListOrdered,
+  ListChecks,
+  Code,
+  Quote,
+  Minus,
+  TextAlignStart,
+  TextAlignCenter,
+  TextAlignEnd,
+  TextAlignJustify,
+  Link as LinkIcon,
+  Image as ImageIcon
+} from "lucide-react";
+import { Button as Button3, cn as cn2 } from "@ampless/runtime/ui";
+
+// src/editor/table-controls.tsx
+import { useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+import { Table as TableIcon } from "lucide-react";
+import { Button as Button2, cn } from "@ampless/runtime/ui";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function TableControls({ editor }) {
+  const t = useT();
+  const [open, setOpen] = useState2(false);
+  const rootRef = useRef2(null);
+  useEffect2(() => {
+    if (!open) return;
+    function onPointerDown(e) {
+      if (!rootRef.current) return;
+      if (e.target instanceof Node && rootRef.current.contains(e.target)) return;
+      setOpen(false);
+    }
+    function onKey(e) {
+      if (e.key === "Escape") setOpen(false);
+    }
+    document.addEventListener("mousedown", onPointerDown);
+    document.addEventListener("keydown", onKey);
+    return () => {
+      document.removeEventListener("mousedown", onPointerDown);
+      document.removeEventListener("keydown", onKey);
+    };
+  }, [open]);
+  const inTable = editor.isActive("table");
+  const items = [
+    {
+      key: "insert",
+      label: t("editor.table.insert"),
+      run: () => editor.chain().focus().insertTable({ rows: 3, cols: 3, withHeaderRow: true }).run(),
+      enabled: !inTable
+    },
+    {
+      key: "addRowBefore",
+      label: t("editor.table.addRowBefore"),
+      run: () => editor.chain().focus().addRowBefore().run(),
+      enabled: inTable && editor.can().addRowBefore()
+    },
+    {
+      key: "addRowAfter",
+      label: t("editor.table.addRowAfter"),
+      run: () => editor.chain().focus().addRowAfter().run(),
+      enabled: inTable && editor.can().addRowAfter()
+    },
+    {
+      key: "addColumnBefore",
+      label: t("editor.table.addColumnBefore"),
+      run: () => editor.chain().focus().addColumnBefore().run(),
+      enabled: inTable && editor.can().addColumnBefore()
+    },
+    {
+      key: "addColumnAfter",
+      label: t("editor.table.addColumnAfter"),
+      run: () => editor.chain().focus().addColumnAfter().run(),
+      enabled: inTable && editor.can().addColumnAfter()
+    },
+    {
+      key: "deleteRow",
+      label: t("editor.table.deleteRow"),
+      run: () => editor.chain().focus().deleteRow().run(),
+      enabled: inTable && editor.can().deleteRow()
+    },
+    {
+      key: "deleteColumn",
+      label: t("editor.table.deleteColumn"),
+      run: () => editor.chain().focus().deleteColumn().run(),
+      enabled: inTable && editor.can().deleteColumn()
+    },
+    {
+      key: "toggleHeaderRow",
+      label: t("editor.table.toggleHeaderRow"),
+      run: () => editor.chain().focus().toggleHeaderRow().run(),
+      enabled: inTable && editor.can().toggleHeaderRow()
+    },
+    {
+      key: "deleteTable",
+      label: t("editor.table.deleteTable"),
+      run: () => editor.chain().focus().deleteTable().run(),
+      enabled: inTable && editor.can().deleteTable()
+    }
+  ];
+  return /* @__PURE__ */ jsxs2("div", { ref: rootRef, className: "relative", children: [
+    /* @__PURE__ */ jsx2(
+      Button2,
+      {
+        type: "button",
+        variant: "ghost",
+        size: "icon",
+        onClick: () => setOpen((v) => !v),
+        className: cn(inTable && "bg-accent text-accent-foreground"),
+        title: t("editor.table.title"),
+        "aria-expanded": open,
+        "aria-haspopup": "menu",
+        children: /* @__PURE__ */ jsx2(TableIcon, { className: "h-4 w-4" })
+      }
+    ),
+    open && /* @__PURE__ */ jsx2(
+      "div",
+      {
+        role: "menu",
+        className: "absolute left-0 top-full z-50 mt-1 min-w-[12rem] rounded-md border bg-popover p-1 shadow",
+        children: items.map((item) => /* @__PURE__ */ jsx2(
+          "button",
+          {
+            type: "button",
+            role: "menuitem",
+            disabled: !item.enabled,
+            onClick: () => {
+              if (!item.enabled) return;
+              item.run();
+              setOpen(false);
+            },
+            className: cn(
+              "block w-full rounded-sm px-2 py-1 text-left text-sm",
+              item.enabled ? "hover:bg-accent hover:text-accent-foreground" : "cursor-not-allowed text-muted-foreground opacity-50"
+            ),
+            children: item.label
+          },
+          item.key
+        ))
+      }
+    )
+  ] });
+}
+
+// src/editor/toolbar.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function Toolbar({ editor }) {
+  const t = useT();
+  if (!editor) return null;
+  const tools = [
+    { name: "bold", icon: Bold, action: () => editor.chain().focus().toggleBold().run(), isActive: () => editor.isActive("bold") },
+    { name: "italic", icon: Italic, action: () => editor.chain().focus().toggleItalic().run(), isActive: () => editor.isActive("italic") },
+    { name: "underline", icon: Underline, action: () => editor.chain().focus().toggleUnderline().run(), isActive: () => editor.isActive("underline") },
+    { name: "strike", icon: Strikethrough, action: () => editor.chain().focus().toggleStrike().run(), isActive: () => editor.isActive("strike") },
+    { name: "highlight", icon: Highlighter, action: () => editor.chain().focus().toggleHighlight().run(), isActive: () => editor.isActive("highlight") },
+    { name: "h1", icon: Heading1, action: () => editor.chain().focus().toggleHeading({ level: 1 }).run(), isActive: () => editor.isActive("heading", { level: 1 }) },
+    { name: "h2", icon: Heading2, action: () => editor.chain().focus().toggleHeading({ level: 2 }).run(), isActive: () => editor.isActive("heading", { level: 2 }) },
+    { name: "bulletList", icon: List, action: () => editor.chain().focus().toggleBulletList().run(), isActive: () => editor.isActive("bulletList") },
+    { name: "orderedList", icon: ListOrdered, action: () => editor.chain().focus().toggleOrderedList().run(), isActive: () => editor.isActive("orderedList") },
+    { name: "taskList", icon: ListChecks, action: () => editor.chain().focus().toggleTaskList().run(), isActive: () => editor.isActive("taskList") },
+    { name: "code", icon: Code, action: () => editor.chain().focus().toggleCodeBlock().run(), isActive: () => editor.isActive("codeBlock") },
+    { name: "blockquote", icon: Quote, action: () => editor.chain().focus().toggleBlockquote().run(), isActive: () => editor.isActive("blockquote") },
+    { name: "hr", icon: Minus, action: () => editor.chain().focus().setHorizontalRule().run(), isActive: () => false },
+    { name: "alignLeft", icon: TextAlignStart, action: () => editor.chain().focus().setTextAlign("left").run(), isActive: () => editor.isActive({ textAlign: "left" }) },
+    { name: "alignCenter", icon: TextAlignCenter, action: () => editor.chain().focus().setTextAlign("center").run(), isActive: () => editor.isActive({ textAlign: "center" }) },
+    { name: "alignRight", icon: TextAlignEnd, action: () => editor.chain().focus().setTextAlign("right").run(), isActive: () => editor.isActive({ textAlign: "right" }) },
+    { name: "alignJustify", icon: TextAlignJustify, action: () => editor.chain().focus().setTextAlign("justify").run(), isActive: () => editor.isActive({ textAlign: "justify" }) }
+  ];
+  const setLink = () => {
+    const previousUrl = editor.getAttributes("link").href ?? "";
+    const url = window.prompt(t("editor.linkPrompt"), previousUrl);
+    if (url === null) return;
+    if (url === "") {
+      editor.chain().focus().extendMarkRange("link").unsetLink().run();
+      return;
+    }
+    editor.chain().focus().extendMarkRange("link").setLink({ href: url }).run();
+  };
+  const insertImage = (url) => {
+    editor.chain().focus().setImage({ src: url }).run();
+  };
+  return /* @__PURE__ */ jsxs3("div", { className: "flex flex-wrap gap-1 border-b p-2", children: [
+    tools.map((tool) => {
+      const Icon = tool.icon;
+      return /* @__PURE__ */ jsx3(
+        Button3,
+        {
+          type: "button",
+          variant: "ghost",
+          size: "icon",
+          onClick: tool.action,
+          className: cn2(tool.isActive() && "bg-accent text-accent-foreground"),
+          children: /* @__PURE__ */ jsx3(Icon, { className: "h-4 w-4" })
+        },
+        tool.name
+      );
+    }),
+    /* @__PURE__ */ jsx3(
+      Button3,
+      {
+        type: "button",
+        variant: "ghost",
+        size: "icon",
+        onClick: setLink,
+        className: cn2(editor.isActive("link") && "bg-accent text-accent-foreground"),
+        children: /* @__PURE__ */ jsx3(LinkIcon, { className: "h-4 w-4" })
+      }
+    ),
+    /* @__PURE__ */ jsx3(
+      MediaPicker,
+      {
+        onSelect: insertImage,
+        trigger: /* @__PURE__ */ jsx3(Button3, { type: "button", variant: "ghost", size: "icon", children: /* @__PURE__ */ jsx3(ImageIcon, { className: "h-4 w-4" }) })
+      }
+    ),
+    /* @__PURE__ */ jsx3(TableControls, { editor })
+  ] });
+}
+
+// src/editor/image-bubble-menu.tsx
+import { BubbleMenu } from "@tiptap/react/menus";
+import { Trash2, Pencil, ImageIcon as ImageIcon2, Maximize2 } from "lucide-react";
+import { Button as Button4, cn as cn3 } from "@ampless/runtime/ui";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function ImageBubbleMenu({ editor }) {
+  const t = useT();
+  const editAlt = () => {
+    const current = editor.getAttributes("image").alt ?? "";
+    const alt = window.prompt(t("editor.altPrompt"), current);
+    if (alt === null) return;
+    editor.chain().focus().updateAttributes("image", { alt }).run();
+  };
+  const remove2 = () => {
+    editor.chain().focus().deleteSelection().run();
+  };
+  const setDisplay = (display) => {
+    const current = editor.getAttributes("image").display ?? null;
+    const next = current === display ? null : display;
+    editor.chain().focus().updateAttributes("image", { display: next }).run();
+  };
+  const currentDisplay = editor.getAttributes("image").display ?? null;
+  return /* @__PURE__ */ jsx4(
+    BubbleMenu,
+    {
+      editor,
+      shouldShow: ({ editor: editor2 }) => editor2.isActive("image"),
+      options: { placement: "top" },
+      children: /* @__PURE__ */ jsxs4("div", { className: "flex items-center gap-1 rounded-md border bg-popover p-1 shadow", children: [
+        /* @__PURE__ */ jsxs4(
+          Button4,
+          {
+            type: "button",
+            variant: "ghost",
+            size: "sm",
+            onClick: () => setDisplay("inline"),
+            className: cn3(currentDisplay === "inline" && "bg-accent text-accent-foreground"),
+            title: t("editor.image.inlineTitle"),
+            children: [
+              /* @__PURE__ */ jsx4(ImageIcon2, { className: "mr-1 h-3 w-3" }),
+              t("editor.image.inline")
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs4(
+          Button4,
+          {
+            type: "button",
+            variant: "ghost",
+            size: "sm",
+            onClick: () => setDisplay("lightbox"),
+            className: cn3(currentDisplay === "lightbox" && "bg-accent text-accent-foreground"),
+            title: t("editor.image.lightboxTitle"),
+            children: [
+              /* @__PURE__ */ jsx4(Maximize2, { className: "mr-1 h-3 w-3" }),
+              t("editor.image.lightbox")
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx4("span", { className: "mx-1 h-4 w-px bg-border" }),
+        /* @__PURE__ */ jsxs4(Button4, { type: "button", variant: "ghost", size: "sm", onClick: editAlt, children: [
+          /* @__PURE__ */ jsx4(Pencil, { className: "mr-1 h-3 w-3" }),
+          t("editor.image.alt")
+        ] }),
+        /* @__PURE__ */ jsxs4(Button4, { type: "button", variant: "ghost", size: "sm", onClick: remove2, children: [
+          /* @__PURE__ */ jsx4(Trash2, { className: "mr-1 h-3 w-3" }),
+          t("editor.image.delete")
+        ] })
+      ] })
+    }
+  );
+}
+
+// src/editor/tiptap-editor.tsx
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var AmplessImage = Image.extend({
+  addAttributes() {
+    return {
+      ...this.parent?.(),
+      display: {
+        default: null,
+        parseHTML: (el) => el.getAttribute("data-display"),
+        renderHTML: (attrs) => {
+          const v = attrs.display;
+          return v ? { "data-display": v } : {};
+        }
+      }
+    };
+  }
+});
+var EDITOR_STYLES = `
+.ProseMirror .tiptap-table,
+.ProseMirror table {
+  border-collapse: collapse;
+  table-layout: fixed;
+  width: 100%;
+  margin: 0.75em 0;
+  overflow: hidden;
+}
+.ProseMirror .tiptap-table td,
+.ProseMirror .tiptap-table th,
+.ProseMirror table td,
+.ProseMirror table th {
+  border: 1px solid var(--border);
+  padding: 0.4em 0.6em;
+  min-width: 1em;
+  vertical-align: top;
+  position: relative;
+}
+.ProseMirror .tiptap-table th,
+.ProseMirror table th {
+  background: var(--muted);
+  font-weight: 600;
+  text-align: left;
+}
+.ProseMirror .tiptap-table .selectedCell,
+.ProseMirror table .selectedCell {
+  background: var(--accent);
+}
+.ProseMirror .tableWrapper {
+  overflow-x: auto;
+  margin: 0.75em 0;
+}
+.ProseMirror .column-resize-handle {
+  position: absolute;
+  right: -2px;
+  top: 0;
+  bottom: 0;
+  width: 4px;
+  background: var(--ring);
+  pointer-events: none;
+}
+.ProseMirror.resize-cursor {
+  cursor: col-resize;
+}
+
+.ProseMirror ul[data-type='taskList'] {
+  list-style: none;
+  padding-left: 0;
+}
+.ProseMirror ul[data-type='taskList'] li {
+  display: flex;
+  align-items: flex-start;
+  gap: 0.5em;
+}
+.ProseMirror ul[data-type='taskList'] li > label {
+  flex: 0 0 auto;
+  margin-top: 0.25em;
+  user-select: none;
+}
+.ProseMirror ul[data-type='taskList'] li > div {
+  flex: 1 1 auto;
+  min-width: 0;
+}
+.ProseMirror ul[data-type='taskList'] li[data-checked='true'] > div {
+  text-decoration: line-through;
+  color: var(--muted-foreground);
+}
+
+.ProseMirror mark {
+  background: #fef08a;
+  color: inherit;
+  padding: 0 0.1em;
+  border-radius: 2px;
+}
+`;
+function TiptapEditor({ initialContent, onChange }) {
+  const editor = useEditor({
+    extensions: [
+      StarterKit,
+      Link.configure({ openOnClick: false }),
+      AmplessImage.configure({ inline: false, allowBase64: false }),
+      Table.configure({ resizable: true, HTMLAttributes: { class: "tiptap-table" } }),
+      TableRow,
+      TableHeader,
+      TableCell,
+      TaskList,
+      TaskItem.configure({ nested: true }),
+      Underline2,
+      Highlight.configure({ multicolor: false }),
+      TextAlign.configure({ types: ["heading", "paragraph"] })
+    ],
+    content: initialContent ?? { type: "doc", content: [{ type: "paragraph" }] },
+    immediatelyRender: false,
+    editorProps: {
+      attributes: {
+        class: "prose prose-neutral dark:prose-invert max-w-none min-h-[400px] px-4 py-3 focus:outline-none"
+      }
+    },
+    onCreate: ({ editor: editor2 }) => {
+      onChange?.(editor2.getJSON());
+    },
+    onUpdate: ({ editor: editor2 }) => {
+      onChange?.(editor2.getJSON());
+    }
+  });
+  return /* @__PURE__ */ jsxs5("div", { className: "rounded-md border", children: [
+    /* @__PURE__ */ jsx5("style", { children: EDITOR_STYLES }),
+    /* @__PURE__ */ jsx5(Toolbar, { editor }),
+    editor && /* @__PURE__ */ jsx5(ImageBubbleMenu, { editor }),
+    /* @__PURE__ */ jsx5(EditorContent, { editor })
+  ] });
+}
+
+// src/components/static-uploader.tsx
+import { useState as useState3 } from "react";
+import { FileText, AlertTriangle, FileArchive, X } from "lucide-react";
+import { Button as Button5 } from "@ampless/runtime/ui";
+
+// src/lib/static-bundle.ts
+import JSZip from "jszip";
+import { uploadData as uploadData2, list as list2, remove } from "aws-amplify/storage";
+import {
+  mimeTypeFor,
+  validateBundlePath,
+  findAbsolutePathRefs,
+  validateBundle,
+  bundlePrefix,
+  pickDefaultEntrypoint,
+  stripCommonPrefix,
+  MAX_BUNDLE_BYTES
+} from "ampless";
+async function extractZip(file) {
+  const zip = await JSZip.loadAsync(file);
+  const files = [];
+  const issues = [];
+  let totalBytes = 0;
+  for (const entry of Object.values(zip.files)) {
+    if (entry.dir) continue;
+    const reason = validateBundlePath(entry.name);
+    if (reason) {
+      const silent = reason === "macOS resource fork" || reason === ".DS_Store junk" || reason === "Thumbs.db junk";
+      if (!silent) issues.push({ path: entry.name, reason });
+      continue;
+    }
+    const data = await entry.async("uint8array");
+    totalBytes += data.byteLength;
+    files.push({ path: entry.name, data });
+  }
+  return { files: stripCommonPrefix(files), issues, totalBytes };
+}
+async function uploadBundle(opts) {
+  if (opts.files.length === 0) {
+    throw new Error("Bundle is empty.");
+  }
+  const totalBytes = opts.files.reduce((sum, f) => sum + f.data.byteLength, 0);
+  if (totalBytes > MAX_BUNDLE_BYTES) {
+    throw new Error(
+      `Bundle too large: ${Math.round(totalBytes / 1024 / 1024)} MB exceeds the ${Math.round(MAX_BUNDLE_BYTES / 1024 / 1024)} MB ceiling for browser-side upload.`
+    );
+  }
+  const entrypoint = opts.entrypoint ?? pickDefaultEntrypoint(opts.files);
+  if (!opts.files.some((f) => f.path === entrypoint)) {
+    throw new Error(`Entrypoint "${entrypoint}" is not present in the bundle.`);
+  }
+  await deleteBundle(opts.slug).catch(() => void 0);
+  const prefix = bundlePrefix(opts.slug);
+  let uploaded = 0;
+  for (const f of opts.files) {
+    const task = uploadData2({
+      path: `${prefix}${f.path}`,
+      data: f.data,
+      // Forcing Content-Type at upload means CloudFront / browsers see
+      // it directly when serving the file via the public bucket URL.
+      // (The runtime route handler overrides it for the proxied path,
+      // but tooling that hits S3 directly benefits from a correct CT.)
+      options: { contentType: mimeTypeFor(f.path) }
+    });
+    await task.result;
+    uploaded += f.data.byteLength;
+    opts.onProgress?.(uploaded, totalBytes);
+  }
+  return {
+    entrypoint,
+    files: opts.files.map((f) => f.path).sort(),
+    uploadedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function deleteBundle(slug) {
+  const prefix = bundlePrefix(slug);
+  const result = await list2({ path: prefix });
+  for (const item of result.items) {
+    await remove({ path: item.path });
+  }
+}
+
+// src/components/static-uploader.tsx
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function StaticUploader({ initial, onFilesReady, onClear }) {
+  const t = useT();
+  const [pending, setPending] = useState3(null);
+  const [issues, setIssues] = useState3([]);
+  const [busy, setBusy] = useState3(false);
+  const [error, setError] = useState3(null);
+  async function handleZip(file) {
+    setBusy(true);
+    setError(null);
+    try {
+      const { files, issues: structuralIssues } = await extractZip(file);
+      if (files.length === 0) {
+        setError(t("posts.form.static.emptyBundle"));
+        return;
+      }
+      const contentIssues = validateBundle(files);
+      const all = [...structuralIssues, ...contentIssues];
+      setPending(files);
+      setIssues(all);
+      if (all.length === 0) {
+        onFilesReady(files, guessEntrypoint(files));
+      }
+    } catch (e) {
+      setError(e instanceof Error ? e.message : String(e));
+    } finally {
+      setBusy(false);
+    }
+  }
+  async function handleLooseFiles(files) {
+    setBusy(true);
+    setError(null);
+    try {
+      const extracted = [];
+      const structural = [];
+      for (const f of Array.from(files)) {
+        const rel = f.webkitRelativePath ?? f.name;
+        const stripped = rel.includes("/") ? rel.slice(rel.indexOf("/") + 1) : rel;
+        const reason = validateBundlePath(stripped);
+        if (reason) {
+          structural.push({ path: stripped, reason });
+          continue;
+        }
+        const buf = new Uint8Array(await f.arrayBuffer());
+        extracted.push({ path: stripped, data: buf });
+      }
+      if (extracted.length === 0) {
+        setError(t("posts.form.static.emptyBundle"));
+        return;
+      }
+      const content = validateBundle(extracted);
+      const all = [...structural, ...content];
+      setPending(extracted);
+      setIssues(all);
+      if (all.length === 0) {
+        onFilesReady(extracted, guessEntrypoint(extracted));
+      }
+    } catch (e) {
+      setError(e instanceof Error ? e.message : String(e));
+    } finally {
+      setBusy(false);
+    }
+  }
+  function onPickerChange(e) {
+    const fl = e.target.files;
+    if (!fl || fl.length === 0) return;
+    e.target.value = "";
+    if (fl.length === 1 && fl[0].name.toLowerCase().endsWith(".zip")) {
+      void handleZip(fl[0]);
+    } else {
+      void handleLooseFiles(fl);
+    }
+  }
+  function clearPending() {
+    setPending(null);
+    setIssues([]);
+    setError(null);
+    onClear();
+  }
+  const showCurrent = !pending && initial && initial.files.length > 0;
+  return /* @__PURE__ */ jsxs6("div", { className: "space-y-4", children: [
+    /* @__PURE__ */ jsxs6("div", { className: "rounded-md border border-dashed p-4", children: [
+      /* @__PURE__ */ jsxs6("label", { className: "flex flex-col items-start gap-2 text-sm", children: [
+        /* @__PURE__ */ jsx6("span", { className: "font-medium", children: t("posts.form.static.pick") }),
+        /* @__PURE__ */ jsx6(
+          "input",
+          {
+            type: "file",
+            accept: ".zip,application/zip,*/*",
+            multiple: true,
+            onChange: onPickerChange,
+            disabled: busy
+          }
+        ),
+        /* @__PURE__ */ jsx6("span", { className: "text-xs text-muted-foreground", children: t("posts.form.static.pickHint") })
+      ] }),
+      busy && /* @__PURE__ */ jsx6("p", { className: "mt-2 text-sm text-muted-foreground", children: t("common.loading") }),
+      error && /* @__PURE__ */ jsx6("p", { className: "mt-2 text-sm text-destructive", children: error })
+    ] }),
+    showCurrent && /* @__PURE__ */ jsx6(CurrentBundle, { body: initial }),
+    pending && /* @__PURE__ */ jsx6(
+      PendingBundle,
+      {
+        files: pending,
+        issues,
+        onClear: clearPending
+      }
+    )
+  ] });
+}
+function CurrentBundle({ body }) {
+  const t = useT();
+  return /* @__PURE__ */ jsxs6("div", { className: "rounded-md border bg-muted/30 p-3", children: [
+    /* @__PURE__ */ jsxs6("div", { className: "mb-2 flex items-center gap-2 text-sm font-medium", children: [
+      /* @__PURE__ */ jsx6(FileArchive, { className: "h-4 w-4" }),
+      t("posts.form.static.currentBundle", {
+        count: body.files.length,
+        entrypoint: body.entrypoint
+      })
+    ] }),
+    /* @__PURE__ */ jsx6(FileList, { files: body.files })
+  ] });
+}
+function PendingBundle({
+  files,
+  issues,
+  onClear
+}) {
+  const t = useT();
+  const totalBytes = files.reduce((sum, f) => sum + f.data.byteLength, 0);
+  return /* @__PURE__ */ jsxs6("div", { className: "rounded-md border p-3", children: [
+    /* @__PURE__ */ jsxs6("div", { className: "mb-2 flex items-center justify-between gap-2 text-sm font-medium", children: [
+      /* @__PURE__ */ jsxs6("span", { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsx6(FileArchive, { className: "h-4 w-4" }),
+        t("posts.form.static.pendingBundle", {
+          count: files.length,
+          size: formatBytes(totalBytes)
+        })
+      ] }),
+      /* @__PURE__ */ jsxs6(Button5, { type: "button", variant: "ghost", size: "sm", onClick: onClear, children: [
+        /* @__PURE__ */ jsx6(X, { className: "mr-1 h-3 w-3" }),
+        t("common.cancel")
+      ] })
+    ] }),
+    issues.length > 0 && /* @__PURE__ */ jsxs6("div", { className: "mb-3 rounded-md border border-destructive/40 bg-destructive/5 p-2 text-sm", children: [
+      /* @__PURE__ */ jsxs6("div", { className: "mb-1 flex items-center gap-2 font-medium text-destructive", children: [
+        /* @__PURE__ */ jsx6(AlertTriangle, { className: "h-4 w-4" }),
+        t("posts.form.static.issuesTitle", { count: issues.length })
+      ] }),
+      /* @__PURE__ */ jsxs6("ul", { className: "space-y-0.5 text-xs", children: [
+        issues.slice(0, 20).map((issue, idx) => /* @__PURE__ */ jsxs6("li", { className: "font-mono", children: [
+          issue.path,
+          ": ",
+          issue.reason
+        ] }, `${issue.path}-${idx}`)),
+        issues.length > 20 && /* @__PURE__ */ jsxs6("li", { className: "font-mono text-muted-foreground", children: [
+          "\u2026 ",
+          issues.length - 20,
+          " more"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx6("p", { className: "mt-2 text-xs text-muted-foreground", children: t("posts.form.static.issuesHint") })
+    ] }),
+    /* @__PURE__ */ jsx6(FileList, { files: files.map((f) => f.path) })
+  ] });
+}
+function FileList({ files }) {
+  return /* @__PURE__ */ jsxs6("ul", { className: "space-y-0.5 text-xs", children: [
+    files.slice(0, 40).map((path) => /* @__PURE__ */ jsxs6("li", { className: "flex items-center gap-1.5 font-mono text-muted-foreground", children: [
+      /* @__PURE__ */ jsx6(FileText, { className: "h-3 w-3 shrink-0" }),
+      path
+    ] }, path)),
+    files.length > 40 && /* @__PURE__ */ jsxs6("li", { className: "font-mono text-xs text-muted-foreground", children: [
+      "\u2026 ",
+      files.length - 40,
+      " more"
+    ] })
+  ] });
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+function guessEntrypoint(files) {
+  const exact = files.find((f) => f.path === "index.html");
+  if (exact) return "index.html";
+  const alt = files.find((f) => f.path === "index.htm");
+  if (alt) return "index.htm";
+  const rootHtml = files.filter((f) => /^[^/]+\.html?$/.test(f.path)).sort((a, b) => a.path.localeCompare(b.path))[0];
+  if (rootHtml) return rootHtml.path;
+  return files[0]?.path ?? "index.html";
+}
+
+// src/components/post-form.tsx
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var EMPTY_TIPTAP_DOC = { type: "doc", content: [{ type: "paragraph" }] };
+var IMAGE_URL_RE = /\.(jpe?g|png|gif|webp|avif|svg|bmp|tiff?)(\?|$)/i;
+var STYLESHEET_URL_RE = /\.css(\?|$)/i;
+var SCRIPT_URL_RE = /\.m?js(\?|$)/i;
+function snippetFor(url, format) {
+  const isImage = IMAGE_URL_RE.test(url);
+  if (format === "markdown") {
+    return isImage ? `![](${url})` : url;
+  }
+  if (isImage) return `<img src="${url}" alt="" />`;
+  if (STYLESHEET_URL_RE.test(url)) return `<link rel="stylesheet" href="${url}" />`;
+  if (SCRIPT_URL_RE.test(url)) return `<script src="${url}"></script>`;
+  return url;
+}
+function slugify(s) {
+  return s.toLowerCase().trim().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-");
+}
+function defaultBodyForFormat(format) {
+  if (format === "tiptap") return EMPTY_TIPTAP_DOC;
+  if (format === "static") return null;
+  return "";
+}
+function isStaticBody(value) {
+  return !!value && typeof value === "object" && "entrypoint" in value && "files" in value && Array.isArray(value.files);
+}
+function PostForm({ post }) {
+  const router = useRouter();
+  const t = useT();
+  const isEdit = !!post;
+  const bodyTextareaRef = useRef3(null);
+  const [title, setTitle] = useState4(post?.title ?? "");
+  const [slug, setSlug] = useState4(post?.slug ?? "");
+  const [excerpt, setExcerpt] = useState4(post?.excerpt ?? "");
+  const [format, setFormat] = useState4(post?.format ?? "tiptap");
+  const [body, setBody] = useState4(post?.body ?? EMPTY_TIPTAP_DOC);
+  const [status, setStatus] = useState4(post?.status ?? "draft");
+  const [tagsInput, setTagsInput] = useState4((post?.tags ?? []).join(", "));
+  const [noLayout, setNoLayout] = useState4(post?.metadata?.no_layout === true);
+  const [saving, setSaving] = useState4(false);
+  const [error, setError] = useState4(null);
+  const [view, setView] = useState4("edit");
+  const [pendingBundle, setPendingBundle] = useState4(null);
+  const initialStaticBody = isStaticBody(post?.body) ? post.body : null;
+  function buildMetadata() {
+    const next = { ...post?.metadata ?? {} };
+    if (noLayout && format === "html") next.no_layout = true;
+    else delete next.no_layout;
+    return Object.keys(next).length > 0 ? next : void 0;
+  }
+  function parseTags(raw) {
+    return Array.from(
+      new Set(
+        raw.split(",").map((t2) => t2.trim()).filter(Boolean)
+      )
+    );
+  }
+  function insertMediaSnippet(url) {
+    if (format === "tiptap") return;
+    const snippet = snippetFor(url, format);
+    const ta = bodyTextareaRef.current;
+    const current = typeof body === "string" ? body : "";
+    if (!ta) {
+      setBody(current + snippet);
+      return;
+    }
+    const start = ta.selectionStart ?? current.length;
+    const end = ta.selectionEnd ?? current.length;
+    const next = current.slice(0, start) + snippet + current.slice(end);
+    setBody(next);
+    requestAnimationFrame(() => {
+      const t2 = bodyTextareaRef.current;
+      if (!t2) return;
+      t2.focus();
+      const pos = start + snippet.length;
+      t2.setSelectionRange(pos, pos);
+    });
+  }
+  function changeFormat(next) {
+    if (next === format) return;
+    let nextBody = body;
+    if (next === "static" || format === "static") {
+      nextBody = defaultBodyForFormat(next);
+    } else {
+      const k = `${format}\u2192${next}`;
+      switch (k) {
+        case "tiptap\u2192html":
+          nextBody = tiptapToHtml(body);
+          break;
+        case "tiptap\u2192markdown":
+          nextBody = tiptapToMarkdown(body);
+          break;
+        case "html\u2192tiptap":
+          nextBody = String(body ?? "");
+          break;
+        case "markdown\u2192tiptap":
+          nextBody = markdownToHtml(String(body ?? ""));
+          break;
+        case "html\u2192markdown":
+          nextBody = htmlToMarkdown(String(body ?? ""));
+          break;
+        case "markdown\u2192html":
+          nextBody = markdownToHtml(String(body ?? ""));
+          break;
+        default:
+          nextBody = defaultBodyForFormat(next);
+      }
+    }
+    setFormat(next);
+    setBody(nextBody);
+    setPendingBundle(null);
+    if (next !== "html") setNoLayout(false);
+  }
+  async function save(e) {
+    e.preventDefault();
+    setSaving(true);
+    setError(null);
+    try {
+      const tags = parseTags(tagsInput);
+      const metadata = buildMetadata();
+      const finalSlug = slug || slugify(title);
+      let nextBody = body;
+      if (format === "static") {
+        if (pendingBundle) {
+          nextBody = await uploadBundle({
+            slug: finalSlug,
+            files: pendingBundle.files,
+            entrypoint: pendingBundle.entrypoint
+          });
+        } else if (initialStaticBody) {
+          nextBody = initialStaticBody;
+        } else {
+          throw new Error(t("posts.form.static.noBundle"));
+        }
+      }
+      if (isEdit) {
+        await updatePost(post.postId, {
+          title,
+          slug: finalSlug,
+          excerpt: excerpt || void 0,
+          format,
+          body: nextBody,
+          status,
+          publishedAt: status === "published" ? post?.publishedAt ?? (/* @__PURE__ */ new Date()).toISOString() : void 0,
+          tags,
+          metadata
+        });
+      } else {
+        await createPost({
+          slug: finalSlug,
+          title,
+          excerpt: excerpt || void 0,
+          format,
+          body: nextBody,
+          status,
+          publishedAt: status === "published" ? (/* @__PURE__ */ new Date()).toISOString() : void 0,
+          tags,
+          metadata
+        });
+      }
+      router.push("/admin/posts");
+      router.refresh();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setSaving(false);
+    }
+  }
+  async function handleDelete() {
+    if (!post) return;
+    if (!confirm(t("posts.form.deleteConfirm", { title: post.title }))) return;
+    setSaving(true);
+    try {
+      if (post.format === "static") {
+        await deleteBundle(post.slug).catch(() => void 0);
+      }
+      await deletePost(post.postId);
+      router.push("/admin/posts");
+      router.refresh();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+      setSaving(false);
+    }
+  }
+  const previewPost = {
+    postId: post?.postId ?? "preview",
+    slug: slug || slugify(title) || "preview",
+    title,
+    excerpt: excerpt || void 0,
+    format,
+    body,
+    status,
+    publishedAt: status === "published" ? post?.publishedAt ?? (/* @__PURE__ */ new Date()).toISOString() : void 0,
+    tags: parseTags(tagsInput)
+  };
+  return /* @__PURE__ */ jsxs7("form", { onSubmit: save, className: "space-y-6", children: [
+    /* @__PURE__ */ jsxs7("div", { className: "flex gap-1 border-b", children: [
+      /* @__PURE__ */ jsx7(
+        "button",
+        {
+          type: "button",
+          onClick: () => setView("edit"),
+          "aria-pressed": view === "edit",
+          className: `px-4 py-2 text-sm font-medium transition ${view === "edit" ? "border-b-2 border-[var(--primary)] text-[var(--primary)]" : "text-muted-foreground hover:text-foreground"}`,
+          children: t("posts.form.tabEdit")
+        }
+      ),
+      /* @__PURE__ */ jsx7(
+        "button",
+        {
+          type: "button",
+          onClick: () => setView("preview"),
+          "aria-pressed": view === "preview",
+          className: `px-4 py-2 text-sm font-medium transition ${view === "preview" ? "border-b-2 border-[var(--primary)] text-[var(--primary)]" : "text-muted-foreground hover:text-foreground"}`,
+          children: t("posts.form.tabPreview")
+        }
+      )
+    ] }),
+    view === "preview" && /* @__PURE__ */ jsxs7("article", { className: "space-y-4", children: [
+      /* @__PURE__ */ jsxs7("header", { className: "border-b pb-4", children: [
+        /* @__PURE__ */ jsx7("h1", { className: "text-3xl font-bold tracking-tight", children: title || /* @__PURE__ */ jsx7("span", { className: "text-muted-foreground italic", children: t("posts.form.previewNoTitle") }) }),
+        /* @__PURE__ */ jsxs7("p", { className: "mt-2 text-sm text-muted-foreground", children: [
+          previewPost.publishedAt ? /* @__PURE__ */ jsx7("time", { dateTime: previewPost.publishedAt, children: formatDate(previewPost.publishedAt) }) : /* @__PURE__ */ jsx7("span", { children: t("common.draft") }),
+          /* @__PURE__ */ jsx7("span", { className: "mx-2", children: "\xB7" }),
+          /* @__PURE__ */ jsx7("span", { className: "font-mono text-xs uppercase", children: format })
+        ] }),
+        excerpt && /* @__PURE__ */ jsx7("p", { className: "mt-3 text-base text-muted-foreground", children: excerpt })
+      ] }),
+      format === "static" ? /* @__PURE__ */ jsx7("p", { className: "text-sm text-muted-foreground", children: t("posts.form.static.previewHint") }) : /* @__PURE__ */ jsx7(
+        "div",
+        {
+          className: "prose prose-neutral dark:prose-invert max-w-none",
+          dangerouslySetInnerHTML: { __html: renderBody(previewPost) }
+        }
+      ),
+      previewPost.tags && previewPost.tags.length > 0 && /* @__PURE__ */ jsx7("div", { className: "flex flex-wrap gap-2 border-t pt-4 text-sm", children: previewPost.tags.map((tag) => /* @__PURE__ */ jsxs7(
+        "span",
+        {
+          className: "rounded-full border px-2 py-0.5 text-xs text-muted-foreground",
+          children: [
+            "#",
+            tag
+          ]
+        },
+        tag
+      )) }),
+      /* @__PURE__ */ jsx7("p", { className: "text-xs text-muted-foreground", children: t("posts.form.previewHint") })
+    ] }),
+    /* @__PURE__ */ jsxs7("div", { className: view === "edit" ? "space-y-6" : "hidden", children: [
+      /* @__PURE__ */ jsxs7("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsx7(Label, { htmlFor: "title", children: t("posts.form.title") }),
+        /* @__PURE__ */ jsx7(
+          Input,
+          {
+            id: "title",
+            required: true,
+            value: title,
+            onChange: (e) => {
+              setTitle(e.target.value);
+              if (!isEdit && !slug) setSlug(slugify(e.target.value));
+            }
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs7("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsx7(Label, { htmlFor: "slug", children: t("posts.form.slug") }),
+        /* @__PURE__ */ jsx7(
+          Input,
+          {
+            id: "slug",
+            value: slug,
+            onChange: (e) => setSlug(e.target.value),
+            placeholder: slugify(title) || t("posts.form.slugPlaceholder")
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs7("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsx7(Label, { htmlFor: "excerpt", children: t("posts.form.excerpt") }),
+        /* @__PURE__ */ jsx7(
+          Textarea,
+          {
+            id: "excerpt",
+            rows: 2,
+            value: excerpt,
+            onChange: (e) => setExcerpt(e.target.value)
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs7("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsx7(Label, { htmlFor: "format", children: t("posts.form.format") }),
+        /* @__PURE__ */ jsxs7(
+          "select",
+          {
+            id: "format",
+            value: format,
+            onChange: (e) => changeFormat(e.target.value),
+            className: "flex h-9 w-full max-w-xs rounded-md border border-input bg-transparent px-3 py-1 text-sm shadow-sm",
+            children: [
+              /* @__PURE__ */ jsx7("option", { value: "tiptap", children: "Tiptap (rich editor)" }),
+              /* @__PURE__ */ jsx7("option", { value: "markdown", children: "Markdown" }),
+              /* @__PURE__ */ jsx7("option", { value: "html", children: "HTML" }),
+              /* @__PURE__ */ jsx7("option", { value: "static", children: t("posts.form.formatStaticLabel") })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx7("p", { className: "text-xs text-muted-foreground", children: t("posts.form.formatHint") })
+      ] }),
+      /* @__PURE__ */ jsxs7("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsxs7("div", { className: "flex items-center justify-between", children: [
+          /* @__PURE__ */ jsx7(Label, { children: t("posts.form.body") }),
+          format !== "tiptap" && format !== "static" && // For textarea-based formats (markdown / html) there's no
+          // embedded toolbar, so we surface the MediaPicker as a
+          // standalone button. Selecting an asset inserts a
+          // format-aware snippet at the cursor.
+          /* @__PURE__ */ jsx7(
+            MediaPicker,
+            {
+              onSelect: insertMediaSnippet,
+              trigger: /* @__PURE__ */ jsxs7(Button6, { type: "button", variant: "outline", size: "sm", children: [
+                /* @__PURE__ */ jsx7(ImageIcon3, { className: "mr-2 h-3 w-3" }),
+                t("posts.form.insertMedia")
+              ] })
+            }
+          )
+        ] }),
+        format === "tiptap" ? /* @__PURE__ */ jsx7(TiptapEditor, { initialContent: body, onChange: setBody }) : format === "static" ? /* @__PURE__ */ jsx7(
+          StaticUploader,
+          {
+            initial: initialStaticBody,
+            onFilesReady: (files, entrypoint) => setPendingBundle({ files, entrypoint }),
+            onClear: () => setPendingBundle(null)
+          }
+        ) : /* @__PURE__ */ jsx7(
+          Textarea,
+          {
+            ref: bodyTextareaRef,
+            rows: 20,
+            value: typeof body === "string" ? body : "",
+            onChange: (e) => setBody(e.target.value),
+            className: "font-mono text-xs"
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs7("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsx7(Label, { htmlFor: "tags", children: t("posts.form.tags") }),
+        /* @__PURE__ */ jsx7(
+          Input,
+          {
+            id: "tags",
+            value: tagsInput,
+            onChange: (e) => setTagsInput(e.target.value),
+            placeholder: t("posts.form.tagsPlaceholder")
+          }
+        ),
+        /* @__PURE__ */ jsx7("p", { className: "text-xs text-muted-foreground", children: t("posts.form.tagsHint") })
+      ] }),
+      /* @__PURE__ */ jsxs7("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsx7(Label, { htmlFor: "status", children: t("posts.form.status") }),
+        /* @__PURE__ */ jsxs7(
+          "select",
+          {
+            id: "status",
+            value: status,
+            onChange: (e) => setStatus(e.target.value),
+            className: "flex h-9 w-full max-w-xs rounded-md border border-input bg-transparent px-3 py-1 text-sm shadow-sm",
+            children: [
+              /* @__PURE__ */ jsx7("option", { value: "draft", children: t("common.draft") }),
+              /* @__PURE__ */ jsx7("option", { value: "published", children: t("common.published") })
+            ]
+          }
+        )
+      ] }),
+      format === "html" && /* @__PURE__ */ jsx7("div", { className: "space-y-2", children: /* @__PURE__ */ jsxs7("label", { className: "flex items-start gap-2 text-sm", children: [
+        /* @__PURE__ */ jsx7(
+          "input",
+          {
+            type: "checkbox",
+            checked: noLayout,
+            onChange: (e) => setNoLayout(e.target.checked),
+            className: "mt-1"
+          }
+        ),
+        /* @__PURE__ */ jsxs7("span", { children: [
+          /* @__PURE__ */ jsx7("span", { className: "font-medium", children: t("posts.form.noLayout") }),
+          /* @__PURE__ */ jsx7("span", { className: "block text-xs text-muted-foreground", children: t("posts.form.noLayoutHint") })
+        ] })
+      ] }) }),
+      error && /* @__PURE__ */ jsx7("p", { className: "text-sm text-destructive", children: error }),
+      /* @__PURE__ */ jsxs7("div", { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsx7(Button6, { type: "submit", disabled: saving, children: saving ? t("common.saving") : isEdit ? t("posts.form.saveChanges") : t("posts.form.createPost") }),
+        isEdit && /* @__PURE__ */ jsx7(Button6, { type: "button", variant: "destructive", onClick: handleDelete, disabled: saving, children: t("posts.form.delete") })
+      ] })
+    ] })
+  ] });
+}
+
+export {
+  sanitizeName,
+  uploadProcessedImage,
+  MediaPicker,
+  PostForm
+};