@setzkasten-cms/ui 0.4.2

package/dist/index.js

@@ -0,0 +1,2936 @@
+// src/providers/setzkasten-provider.tsx
+import { createContext, useContext, useMemo } from "react";
+import { createEventBus } from "@setzkasten-cms/core";
+import { jsx } from "react/jsx-runtime";
+var Context = createContext(null);
+function SetzKastenProvider({
+  config,
+  repository,
+  auth,
+  assets,
+  children
+}) {
+  const value = useMemo(
+    () => ({
+      config,
+      repository,
+      auth,
+      assets,
+      eventBus: createEventBus()
+    }),
+    [config, repository, auth, assets]
+  );
+  return /* @__PURE__ */ jsx(Context, { value, children });
+}
+function useSetzKasten() {
+  const context = useContext(Context);
+  if (!context) {
+    throw new Error("useSetzKasten must be used within a <SetzKastenProvider>");
+  }
+  return context;
+}
+function useRepository() {
+  return useSetzKasten().repository;
+}
+function useAuth() {
+  return useSetzKasten().auth;
+}
+function useAssets() {
+  return useSetzKasten().assets;
+}
+function useEventBus() {
+  return useSetzKasten().eventBus;
+}
+function useConfig() {
+  return useSetzKasten().config;
+}
+
+// src/stores/form-store.ts
+import { produce, enableMapSet } from "immer";
+import { createStore } from "zustand/vanilla";
+import { createCommandHistory } from "@setzkasten-cms/core";
+enableMapSet();
+function getIn(obj, path) {
+  let current = obj;
+  for (const key of path) {
+    if (current === null || current === void 0) return void 0;
+    if (typeof current === "object") {
+      current = current[key];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function setIn(obj, path, value) {
+  if (path.length === 0) return;
+  let current = obj;
+  for (let i = 0; i < path.length - 1; i++) {
+    const key = path[i];
+    const next = current[key];
+    if (next === null || next === void 0 || typeof next !== "object") {
+      const nextKey = path[i + 1];
+      current[key] = typeof nextKey === "number" ? [] : {};
+    }
+    current = current[key];
+  }
+  const lastKey = path[path.length - 1];
+  current[lastKey] = value;
+}
+function pathToKey(path) {
+  return path.join(".");
+}
+function createFormStore() {
+  const history = createCommandHistory();
+  let snapshotTimer = null;
+  let pendingSnapshot = null;
+  let isRestoring = false;
+  function flushSnapshot(store2) {
+    if (!pendingSnapshot) return;
+    const before = pendingSnapshot;
+    const after = structuredClone(store2.getState().values);
+    pendingSnapshot = null;
+    if (JSON.stringify(before) === JSON.stringify(after)) return;
+    const command = {
+      execute() {
+        isRestoring = true;
+        store2.setState({ values: structuredClone(after) });
+        isRestoring = false;
+      },
+      undo() {
+        isRestoring = true;
+        store2.setState({ values: structuredClone(before) });
+        isRestoring = false;
+      },
+      describe() {
+        return "Field change";
+      }
+    };
+    history.execute(command);
+  }
+  const store = createStore((set, get) => ({
+    // State
+    schema: null,
+    values: {},
+    initialValues: {},
+    errors: {},
+    touched: /* @__PURE__ */ new Set(),
+    status: "idle",
+    // Actions
+    init(schema, values, draftValues) {
+      history.clear();
+      pendingSnapshot = null;
+      if (snapshotTimer) clearTimeout(snapshotTimer);
+      set({
+        schema,
+        values: structuredClone(draftValues ?? values),
+        initialValues: structuredClone(values),
+        errors: {},
+        touched: /* @__PURE__ */ new Set(),
+        status: "idle",
+        errorMessage: void 0
+      });
+    },
+    setFieldValue(path, value) {
+      if (!isRestoring) {
+        if (!pendingSnapshot) {
+          pendingSnapshot = structuredClone(get().values);
+        }
+        if (snapshotTimer) clearTimeout(snapshotTimer);
+        snapshotTimer = setTimeout(() => flushSnapshot(store), 500);
+      }
+      set(
+        produce((state) => {
+          setIn(state.values, path, value);
+        })
+      );
+    },
+    getFieldValue(path) {
+      return getIn(get().values, path);
+    },
+    touchField(path) {
+      set(
+        produce((state) => {
+          state.touched.add(pathToKey(path));
+        })
+      );
+    },
+    isFieldDirty(path) {
+      const current = getIn(get().values, path);
+      const initial = getIn(get().initialValues, path);
+      return JSON.stringify(current) !== JSON.stringify(initial);
+    },
+    isDirty() {
+      const { values, initialValues } = get();
+      return JSON.stringify(values) !== JSON.stringify(initialValues);
+    },
+    setFieldErrors(path, errors) {
+      set(
+        produce((state) => {
+          const key = pathToKey(path);
+          if (errors.length > 0) {
+            state.errors[key] = errors;
+          } else {
+            delete state.errors[key];
+          }
+        })
+      );
+    },
+    clearErrors() {
+      set({ errors: {} });
+    },
+    setStatus(status, errorMessage) {
+      set({ status, errorMessage });
+    },
+    reset() {
+      const { initialValues } = get();
+      set({
+        values: structuredClone(initialValues),
+        errors: {},
+        touched: /* @__PURE__ */ new Set(),
+        status: "idle",
+        errorMessage: void 0
+      });
+    },
+    undo() {
+      flushSnapshot(store);
+      history.undo();
+    },
+    redo() {
+      history.redo();
+    },
+    canUndo() {
+      return history.canUndo() || pendingSnapshot !== null;
+    },
+    canRedo() {
+      return history.canRedo();
+    },
+    resetToInitial() {
+      const { initialValues } = get();
+      history.clear();
+      pendingSnapshot = null;
+      if (snapshotTimer) clearTimeout(snapshotTimer);
+      isRestoring = true;
+      set({
+        values: structuredClone(initialValues),
+        errors: {},
+        touched: /* @__PURE__ */ new Set(),
+        status: "idle",
+        errorMessage: void 0
+      });
+      isRestoring = false;
+    }
+  }));
+  return store;
+}
+
+// src/stores/app-store.ts
+import { createStore as createStore2 } from "zustand/vanilla";
+var MAX_RECENT = 10;
+function createAppStore() {
+  return createStore2((set, get) => ({
+    currentCollection: null,
+    currentSlug: null,
+    sidebarOpen: true,
+    theme: "system",
+    recentEntries: [],
+    navigate(collection, slug) {
+      set({ currentCollection: collection, currentSlug: slug });
+      get().addRecentEntry({ collection, slug, label: `${collection}/${slug}` });
+    },
+    toggleSidebar() {
+      set((state) => ({ sidebarOpen: !state.sidebarOpen }));
+    },
+    setTheme(theme) {
+      set({ theme });
+    },
+    addRecentEntry(entry) {
+      set((state) => {
+        const filtered = state.recentEntries.filter(
+          (e) => !(e.collection === entry.collection && e.slug === entry.slug)
+        );
+        return {
+          recentEntries: [{ ...entry, timestamp: Date.now() }, ...filtered].slice(0, MAX_RECENT)
+        };
+      });
+    }
+  }));
+}
+
+// src/fields/field-renderer.tsx
+import { memo as memo10 } from "react";
+
+// src/fields/text-field-renderer.tsx
+import { memo, useCallback as useCallback2, useEffect, useRef as useRef2, useState } from "react";
+
+// src/hooks/use-field.ts
+import { useCallback, useMemo as useMemo2 } from "react";
+import { useStore } from "zustand";
+var EMPTY_ERRORS = [];
+function getIn2(obj, path) {
+  let current = obj;
+  for (const key of path) {
+    if (current === null || current === void 0) return void 0;
+    if (typeof current === "object") {
+      current = current[key];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function useField(store, path) {
+  const pathKey = path.join(".");
+  const value = useStore(store, useCallback(
+    (s) => getIn2(s.values, path),
+    [pathKey]
+  ));
+  const errors = useStore(store, useCallback(
+    (s) => {
+      const fieldErrors = s.errors[pathKey];
+      return fieldErrors && fieldErrors.length > 0 ? fieldErrors : EMPTY_ERRORS;
+    },
+    [pathKey]
+  ));
+  const isTouched = useStore(store, useCallback(
+    (s) => s.touched.has(pathKey),
+    [pathKey]
+  ));
+  const initialValues = useStore(store, useCallback(
+    (s) => getIn2(s.initialValues, path),
+    [pathKey]
+  ));
+  const isDirty = JSON.stringify(value) !== JSON.stringify(initialValues);
+  const setValue = useCallback(
+    (newValue) => {
+      store.getState().setFieldValue(path, newValue);
+    },
+    [store, pathKey]
+  );
+  const touch = useCallback(() => {
+    store.getState().touchField(path);
+  }, [store, pathKey]);
+  return useMemo2(
+    () => ({
+      value,
+      errors,
+      isTouched,
+      isDirty,
+      setValue,
+      touch,
+      path
+    }),
+    [value, errors, isTouched, isDirty, setValue, touch, path]
+  );
+}
+
+// src/fields/text-field-renderer.tsx
+import { useEditor, EditorContent } from "@tiptap/react";
+import StarterKit from "@tiptap/starter-kit";
+import Placeholder from "@tiptap/extension-placeholder";
+import Link from "@tiptap/extension-link";
+import TextAlign from "@tiptap/extension-text-align";
+import {
+  Type,
+  AlignLeft,
+  AlignCenter,
+  AlignRight,
+  AlignJustify
+} from "lucide-react";
+import { Fragment, jsx as jsx2, jsxs } from "react/jsx-runtime";
+var STORAGE_KEY = "sk-formatting-fields";
+function getFormattingState(fieldPath) {
+  try {
+    const stored = localStorage.getItem(STORAGE_KEY);
+    if (!stored) return false;
+    const map = JSON.parse(stored);
+    return map[fieldPath] ?? false;
+  } catch {
+    return false;
+  }
+}
+function setFormattingState(fieldPath, enabled) {
+  try {
+    const stored = localStorage.getItem(STORAGE_KEY);
+    const map = stored ? JSON.parse(stored) : {};
+    if (enabled) {
+      map[fieldPath] = true;
+    } else {
+      delete map[fieldPath];
+    }
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(map));
+  } catch {
+  }
+}
+var InlineToolbarButton = memo(function InlineToolbarButton2({
+  label,
+  isActive,
+  onClick,
+  title,
+  children
+}) {
+  return /* @__PURE__ */ jsx2(
+    "button",
+    {
+      type: "button",
+      className: `sk-rte__btn${isActive ? " sk-rte__btn--active" : ""}`,
+      onClick,
+      title: title ?? label,
+      children: children ?? label
+    }
+  );
+});
+var FormattedTextInput = memo(function FormattedTextInput2({
+  field,
+  path,
+  store
+}) {
+  const textField = field;
+  const { value, errors, isDirty, setValue, touch } = useField(store, path);
+  const isUpdatingRef = useRef2(false);
+  const editor = useEditor({
+    extensions: [
+      StarterKit.configure({
+        heading: false,
+        horizontalRule: false,
+        codeBlock: false
+      }),
+      Placeholder.configure({ placeholder: textField.placeholder ?? "Schreibe hier..." }),
+      Link.configure({
+        openOnClick: false,
+        HTMLAttributes: { rel: "noopener noreferrer", target: "_blank" }
+      }),
+      TextAlign.configure({ types: ["paragraph"] })
+    ],
+    content: value || "",
+    onUpdate: ({ editor: ed }) => {
+      isUpdatingRef.current = true;
+      setValue(ed.getHTML());
+      isUpdatingRef.current = false;
+    },
+    onBlur: () => touch()
+  });
+  useEffect(() => {
+    if (!editor || isUpdatingRef.current) return;
+    const current = editor.getHTML();
+    if (current !== value && typeof value === "string") {
+      editor.commands.setContent(value, { emitUpdate: false });
+    }
+  }, [editor, value]);
+  const handleLink = useCallback2(() => {
+    if (!editor) return;
+    if (editor.isActive("link")) {
+      editor.chain().focus().unsetLink().run();
+      return;
+    }
+    const url = window.prompt("URL eingeben:");
+    if (!url) return;
+    editor.chain().focus().setLink({ href: url }).run();
+  }, [editor]);
+  if (!editor) return null;
+  return /* @__PURE__ */ jsxs("div", { className: "sk-rte sk-rte--inline", children: [
+    /* @__PURE__ */ jsxs("div", { className: "sk-rte__toolbar", children: [
+      /* @__PURE__ */ jsx2(
+        InlineToolbarButton,
+        {
+          label: "B",
+          isActive: editor.isActive("bold"),
+          onClick: () => {
+            editor.chain().focus().toggleBold().run();
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx2(
+        InlineToolbarButton,
+        {
+          label: "I",
+          isActive: editor.isActive("italic"),
+          onClick: () => {
+            editor.chain().focus().toggleItalic().run();
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx2(
+        InlineToolbarButton,
+        {
+          label: "S",
+          isActive: editor.isActive("strike"),
+          onClick: () => {
+            editor.chain().focus().toggleStrike().run();
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx2(
+        InlineToolbarButton,
+        {
+          label: "\u{1F517}",
+          isActive: editor.isActive("link"),
+          onClick: handleLink,
+          title: "Link"
+        }
+      ),
+      /* @__PURE__ */ jsx2("span", { className: "sk-rte__sep" }),
+      /* @__PURE__ */ jsx2(
+        InlineToolbarButton,
+        {
+          label: "\u2022",
+          isActive: editor.isActive("bulletList"),
+          onClick: () => {
+            editor.chain().focus().toggleBulletList().run();
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx2(
+        InlineToolbarButton,
+        {
+          label: "1.",
+          isActive: editor.isActive("orderedList"),
+          onClick: () => {
+            editor.chain().focus().toggleOrderedList().run();
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx2(
+        InlineToolbarButton,
+        {
+          label: "\u201C",
+          isActive: editor.isActive("blockquote"),
+          onClick: () => {
+            editor.chain().focus().toggleBlockquote().run();
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx2("span", { className: "sk-rte__sep" }),
+      /* @__PURE__ */ jsx2(
+        InlineToolbarButton,
+        {
+          isActive: editor.isActive({ textAlign: "left" }),
+          onClick: () => {
+            editor.chain().focus().setTextAlign("left").run();
+          },
+          title: "Linksb\xFCndig",
+          children: /* @__PURE__ */ jsx2(AlignLeft, { size: 14 })
+        }
+      ),
+      /* @__PURE__ */ jsx2(
+        InlineToolbarButton,
+        {
+          isActive: editor.isActive({ textAlign: "center" }),
+          onClick: () => {
+            editor.chain().focus().setTextAlign("center").run();
+          },
+          title: "Zentriert",
+          children: /* @__PURE__ */ jsx2(AlignCenter, { size: 14 })
+        }
+      ),
+      /* @__PURE__ */ jsx2(
+        InlineToolbarButton,
+        {
+          isActive: editor.isActive({ textAlign: "right" }),
+          onClick: () => {
+            editor.chain().focus().setTextAlign("right").run();
+          },
+          title: "Rechtsb\xFCndig",
+          children: /* @__PURE__ */ jsx2(AlignRight, { size: 14 })
+        }
+      ),
+      /* @__PURE__ */ jsx2(
+        InlineToolbarButton,
+        {
+          isActive: editor.isActive({ textAlign: "justify" }),
+          onClick: () => {
+            editor.chain().focus().setTextAlign("justify").run();
+          },
+          title: "Blocksatz",
+          children: /* @__PURE__ */ jsx2(AlignJustify, { size: 14 })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx2(EditorContent, { editor, className: "sk-rte__content sk-rte__content--inline" })
+  ] });
+});
+var PlainTextInput = memo(function PlainTextInput2({
+  field,
+  path,
+  store
+}) {
+  const textField = field;
+  const { value, errors, setValue, touch } = useField(store, path);
+  const handleChange = (e) => {
+    setValue(e.target.value);
+  };
+  const inputProps = {
+    value: value ?? "",
+    onChange: handleChange,
+    onBlur: touch,
+    placeholder: textField.placeholder,
+    maxLength: textField.maxLength,
+    "aria-label": textField.label,
+    "aria-invalid": errors.length > 0
+  };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    textField.multiline ? /* @__PURE__ */ jsx2("textarea", { className: "sk-field__input sk-field__textarea", rows: 4, ...inputProps }) : /* @__PURE__ */ jsx2("input", { className: "sk-field__input", type: "text", ...inputProps }),
+    textField.maxLength && /* @__PURE__ */ jsxs("span", { className: "sk-field__counter", children: [
+      (value ?? "").length,
+      "/",
+      textField.maxLength
+    ] })
+  ] });
+});
+var TextFieldRenderer = memo(function TextFieldRenderer2(props) {
+  const textField = props.field;
+  const { errors, isDirty } = useField(props.store, props.path);
+  const fieldPath = props.path.join(".");
+  const [formatting, setFormatting] = useState(
+    () => textField.formatting || getFormattingState(fieldPath)
+  );
+  const toggleFormatting = useCallback2(() => {
+    setFormatting((prev) => {
+      const next = !prev;
+      setFormattingState(fieldPath, next);
+      return next;
+    });
+  }, [fieldPath]);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `sk-field sk-field--text${formatting ? " sk-field--formatted" : ""}`,
+      "data-dirty": isDirty || void 0,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "sk-field__header", children: [
+          /* @__PURE__ */ jsxs("label", { className: "sk-field__label", children: [
+            textField.label,
+            textField.required && /* @__PURE__ */ jsx2("span", { className: "sk-field__required", children: "*" })
+          ] }),
+          /* @__PURE__ */ jsx2(
+            "button",
+            {
+              type: "button",
+              className: `sk-field__format-toggle${formatting ? " sk-field__format-toggle--active" : ""}`,
+              onClick: toggleFormatting,
+              title: formatting ? "Formatierung ausschalten" : "Formatierung einschalten",
+              children: /* @__PURE__ */ jsx2(Type, { size: 14 })
+            }
+          )
+        ] }),
+        textField.description && /* @__PURE__ */ jsx2("p", { className: "sk-field__description", children: textField.description }),
+        formatting ? /* @__PURE__ */ jsx2(FormattedTextInput, { ...props }) : /* @__PURE__ */ jsx2(PlainTextInput, { ...props }),
+        errors.length > 0 && /* @__PURE__ */ jsx2("div", { className: "sk-field__errors", children: errors.map((err3, i) => /* @__PURE__ */ jsx2("p", { className: "sk-field__error", children: err3 }, i)) })
+      ]
+    }
+  );
+});
+
+// src/fields/number-field-renderer.tsx
+import { memo as memo2 } from "react";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var NumberFieldRenderer = memo2(function NumberFieldRenderer2({
+  field,
+  path,
+  store
+}) {
+  const numField = field;
+  const { value, errors, setValue, touch } = useField(store, path);
+  return /* @__PURE__ */ jsxs2("div", { className: "sk-field sk-field--number", children: [
+    /* @__PURE__ */ jsx3("label", { className: "sk-field__label", children: numField.label }),
+    numField.description && /* @__PURE__ */ jsx3("p", { className: "sk-field__description", children: numField.description }),
+    /* @__PURE__ */ jsx3(
+      "input",
+      {
+        className: "sk-field__input",
+        type: "number",
+        value: value ?? 0,
+        onChange: (e) => setValue(Number(e.target.value)),
+        onBlur: touch,
+        min: numField.min,
+        max: numField.max,
+        step: numField.step,
+        "aria-label": numField.label
+      }
+    ),
+    errors.length > 0 && /* @__PURE__ */ jsx3("div", { className: "sk-field__errors", children: errors.map((err3, i) => /* @__PURE__ */ jsx3("p", { className: "sk-field__error", children: err3 }, i)) })
+  ] });
+});
+
+// src/fields/boolean-field-renderer.tsx
+import { memo as memo3 } from "react";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var BooleanFieldRenderer = memo3(function BooleanFieldRenderer2({
+  field,
+  path,
+  store
+}) {
+  const boolField = field;
+  const { value, setValue } = useField(store, path);
+  return /* @__PURE__ */ jsxs3("div", { className: "sk-field sk-field--boolean", children: [
+    /* @__PURE__ */ jsxs3("label", { className: "sk-field__toggle", children: [
+      /* @__PURE__ */ jsx4(
+        "input",
+        {
+          type: "checkbox",
+          checked: Boolean(value),
+          onChange: (e) => setValue(e.target.checked),
+          "aria-label": boolField.label
+        }
+      ),
+      /* @__PURE__ */ jsx4("span", { className: "sk-field__toggle-label", children: boolField.label })
+    ] }),
+    boolField.description && /* @__PURE__ */ jsx4("p", { className: "sk-field__description", children: boolField.description })
+  ] });
+});
+
+// src/fields/select-field-renderer.tsx
+import { memo as memo4 } from "react";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var SelectFieldRenderer = memo4(function SelectFieldRenderer2({
+  field,
+  path,
+  store
+}) {
+  const selectField = field;
+  const { value, errors, setValue, touch } = useField(store, path);
+  return /* @__PURE__ */ jsxs4("div", { className: "sk-field sk-field--select", children: [
+    /* @__PURE__ */ jsx5("label", { className: "sk-field__label", children: selectField.label }),
+    selectField.description && /* @__PURE__ */ jsx5("p", { className: "sk-field__description", children: selectField.description }),
+    /* @__PURE__ */ jsx5(
+      "select",
+      {
+        className: "sk-field__input sk-field__select",
+        value: value ?? "",
+        onChange: (e) => setValue(e.target.value),
+        onBlur: touch,
+        "aria-label": selectField.label,
+        children: selectField.options.map((opt) => /* @__PURE__ */ jsx5("option", { value: opt.value, children: opt.label }, opt.value))
+      }
+    ),
+    errors.length > 0 && /* @__PURE__ */ jsx5("div", { className: "sk-field__errors", children: errors.map((err3, i) => /* @__PURE__ */ jsx5("p", { className: "sk-field__error", children: err3 }, i)) })
+  ] });
+});
+
+// src/fields/icon-field-renderer.tsx
+import { memo as memo5, useState as useState2, useMemo as useMemo3, useCallback as useCallback3, useRef as useRef3, useEffect as useEffect2 } from "react";
+import { icons } from "lucide-react";
+import { Fragment as Fragment2, jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function toKebab(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function toPascal(name) {
+  return name.replace(/(^|-)([a-z])/g, (_, __, c) => c.toUpperCase());
+}
+var ALL_ICONS = Object.entries(icons).map(
+  ([pascal, comp]) => [toKebab(pascal), pascal, comp]
+);
+var MAX_VISIBLE = 120;
+var IconFieldRenderer = memo5(function IconFieldRenderer2({
+  field,
+  path,
+  store
+}) {
+  const { value, errors, setValue } = useField(store, path);
+  const [open, setOpen] = useState2(false);
+  const [search, setSearch] = useState2("");
+  const searchRef = useRef3(null);
+  const panelRef = useRef3(null);
+  const currentValue = value ?? "";
+  const CurrentIcon = currentValue ? icons[toPascal(currentValue)] ?? null : null;
+  const filtered = useMemo3(() => {
+    if (!search) return ALL_ICONS.slice(0, MAX_VISIBLE);
+    const q = search.toLowerCase();
+    return ALL_ICONS.filter(([kebab]) => kebab.includes(q)).slice(0, MAX_VISIBLE);
+  }, [search]);
+  const selectIcon = useCallback3(
+    (kebab) => {
+      setValue(kebab);
+      setOpen(false);
+      setSearch("");
+    },
+    [setValue]
+  );
+  useEffect2(() => {
+    if (open) searchRef.current?.focus();
+  }, [open]);
+  useEffect2(() => {
+    if (!open) return;
+    const handler = (e) => {
+      if (panelRef.current && !panelRef.current.contains(e.target)) {
+        setOpen(false);
+        setSearch("");
+      }
+    };
+    document.addEventListener("mousedown", handler);
+    return () => document.removeEventListener("mousedown", handler);
+  }, [open]);
+  return /* @__PURE__ */ jsxs5("div", { className: "sk-field sk-field--icon", children: [
+    /* @__PURE__ */ jsx6("label", { className: "sk-field__label", children: field.label }),
+    field.description && /* @__PURE__ */ jsx6("p", { className: "sk-field__description", children: field.description }),
+    /* @__PURE__ */ jsx6(
+      "button",
+      {
+        type: "button",
+        className: "sk-icon-picker__trigger",
+        onClick: () => setOpen(!open),
+        children: CurrentIcon ? /* @__PURE__ */ jsxs5(Fragment2, { children: [
+          /* @__PURE__ */ jsx6(CurrentIcon, { size: 20 }),
+          /* @__PURE__ */ jsx6("span", { children: currentValue })
+        ] }) : /* @__PURE__ */ jsx6("span", { className: "sk-icon-picker__placeholder", children: "Icon w\xE4hlen..." })
+      }
+    ),
+    open && /* @__PURE__ */ jsxs5("div", { className: "sk-icon-picker__panel", ref: panelRef, children: [
+      /* @__PURE__ */ jsx6(
+        "input",
+        {
+          ref: searchRef,
+          type: "text",
+          className: "sk-icon-picker__search",
+          placeholder: "Icon suchen...",
+          value: search,
+          onChange: (e) => setSearch(e.target.value)
+        }
+      ),
+      /* @__PURE__ */ jsxs5("div", { className: "sk-icon-picker__grid", children: [
+        filtered.map(([kebab, , Icon]) => /* @__PURE__ */ jsx6(
+          "button",
+          {
+            type: "button",
+            className: `sk-icon-picker__item${kebab === currentValue ? " sk-icon-picker__item--active" : ""}`,
+            onClick: () => selectIcon(kebab),
+            title: kebab,
+            children: /* @__PURE__ */ jsx6(Icon, { size: 20 })
+          },
+          kebab
+        )),
+        filtered.length === 0 && /* @__PURE__ */ jsx6("p", { className: "sk-icon-picker__empty", children: "Kein Icon gefunden" })
+      ] })
+    ] }),
+    errors.length > 0 && /* @__PURE__ */ jsx6("div", { className: "sk-field__errors", children: errors.map((err3, i) => /* @__PURE__ */ jsx6("p", { className: "sk-field__error", children: err3 }, i)) })
+  ] });
+});
+
+// src/fields/array-field-renderer.tsx
+import { memo as memo6, useCallback as useCallback4 } from "react";
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+var ArrayFieldRenderer = memo6(function ArrayFieldRenderer2({
+  field,
+  path,
+  store
+}) {
+  const arrayField = field;
+  const { value, setValue } = useField(store, path);
+  const items = value ?? [];
+  const addItem = useCallback4(() => {
+    const defaultValue = arrayField.itemField.defaultValue ?? (arrayField.itemField.type === "object" ? {} : arrayField.itemField.type === "text" ? "" : arrayField.itemField.type === "number" ? 0 : arrayField.itemField.type === "boolean" ? false : null);
+    setValue([...items, defaultValue]);
+  }, [items, arrayField.itemField, setValue]);
+  const removeItem = useCallback4(
+    (index) => {
+      setValue(items.filter((_, i) => i !== index));
+    },
+    [items, setValue]
+  );
+  const moveItem = useCallback4(
+    (from, to) => {
+      const newItems = [...items];
+      const [moved] = newItems.splice(from, 1);
+      newItems.splice(to, 0, moved);
+      setValue(newItems);
+    },
+    [items, setValue]
+  );
+  const canAdd = arrayField.maxItems === void 0 || items.length < arrayField.maxItems;
+  const canRemove = arrayField.minItems === void 0 || items.length > arrayField.minItems;
+  return /* @__PURE__ */ jsxs6("div", { className: "sk-field sk-field--array", children: [
+    /* @__PURE__ */ jsx7("div", { className: "sk-array__header", children: /* @__PURE__ */ jsxs6("label", { className: "sk-field__label", children: [
+      arrayField.label,
+      /* @__PURE__ */ jsxs6("span", { className: "sk-array__count", children: [
+        "(",
+        items.length,
+        ")"
+      ] })
+    ] }) }),
+    /* @__PURE__ */ jsx7("div", { className: "sk-array__items", children: items.map((_, index) => {
+      const itemLabel = arrayField.itemLabel ? arrayField.itemLabel(items[index], index) : `#${index + 1}`;
+      return /* @__PURE__ */ jsxs6("div", { className: "sk-array__item", children: [
+        /* @__PURE__ */ jsxs6("div", { className: "sk-array__item-header", children: [
+          /* @__PURE__ */ jsx7("span", { className: "sk-array__item-label", children: itemLabel }),
+          /* @__PURE__ */ jsxs6("div", { className: "sk-array__item-actions", children: [
+            index > 0 && /* @__PURE__ */ jsx7("button", { type: "button", className: "sk-button sk-button--sm", onClick: () => moveItem(index, index - 1), title: "Nach oben", children: "\u2191" }),
+            index < items.length - 1 && /* @__PURE__ */ jsx7("button", { type: "button", className: "sk-button sk-button--sm", onClick: () => moveItem(index, index + 1), title: "Nach unten", children: "\u2193" }),
+            canRemove && /* @__PURE__ */ jsx7("button", { type: "button", className: "sk-button sk-button--sm sk-button--danger", onClick: () => removeItem(index), title: "Entfernen", children: "\xD7" })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx7(
+          FieldRenderer,
+          {
+            field: arrayField.itemField,
+            path: [...path, index],
+            store
+          }
+        )
+      ] }, index);
+    }) }),
+    canAdd && /* @__PURE__ */ jsx7("button", { type: "button", className: "sk-button sk-button--sm sk-array__add", onClick: addItem, children: "+ Hinzuf\xFCgen" })
+  ] });
+});
+
+// src/fields/object-field-renderer.tsx
+import { memo as memo7, useState as useState3 } from "react";
+import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+var ObjectFieldRenderer = memo7(function ObjectFieldRenderer2({
+  field,
+  path,
+  store
+}) {
+  const objField = field;
+  const [collapsed, setCollapsed] = useState3(false);
+  return /* @__PURE__ */ jsxs7("div", { className: "sk-field sk-field--object", children: [
+    /* @__PURE__ */ jsxs7("div", { className: "sk-field__object-header", children: [
+      /* @__PURE__ */ jsx8("label", { className: "sk-field__label", children: objField.label }),
+      objField.collapsible && /* @__PURE__ */ jsx8(
+        "button",
+        {
+          type: "button",
+          className: "sk-field__object-toggle",
+          onClick: () => setCollapsed(!collapsed),
+          children: collapsed ? "\u25B8" : "\u25BE"
+        }
+      )
+    ] }),
+    !collapsed && /* @__PURE__ */ jsx8("div", { className: "sk-field__object-fields", children: Object.entries(objField.fields).map(([key, childField]) => /* @__PURE__ */ jsx8(
+      FieldRenderer,
+      {
+        field: childField,
+        path: [...path, key],
+        store
+      },
+      key
+    )) })
+  ] });
+});
+
+// src/fields/image-field-renderer.tsx
+import { memo as memo8, useCallback as useCallback5, useRef as useRef4, useState as useState4 } from "react";
+import { jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
+function previewUrl(assets, path) {
+  return assets.getPreviewUrl?.(path) ?? assets.getUrl(path);
+}
+async function compressToWebP(file, quality = 0.85) {
+  const skipTypes = ["image/svg+xml", "image/gif", "image/webp", "image/avif"];
+  if (skipTypes.includes(file.type)) {
+    return { bytes: new Uint8Array(await file.arrayBuffer()), filename: file.name, mimeType: file.type };
+  }
+  const bitmap = await createImageBitmap(file);
+  const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
+  const ctx = canvas.getContext("2d");
+  ctx.drawImage(bitmap, 0, 0);
+  bitmap.close();
+  const blob = await canvas.convertToBlob({ type: "image/webp", quality });
+  const webpName = file.name.replace(/\.(jpe?g|png|bmp|tiff?)$/i, ".webp");
+  return { bytes: new Uint8Array(await blob.arrayBuffer()), filename: webpName, mimeType: "image/webp" };
+}
+var ImageFieldRenderer = memo8(function ImageFieldRenderer2({
+  field,
+  path,
+  store
+}) {
+  const imgField = field;
+  const { value, errors, setValue, touch } = useField(store, path);
+  const assets = useAssets();
+  const fileInputRef = useRef4(null);
+  const [uploading, setUploading] = useState4(false);
+  const [dragOver, setDragOver] = useState4(false);
+  const [showBrowser, setShowBrowser] = useState4(false);
+  const [browserScope, setBrowserScope] = useState4("directory");
+  const [existing, setExisting] = useState4([]);
+  const [loadingExisting, setLoadingExisting] = useState4(false);
+  const imageValue = value;
+  const acceptStr = imgField.accept.map((ext) => `.${ext}`).join(",");
+  const selectedThumbUrl = imageValue?.path && assets.getPreviewUrl ? assets.getPreviewUrl(imageValue.path) : imageValue?.path || void 0;
+  const uploadFile = useCallback5(
+    async (file) => {
+      setUploading(true);
+      try {
+        const { bytes, filename, mimeType } = await compressToWebP(file);
+        const result = await assets.upload(imgField.directory, filename, bytes, mimeType);
+        if (result.ok) {
+          const publicUrl = assets.getUrl(result.value.path);
+          setValue({ path: publicUrl, alt: imageValue?.alt ?? "" });
+        } else {
+          const dir = imgField.directory.replace(/^\/+|\/+$/g, "");
+          const publicUrl = assets.getUrl(`public/images/${dir}/${filename}`);
+          setValue({ path: publicUrl, alt: imageValue?.alt ?? "" });
+        }
+      } catch {
+        const dir = imgField.directory.replace(/^\/+|\/+$/g, "");
+        const publicUrl = assets.getUrl(`public/images/${dir}/${file.name}`);
+        setValue({ path: publicUrl, alt: imageValue?.alt ?? "" });
+      }
+      setUploading(false);
+      touch();
+    },
+    [assets, imgField.directory, imageValue?.alt, setValue, touch]
+  );
+  const loadExisting = useCallback5(async (scope) => {
+    setLoadingExisting(true);
+    setBrowserScope(scope);
+    try {
+      const dir = scope === "all" ? "" : imgField.directory;
+      const result = await assets.list(dir);
+      if (result.ok) {
+        setExisting(result.value);
+      }
+    } catch {
+    }
+    setLoadingExisting(false);
+  }, [assets, imgField.directory]);
+  const handleBrowse = useCallback5(() => {
+    setShowBrowser(true);
+    loadExisting("directory");
+  }, [loadExisting]);
+  const handleSelectExisting = useCallback5(
+    (asset) => {
+      const publicUrl = assets.getUrl(asset.path);
+      setValue({ path: publicUrl, alt: imageValue?.alt ?? "" });
+      setShowBrowser(false);
+    },
+    [assets, imageValue?.alt, setValue]
+  );
+  const handleFileSelect = useCallback5(
+    async (e) => {
+      const file = e.target.files?.[0];
+      if (!file) return;
+      await uploadFile(file);
+    },
+    [uploadFile]
+  );
+  const handleDrop = useCallback5(
+    async (e) => {
+      e.preventDefault();
+      setDragOver(false);
+      const file = e.dataTransfer.files[0];
+      if (file) await uploadFile(file);
+    },
+    [uploadFile]
+  );
+  const handleAltChange = useCallback5(
+    (e) => {
+      setValue({ path: imageValue?.path ?? "", alt: e.target.value });
+    },
+    [imageValue?.path, setValue]
+  );
+  const handleRemove = useCallback5(() => {
+    setValue({ path: "", alt: "" });
+    if (fileInputRef.current) {
+      fileInputRef.current.value = "";
+    }
+  }, [setValue]);
+  return /* @__PURE__ */ jsxs8("div", { className: "sk-field sk-field--image", children: [
+    /* @__PURE__ */ jsxs8("label", { className: "sk-field__label", children: [
+      imgField.label,
+      imgField.required && /* @__PURE__ */ jsx9("span", { className: "sk-field__required", children: "*" })
+    ] }),
+    imgField.description && /* @__PURE__ */ jsx9("p", { className: "sk-field__description", children: imgField.description }),
+    /* @__PURE__ */ jsxs8("div", { className: "sk-field__image-zone", children: [
+      uploading ? /* @__PURE__ */ jsx9("div", { className: "sk-field__image-upload", style: { borderColor: "var(--sk-accent)" }, children: "Wird hochgeladen..." }) : imageValue?.path ? /* @__PURE__ */ jsxs8("div", { className: "sk-field__image-preview", children: [
+        selectedThumbUrl && /* @__PURE__ */ jsx9("img", { src: selectedThumbUrl, alt: imageValue.alt ?? "", className: "sk-field__image-thumb" }),
+        /* @__PURE__ */ jsx9("p", { className: "sk-field__image-path", children: imageValue.path }),
+        /* @__PURE__ */ jsxs8("div", { className: "sk-field__image-actions", children: [
+          /* @__PURE__ */ jsx9("button", { type: "button", className: "sk-button sk-button--sm", onClick: () => fileInputRef.current?.click(), children: "Neu hochladen" }),
+          /* @__PURE__ */ jsx9("button", { type: "button", className: "sk-button sk-button--sm", onClick: handleBrowse, children: "Aus Bibliothek" }),
+          /* @__PURE__ */ jsx9("button", { type: "button", className: "sk-button sk-button--sm sk-button--danger", onClick: handleRemove, children: "Entfernen" })
+        ] })
+      ] }) : /* @__PURE__ */ jsxs8("div", { className: "sk-field__image-empty", children: [
+        /* @__PURE__ */ jsx9(
+          "button",
+          {
+            type: "button",
+            className: `sk-field__image-upload${dragOver ? " sk-field__image-upload--drag" : ""}`,
+            onClick: () => fileInputRef.current?.click(),
+            onDragOver: (e) => {
+              e.preventDefault();
+              setDragOver(true);
+            },
+            onDragLeave: () => setDragOver(false),
+            onDrop: handleDrop,
+            children: "Bild hochladen oder hierher ziehen"
+          }
+        ),
+        /* @__PURE__ */ jsx9("button", { type: "button", className: "sk-button sk-button--sm sk-field__image-browse", onClick: handleBrowse, children: "Aus Bibliothek w\xE4hlen" })
+      ] }),
+      /* @__PURE__ */ jsx9(
+        "input",
+        {
+          ref: fileInputRef,
+          type: "file",
+          accept: acceptStr,
+          onChange: handleFileSelect,
+          style: { display: "none" }
+        }
+      )
+    ] }),
+    showBrowser && /* @__PURE__ */ jsxs8("div", { className: "sk-field__image-browser", children: [
+      /* @__PURE__ */ jsxs8("div", { className: "sk-field__image-browser-header", children: [
+        /* @__PURE__ */ jsx9("span", { className: "sk-field__image-browser-title", children: browserScope === "all" ? "Alle Bilder" : `Bilder in ${imgField.directory || "Bibliothek"}` }),
+        /* @__PURE__ */ jsxs8("div", { className: "sk-field__image-browser-controls", children: [
+          browserScope === "directory" ? /* @__PURE__ */ jsx9("button", { type: "button", className: "sk-button sk-button--sm", onClick: () => loadExisting("all"), children: "Alle Bilder" }) : /* @__PURE__ */ jsxs8("button", { type: "button", className: "sk-button sk-button--sm", onClick: () => loadExisting("directory"), children: [
+            "Nur ",
+            imgField.directory || "Ordner"
+          ] }),
+          /* @__PURE__ */ jsx9("button", { type: "button", className: "sk-button sk-button--sm", onClick: () => setShowBrowser(false), children: "Schlie\xDFen" })
+        ] })
+      ] }),
+      loadingExisting ? /* @__PURE__ */ jsx9("p", { className: "sk-field__image-browser-loading", children: "Lade Bilder..." }) : existing.length === 0 ? /* @__PURE__ */ jsx9("p", { className: "sk-field__image-browser-empty", children: "Keine Bilder vorhanden" }) : /* @__PURE__ */ jsx9("div", { className: "sk-field__image-browser-grid", children: existing.map((asset) => {
+        const thumbUrl = previewUrl(assets, asset.path);
+        return /* @__PURE__ */ jsxs8(
+          "button",
+          {
+            type: "button",
+            className: "sk-field__image-browser-item",
+            onClick: () => handleSelectExisting(asset),
+            title: asset.path.split("/").pop(),
+            children: [
+              /* @__PURE__ */ jsx9("img", { src: thumbUrl, alt: "", className: "sk-field__image-browser-thumb" }),
+              /* @__PURE__ */ jsx9("span", { className: "sk-field__image-browser-name", children: asset.path.split("/").pop() })
+            ]
+          },
+          asset.path
+        );
+      }) })
+    ] }),
+    imageValue?.path && /* @__PURE__ */ jsx9(
+      "input",
+      {
+        className: "sk-field__input",
+        type: "text",
+        value: imageValue.alt ?? "",
+        onChange: handleAltChange,
+        placeholder: "Alt-Text (f\xFCr SEO)",
+        "aria-label": "Alt text"
+      }
+    ),
+    errors.length > 0 && /* @__PURE__ */ jsx9("div", { className: "sk-field__errors", children: errors.map((err3, i) => /* @__PURE__ */ jsx9("p", { className: "sk-field__error", children: err3 }, i)) })
+  ] });
+});
+
+// src/fields/override-field-renderer.tsx
+import { memo as memo9 } from "react";
+import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+var OverrideFieldRenderer = memo9(function OverrideFieldRenderer2({
+  field,
+  path,
+  store
+}) {
+  const overrideField = field;
+  const { value, setValue } = useField(store, path);
+  const overrideValue = value ?? { active: false };
+  const isActive = overrideValue.active;
+  const toggleActive = () => {
+    setValue({ ...overrideValue, active: !isActive });
+  };
+  return /* @__PURE__ */ jsxs9("div", { className: "sk-field sk-field--override", "data-active": isActive || void 0, children: [
+    /* @__PURE__ */ jsx10("div", { className: "sk-field__override-header", children: /* @__PURE__ */ jsxs9("label", { className: "sk-field__toggle", children: [
+      /* @__PURE__ */ jsx10("input", { type: "checkbox", checked: isActive, onChange: toggleActive }),
+      /* @__PURE__ */ jsx10("span", { className: "sk-field__toggle-label", children: overrideField.label })
+    ] }) }),
+    isActive && /* @__PURE__ */ jsx10("div", { className: "sk-field__override-fields", children: Object.entries(overrideField.fields).map(([key, childField]) => /* @__PURE__ */ jsx10(
+      FieldRenderer,
+      {
+        field: childField,
+        path: [...path, key],
+        store
+      },
+      key
+    )) })
+  ] });
+});
+
+// src/fields/field-renderer.tsx
+import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
+var rendererMap = {
+  text: TextFieldRenderer,
+  number: NumberFieldRenderer,
+  boolean: BooleanFieldRenderer,
+  select: SelectFieldRenderer,
+  icon: IconFieldRenderer,
+  array: ArrayFieldRenderer,
+  object: ObjectFieldRenderer,
+  image: ImageFieldRenderer,
+  override: OverrideFieldRenderer
+};
+var FieldRenderer = memo10(function FieldRenderer2({
+  field,
+  path,
+  store
+}) {
+  const Renderer = rendererMap[field.type];
+  if (!Renderer) {
+    return /* @__PURE__ */ jsxs10("div", { style: { color: "#ef4444", padding: "8px", fontSize: "14px" }, children: [
+      "Unknown field type: ",
+      field.type
+    ] });
+  }
+  return /* @__PURE__ */ jsx11(Renderer, { field, path, store });
+});
+
+// src/components/entry-form.tsx
+import { memo as memo11, useEffect as useEffect3, useMemo as useMemo4 } from "react";
+import { jsx as jsx12, jsxs as jsxs11 } from "react/jsx-runtime";
+var EntryForm = memo11(function EntryForm2({
+  schema,
+  initialValues,
+  draftValues,
+  onSave,
+  storeRef
+}) {
+  const store = useMemo4(() => createFormStore(), []);
+  useEffect3(() => {
+    if (storeRef) {
+      storeRef.current = store;
+    }
+    return () => {
+      if (storeRef) {
+        storeRef.current = null;
+      }
+    };
+  }, [store, storeRef]);
+  useEffect3(() => {
+    store.getState().init(schema, initialValues, draftValues);
+  }, [store, schema, initialValues, draftValues]);
+  const handleSave = () => {
+    const { values, isDirty } = store.getState();
+    if (isDirty() && onSave) {
+      onSave(values);
+    }
+  };
+  return /* @__PURE__ */ jsxs11("div", { className: "sk-entry-form", children: [
+    /* @__PURE__ */ jsx12("div", { className: "sk-entry-form__fields", children: Object.entries(schema).map(([key, field]) => /* @__PURE__ */ jsx12(
+      FieldRenderer,
+      {
+        field,
+        path: [key],
+        store
+      },
+      key
+    )) }),
+    onSave && /* @__PURE__ */ jsx12("div", { className: "sk-entry-form__actions", children: /* @__PURE__ */ jsx12("button", { type: "button", className: "sk-button sk-button--primary", onClick: handleSave, children: "Speichern" }) })
+  ] });
+});
+
+// src/components/entry-list.tsx
+import { useEffect as useEffect4, useState as useState5, useCallback as useCallback6 } from "react";
+import { jsx as jsx13, jsxs as jsxs12 } from "react/jsx-runtime";
+function EntryList({
+  collection,
+  label,
+  onSelect,
+  onCreate,
+  selectedSlug
+}) {
+  const repository = useRepository();
+  const [entries, setEntries] = useState5([]);
+  const [loading, setLoading] = useState5(true);
+  const loadEntries = useCallback6(async () => {
+    setLoading(true);
+    const result = await repository.listEntries(collection);
+    if (result.ok) {
+      setEntries(result.value);
+    }
+    setLoading(false);
+  }, [repository, collection]);
+  useEffect4(() => {
+    loadEntries();
+  }, [loadEntries]);
+  const handleDelete = useCallback6(
+    async (slug) => {
+      if (!confirm(`"${slug}" wirklich l\xF6schen?`)) return;
+      const result = await repository.deleteEntry(collection, slug);
+      if (result.ok) {
+        loadEntries();
+      }
+    },
+    [repository, collection, loadEntries]
+  );
+  if (loading) {
+    return /* @__PURE__ */ jsxs12("div", { className: "sk-entry-list sk-entry-list--loading", children: [
+      /* @__PURE__ */ jsx13("div", { className: "sk-entry-list__header", children: /* @__PURE__ */ jsx13("h2", { className: "sk-entry-list__title", children: label }) }),
+      /* @__PURE__ */ jsx13("div", { className: "sk-entry-list__empty", children: "Lade..." })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs12("div", { className: "sk-entry-list", children: [
+    /* @__PURE__ */ jsxs12("div", { className: "sk-entry-list__header", children: [
+      /* @__PURE__ */ jsx13("h2", { className: "sk-entry-list__title", children: label }),
+      /* @__PURE__ */ jsx13("span", { className: "sk-entry-list__count", children: entries.length }),
+      /* @__PURE__ */ jsx13(
+        "button",
+        {
+          type: "button",
+          className: "sk-button sk-button--primary sk-button--sm",
+          onClick: onCreate,
+          children: "+ Neu"
+        }
+      )
+    ] }),
+    entries.length === 0 ? /* @__PURE__ */ jsxs12("div", { className: "sk-entry-list__empty", children: [
+      /* @__PURE__ */ jsx13("p", { children: "Noch keine Eintr\xE4ge." }),
+      /* @__PURE__ */ jsx13(
+        "button",
+        {
+          type: "button",
+          className: "sk-button sk-button--primary",
+          onClick: onCreate,
+          children: "Ersten Eintrag erstellen"
+        }
+      )
+    ] }) : /* @__PURE__ */ jsx13("ul", { className: "sk-entry-list__items", role: "list", children: entries.map((entry) => /* @__PURE__ */ jsxs12(
+      "li",
+      {
+        className: `sk-entry-list__item ${entry.slug === selectedSlug ? "sk-entry-list__item--active" : ""}`,
+        children: [
+          /* @__PURE__ */ jsxs12(
+            "button",
+            {
+              type: "button",
+              className: "sk-entry-list__item-btn",
+              onClick: () => onSelect(entry.slug),
+              children: [
+                /* @__PURE__ */ jsx13("span", { className: "sk-entry-list__item-name", children: entry.name }),
+                /* @__PURE__ */ jsx13("span", { className: "sk-entry-list__item-slug", children: entry.slug })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx13(
+            "button",
+            {
+              type: "button",
+              className: "sk-entry-list__item-delete",
+              onClick: (e) => {
+                e.stopPropagation();
+                handleDelete(entry.slug);
+              },
+              title: "L\xF6schen",
+              "aria-label": `${entry.name} l\xF6schen`,
+              children: "\xD7"
+            }
+          )
+        ]
+      },
+      entry.slug
+    )) })
+  ] });
+}
+
+// src/components/collection-view.tsx
+import { useState as useState6, useCallback as useCallback7, useRef as useRef5 } from "react";
+import { jsx as jsx14, jsxs as jsxs13 } from "react/jsx-runtime";
+function CollectionView({ collectionKey, collection }) {
+  const repository = useRepository();
+  const [selectedSlug, setSelectedSlug] = useState6(null);
+  const [entryData, setEntryData] = useState6(null);
+  const [loading, setLoading] = useState6(false);
+  const [creating, setCreating] = useState6(false);
+  const formStoreRef = useRef5(null);
+  const loadEntry = useCallback7(
+    async (slug) => {
+      setLoading(true);
+      setCreating(false);
+      const result = await repository.getEntry(collectionKey, slug);
+      if (result.ok && result.value) {
+        setSelectedSlug(slug);
+        setEntryData(result.value.content);
+      }
+      setLoading(false);
+    },
+    [repository, collectionKey]
+  );
+  const handleCreate = useCallback7(() => {
+    setSelectedSlug(null);
+    setEntryData({});
+    setCreating(true);
+  }, []);
+  const handleSave = useCallback7(
+    async (values) => {
+      const slug = creating ? prompt("Slug f\xFCr den neuen Eintrag:") : selectedSlug;
+      if (!slug) return;
+      const result = await repository.saveEntry(collectionKey, slug, {
+        content: values
+      });
+      if (result.ok) {
+        setSelectedSlug(slug);
+        setCreating(false);
+        console.log(`[CollectionView] Saved ${slug}`);
+      }
+    },
+    [repository, collectionKey, selectedSlug, creating]
+  );
+  return /* @__PURE__ */ jsxs13("div", { className: "sk-collection-view", children: [
+    /* @__PURE__ */ jsx14("div", { className: "sk-collection-view__list", children: /* @__PURE__ */ jsx14(
+      EntryList,
+      {
+        collection: collectionKey,
+        label: collection.label,
+        onSelect: loadEntry,
+        onCreate: handleCreate,
+        selectedSlug: selectedSlug ?? void 0
+      }
+    ) }),
+    /* @__PURE__ */ jsx14("div", { className: "sk-collection-view__editor", children: loading ? /* @__PURE__ */ jsx14("div", { className: "sk-empty", children: /* @__PURE__ */ jsx14("p", { children: "Lade Eintrag..." }) }) : entryData !== null ? /* @__PURE__ */ jsxs13("div", { children: [
+      /* @__PURE__ */ jsx14("div", { className: "sk-collection-view__editor-header", children: /* @__PURE__ */ jsx14("h3", { children: creating ? "Neuer Eintrag" : selectedSlug }) }),
+      /* @__PURE__ */ jsx14(
+        EntryForm,
+        {
+          schema: collection.fields,
+          initialValues: entryData,
+          onSave: handleSave,
+          storeRef: formStoreRef
+        },
+        selectedSlug ?? "new"
+      )
+    ] }) : /* @__PURE__ */ jsx14("div", { className: "sk-empty", children: /* @__PURE__ */ jsx14("p", { children: "W\xE4hle einen Eintrag aus der Liste oder erstelle einen neuen." }) }) })
+  ] });
+}
+
+// src/components/admin-app.tsx
+import { useState as useState9, useEffect as useEffect7 } from "react";
+
+// src/components/page-builder.tsx
+import { useState as useState8, useEffect as useEffect6, useCallback as useCallback9, useRef as useRef6, useSyncExternalStore } from "react";
+
+// src/components/toast.tsx
+import { useState as useState7, useCallback as useCallback8, createContext as createContext2, useContext as useContext2 } from "react";
+import { jsx as jsx15, jsxs as jsxs14 } from "react/jsx-runtime";
+var ToastContext = createContext2({ toast: () => {
+} });
+function useToast() {
+  return useContext2(ToastContext);
+}
+var nextId = 0;
+function ToastProvider({ children }) {
+  const [toasts, setToasts] = useState7([]);
+  const toast = useCallback8((message, type = "info") => {
+    const id = nextId++;
+    setToasts((prev) => [...prev, { id, message, type }]);
+    setTimeout(() => {
+      setToasts((prev) => prev.filter((t) => t.id !== id));
+    }, 3e3);
+  }, []);
+  return /* @__PURE__ */ jsxs14(ToastContext.Provider, { value: { toast }, children: [
+    children,
+    toasts.length > 0 && /* @__PURE__ */ jsx15("div", { className: "sk-toast-container", children: toasts.map((t) => /* @__PURE__ */ jsx15("div", { className: `sk-toast sk-toast--${t.type}`, children: t.message }, t.id)) })
+  ] });
+}
+
+// src/components/page-builder.tsx
+import {
+  LayoutGrid,
+  Star,
+  Megaphone,
+  Puzzle,
+  Code,
+  Eye,
+  EyeOff,
+  Shield,
+  Palette,
+  Zap,
+  Image,
+  Link as Link2,
+  Settings,
+  FileText,
+  Folder,
+  List,
+  Edit,
+  Tag,
+  Globe,
+  Heart,
+  Users,
+  X,
+  GripVertical,
+  Monitor,
+  AppWindow,
+  Tablet,
+  Smartphone,
+  Save,
+  ChevronUp,
+  ChevronDown,
+  PanelRightClose,
+  PanelRightOpen,
+  RotateCcw,
+  Undo2,
+  Redo2,
+  Trash2
+} from "lucide-react";
+import { Fragment as Fragment3, jsx as jsx16, jsxs as jsxs15 } from "react/jsx-runtime";
+var ICON_MAP = {
+  layout: LayoutGrid,
+  star: Star,
+  megaphone: Megaphone,
+  puzzle: Puzzle,
+  code: Code,
+  eye: Eye,
+  shield: Shield,
+  palette: Palette,
+  zap: Zap,
+  image: Image,
+  link: Link2,
+  settings: Settings,
+  file: FileText,
+  folder: Folder,
+  list: List,
+  edit: Edit,
+  tag: Tag,
+  globe: Globe,
+  heart: Heart,
+  users: Users
+};
+function useDraggable() {
+  const [offset, setOffset] = useState8({ x: 0, y: 0 });
+  const dragging = useRef6(false);
+  const start = useRef6({ x: 0, y: 0 });
+  const startOffset = useRef6({ x: 0, y: 0 });
+  const onMouseDown = useCallback9((e) => {
+    const target = e.target;
+    if (target.closest("button") || target.closest("input") || target.closest("select")) return;
+    if (!target.closest(".sk-pb__nav-header, .sk-pb__slide-over-header, .sk-pb__drag-handle")) return;
+    e.preventDefault();
+    dragging.current = true;
+    start.current = { x: e.clientX, y: e.clientY };
+    startOffset.current = { ...offset };
+    const onMouseMove = (ev) => {
+      if (!dragging.current) return;
+      setOffset({
+        x: startOffset.current.x + ev.clientX - start.current.x,
+        y: startOffset.current.y + ev.clientY - start.current.y
+      });
+    };
+    const onMouseUp = () => {
+      dragging.current = false;
+      document.removeEventListener("mousemove", onMouseMove);
+      document.removeEventListener("mouseup", onMouseUp);
+    };
+    document.addEventListener("mousemove", onMouseMove);
+    document.addEventListener("mouseup", onMouseUp);
+  }, [offset]);
+  const reset = useCallback9(() => setOffset({ x: 0, y: 0 }), []);
+  const hasMoved = offset.x !== 0 || offset.y !== 0;
+  const style = hasMoved ? { transform: `translate(${offset.x}px, ${offset.y}px)` } : void 0;
+  return { onMouseDown, style, offset, reset, hasMoved };
+}
+function useResizable(defaultWidth, minW = 280, maxW = 800, minH = 200, maxH = 900) {
+  const [width, setWidth] = useState8(defaultWidth);
+  const [height, setHeight] = useState8(0);
+  const resizing = useRef6(false);
+  const startMouse = useRef6({ x: 0, y: 0 });
+  const startW = useRef6(defaultWidth);
+  const startH = useRef6(0);
+  const mode = useRef6("bl");
+  const onResizeStart = useCallback9((e, corner) => {
+    e.preventDefault();
+    e.stopPropagation();
+    resizing.current = true;
+    startMouse.current = { x: e.clientX, y: e.clientY };
+    startW.current = width;
+    startH.current = height || (e.currentTarget.parentElement?.offsetHeight ?? 400);
+    mode.current = corner;
+    document.querySelector(".sk-pb")?.classList.add("sk-pb--splitting");
+    const onMouseMove = (ev) => {
+      if (!resizing.current) return;
+      const dx = ev.clientX - startMouse.current.x;
+      const dy = ev.clientY - startMouse.current.y;
+      const newW = corner === "bl" ? startW.current - dx : startW.current + dx;
+      const newH = startH.current + dy;
+      setWidth(Math.min(maxW, Math.max(minW, newW)));
+      setHeight(Math.min(maxH, Math.max(minH, newH)));
+    };
+    const onMouseUp = () => {
+      resizing.current = false;
+      document.querySelector(".sk-pb")?.classList.remove("sk-pb--splitting");
+      document.removeEventListener("mousemove", onMouseMove);
+      document.removeEventListener("mouseup", onMouseUp);
+    };
+    document.addEventListener("mousemove", onMouseMove);
+    document.addEventListener("mouseup", onMouseUp);
+  }, [width, height, minW, maxW, minH, maxH]);
+  const reset = useCallback9(() => {
+    setWidth(defaultWidth);
+    setHeight(0);
+  }, [defaultWidth]);
+  const hasResized = width !== defaultWidth || height !== 0;
+  return { width, height, onResizeStart, reset, hasResized };
+}
+function PageBuilder({ pageKey = "index", pages = [], onPageChange, onExit }) {
+  const config = useConfig();
+  const repository = useRepository();
+  const { toast } = useToast();
+  const [pageConfig, setPageConfig] = useState8(null);
+  const [visibleSection, setVisibleSection] = useState8(null);
+  const [editingSection, setEditingSection] = useState8(null);
+  const [editorOpen, setEditorOpen] = useState8(false);
+  const [viewport, setViewport] = useState8("compact");
+  const [loading, setLoading] = useState8(true);
+  const [previewKey, setPreviewKey] = useState8(0);
+  const [configDirty, setConfigDirty] = useState8(false);
+  const [savingConfig, setSavingConfig] = useState8(false);
+  const [configSha, setConfigSha] = useState8();
+  const [navCollapsed, setNavCollapsed] = useState8(true);
+  const [editorCollapsed, setEditorCollapsed] = useState8(false);
+  const [dragIndex, setDragIndex] = useState8(null);
+  const [dragOverIndex, setDragOverIndex] = useState8(null);
+  const iframeRef = useRef6(null);
+  const navRef = useRef6(null);
+  const scrollAfterLoadRef = useRef6(null);
+  const draftCacheRef = useRef6({});
+  const navDrag = useDraggable();
+  const editorDrag = useDraggable();
+  const editorResize = useResizable(380);
+  const [compactSplit, setCompactSplit] = useState8(66);
+  const compactSplitDefault = 66;
+  const pbRef = useRef6(null);
+  const onSplitDragStart = useCallback9((e) => {
+    e.preventDefault();
+    const root = pbRef.current;
+    if (!root) return;
+    root.classList.add("sk-pb--splitting");
+    const onMouseMove = (ev) => {
+      const pct = ev.clientX / window.innerWidth * 100;
+      const clamped = Math.min(95, Math.max(30, pct));
+      root.style.setProperty("--sk-split", `${clamped}`);
+    };
+    const onMouseUp = (ev) => {
+      root.classList.remove("sk-pb--splitting");
+      const pct = ev.clientX / window.innerWidth * 100;
+      setCompactSplit(Math.min(95, Math.max(30, pct)));
+      root.style.removeProperty("--sk-split");
+      document.removeEventListener("mousemove", onMouseMove);
+      document.removeEventListener("mouseup", onMouseUp);
+    };
+    document.addEventListener("mousemove", onMouseMove);
+    document.addEventListener("mouseup", onMouseUp);
+  }, []);
+  const resetAllPositions = useCallback9(() => {
+    navDrag.reset();
+    editorDrag.reset();
+    editorResize.reset();
+    setCompactSplit(compactSplitDefault);
+  }, [navDrag.reset, editorDrag.reset, editorResize.reset]);
+  const compactSplitMoved = compactSplit !== compactSplitDefault;
+  const anyMoved = navDrag.hasMoved || editorDrag.hasMoved || editorResize.hasResized || compactSplitMoved;
+  const configKey = "_" + pageKey.replace(/\//g, "--");
+  useEffect6(() => {
+    loadPageConfig();
+  }, [pageKey]);
+  async function loadPageConfig() {
+    try {
+      const result = await repository.getEntry("pages", configKey);
+      if (result.ok) {
+        setPageConfig(result.value.content);
+        setConfigSha(result.value.sha);
+      } else {
+        setPageConfig({
+          label: pageKey === "index" ? "Startseite" : pageKey,
+          sections: []
+        });
+      }
+    } catch (e) {
+      console.error("[PageBuilder] Failed to load page config:", e);
+    } finally {
+      setLoading(false);
+    }
+  }
+  function getSectionDef(key) {
+    for (const product of Object.values(config.products)) {
+      if (product.sections[key]) return product.sections[key];
+    }
+    return null;
+  }
+  const scrollToSection = useCallback9((sectionKey) => {
+    const iframe = iframeRef.current;
+    if (!iframe?.contentWindow) return;
+    iframe.contentWindow.postMessage(
+      { type: "sk:scroll-to", section: sectionKey },
+      "*"
+    );
+  }, []);
+  const syncSectionsToPreview = useCallback9((sections2) => {
+    const iframe = iframeRef.current;
+    if (!iframe?.contentWindow) return;
+    iframe.contentWindow.postMessage(
+      { type: "sk:update-sections", sections: sections2 },
+      "*"
+    );
+  }, []);
+  const pageConfigRef = useRef6(pageConfig);
+  pageConfigRef.current = pageConfig;
+  const handleIframeLoad = useCallback9(() => {
+    setTimeout(() => {
+      if (scrollAfterLoadRef.current) {
+        scrollToSection(scrollAfterLoadRef.current);
+        scrollAfterLoadRef.current = null;
+      }
+      if (pageConfigRef.current?.sections) {
+        syncSectionsToPreview(pageConfigRef.current.sections);
+      }
+    }, 200);
+  }, [scrollToSection, syncSectionsToPreview]);
+  useEffect6(() => {
+    function handleMessage(event) {
+      if (event.data?.type === "sk:visible-section") {
+        setVisibleSection(event.data.section);
+      }
+    }
+    window.addEventListener("message", handleMessage);
+    return () => window.removeEventListener("message", handleMessage);
+  }, []);
+  const openEditor = useCallback9((sectionKey) => {
+    setEditingSection(sectionKey);
+    setEditorOpen(true);
+    setEditorCollapsed(false);
+    scrollToSection(sectionKey);
+  }, [scrollToSection]);
+  const closeEditor = useCallback9(() => {
+    setEditorOpen(false);
+    setEditorCollapsed(false);
+    setEditingSection(null);
+  }, []);
+  const reloadPreview = useCallback9((scrollTo) => {
+    scrollAfterLoadRef.current = scrollTo ?? visibleSection;
+    setPreviewKey((k) => k + 1);
+  }, [visibleSection]);
+  const needsSsrReload = useCallback9((sectionKey, values) => {
+    const product = Object.values(config.products)[0];
+    const section = product?.sections[sectionKey];
+    if (!section) return true;
+    const prev = draftCacheRef.current[sectionKey];
+    if (!prev) return false;
+    function hasNonTextChanges(prevObj, nextObj, fields) {
+      for (const [key, val] of Object.entries(nextObj)) {
+        if (JSON.stringify(prevObj[key]) === JSON.stringify(val)) continue;
+        const fieldDef = fields[key];
+        if (!fieldDef) return true;
+        if (fieldDef.type === "text") continue;
+        if (fieldDef.type === "array" && fieldDef.itemField?.type === "object" && fieldDef.itemField.fields) {
+          const prevArr = prevObj[key] ?? [];
+          const nextArr = val ?? [];
+          if (prevArr.length !== nextArr.length) return true;
+          for (let i = 0; i < nextArr.length; i++) {
+            const prevItem = prevArr[i] ?? {};
+            const nextItem = nextArr[i] ?? {};
+            if (hasNonTextChanges(prevItem, nextItem, fieldDef.itemField.fields)) return true;
+          }
+          continue;
+        }
+        return true;
+      }
+      return false;
+    }
+    return hasNonTextChanges(prev, values, section.fields);
+  }, [config]);
+  const updateDraft = useCallback9((sectionKey, values) => {
+    const requiresReload = needsSsrReload(sectionKey, values);
+    draftCacheRef.current[sectionKey] = values;
+    if (requiresReload) {
+      fetch("/api/setzkasten/draft", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ section: sectionKey, values })
+      }).then(() => {
+        reloadPreview(sectionKey);
+      });
+    } else {
+      const iframe = iframeRef.current;
+      if (!iframe?.contentWindow) return;
+      iframe.contentWindow.postMessage(
+        { type: "sk:draft-update", section: sectionKey, values },
+        "*"
+      );
+    }
+  }, [needsSsrReload, reloadPreview]);
+  const clearDraftCache = useCallback9((sectionKey) => {
+    delete draftCacheRef.current[sectionKey];
+    fetch("/api/setzkasten/draft", {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ section: sectionKey })
+    }).catch(() => {
+    });
+  }, []);
+  const discardDraft = useCallback9((sectionKey) => {
+    clearDraftCache(sectionKey);
+    reloadPreview(sectionKey);
+  }, [clearDraftCache, reloadPreview]);
+  const toggleSection = useCallback9((sectionKey) => {
+    setPageConfig((prev) => {
+      if (!prev) return prev;
+      const updated = {
+        ...prev,
+        sections: prev.sections.map(
+          (s) => s.key === sectionKey ? { ...s, enabled: !s.enabled } : s
+        )
+      };
+      syncSectionsToPreview(updated.sections);
+      return updated;
+    });
+    setConfigDirty(true);
+  }, [syncSectionsToPreview]);
+  const handleDragStart = useCallback9((index) => {
+    setDragIndex(index);
+  }, []);
+  const handleDragOver = useCallback9((e, index) => {
+    e.preventDefault();
+    setDragOverIndex(index);
+  }, []);
+  const handleDragEnd = useCallback9(() => {
+    if (dragIndex !== null && dragOverIndex !== null && dragIndex !== dragOverIndex) {
+      setPageConfig((prev) => {
+        if (!prev) return prev;
+        const newSections = [...prev.sections];
+        const [moved] = newSections.splice(dragIndex, 1);
+        if (!moved) return prev;
+        newSections.splice(dragOverIndex, 0, moved);
+        const updated = { ...prev, sections: newSections };
+        syncSectionsToPreview(updated.sections);
+        return updated;
+      });
+      setConfigDirty(true);
+    }
+    setDragIndex(null);
+    setDragOverIndex(null);
+  }, [dragIndex, dragOverIndex, syncSectionsToPreview]);
+  const savePageConfig = useCallback9(async () => {
+    if (!pageConfig || savingConfig) return;
+    setSavingConfig(true);
+    try {
+      const result = await repository.saveEntry("pages", configKey, {
+        content: pageConfig,
+        sha: configSha
+      });
+      if (result.ok) {
+        setConfigDirty(false);
+        setConfigSha(void 0);
+        toast("Seitenkonfiguration gespeichert", "success");
+      } else {
+        toast(`Fehler: ${result.error?.message ?? "Unbekannt"}`, "error");
+      }
+    } catch (e) {
+      toast("Speichern fehlgeschlagen", "error");
+    }
+    setSavingConfig(false);
+  }, [pageConfig, configSha, savingConfig, repository, toast]);
+  const viewportWidths = {
+    compact: `${compactSplit}vw`,
+    desktop: "100%",
+    tablet: "768px",
+    mobile: "375px"
+  };
+  const viewportWidth = viewportWidths[viewport];
+  const isCompact = viewport === "compact";
+  if (loading) {
+    return /* @__PURE__ */ jsx16("div", { className: "sk-pb", children: /* @__PURE__ */ jsx16("div", { className: "sk-pb__loading", children: "Lade Page Builder..." }) });
+  }
+  const sections = pageConfig?.sections ?? [];
+  const navContent = /* @__PURE__ */ jsxs15(Fragment3, { children: [
+    /* @__PURE__ */ jsxs15("div", { className: "sk-pb__nav-header", children: [
+      navCollapsed && visibleSection && /* @__PURE__ */ jsxs15(
+        "button",
+        {
+          type: "button",
+          className: "sk-pb__inline-edit-btn",
+          onClick: () => openEditor(visibleSection),
+          children: [
+            /* @__PURE__ */ jsx16(Edit, { size: 14 }),
+            getSectionDef(visibleSection)?.label ?? visibleSection
+          ]
+        }
+      ),
+      !navCollapsed && /* @__PURE__ */ jsx16("span", { className: "sk-pb__nav-title", children: "Sections" }),
+      !navCollapsed && /* @__PURE__ */ jsxs15("div", { className: "sk-pb__nav-actions", children: [
+        /* @__PURE__ */ jsx16(
+          "button",
+          {
+            type: "button",
+            className: `sk-pb__viewport-btn${viewport === "compact" ? " sk-pb__viewport-btn--active" : ""}`,
+            onClick: () => {
+              setViewport("compact");
+              setNavCollapsed(true);
+            },
+            title: "Compact Desktop",
+            children: /* @__PURE__ */ jsx16(AppWindow, { size: 14 })
+          }
+        ),
+        /* @__PURE__ */ jsx16(
+          "button",
+          {
+            type: "button",
+            className: `sk-pb__viewport-btn${viewport === "desktop" ? " sk-pb__viewport-btn--active" : ""}`,
+            onClick: () => {
+              setViewport("desktop");
+              setNavCollapsed(true);
+            },
+            title: "Desktop",
+            children: /* @__PURE__ */ jsx16(Monitor, { size: 14 })
+          }
+        ),
+        /* @__PURE__ */ jsx16(
+          "button",
+          {
+            type: "button",
+            className: `sk-pb__viewport-btn${viewport === "tablet" ? " sk-pb__viewport-btn--active" : ""}`,
+            onClick: () => {
+              setViewport("tablet");
+              setNavCollapsed(false);
+            },
+            title: "Tablet",
+            children: /* @__PURE__ */ jsx16(Tablet, { size: 14 })
+          }
+        ),
+        /* @__PURE__ */ jsx16(
+          "button",
+          {
+            type: "button",
+            className: `sk-pb__viewport-btn${viewport === "mobile" ? " sk-pb__viewport-btn--active" : ""}`,
+            onClick: () => {
+              setViewport("mobile");
+              setNavCollapsed(false);
+            },
+            title: "Mobile",
+            children: /* @__PURE__ */ jsx16(Smartphone, { size: 14 })
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs15("div", { className: "sk-pb__nav-header-right", children: [
+        /* @__PURE__ */ jsx16(
+          "button",
+          {
+            type: "button",
+            className: "sk-pb__collapse-btn",
+            onClick: () => setNavCollapsed((c) => !c),
+            title: navCollapsed ? "Navigation aufklappen" : "Navigation einklappen",
+            children: navCollapsed ? /* @__PURE__ */ jsx16(ChevronDown, { size: 14 }) : /* @__PURE__ */ jsx16(ChevronUp, { size: 14 })
+          }
+        ),
+        /* @__PURE__ */ jsx16(
+          "button",
+          {
+            type: "button",
+            className: "sk-pb__exit-btn",
+            onClick: onExit,
+            title: "Page Builder verlassen",
+            children: /* @__PURE__ */ jsx16(X, { size: 16 })
+          }
+        )
+      ] })
+    ] }),
+    !navCollapsed && /* @__PURE__ */ jsxs15(Fragment3, { children: [
+      pages.length > 1 && onPageChange && /* @__PURE__ */ jsxs15("div", { className: "sk-pb__page-switcher", children: [
+        /* @__PURE__ */ jsx16("label", { className: "sk-pb__page-switcher-label", children: "Seite" }),
+        /* @__PURE__ */ jsx16(
+          "select",
+          {
+            className: "sk-pb__page-select",
+            value: pageKey,
+            onChange: (e) => onPageChange(e.target.value),
+            children: pages.map((p) => /* @__PURE__ */ jsx16("option", { value: p.pageKey, children: p.label }, p.pageKey))
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx16("div", { className: "sk-pb__section-list", children: sections.map((section, index) => {
+        const def = getSectionDef(section.key);
+        const IconComp = def?.icon ? ICON_MAP[def.icon] : null;
+        const isVisible = visibleSection === section.key;
+        const isEditing = editingSection === section.key;
+        const isDragging = dragIndex === index;
+        const isDragOver = dragOverIndex === index;
+        return /* @__PURE__ */ jsxs15(
+          "div",
+          {
+            className: `sk-pb__section-pill${isEditing ? " sk-pb__section-pill--editing" : ""}${isVisible && !isEditing ? " sk-pb__section-pill--visible" : ""}${!section.enabled ? " sk-pb__section-pill--disabled" : ""}${isDragging ? " sk-pb__section-pill--dragging" : ""}${isDragOver ? " sk-pb__section-pill--dragover" : ""}`,
+            draggable: true,
+            onDragStart: () => handleDragStart(index),
+            onDragOver: (e) => handleDragOver(e, index),
+            onDragEnd: handleDragEnd,
+            children: [
+              /* @__PURE__ */ jsx16("span", { className: "sk-pb__section-grip", children: /* @__PURE__ */ jsx16(GripVertical, { size: 14 }) }),
+              /* @__PURE__ */ jsxs15(
+                "button",
+                {
+                  type: "button",
+                  className: "sk-pb__section-main",
+                  onClick: () => openEditor(section.key),
+                  children: [
+                    IconComp && /* @__PURE__ */ jsx16("span", { className: "sk-pb__section-icon", children: /* @__PURE__ */ jsx16(IconComp, { size: 16 }) }),
+                    /* @__PURE__ */ jsx16("span", { className: "sk-pb__section-label", children: def?.label ?? section.key })
+                  ]
+                }
+              ),
+              /* @__PURE__ */ jsx16(
+                "button",
+                {
+                  type: "button",
+                  className: "sk-pb__section-toggle",
+                  onClick: (e) => {
+                    e.stopPropagation();
+                    toggleSection(section.key);
+                  },
+                  title: section.enabled ? "Section ausblenden" : "Section einblenden",
+                  children: section.enabled ? /* @__PURE__ */ jsx16(Eye, { size: 14 }) : /* @__PURE__ */ jsx16(EyeOff, { size: 14 })
+                }
+              )
+            ]
+          },
+          section.key
+        );
+      }) }),
+      configDirty && /* @__PURE__ */ jsx16("div", { className: "sk-pb__nav-footer", children: /* @__PURE__ */ jsxs15(
+        "button",
+        {
+          type: "button",
+          className: "sk-pb__save-btn",
+          onClick: savePageConfig,
+          disabled: savingConfig,
+          children: [
+            /* @__PURE__ */ jsx16(Save, { size: 14 }),
+            savingConfig ? "Speichert..." : "Reihenfolge speichern"
+          ]
+        }
+      ) })
+    ] })
+  ] });
+  const editorPanel = editorOpen && editingSection && !editorCollapsed && (getSectionDef(editingSection) ? /* @__PURE__ */ jsx16(
+    SectionSlideOver,
+    {
+      sectionKey: editingSection,
+      section: getSectionDef(editingSection),
+      cachedValues: draftCacheRef.current[editingSection],
+      onClose: closeEditor,
+      onCollapse: () => setEditorCollapsed(true),
+      onDraftUpdate: updateDraft,
+      onDiscard: discardDraft,
+      onSaved: clearDraftCache
+    },
+    editingSection
+  ) : /* @__PURE__ */ jsxs15("div", { className: "sk-pb__slide-over", children: [
+    /* @__PURE__ */ jsxs15("div", { className: "sk-pb__slide-over-header", children: [
+      /* @__PURE__ */ jsx16("h3", { children: editingSection }),
+      /* @__PURE__ */ jsxs15("div", { className: "sk-pb__slide-over-actions", children: [
+        /* @__PURE__ */ jsx16("button", { type: "button", className: "sk-pb__collapse-btn", onClick: () => setEditorCollapsed(true), title: "Einklappen", children: /* @__PURE__ */ jsx16(PanelRightClose, { size: 16 }) }),
+        /* @__PURE__ */ jsx16("button", { type: "button", className: "sk-pb__close-btn", onClick: closeEditor, children: /* @__PURE__ */ jsx16(X, { size: 18 }) })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx16("div", { className: "sk-pb__slide-over-body", children: /* @__PURE__ */ jsx16("p", { className: "sk-pb__slide-over-info", children: "Diese Section hat noch kein editierbares Schema." }) })
+  ] }));
+  const editorFloatTransform = editorDrag.hasMoved ? { transform: `translate(${editorDrag.offset.x}px, ${editorDrag.offset.y}px)` } : {};
+  return /* @__PURE__ */ jsxs15(
+    "div",
+    {
+      ref: pbRef,
+      className: `sk-pb${isCompact ? " sk-pb--compact" : ""}`,
+      style: isCompact ? { "--sk-split": `${compactSplit}` } : void 0,
+      children: [
+        /* @__PURE__ */ jsx16("div", { className: "sk-pb__preview", children: /* @__PURE__ */ jsx16(
+          "div",
+          {
+            className: "sk-pb__iframe-container",
+            style: {
+              maxWidth: isCompact ? "calc(var(--sk-split, 66) * 1vw)" : viewportWidth,
+              margin: viewport === "desktop" ? void 0 : isCompact ? "0" : "0 auto"
+            },
+            children: /* @__PURE__ */ jsx16(
+              "iframe",
+              {
+                ref: iframeRef,
+                src: `/${pageKey === "index" ? "" : pageKey}?_sk_preview=1&_t=${previewKey}`,
+                className: "sk-pb__iframe",
+                title: "Live Preview",
+                onLoad: handleIframeLoad
+              },
+              previewKey
+            )
+          }
+        ) }),
+        isCompact && /* @__PURE__ */ jsx16(
+          "div",
+          {
+            className: "sk-pb__split-divider",
+            style: { left: "calc(var(--sk-split, 66) * 1vw)" },
+            onMouseDown: onSplitDragStart
+          }
+        ),
+        /* @__PURE__ */ jsx16(
+          "div",
+          {
+            ref: navRef,
+            className: `sk-pb__nav${navCollapsed ? " sk-pb__nav--collapsed" : ""}`,
+            style: navDrag.style,
+            onMouseDown: navDrag.onMouseDown,
+            children: navContent
+          }
+        ),
+        editorPanel && /* @__PURE__ */ jsxs15(
+          "div",
+          {
+            className: "sk-pb__editor-float",
+            style: {
+              ...!isCompact || editorResize.hasResized ? { width: editorResize.width } : {},
+              ...editorResize.height > 0 ? { height: editorResize.height } : {},
+              ...editorFloatTransform
+            },
+            onMouseDown: editorDrag.onMouseDown,
+            children: [
+              /* @__PURE__ */ jsx16(
+                "div",
+                {
+                  className: "sk-pb__resize-corner sk-pb__resize-corner--bl",
+                  onMouseDown: (e) => editorResize.onResizeStart(e, "bl")
+                }
+              ),
+              editorPanel
+            ]
+          }
+        ),
+        editorOpen && editingSection && editorCollapsed && /* @__PURE__ */ jsx16(
+          "button",
+          {
+            type: "button",
+            className: "sk-pb__editor-expand-btn",
+            onClick: () => setEditorCollapsed(false),
+            title: "Editor aufklappen",
+            children: /* @__PURE__ */ jsx16(PanelRightOpen, { size: 16 })
+          }
+        ),
+        anyMoved && /* @__PURE__ */ jsx16(
+          "button",
+          {
+            type: "button",
+            className: "sk-pb__reset-pos-btn",
+            onClick: resetAllPositions,
+            title: "Panel-Positionen zur\xFCcksetzen",
+            children: /* @__PURE__ */ jsx16(RotateCcw, { size: 14 })
+          }
+        )
+      ]
+    }
+  );
+}
+function SectionSlideOver({ sectionKey, section, cachedValues, onClose, onCollapse, onDraftUpdate, onDiscard, onSaved }) {
+  const repository = useRepository();
+  const { toast } = useToast();
+  const [initialValues, setInitialValues] = useState8({});
+  const [loading, setLoading] = useState8(true);
+  const [saving, setSaving] = useState8(false);
+  const [sha, setSha] = useState8();
+  const [conflict, setConflict] = useState8(null);
+  const storeRef = useRef6(null);
+  const [formStore, setFormStore] = useState8(null);
+  const draftTimerRef = useRef6(null);
+  const saveRef = useRef6(null);
+  const undoRef = useRef6(null);
+  const redoRef = useRef6(null);
+  const storeSnapshotRef = useRef6({ dirty: false, canUndo: false, canRedo: false });
+  const storeState = useSyncExternalStore(
+    useCallback9((cb) => formStore?.subscribe(cb) ?? (() => {
+    }), [formStore]),
+    useCallback9(() => {
+      if (!formStore) return storeSnapshotRef.current;
+      const s = formStore.getState();
+      const dirty = s.isDirty();
+      const canUndo = s.canUndo();
+      const canRedo = s.canRedo();
+      const prev = storeSnapshotRef.current;
+      if (prev.dirty !== dirty || prev.canUndo !== canUndo || prev.canRedo !== canRedo) {
+        storeSnapshotRef.current = { dirty, canUndo, canRedo };
+      }
+      return storeSnapshotRef.current;
+    }, [formStore])
+  );
+  useEffect6(() => {
+    setLoading(true);
+    repository.getEntry("_sections", sectionKey).then((result) => {
+      if (result.ok) {
+        setInitialValues(result.value.content);
+        setSha(result.value.sha);
+      }
+      setLoading(false);
+    });
+  }, [sectionKey, repository]);
+  useEffect6(() => {
+    if (formStore) return;
+    const check = setInterval(() => {
+      if (storeRef.current && !formStore) {
+        setFormStore(storeRef.current);
+        clearInterval(check);
+      }
+    }, 50);
+    return () => clearInterval(check);
+  }, [formStore, loading]);
+  useEffect6(() => {
+    if (!formStore) return;
+    const unsub = formStore.subscribe((state) => {
+      if (draftTimerRef.current) clearTimeout(draftTimerRef.current);
+      draftTimerRef.current = setTimeout(() => {
+        onDraftUpdate(sectionKey, state.values);
+      }, 500);
+    });
+    return () => {
+      unsub();
+      if (draftTimerRef.current) clearTimeout(draftTimerRef.current);
+    };
+  }, [formStore, sectionKey, onDraftUpdate]);
+  const handleSave = useCallback9(async (values) => {
+    setSaving(true);
+    const result = await repository.saveEntry("_sections", sectionKey, {
+      content: values,
+      sha
+    });
+    if (result.ok) {
+      setInitialValues(values);
+      setSha(result.value.sha);
+      setConflict(null);
+      onSaved(sectionKey);
+      toast("Gespeichert \u2013 \xC4nderungen sind in 1\u20132 Minuten live.", "success");
+    } else {
+      if (result.error?.type === "conflict") {
+        const remoteResult = await repository.getEntry("_sections", sectionKey);
+        if (remoteResult.ok) {
+          setConflict({
+            local: values,
+            remote: remoteResult.value.content,
+            remoteSha: remoteResult.value.sha
+          });
+        } else {
+          toast("Konflikt: Jemand hat gleichzeitig bearbeitet. Seite neu laden.", "error");
+        }
+      } else {
+        toast(`Fehler: ${result.error?.message ?? "Unbekannt"}`, "error");
+      }
+    }
+    setSaving(false);
+  }, [repository, sectionKey, sha, toast]);
+  saveRef.current = () => {
+    const store = storeRef.current;
+    if (!store || saving) return;
+    const { values } = store.getState();
+    handleSave(values);
+  };
+  undoRef.current = () => {
+    const store = storeRef.current;
+    if (!store) return;
+    store.getState().undo();
+  };
+  redoRef.current = () => {
+    const store = storeRef.current;
+    if (!store) return;
+    store.getState().redo();
+  };
+  const resolveConflictLocal = useCallback9(async () => {
+    if (!conflict) return;
+    setSaving(true);
+    const result = await repository.saveEntry("_sections", sectionKey, {
+      content: conflict.local,
+      sha: conflict.remoteSha
+    });
+    if (result.ok) {
+      setInitialValues(conflict.local);
+      setSha(result.value.sha);
+      setConflict(null);
+      onSaved(sectionKey);
+      toast("Gespeichert (deine Version \xFCbernommen).", "success");
+    } else {
+      toast("Speichern fehlgeschlagen. Bitte erneut versuchen.", "error");
+    }
+    setSaving(false);
+  }, [conflict, repository, sectionKey, onSaved, toast]);
+  const resolveConflictRemote = useCallback9(() => {
+    if (!conflict) return;
+    const store = storeRef.current;
+    if (store) {
+      store.getState().init(section.fields, conflict.remote);
+    }
+    setInitialValues(conflict.remote);
+    setSha(conflict.remoteSha);
+    setConflict(null);
+    onDiscard(sectionKey);
+    toast("Remote-Version \xFCbernommen.", "success");
+  }, [conflict, section.fields, sectionKey, onDiscard, toast]);
+  const handleDiscard = useCallback9(() => {
+    const store = storeRef.current;
+    if (!store) return;
+    store.getState().resetToInitial();
+    onDiscard(sectionKey);
+  }, [sectionKey, onDiscard]);
+  useEffect6(() => {
+    const handler = (e) => {
+      if ((e.metaKey || e.ctrlKey) && e.key === "s") {
+        e.preventDefault();
+        saveRef.current?.();
+      }
+      if ((e.metaKey || e.ctrlKey) && e.key === "z" && !e.shiftKey) {
+        e.preventDefault();
+        undoRef.current?.();
+      }
+      if ((e.metaKey || e.ctrlKey) && e.key === "z" && e.shiftKey) {
+        e.preventDefault();
+        redoRef.current?.();
+      }
+      if (e.key === "Escape") {
+        onClose();
+      }
+    };
+    document.addEventListener("keydown", handler);
+    return () => document.removeEventListener("keydown", handler);
+  }, [onClose]);
+  return /* @__PURE__ */ jsxs15("div", { className: "sk-pb__slide-over", children: [
+    /* @__PURE__ */ jsxs15("div", { className: "sk-pb__slide-over-header", children: [
+      /* @__PURE__ */ jsx16("div", { className: "sk-pb__slide-over-title", children: storeState.dirty && /* @__PURE__ */ jsxs15("span", { className: "sk-pb__draft-indicator", title: "Ungespeicherte \xC4nderungen", children: [
+        /* @__PURE__ */ jsx16("span", { className: "sk-pb__draft-dot" }),
+        "Entwurf"
+      ] }) }),
+      /* @__PURE__ */ jsxs15("div", { className: "sk-pb__slide-over-actions", children: [
+        storeState.dirty && /* @__PURE__ */ jsx16(
+          "button",
+          {
+            type: "button",
+            className: "sk-pb__discard-btn",
+            onClick: handleDiscard,
+            title: "\xC4nderungen verwerfen",
+            children: /* @__PURE__ */ jsx16(Trash2, { size: 14 })
+          }
+        ),
+        /* @__PURE__ */ jsx16(
+          "button",
+          {
+            type: "button",
+            className: "sk-pb__undo-btn",
+            onClick: () => undoRef.current?.(),
+            disabled: !storeState.canUndo,
+            title: "R\xFCckg\xE4ngig (Cmd+Z)",
+            children: /* @__PURE__ */ jsx16(Undo2, { size: 14 })
+          }
+        ),
+        /* @__PURE__ */ jsx16(
+          "button",
+          {
+            type: "button",
+            className: "sk-pb__undo-btn",
+            onClick: () => redoRef.current?.(),
+            disabled: !storeState.canRedo,
+            title: "Wiederholen (Cmd+Shift+Z)",
+            children: /* @__PURE__ */ jsx16(Redo2, { size: 14 })
+          }
+        ),
+        /* @__PURE__ */ jsx16(
+          "button",
+          {
+            type: "button",
+            className: "sk-pb__header-save-btn",
+            onClick: () => saveRef.current?.(),
+            disabled: saving || !storeState.dirty,
+            title: "Speichern (Cmd+S)",
+            children: /* @__PURE__ */ jsx16(Save, { size: 14 })
+          }
+        ),
+        /* @__PURE__ */ jsx16("button", { type: "button", className: "sk-pb__collapse-btn", onClick: onCollapse, title: "Einklappen", children: /* @__PURE__ */ jsx16(PanelRightClose, { size: 16 }) }),
+        /* @__PURE__ */ jsx16("button", { type: "button", className: "sk-pb__close-btn", onClick: onClose, children: /* @__PURE__ */ jsx16(X, { size: 18 }) })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs15("div", { className: "sk-pb__slide-over-body", children: [
+      conflict && /* @__PURE__ */ jsxs15("div", { className: "sk-pb__conflict", children: [
+        /* @__PURE__ */ jsxs15("div", { className: "sk-pb__conflict-header", children: [
+          /* @__PURE__ */ jsx16(Shield, { size: 16 }),
+          /* @__PURE__ */ jsx16("strong", { children: "Konflikt" }),
+          " \u2014 Die Datei wurde extern ge\xE4ndert."
+        ] }),
+        /* @__PURE__ */ jsx16("div", { className: "sk-pb__conflict-diff", children: Object.keys({ ...conflict.local, ...conflict.remote }).filter((key) => JSON.stringify(conflict.local[key]) !== JSON.stringify(conflict.remote[key])).map((key) => {
+          const fieldDef = section.fields[key];
+          const label = fieldDef?.label ?? key;
+          const localVal = JSON.stringify(conflict.local[key], null, 2) ?? "\u2014";
+          const remoteVal = JSON.stringify(conflict.remote[key], null, 2) ?? "\u2014";
+          return /* @__PURE__ */ jsxs15("div", { className: "sk-pb__conflict-field", children: [
+            /* @__PURE__ */ jsx16("div", { className: "sk-pb__conflict-label", children: label }),
+            /* @__PURE__ */ jsxs15("div", { className: "sk-pb__conflict-values", children: [
+              /* @__PURE__ */ jsxs15("div", { className: "sk-pb__conflict-local", children: [
+                /* @__PURE__ */ jsx16("span", { className: "sk-pb__conflict-tag", children: "Deine Version" }),
+                /* @__PURE__ */ jsx16("pre", { children: localVal })
+              ] }),
+              /* @__PURE__ */ jsxs15("div", { className: "sk-pb__conflict-remote", children: [
+                /* @__PURE__ */ jsx16("span", { className: "sk-pb__conflict-tag", children: "Remote" }),
+                /* @__PURE__ */ jsx16("pre", { children: remoteVal })
+              ] })
+            ] })
+          ] }, key);
+        }) }),
+        /* @__PURE__ */ jsxs15("div", { className: "sk-pb__conflict-actions", children: [
+          /* @__PURE__ */ jsx16(
+            "button",
+            {
+              type: "button",
+              className: "sk-button sk-button--primary",
+              onClick: resolveConflictLocal,
+              disabled: saving,
+              children: "Meine Version \xFCbernehmen"
+            }
+          ),
+          /* @__PURE__ */ jsx16(
+            "button",
+            {
+              type: "button",
+              className: "sk-button",
+              onClick: resolveConflictRemote,
+              children: "Remote \xFCbernehmen"
+            }
+          )
+        ] })
+      ] }),
+      loading ? /* @__PURE__ */ jsx16("p", { className: "sk-pb__slide-over-loading", children: "Lade..." }) : /* @__PURE__ */ jsx16(
+        EntryForm,
+        {
+          schema: section.fields,
+          initialValues,
+          draftValues: cachedValues,
+          onSave: handleSave,
+          storeRef
+        }
+      )
+    ] })
+  ] });
+}
+
+// src/components/admin-app.tsx
+import { Layers, Globe as Globe2, Settings as Settings2 } from "lucide-react";
+import { jsx as jsx17, jsxs as jsxs16 } from "react/jsx-runtime";
+function AdminApp() {
+  const config = useConfig();
+  const [user, setUser] = useState9(null);
+  const [checking, setChecking] = useState9(true);
+  useEffect7(() => {
+    checkSession();
+  }, []);
+  async function checkSession() {
+    try {
+      const response = await fetch("/api/setzkasten/auth/session");
+      const session = await response.json();
+      if (session.authenticated) {
+        setUser(session.user);
+      }
+    } catch {
+    } finally {
+      setChecking(false);
+    }
+  }
+  if (checking) {
+    return /* @__PURE__ */ jsx17(LoadingScreen, {});
+  }
+  if (!user) {
+    return /* @__PURE__ */ jsx17(LoginScreen, { config });
+  }
+  return /* @__PURE__ */ jsx17(ToastProvider, { children: /* @__PURE__ */ jsx17(AdminShell, { config, user }) });
+}
+function LoadingScreen() {
+  return /* @__PURE__ */ jsxs16("div", { className: "sk-admin-loading", children: [
+    /* @__PURE__ */ jsx17("div", { className: "sk-admin-loading__spinner" }),
+    /* @__PURE__ */ jsx17("p", { className: "sk-admin-loading__text", children: "Lade Setzkasten..." })
+  ] });
+}
+function LoginScreen({ config }) {
+  const providers = config.auth?.providers ?? ["github"];
+  return /* @__PURE__ */ jsx17("div", { className: "sk-login", children: /* @__PURE__ */ jsxs16("div", { className: "sk-login__card", children: [
+    /* @__PURE__ */ jsx17("div", { className: "sk-login__logo", children: "S" }),
+    /* @__PURE__ */ jsx17("h1", { className: "sk-login__title", children: config.theme?.brandName ?? "Setzkasten" }),
+    /* @__PURE__ */ jsx17("p", { className: "sk-login__subtitle", children: "Melde dich an, um Inhalte zu bearbeiten." }),
+    providers.includes("github") && /* @__PURE__ */ jsxs16("a", { href: "/api/setzkasten/auth/login?provider=github", className: "sk-login__btn", children: [
+      /* @__PURE__ */ jsx17("svg", { viewBox: "0 0 24 24", fill: "currentColor", width: "20", height: "20", children: /* @__PURE__ */ jsx17("path", { d: "M12 2C6.477 2 2 6.484 2 12.017c0 4.425 2.865 8.18 6.839 9.504.5.092.682-.217.682-.483 0-.237-.008-.868-.013-1.703-2.782.605-3.369-1.343-3.369-1.343-.454-1.158-1.11-1.466-1.11-1.466-.908-.62.069-.608.069-.608 1.003.07 1.531 1.032 1.531 1.032.892 1.53 2.341 1.088 2.91.832.092-.647.35-1.088.636-1.338-2.22-.253-4.555-1.113-4.555-4.951 0-1.093.39-1.988 1.029-2.688-.103-.253-.446-1.272.098-2.65 0 0 .84-.27 2.75 1.026A9.564 9.564 0 0112 6.844a9.59 9.59 0 012.504.337c1.909-1.296 2.747-1.027 2.747-1.027.546 1.379.202 2.398.1 2.651.64.7 1.028 1.595 1.028 2.688 0 3.848-2.339 4.695-4.566 4.943.359.309.678.92.678 1.855 0 1.338-.012 2.419-.012 2.747 0 .268.18.58.688.482A10.02 10.02 0 0022 12.017C22 6.484 17.522 2 12 2Z" }) }),
+      "Mit GitHub anmelden"
+    ] }),
+    providers.includes("google") && /* @__PURE__ */ jsxs16("a", { href: "/api/setzkasten/auth/login?provider=google", className: "sk-login__btn", children: [
+      /* @__PURE__ */ jsxs16("svg", { viewBox: "0 0 24 24", width: "20", height: "20", children: [
+        /* @__PURE__ */ jsx17("path", { d: "M22.56 12.25c0-.78-.07-1.53-.2-2.25H12v4.26h5.92a5.06 5.06 0 01-2.2 3.32v2.77h3.57c2.08-1.92 3.28-4.74 3.28-8.1z", fill: "#4285F4" }),
+        /* @__PURE__ */ jsx17("path", { d: "M12 23c2.97 0 5.46-.98 7.28-2.66l-3.57-2.77c-.98.66-2.23 1.06-3.71 1.06-2.86 0-5.29-1.93-6.16-4.53H2.18v2.84C3.99 20.53 7.7 23 12 23z", fill: "#34A853" }),
+        /* @__PURE__ */ jsx17("path", { d: "M5.84 14.09c-.22-.66-.35-1.36-.35-2.09s.13-1.43.35-2.09V7.07H2.18C1.43 8.55 1 10.22 1 12s.43 3.45 1.18 4.93l2.85-2.22.81-.62z", fill: "#FBBC05" }),
+        /* @__PURE__ */ jsx17("path", { d: "M12 5.38c1.62 0 3.06.56 4.21 1.64l3.15-3.15C17.45 2.09 14.97 1 12 1 7.7 1 3.99 3.47 2.18 7.07l3.66 2.84c.87-2.6 3.3-4.53 6.16-4.53z", fill: "#EA4335" })
+      ] }),
+      "Mit Google anmelden"
+    ] })
+  ] }) });
+}
+function AdminShell({ config, user }) {
+  const [view, setView] = useState9("dashboard");
+  const [pages, setPages] = useState9([]);
+  const [selectedPageKey, setSelectedPageKey] = useState9("index");
+  const [loadingPages, setLoadingPages] = useState9(true);
+  useEffect7(() => {
+    fetch("/api/setzkasten/pages").then((r) => r.json()).then((data) => {
+      setPages(data.pages ?? []);
+    }).catch(() => {
+    }).finally(() => setLoadingPages(false));
+  }, []);
+  if (view === "page-builder") {
+    return /* @__PURE__ */ jsx17(
+      PageBuilder,
+      {
+        pageKey: selectedPageKey,
+        pages,
+        onPageChange: setSelectedPageKey,
+        onExit: () => setView("dashboard")
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx17(
+    Dashboard,
+    {
+      config,
+      user,
+      pages,
+      loadingPages,
+      selectedPageKey,
+      onSelectPage: setSelectedPageKey,
+      onOpenPageBuilder: () => setView("page-builder")
+    }
+  );
+}
+function Dashboard({
+  config,
+  user,
+  pages,
+  loadingPages,
+  selectedPageKey,
+  onSelectPage,
+  onOpenPageBuilder
+}) {
+  const brandName = config.theme?.brandName ?? "Setzkasten";
+  return /* @__PURE__ */ jsxs16("div", { className: "sk-dashboard", children: [
+    /* @__PURE__ */ jsxs16("header", { className: "sk-dashboard__topbar", children: [
+      /* @__PURE__ */ jsxs16("div", { className: "sk-dashboard__brand", children: [
+        /* @__PURE__ */ jsx17("span", { className: "sk-dashboard__logo", children: "S" }),
+        /* @__PURE__ */ jsx17("span", { className: "sk-dashboard__brand-name", children: "Setzkasten" })
+      ] }),
+      /* @__PURE__ */ jsxs16("div", { className: "sk-dashboard__user", children: [
+        user.avatarUrl ? /* @__PURE__ */ jsx17("img", { src: user.avatarUrl, className: "sk-dashboard__avatar", alt: "" }) : /* @__PURE__ */ jsx17("span", { className: "sk-dashboard__avatar sk-dashboard__avatar--placeholder", children: (user.name ?? user.email ?? "?")[0].toUpperCase() }),
+        /* @__PURE__ */ jsx17("span", { className: "sk-dashboard__user-name", children: user.name || user.email }),
+        /* @__PURE__ */ jsx17("a", { href: "/api/setzkasten/auth/logout", className: "sk-dashboard__logout", children: "Abmelden" })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs16("main", { className: "sk-dashboard__content", children: [
+      /* @__PURE__ */ jsxs16("div", { className: "sk-dashboard__card sk-dashboard__card--primary", children: [
+        /* @__PURE__ */ jsx17("div", { className: "sk-dashboard__card-icon", children: /* @__PURE__ */ jsx17(Layers, { size: 28 }) }),
+        /* @__PURE__ */ jsx17("h2", { className: "sk-dashboard__card-title", children: "Zum Setzkasten f\xFCr" }),
+        /* @__PURE__ */ jsxs16("div", { className: "sk-dashboard__card-controls", children: [
+          /* @__PURE__ */ jsx17(
+            "select",
+            {
+              className: "sk-dashboard__select",
+              disabled: true,
+              value: brandName,
+              children: /* @__PURE__ */ jsx17("option", { children: brandName })
+            }
+          ),
+          /* @__PURE__ */ jsx17(
+            "select",
+            {
+              className: "sk-dashboard__select",
+              value: selectedPageKey,
+              onChange: (e) => onSelectPage(e.target.value),
+              disabled: loadingPages || pages.length === 0,
+              children: loadingPages ? /* @__PURE__ */ jsx17("option", { children: "Lade..." }) : pages.length === 0 ? /* @__PURE__ */ jsx17("option", { value: "index", children: "Startseite" }) : pages.map((p) => /* @__PURE__ */ jsx17("option", { value: p.pageKey, children: p.label }, p.pageKey))
+            }
+          ),
+          /* @__PURE__ */ jsx17(
+            "button",
+            {
+              type: "button",
+              className: "sk-dashboard__btn",
+              onClick: onOpenPageBuilder,
+              children: "\xD6ffnen"
+            }
+          )
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs16("div", { className: "sk-dashboard__cards-row", children: [
+        /* @__PURE__ */ jsxs16("div", { className: "sk-dashboard__card sk-dashboard__card--disabled", children: [
+          /* @__PURE__ */ jsx17("div", { className: "sk-dashboard__card-icon", children: /* @__PURE__ */ jsx17(Globe2, { size: 22 }) }),
+          /* @__PURE__ */ jsx17("h3", { className: "sk-dashboard__card-subtitle", children: "Websites verwalten" }),
+          /* @__PURE__ */ jsx17("span", { className: "sk-dashboard__badge", children: "Kommt bald" })
+        ] }),
+        /* @__PURE__ */ jsxs16("div", { className: "sk-dashboard__card sk-dashboard__card--disabled", children: [
+          /* @__PURE__ */ jsx17("div", { className: "sk-dashboard__card-icon", children: /* @__PURE__ */ jsx17(Settings2, { size: 22 }) }),
+          /* @__PURE__ */ jsx17("h3", { className: "sk-dashboard__card-subtitle", children: "Globale Konfiguration" }),
+          /* @__PURE__ */ jsx17("span", { className: "sk-dashboard__badge", children: "Kommt bald" })
+        ] })
+      ] })
+    ] })
+  ] });
+}
+
+// src/hooks/use-save.ts
+import { useCallback as useCallback10, useState as useState10 } from "react";
+function useSave(store, collection, slug) {
+  const repository = useRepository();
+  const eventBus = useEventBus();
+  const [saving, setSaving] = useState10(false);
+  const save = useCallback10(async () => {
+    const state = store.getState();
+    if (!state.isDirty()) {
+      return { ok: true, value: { sha: "", message: "No changes" } };
+    }
+    setSaving(true);
+    state.setStatus("saving");
+    const result = await repository.saveEntry(collection, slug, {
+      content: state.values
+    });
+    if (result.ok) {
+      state.init(state.schema, state.values);
+      state.setStatus("idle");
+      eventBus.emit({ type: "entry-saved", collection, slug });
+    } else {
+      state.setStatus("error", result.error.message);
+    }
+    setSaving(false);
+    return result;
+  }, [store, repository, eventBus, collection, slug]);
+  return { save, saving };
+}
+
+// src/adapters/proxy-content-repository.ts
+import {
+  ok,
+  err,
+  networkError,
+  conflictError
+} from "@setzkasten-cms/core";
+var ProxyContentRepository = class {
+  baseUrl;
+  owner;
+  repo;
+  branch;
+  contentPath;
+  constructor(config) {
+    this.baseUrl = config.proxyBaseUrl.replace(/\/$/, "");
+    this.owner = config.owner;
+    this.repo = config.repo;
+    this.branch = config.branch;
+    this.contentPath = config.contentPath ?? "src/content";
+  }
+  apiUrl(path) {
+    return `${this.baseUrl}/repos/${this.owner}/${this.repo}/${path}`;
+  }
+  contentFilePath(collection, slug) {
+    return `${this.contentPath}/${collection}/${slug}.json`;
+  }
+  async listEntries(collection) {
+    try {
+      const dirPath = `${this.contentPath}/${collection}`;
+      const response = await fetch(
+        this.apiUrl(`contents/${dirPath}?ref=${this.branch}`)
+      );
+      if (!response.ok) {
+        if (response.status === 404) return ok([]);
+        return err(networkError(`HTTP ${response.status}`, null));
+      }
+      const data = await response.json();
+      return ok(
+        data.filter((item) => item.name.endsWith(".json")).map((item) => ({
+          slug: item.name.replace(/\.json$/, ""),
+          name: item.name.replace(/\.json$/, "")
+        }))
+      );
+    } catch (error) {
+      return err(networkError(error instanceof Error ? error.message : "Network error", error));
+    }
+  }
+  async getEntry(collection, slug) {
+    try {
+      const filePath = this.contentFilePath(collection, slug);
+      const response = await fetch(
+        this.apiUrl(`contents/${filePath}?ref=${this.branch}`)
+      );
+      if (!response.ok) {
+        return err(networkError(`HTTP ${response.status}`, null));
+      }
+      const data = await response.json();
+      const binary = atob(data.content.replace(/\n/g, ""));
+      const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+      const decoded = new TextDecoder().decode(bytes);
+      const content = JSON.parse(decoded);
+      return ok({ content, sha: data.sha });
+    } catch (error) {
+      return err(networkError(error instanceof Error ? error.message : "Network error", error));
+    }
+  }
+  async saveEntry(collection, slug, data, assets) {
+    try {
+      if (assets && assets.length > 0) {
+        for (const asset of assets) {
+          const assetResult = await this.uploadAsset(asset);
+          if (!assetResult.ok) return assetResult;
+        }
+      }
+      const filePath = this.contentFilePath(collection, slug);
+      const jsonContent = JSON.stringify(data.content, null, 2);
+      const base64Content = btoa(unescape(encodeURIComponent(jsonContent)));
+      const body = {
+        message: `Update ${collection}/${slug}`,
+        content: base64Content,
+        branch: this.branch
+      };
+      if (data.sha) {
+        body.sha = data.sha;
+      }
+      const response = await fetch(this.apiUrl(`contents/${filePath}`), {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        if (response.status === 409) {
+          return err(conflictError("Concurrent edit detected. The file was modified since you loaded it."));
+        }
+        const text = await response.text();
+        return err(networkError(`Save failed: HTTP ${response.status} - ${text}`, null));
+      }
+      const result = await response.json();
+      return ok({
+        sha: result.content.sha,
+        message: `Update ${collection}/${slug}`,
+        url: result.commit.html_url
+      });
+    } catch (error) {
+      return err(networkError(error instanceof Error ? error.message : "Save failed", error));
+    }
+  }
+  async deleteEntry(collection, slug) {
+    try {
+      const entryResult = await this.getEntry(collection, slug);
+      if (!entryResult.ok) return entryResult;
+      const filePath = this.contentFilePath(collection, slug);
+      const response = await fetch(this.apiUrl(`contents/${filePath}`), {
+        method: "DELETE",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          message: `Delete ${collection}/${slug}`,
+          sha: entryResult.value.sha,
+          branch: this.branch
+        })
+      });
+      if (!response.ok) {
+        return err(networkError(`Delete failed: HTTP ${response.status}`, null));
+      }
+      const result = await response.json();
+      return ok({
+        sha: result.commit.sha,
+        message: `Delete ${collection}/${slug}`
+      });
+    } catch (error) {
+      return err(networkError(error instanceof Error ? error.message : "Delete failed", error));
+    }
+  }
+  async getTree(ref) {
+    try {
+      const response = await fetch(
+        this.apiUrl(`git/trees/${ref ?? this.branch}?recursive=1`)
+      );
+      if (!response.ok) {
+        return err(networkError(`HTTP ${response.status}`, null));
+      }
+      const data = await response.json();
+      return ok(
+        data.tree.filter((item) => item.path.startsWith(this.contentPath)).map((item) => ({
+          path: item.path,
+          type: item.type === "tree" ? "dir" : "file",
+          sha: item.sha
+        }))
+      );
+    } catch (error) {
+      return err(networkError(error instanceof Error ? error.message : "Network error", error));
+    }
+  }
+  async uploadAsset(asset) {
+    try {
+      const base64Content = this.uint8ToBase64(asset.content);
+      const response = await fetch(this.apiUrl(`contents/${asset.path}`), {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          message: `Upload ${asset.path}`,
+          content: base64Content,
+          branch: this.branch
+        })
+      });
+      if (!response.ok) {
+        return err(networkError(`Asset upload failed: HTTP ${response.status}`, null));
+      }
+      const result = await response.json();
+      return ok({ sha: result.content.sha });
+    } catch (error) {
+      return err(networkError(error instanceof Error ? error.message : "Upload failed", error));
+    }
+  }
+  uint8ToBase64(bytes) {
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+  }
+};
+
+// src/adapters/proxy-asset-store.ts
+import {
+  ok as ok2,
+  err as err2,
+  networkError as networkError2
+} from "@setzkasten-cms/core";
+var ProxyAssetStore = class {
+  baseUrl;
+  owner;
+  repo;
+  branch;
+  assetsPath;
+  publicUrlPrefix;
+  constructor(config) {
+    this.baseUrl = config.proxyBaseUrl.replace(/\/$/, "");
+    this.owner = config.owner;
+    this.repo = config.repo;
+    this.branch = config.branch;
+    this.assetsPath = config.assetsPath ?? "public/images";
+    this.publicUrlPrefix = config.publicUrlPrefix ?? "/images";
+  }
+  apiUrl(path) {
+    return `${this.baseUrl}/repos/${this.owner}/${this.repo}/${path}`;
+  }
+  async upload(directory, filename, content, mimeType) {
+    try {
+      const dir = directory.replace(/^\/+|\/+$/g, "");
+      const repoPath = `${this.assetsPath}/${dir}/${filename}`;
+      const base64Content = this.uint8ToBase64(content);
+      const response = await fetch(this.apiUrl(`contents/${repoPath}`), {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          message: `Upload ${filename}`,
+          content: base64Content,
+          branch: this.branch
+        })
+      });
+      if (!response.ok) {
+        const text = await response.text();
+        return err2(networkError2(`Upload failed: HTTP ${response.status} - ${text}`, null));
+      }
+      return ok2({
+        path: repoPath,
+        size: content.byteLength,
+        mimeType
+      });
+    } catch (error) {
+      return err2(networkError2(error instanceof Error ? error.message : "Upload failed", error));
+    }
+  }
+  async delete(path) {
+    try {
+      const fileResponse = await fetch(
+        this.apiUrl(`contents/${path}?ref=${this.branch}`)
+      );
+      if (!fileResponse.ok) {
+        return err2(networkError2(`File not found: ${path}`, null));
+      }
+      const fileData = await fileResponse.json();
+      const response = await fetch(this.apiUrl(`contents/${path}`), {
+        method: "DELETE",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          message: `Delete ${path}`,
+          sha: fileData.sha,
+          branch: this.branch
+        })
+      });
+      if (!response.ok) {
+        return err2(networkError2(`Delete failed: HTTP ${response.status}`, null));
+      }
+      return ok2(void 0);
+    } catch (error) {
+      return err2(networkError2(error instanceof Error ? error.message : "Delete failed", error));
+    }
+  }
+  async list(directory) {
+    try {
+      const dirPath = `${this.assetsPath}/${directory}`.replace(/\/+$/, "");
+      return await this.listRecursive(dirPath);
+    } catch (error) {
+      return err2(networkError2(error instanceof Error ? error.message : "List failed", error));
+    }
+  }
+  async listRecursive(dirPath) {
+    const response = await fetch(
+      this.apiUrl(`contents/${dirPath}?ref=${this.branch}`)
+    );
+    if (!response.ok) {
+      if (response.status === 404) return ok2([]);
+      return err2(networkError2(`HTTP ${response.status}`, null));
+    }
+    const data = await response.json();
+    const files = data.filter((item) => item.type === "file" && this.isImageFile(item.name)).map((item) => ({
+      path: item.path,
+      size: item.size,
+      mimeType: this.guessMimeType(item.name)
+    }));
+    const dirs = data.filter((item) => item.type === "dir");
+    for (const dir of dirs) {
+      const subResult = await this.listRecursive(dir.path);
+      if (subResult.ok) {
+        files.push(...subResult.value);
+      }
+    }
+    return ok2(files);
+  }
+  isImageFile(name) {
+    const ext = name.split(".").pop()?.toLowerCase() ?? "";
+    return ["jpg", "jpeg", "png", "gif", "webp", "avif", "svg"].includes(ext);
+  }
+  getUrl(path) {
+    if (path.startsWith(this.assetsPath)) {
+      return this.publicUrlPrefix + path.slice(this.assetsPath.length);
+    }
+    return path;
+  }
+  getPreviewUrl(path) {
+    const repoPath = path.startsWith(this.publicUrlPrefix) ? this.assetsPath + path.slice(this.publicUrlPrefix.length) : path;
+    return `/api/setzkasten/asset/${repoPath}`;
+  }
+  uint8ToBase64(bytes) {
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+  }
+  guessMimeType(filename) {
+    const ext = filename.split(".").pop()?.toLowerCase();
+    const mimeTypes = {
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      png: "image/png",
+      gif: "image/gif",
+      webp: "image/webp",
+      avif: "image/avif",
+      svg: "image/svg+xml",
+      pdf: "application/pdf"
+    };
+    return mimeTypes[ext ?? ""] ?? "application/octet-stream";
+  }
+};
+export {
+  AdminApp,
+  CollectionView,
+  EntryForm,
+  EntryList,
+  FieldRenderer,
+  ProxyAssetStore,
+  ProxyContentRepository,
+  SetzKastenProvider,
+  ToastProvider,
+  createAppStore,
+  createFormStore,
+  useAssets,
+  useAuth,
+  useConfig,
+  useEventBus,
+  useField,
+  useRepository,
+  useSave,
+  useSetzKasten,
+  useToast
+};