@agntcms/next 0.2.0

package/dist/server.cjs

@@ -0,0 +1,1970 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server.ts
+var server_exports = {};
+__export(server_exports, {
+  BooleanField: () => BooleanField,
+  ButtonField: () => ButtonField,
+  DuplicateFormNameError: () => DuplicateFormNameError,
+  FormOverridesField: () => FormOverridesField,
+  GlobalSlot: () => GlobalSlot,
+  HoneypotCollisionError: () => HoneypotCollisionError,
+  ImageField: () => ImageField,
+  InvalidFormFieldError: () => InvalidFormFieldError,
+  InvalidFormNameError: () => InvalidFormNameError,
+  LinkField: () => LinkField,
+  ListField: () => ListField,
+  NOT_FOUND_PAGE_SLUG: () => NOT_FOUND_PAGE_SLUG,
+  NumberField: () => NumberField,
+  ReferenceField: () => ReferenceField,
+  RichTextField: () => RichTextField,
+  SERVER_ERROR_PAGE_SLUG: () => SERVER_ERROR_PAGE_SLUG,
+  SelectField: () => SelectField,
+  SubmissionsNotReadableError: () => SubmissionsNotReadableError,
+  TextField: () => TextField,
+  VideoField: () => VideoField,
+  buildFormRegistry: () => buildFormRegistry,
+  createDefaultAssetAdapter: () => createDefaultAssetAdapter,
+  createDefaultContentAdapter: () => createDefaultContentAdapter,
+  createDefaultSubmissionAdapter: () => createDefaultSubmissionAdapter,
+  createFsAssetAdapter: () => createFsAssetAdapter,
+  createFsContentAdapter: () => createFsContentAdapter,
+  createFsSubmissionAdapter: () => createFsSubmissionAdapter,
+  createListPages: () => createListPages,
+  createRateLimit: () => createRateLimit,
+  createRuntime: () => createRuntime,
+  createSubmitForm: () => createSubmitForm,
+  createWebhookSubmissionAdapter: () => createWebhookSubmissionAdapter,
+  defineForm: () => defineForm,
+  defineSection: () => defineSection,
+  getReservedPageSlugViolation: () => getReservedPageSlugViolation,
+  hasUniqueSectionIds: () => hasUniqueSectionIds,
+  hrefOf: () => hrefOf,
+  isExternalLink: () => isExternalLink,
+  isSitemapEligibleSlug: () => isSitemapEligibleSlug,
+  linkAnchorAttrs: () => linkAnchorAttrs,
+  normalizeLinkValue: () => normalizeLinkValue,
+  validateEmail: () => validateEmail,
+  validateExternalUrl: () => validateExternalUrl,
+  validateInternalSlug: () => validateInternalSlug,
+  validatePhone: () => validatePhone
+});
+module.exports = __toCommonJS(server_exports);
+
+// src/storage/fs/assets.ts
+var import_node_crypto = require("crypto");
+var fs2 = __toESM(require("fs/promises"), 1);
+var path2 = __toESM(require("path"), 1);
+
+// src/storage/fs/_helpers.ts
+var fs = __toESM(require("fs/promises"), 1);
+var path = __toESM(require("path"), 1);
+var isEnoent = (err) => typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+var defaultRandomSuffix = () => Math.random().toString(36).slice(2);
+var writeAtomic = async (target, data, randomSuffix = defaultRandomSuffix) => {
+  const dir = path.dirname(target);
+  await fs.mkdir(dir, { recursive: true });
+  const tmp = path.join(
+    dir,
+    `.${path.basename(target)}.${process.pid}.${randomSuffix()}.tmp`
+  );
+  try {
+    await fs.writeFile(tmp, data);
+    await fs.rename(tmp, target);
+  } catch (err) {
+    await fs.unlink(tmp).catch(() => {
+    });
+    throw err;
+  }
+};
+var resolveUnderBucket = (bucket, key, errorLabel, errorKey = key) => {
+  const resolved = path.resolve(bucket, key);
+  const bucketWithSep = bucket.endsWith(path.sep) ? bucket : bucket + path.sep;
+  if (!resolved.startsWith(bucketWithSep)) {
+    throw new Error(`${errorLabel}: ${JSON.stringify(errorKey)}`);
+  }
+  return resolved;
+};
+
+// src/storage/fs/assets.ts
+var EXT_PATTERN = /^\.[a-z0-9_-]{1,16}$/;
+var JSON_SUFFIX = ".json";
+var extensionFrom = (filename) => {
+  const dot = filename.lastIndexOf(".");
+  if (dot < 0 || dot === filename.length - 1) return "";
+  const raw = filename.slice(dot).toLowerCase();
+  return EXT_PATTERN.test(raw) ? raw : "";
+};
+var CONTENT_TYPE_BY_EXT = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".avif": "image/avif"
+};
+var contentTypeFor = (filename) => {
+  const dot = filename.lastIndexOf(".");
+  if (dot < 0) return void 0;
+  const ext = filename.slice(dot).toLowerCase();
+  return CONTENT_TYPE_BY_EXT[ext];
+};
+var createFsAssetAdapter = (options) => {
+  const { assetsRoot, publicUrlBase } = options;
+  if (!path2.isAbsolute(assetsRoot)) {
+    throw new Error(
+      `assetsRoot must be an absolute path, got: ${JSON.stringify(assetsRoot)}`
+    );
+  }
+  if (publicUrlBase.endsWith("/")) {
+    throw new Error(
+      `publicUrlBase must not end with '/', got: ${JSON.stringify(publicUrlBase)}`
+    );
+  }
+  const rootResolved = path2.resolve(assetsRoot);
+  const rootWithSep = rootResolved.endsWith(path2.sep) ? rootResolved : rootResolved + path2.sep;
+  const upload = async (input) => {
+    const hash = (0, import_node_crypto.createHash)("sha256").update(input.bytes).digest("hex");
+    const ext = extensionFrom(input.filename);
+    const storedName = `${hash}${ext}`;
+    const target = path2.resolve(rootResolved, storedName);
+    if (!target.startsWith(rootWithSep)) {
+      throw new Error(`asset path escapes assetsRoot: ${JSON.stringify(target)}`);
+    }
+    let bytesExist = false;
+    try {
+      await fs2.stat(target);
+      bytesExist = true;
+    } catch (err) {
+      if (!isEnoent(err)) throw err;
+    }
+    if (!bytesExist) {
+      await writeAtomic(target, input.bytes);
+    }
+    return {
+      url: `${publicUrlBase}/${storedName}`,
+      filename: storedName
+    };
+  };
+  const list = async () => {
+    let names;
+    try {
+      names = await fs2.readdir(rootResolved);
+    } catch (err) {
+      if (isEnoent(err)) return [];
+      throw err;
+    }
+    const candidates = names.filter(
+      (n) => !n.startsWith(".") && !n.endsWith(JSON_SUFFIX)
+    );
+    const entries = [];
+    for (const filename of candidates) {
+      const full = path2.join(rootResolved, filename);
+      let stat3;
+      try {
+        stat3 = await fs2.stat(full);
+      } catch (err) {
+        if (isEnoent(err)) continue;
+        throw err;
+      }
+      if (!stat3.isFile()) continue;
+      entries.push({
+        filename,
+        url: `${publicUrlBase}/${filename}`,
+        contentType: contentTypeFor(filename),
+        modifiedAt: stat3.mtime
+      });
+    }
+    entries.sort((a, b) => {
+      const delta = b.modifiedAt.getTime() - a.modifiedAt.getTime();
+      if (delta !== 0) return delta;
+      return a.filename.localeCompare(b.filename);
+    });
+    return entries;
+  };
+  return { upload, list };
+};
+
+// src/storage/fs/content.ts
+var import_node_fs = require("fs");
+var fs3 = __toESM(require("fs/promises"), 1);
+var path3 = __toESM(require("path"), 1);
+
+// src/domain/page.ts
+function assertValidPageMeta(obj) {
+  if (typeof obj["slug"] !== "string" || obj["slug"] === "") {
+    throw new Error("invalid page: missing or empty slug");
+  }
+  const slug = obj["slug"];
+  const rawSeo = obj["seo"];
+  if (rawSeo === null || typeof rawSeo !== "object") {
+    throw new Error(`invalid page "${slug}": seo must be an object`);
+  }
+  const seo = rawSeo;
+  if (typeof seo["title"] !== "string" || seo["title"].trim() === "") {
+    throw new Error(
+      `invalid page "${slug}": seo.title must be a non-empty string`
+    );
+  }
+  if (typeof seo["description"] !== "string" || seo["description"].trim() === "") {
+    throw new Error(
+      `invalid page "${slug}": seo.description must be a non-empty string`
+    );
+  }
+  if (seo["canonical"] !== void 0) {
+    if (typeof seo["canonical"] !== "string" || seo["canonical"].trim() === "") {
+      throw new Error(
+        `invalid page "${slug}": seo.canonical, when present, must be a non-empty string`
+      );
+    }
+  }
+}
+function assertValidPage(page) {
+  if (page === null || typeof page !== "object") {
+    throw new Error("invalid page: expected an object");
+  }
+  const obj = page;
+  if (typeof obj["slug"] !== "string" || obj["slug"] === "") {
+    throw new Error("invalid page: missing or empty slug");
+  }
+  const slug = obj["slug"];
+  if (!Array.isArray(obj["sections"])) {
+    throw new Error(`invalid page "${slug}": sections must be an array`);
+  }
+  assertValidPageMeta(obj);
+}
+function assertValidPageSummary(summary) {
+  if (summary === null || typeof summary !== "object") {
+    throw new Error("invalid page summary: expected an object");
+  }
+  assertValidPageMeta(summary);
+}
+
+// src/domain/fields.ts
+var TextField = { kind: "text" };
+var RichTextField = { kind: "richText" };
+var ImageField = { kind: "image" };
+var VideoField = { kind: "video" };
+var ReferenceField = { kind: "reference" };
+var LinkField = { kind: "link" };
+var NumberField = { kind: "number" };
+var BooleanField = { kind: "boolean" };
+var SelectField = (options, opts) => ({
+  kind: "select",
+  options,
+  ...opts?.default !== void 0 ? { default: opts.default } : {}
+});
+var ButtonField = (variants, opts) => ({
+  kind: "button",
+  variants,
+  ...opts?.default !== void 0 ? { default: opts.default } : {}
+});
+var ListField = (itemSchema, opts) => ({
+  kind: "list",
+  itemSchema,
+  ...opts?.min !== void 0 ? { min: opts.min } : {},
+  ...opts?.max !== void 0 ? { max: opts.max } : {},
+  ...opts?.default !== void 0 ? { default: opts.default } : {}
+});
+
+// src/domain/invariants.ts
+function hasUniqueSectionIds(page) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const section of page.sections) {
+    if (seen.has(section.id)) return false;
+    seen.add(section.id);
+  }
+  return true;
+}
+
+// src/domain/linkValidation.ts
+var SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-/]*[a-z0-9])?$/;
+var validateInternalSlug = (slug) => {
+  if (slug === "") return null;
+  if (/^https?:\/\//i.test(slug)) return "slug must not include a protocol";
+  if (slug.startsWith("//")) return "slug must not start with //";
+  if (slug.startsWith("/")) return "slug must not start with /";
+  if (slug.endsWith("/")) return "slug must not end with /";
+  if (slug.includes("//")) return "slug must not contain //";
+  if (slug.includes("..")) return "slug must not contain ..";
+  if (!SLUG_PATTERN.test(slug)) {
+    return "slug must use lowercase letters, digits, hyphens, and slashes only";
+  }
+  return null;
+};
+var validateExternalUrl = (url) => {
+  if (url === "") return null;
+  if (typeof url !== "string") return "URL must be a string";
+  if (!/^https?:\/\//i.test(url)) {
+    return "External link must start with http:// or https://";
+  }
+  try {
+    const parsed = new globalThis.URL(url);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return "External link must use http or https";
+    }
+  } catch {
+    return "External link is not a valid URL";
+  }
+  return null;
+};
+var EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var validateEmail = (email) => {
+  if (email === "") return null;
+  if (typeof email !== "string") return "Invalid email address";
+  if (!EMAIL_PATTERN.test(email)) return "Invalid email address";
+  return null;
+};
+var validatePhone = (phone) => {
+  if (phone === "") return null;
+  if (typeof phone !== "string") return "Phone number is too short";
+  const digits = phone.replace(/[^\d+]/g, "").replace(/\+/g, "");
+  if (digits.length < 7) return "Phone number is too short";
+  return null;
+};
+
+// src/domain/link.ts
+function hrefOf(link) {
+  if (link.type === "external") return link.url;
+  if (link.type === "email") {
+    if (link.email === "") return "";
+    return "mailto:" + link.email;
+  }
+  if (link.type === "phone") {
+    if (link.phone === "") return "";
+    return "tel:" + link.phone.replace(/[^\d+]/g, "");
+  }
+  const slug = link.slug.startsWith("/") ? link.slug.slice(1) : link.slug;
+  if (slug === "" || slug === "home") return "/";
+  return "/" + slug;
+}
+function isExternalLink(link) {
+  return link.type === "external";
+}
+function linkAnchorAttrs(link) {
+  const href = hrefOf(link);
+  if (link.type === "external") {
+    return { href, target: "_blank", rel: "noreferrer" };
+  }
+  return { href };
+}
+function normalizeLinkValue(raw) {
+  if (raw === null || typeof raw !== "object") {
+    return { type: "internal", slug: "", label: "" };
+  }
+  const obj = raw;
+  const label = typeof obj["label"] === "string" ? obj["label"] : "";
+  if (obj["type"] === "internal") {
+    const slug = typeof obj["slug"] === "string" ? obj["slug"] : "";
+    return { type: "internal", slug, label };
+  }
+  if (obj["type"] === "external") {
+    const url = typeof obj["url"] === "string" ? obj["url"] : "";
+    return { type: "external", url, label };
+  }
+  if (obj["type"] === "email") {
+    const email = typeof obj["email"] === "string" ? obj["email"] : "";
+    return { type: "email", email, label };
+  }
+  if (obj["type"] === "phone") {
+    const phone = typeof obj["phone"] === "string" ? obj["phone"] : "";
+    return { type: "phone", phone, label };
+  }
+  if (typeof obj["href"] === "string") {
+    const href = obj["href"];
+    if (/^mailto:/i.test(href)) {
+      return { type: "email", email: href.slice("mailto:".length), label };
+    }
+    if (/^tel:/i.test(href)) {
+      return { type: "phone", phone: href.slice("tel:".length), label };
+    }
+    if (/^https?:\/\//i.test(href)) {
+      return { type: "external", url: href, label };
+    }
+    const slug = href.startsWith("/") ? href.slice(1) : href;
+    return { type: "internal", slug, label };
+  }
+  return { type: "internal", slug: "", label: "" };
+}
+
+// src/domain/form.ts
+var FORM_FORBIDDEN_KINDS = /* @__PURE__ */ new Set([
+  "image",
+  "video",
+  "reference",
+  "list",
+  // `formOverrides` is a section-only descriptor (it overrides another
+  // form schema instance). Putting it inside a form would mean a form's
+  // payload could carry overrides for itself or another form — a
+  // recursive shape with no ergonomic editor UI. Section-only by design.
+  "formOverrides",
+  // `button` is a section-only descriptor: a styled CTA with an
+  // optional link. Public-form payloads collect user input — a button
+  // value is authored content, not a submitted answer. Section-only
+  // by design (mirrors `formOverrides`).
+  "button"
+]);
+var SubmissionsNotReadableError = class extends Error {
+  constructor(message = "submission adapter does not support reading") {
+    super(message);
+    this.name = "SubmissionsNotReadableError";
+  }
+};
+
+// src/domain/formOverrides.ts
+var FormOverridesField = (formName, opts) => ({
+  kind: "formOverrides",
+  formName,
+  ...opts?.default !== void 0 ? { default: opts.default } : {}
+});
+
+// src/storage/fs/content.ts
+var SLUG_PATTERN2 = /^[a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_-]+)*$/;
+var assertValidSlug = (slug) => {
+  if (!SLUG_PATTERN2.test(slug)) {
+    throw new Error(`invalid slug: ${JSON.stringify(slug)}`);
+  }
+};
+var deepEqual = (a, b) => {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return false;
+  if (typeof a !== "object") return false;
+  const aIsArr = Array.isArray(a);
+  const bIsArr = Array.isArray(b);
+  if (aIsArr !== bIsArr) return false;
+  if (aIsArr) {
+    const arrA = a;
+    const arrB = b;
+    if (arrA.length !== arrB.length) return false;
+    for (let i = 0; i < arrA.length; i += 1) {
+      if (!deepEqual(arrA[i], arrB[i])) return false;
+    }
+    return true;
+  }
+  const objA = a;
+  const objB = b;
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!Object.prototype.hasOwnProperty.call(objB, key)) return false;
+    if (!deepEqual(objA[key], objB[key])) return false;
+  }
+  return true;
+};
+var createFsContentAdapter = (options) => {
+  const { contentRoot } = options;
+  if (!path3.isAbsolute(contentRoot)) {
+    throw new Error(
+      `contentRoot must be an absolute path, got: ${JSON.stringify(contentRoot)}`
+    );
+  }
+  const pagesDir = path3.resolve(contentRoot, "pages");
+  const draftsDir = path3.resolve(contentRoot, "drafts");
+  const historyDir = path3.resolve(contentRoot, "history");
+  const globalsDir = path3.resolve(contentRoot, "globals");
+  const globalsHistoryDir = path3.resolve(contentRoot, "history-globals");
+  const resolveSlugPath = (bucket, slug, ext) => {
+    assertValidSlug(slug);
+    return resolveUnderBucket(bucket, `${slug}${ext}`, "slug escapes storage bucket", slug);
+  };
+  const readJsonOrNull = async (filePath) => {
+    try {
+      const raw = await fs3.readFile(filePath, { encoding: "utf8" });
+      return JSON.parse(raw);
+    } catch (err) {
+      if (isEnoent(err)) return null;
+      throw err;
+    }
+  };
+  const listJsonFiles2 = async (dir) => {
+    let entries;
+    try {
+      entries = await fs3.readdir(dir, { withFileTypes: true });
+    } catch (err) {
+      if (isEnoent(err)) return [];
+      throw err;
+    }
+    const results = [];
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".json")) {
+        results.push(entry.name);
+      } else if (entry.isDirectory()) {
+        const subDir = path3.join(dir, entry.name);
+        const subFiles = await listJsonFiles2(subDir);
+        for (const sub of subFiles) {
+          results.push(`${entry.name}/${sub}`);
+        }
+      }
+    }
+    return results;
+  };
+  const bucketFor = (mode) => mode === "published" ? pagesDir : draftsDir;
+  const uniqueTimestampedPath = async (baseDir, key, errorLabel) => {
+    const keyDir = resolveUnderBucket(baseDir, key, errorLabel);
+    await fs3.mkdir(keyDir, { recursive: true });
+    const base = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-");
+    let candidate = path3.join(keyDir, `${base}.json`);
+    let suffix = 0;
+    while (true) {
+      try {
+        await fs3.access(candidate, import_node_fs.constants.F_OK);
+        suffix += 1;
+        candidate = path3.join(keyDir, `${base}-${suffix}.json`);
+      } catch (err) {
+        if (isEnoent(err)) return candidate;
+        throw err;
+      }
+    }
+  };
+  const uniqueHistoryPath = async (slug) => {
+    assertValidSlug(slug);
+    return uniqueTimestampedPath(historyDir, slug, "slug escapes history bucket");
+  };
+  const readPage = async (slug, mode) => {
+    const filePath = resolveSlugPath(bucketFor(mode), slug, ".json");
+    return readJsonOrNull(filePath);
+  };
+  const saveDraft = async (page) => {
+    const filePath = resolveSlugPath(draftsDir, page.slug, ".json");
+    await writeAtomic(filePath, JSON.stringify(page, null, 2));
+  };
+  const listDrafts = async () => {
+    const files = await listJsonFiles2(draftsDir);
+    const results = [];
+    for (const relPath of files) {
+      const slug = relPath.slice(0, -".json".length);
+      const stat3 = await fs3.stat(path3.join(draftsDir, relPath));
+      results.push({ slug, updatedAt: stat3.mtime });
+    }
+    return results;
+  };
+  const listPages = async () => {
+    const files = await listJsonFiles2(pagesDir);
+    const results = [];
+    for (const relPath of files) {
+      const slug = relPath.slice(0, -".json".length);
+      const stat3 = await fs3.stat(path3.join(pagesDir, relPath));
+      results.push({ slug, updatedAt: stat3.mtime });
+    }
+    return results;
+  };
+  const listPageSummaries = async () => {
+    const files = await listJsonFiles2(pagesDir);
+    const results = [];
+    for (const relPath of files) {
+      const slug = relPath.slice(0, -".json".length);
+      const filePath = path3.join(pagesDir, relPath);
+      const page = await readJsonOrNull(filePath);
+      if (page === null) continue;
+      const stat3 = await fs3.stat(filePath).catch(() => null);
+      if (stat3 === null) continue;
+      const { sections: _sections, ...meta } = page;
+      void _sections;
+      results.push({ ...meta, slug, updatedAt: stat3.mtime });
+    }
+    return results;
+  };
+  const readLatestSnapshotIn = async (baseDir, key, errorLabel) => {
+    const keyDir = resolveUnderBucket(baseDir, key, errorLabel);
+    let entries;
+    try {
+      entries = await fs3.readdir(keyDir, { withFileTypes: true });
+    } catch (err) {
+      if (isEnoent(err)) return null;
+      throw err;
+    }
+    let latest = null;
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      if (!entry.name.endsWith(".json")) continue;
+      if (latest === null || entry.name > latest) latest = entry.name;
+    }
+    if (latest === null) return null;
+    return readJsonOrNull(path3.join(keyDir, latest));
+  };
+  const readLatestHistorySnapshot = async (slug) => {
+    assertValidSlug(slug);
+    return readLatestSnapshotIn(historyDir, slug, "slug escapes history bucket");
+  };
+  const publishDraft = async (slug) => {
+    const draftPath = resolveSlugPath(draftsDir, slug, ".json");
+    const pagePath = resolveSlugPath(pagesDir, slug, ".json");
+    const page = await readJsonOrNull(draftPath);
+    if (page === null) {
+      throw new Error(`no draft to publish for slug: ${JSON.stringify(slug)}`);
+    }
+    assertValidPage(page);
+    const serialised = JSON.stringify(page, null, 2);
+    const latestSnapshot = await readLatestHistorySnapshot(slug);
+    const skipHistory = latestSnapshot !== null && deepEqual(latestSnapshot, page);
+    if (!skipHistory) {
+      const historyPath = await uniqueHistoryPath(slug);
+      await writeAtomic(historyPath, serialised);
+    }
+    await writeAtomic(pagePath, serialised);
+    try {
+      await fs3.unlink(draftPath);
+    } catch (err) {
+      if (!isEnoent(err)) throw err;
+    }
+    return page;
+  };
+  const deleteDraft = async (slug) => {
+    const draftPath = resolveSlugPath(draftsDir, slug, ".json");
+    try {
+      await fs3.unlink(draftPath);
+    } catch (err) {
+      if (isEnoent(err)) {
+        throw new Error(`no draft to discard for slug: ${JSON.stringify(slug)}`);
+      }
+      throw err;
+    }
+  };
+  const deletePage = async (slug) => {
+    const publishedPath = resolveSlugPath(pagesDir, slug, ".json");
+    try {
+      await fs3.access(publishedPath);
+    } catch {
+      throw new Error(`page not found: ${slug}`);
+    }
+    await fs3.unlink(publishedPath);
+    const draftPath = resolveSlugPath(draftsDir, slug, ".json");
+    try {
+      await fs3.unlink(draftPath);
+    } catch {
+    }
+  };
+  const unpublishPage = async (slug) => {
+    const publishedPath = resolveSlugPath(pagesDir, slug, ".json");
+    const draftPath = resolveSlugPath(draftsDir, slug, ".json");
+    const published = await readJsonOrNull(publishedPath);
+    if (published === null) {
+      throw new Error(`page not found: ${slug}`);
+    }
+    const existingDraft = await readJsonOrNull(draftPath);
+    if (existingDraft === null) {
+      await writeAtomic(draftPath, JSON.stringify(published, null, 2));
+    }
+    await fs3.unlink(publishedPath);
+  };
+  const listHistory = async (slug) => {
+    assertValidSlug(slug);
+    const slugDir = resolveUnderBucket(historyDir, slug, "slug escapes history bucket");
+    let entries;
+    try {
+      entries = await fs3.readdir(slugDir, { withFileTypes: true });
+    } catch (err) {
+      if (isEnoent(err)) return [];
+      throw err;
+    }
+    const results = [];
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      if (!entry.name.endsWith(".json")) continue;
+      const timestamp = entry.name.slice(0, -".json".length);
+      const stat3 = await fs3.stat(path3.join(slugDir, entry.name));
+      results.push({ slug, timestamp, size: stat3.size });
+    }
+    results.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    return results;
+  };
+  const readHistorySnapshot = async (slug, timestamp) => {
+    assertValidSlug(slug);
+    const slugDir = resolveUnderBucket(historyDir, slug, "slug escapes history bucket");
+    const filePath = resolveUnderBucket(
+      slugDir,
+      `${timestamp}.json`,
+      "timestamp escapes history directory",
+      timestamp
+    );
+    return readJsonOrNull(filePath);
+  };
+  const renamePage = async (fromSlug, toSlug) => {
+    assertValidSlug(fromSlug);
+    assertValidSlug(toSlug);
+    const fromPublished = resolveSlugPath(pagesDir, fromSlug, ".json");
+    const toPublished = resolveSlugPath(pagesDir, toSlug, ".json");
+    try {
+      await fs3.access(fromPublished);
+    } catch {
+      throw new Error(`page not found: ${fromSlug}`);
+    }
+    try {
+      await fs3.access(toPublished);
+      throw new Error(`target slug already exists: ${toSlug}`);
+    } catch (err) {
+      if (isEnoent(err)) {
+      } else {
+        throw err;
+      }
+    }
+    await fs3.rename(fromPublished, toPublished);
+    const fromDraft = resolveSlugPath(draftsDir, fromSlug, ".json");
+    const toDraft = resolveSlugPath(draftsDir, toSlug, ".json");
+    try {
+      await fs3.rename(fromDraft, toDraft);
+    } catch (err) {
+      if (!isEnoent(err)) throw err;
+    }
+    const fromHistory = path3.resolve(historyDir, fromSlug);
+    const toHistory = path3.resolve(historyDir, toSlug);
+    try {
+      await fs3.rename(fromHistory, toHistory);
+    } catch (err) {
+      if (!isEnoent(err)) throw err;
+    }
+  };
+  const readGlobal = async (name) => {
+    const filePath = resolveSlugPath(globalsDir, name, ".json");
+    return readJsonOrNull(filePath);
+  };
+  const uniqueGlobalHistoryPath = async (name) => {
+    assertValidSlug(name);
+    return uniqueTimestampedPath(
+      globalsHistoryDir,
+      name,
+      "name escapes globals history bucket"
+    );
+  };
+  const readLatestGlobalHistorySnapshot = async (name) => {
+    assertValidSlug(name);
+    return readLatestSnapshotIn(
+      globalsHistoryDir,
+      name,
+      "name escapes globals history bucket"
+    );
+  };
+  const saveGlobal = async (global) => {
+    const filePath = resolveSlugPath(globalsDir, global.name, ".json");
+    const serialised = JSON.stringify(global, null, 2);
+    const latestSnapshot = await readLatestGlobalHistorySnapshot(global.name);
+    const skipHistory = latestSnapshot !== null && deepEqual(latestSnapshot, global);
+    if (!skipHistory) {
+      const historyPath = await uniqueGlobalHistoryPath(global.name);
+      await writeAtomic(historyPath, serialised);
+    }
+    await writeAtomic(filePath, serialised);
+  };
+  const listGlobals = async () => {
+    let entries;
+    try {
+      entries = await fs3.readdir(globalsDir, { withFileTypes: true });
+    } catch (err) {
+      if (isEnoent(err)) return [];
+      throw err;
+    }
+    const results = [];
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      if (!entry.name.endsWith(".json")) continue;
+      const filePath = path3.join(globalsDir, entry.name);
+      const json = await readJsonOrNull(filePath);
+      if (json === null) continue;
+      const stat3 = await fs3.stat(filePath).catch(() => null);
+      if (stat3 === null) continue;
+      results.push({ name: json.name, type: json.type, updatedAt: stat3.mtime });
+    }
+    return results;
+  };
+  const deleteGlobal = async (name) => {
+    const filePath = resolveSlugPath(globalsDir, name, ".json");
+    try {
+      await fs3.unlink(filePath);
+    } catch (err) {
+      if (isEnoent(err)) {
+        throw new Error(`global not found: ${name}`);
+      }
+      throw err;
+    }
+  };
+  const listGlobalHistory = async (name) => {
+    assertValidSlug(name);
+    const nameDir = resolveUnderBucket(
+      globalsHistoryDir,
+      name,
+      "name escapes globals history bucket"
+    );
+    let entries;
+    try {
+      entries = await fs3.readdir(nameDir, { withFileTypes: true });
+    } catch (err) {
+      if (isEnoent(err)) return [];
+      throw err;
+    }
+    const results = [];
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      if (!entry.name.endsWith(".json")) continue;
+      const timestamp = entry.name.slice(0, -".json".length);
+      const stat3 = await fs3.stat(path3.join(nameDir, entry.name));
+      results.push({ name, timestamp, size: stat3.size });
+    }
+    results.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    return results;
+  };
+  const readGlobalHistorySnapshot = async (name, timestamp) => {
+    assertValidSlug(name);
+    const nameDir = resolveUnderBucket(
+      globalsHistoryDir,
+      name,
+      "name escapes globals history bucket"
+    );
+    const filePath = resolveUnderBucket(
+      nameDir,
+      `${timestamp}.json`,
+      "timestamp escapes history directory",
+      timestamp
+    );
+    return readJsonOrNull(filePath);
+  };
+  const rollbackGlobal = async (name, timestamp) => {
+    const snapshot = await readGlobalHistorySnapshot(name, timestamp);
+    if (snapshot === null) {
+      throw new Error(`global history snapshot not found: ${name} @ ${timestamp}`);
+    }
+    await saveGlobal(snapshot);
+  };
+  return {
+    readPage,
+    saveDraft,
+    listDrafts,
+    listPages,
+    listPageSummaries,
+    publishDraft,
+    deleteDraft,
+    deletePage,
+    unpublishPage,
+    listHistory,
+    readHistorySnapshot,
+    renamePage,
+    readGlobal,
+    saveGlobal,
+    listGlobals,
+    deleteGlobal,
+    listGlobalHistory,
+    readGlobalHistorySnapshot,
+    rollbackGlobal
+  };
+};
+
+// src/storage/fs/submissions.ts
+var import_node_crypto2 = require("crypto");
+var fs4 = __toESM(require("fs/promises"), 1);
+var path4 = __toESM(require("path"), 1);
+var DEFAULT_MAX_LIST = 500;
+var FORM_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
+var parseSubmission = (raw) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return null;
+  }
+  const obj = parsed;
+  if (typeof obj["formName"] !== "string") return null;
+  if (typeof obj["id"] !== "string") return null;
+  if (typeof obj["submittedAt"] !== "string") return null;
+  if (obj["payload"] === null || typeof obj["payload"] !== "object" || Array.isArray(obj["payload"])) {
+    return null;
+  }
+  return {
+    formName: obj["formName"],
+    id: obj["id"],
+    submittedAt: obj["submittedAt"],
+    payload: obj["payload"]
+  };
+};
+var assertValidFormName = (name) => {
+  if (typeof name !== "string" || !FORM_NAME_PATTERN.test(name)) {
+    throw new Error(`invalid form name: ${JSON.stringify(name)}`);
+  }
+};
+var submissionFilename = (submittedAt, id) => {
+  const ts = submittedAt.replace(/:/g, "-");
+  return `${ts}-${id}.json`;
+};
+var listJsonFiles = async (dir) => {
+  let entries;
+  try {
+    entries = await fs4.readdir(dir, { withFileTypes: true });
+  } catch (err) {
+    if (isEnoent(err)) return [];
+    throw err;
+  }
+  const results = [];
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith(".json")) {
+      results.push(entry.name);
+    }
+  }
+  return results;
+};
+var createFsSubmissionAdapter = (options) => {
+  const { submissionsRoot } = options;
+  if (!path4.isAbsolute(submissionsRoot)) {
+    throw new Error(
+      `submissionsRoot must be an absolute path, got: ${JSON.stringify(submissionsRoot)}`
+    );
+  }
+  const maxList = options.maxList ?? DEFAULT_MAX_LIST;
+  if (!Number.isFinite(maxList) || maxList <= 0 || !Number.isInteger(maxList)) {
+    throw new Error(
+      `maxList must be a positive integer, got: ${maxList}`
+    );
+  }
+  const rootResolved = path4.resolve(submissionsRoot);
+  const rootWithSep = rootResolved.endsWith(path4.sep) ? rootResolved : rootResolved + path4.sep;
+  const formDir = (formName) => {
+    assertValidFormName(formName);
+    const dir = path4.resolve(rootResolved, formName);
+    if (!dir.startsWith(rootWithSep)) {
+      throw new Error(`form name escapes submissions root: ${JSON.stringify(formName)}`);
+    }
+    return dir;
+  };
+  const cryptoSuffix = () => (0, import_node_crypto2.randomUUID)();
+  const store = async (submission) => {
+    const dir = formDir(submission.formName);
+    const filename = submissionFilename(submission.submittedAt, submission.id);
+    if (filename.includes("/") || filename.includes("\\")) {
+      throw new Error(`submission id contains path separator: ${JSON.stringify(submission.id)}`);
+    }
+    const target = path4.join(dir, filename);
+    await writeAtomic(target, JSON.stringify(submission, null, 2), cryptoSuffix);
+  };
+  const list = async (formName) => {
+    const dir = formDir(formName);
+    const files = await listJsonFiles(dir);
+    const summaries = [];
+    for (const filename of files) {
+      const stem = filename.slice(0, -".json".length);
+      const lastDash = stem.lastIndexOf("-");
+      if (lastDash < 0) continue;
+      const tsRaw = stem.slice(0, lastDash);
+      const id = stem.slice(lastDash + 1);
+      if (id === "") continue;
+      const tIndex = tsRaw.indexOf("T");
+      if (tIndex < 0) continue;
+      const datePart = tsRaw.slice(0, tIndex);
+      const timePart = tsRaw.slice(tIndex + 1).replace(/-/g, ":");
+      const submittedAt = `${datePart}T${timePart}`;
+      summaries.push({ id, submittedAt });
+    }
+    summaries.sort((a, b) => {
+      if (a.submittedAt !== b.submittedAt) {
+        return a.submittedAt < b.submittedAt ? 1 : -1;
+      }
+      if (a.id !== b.id) {
+        return a.id < b.id ? 1 : -1;
+      }
+      return 0;
+    });
+    return summaries.length > maxList ? summaries.slice(0, maxList) : summaries;
+  };
+  const read = async (formName, id) => {
+    if (id.includes("/") || id.includes("\\") || id.includes("..")) {
+      return null;
+    }
+    const dir = formDir(formName);
+    let entries;
+    try {
+      entries = (await fs4.readdir(dir)).filter((n) => n.endsWith(".json"));
+    } catch (err) {
+      if (isEnoent(err)) return null;
+      throw err;
+    }
+    const suffix = `-${id}.json`;
+    const found = entries.find((n) => n.endsWith(suffix));
+    if (!found) return null;
+    const target = path4.join(dir, found);
+    let raw;
+    try {
+      raw = await fs4.readFile(target, { encoding: "utf8" });
+    } catch (err) {
+      if (isEnoent(err)) return null;
+      throw err;
+    }
+    return parseSubmission(raw);
+  };
+  return { info: { kind: "fs" }, store, list, read };
+};
+
+// src/config/defaults-registry.ts
+var SLOT = /* @__PURE__ */ Symbol.for("@agntcms/next/default-adapter-factories");
+function holder() {
+  return globalThis;
+}
+function registerDefaultAdapterFactories(factories) {
+  holder()[SLOT] = factories;
+}
+
+// src/config/defaults.ts
+var path5 = __toESM(require("path"), 1);
+function createDefaultContentAdapter(options) {
+  const root = options?.projectRoot ?? process.cwd();
+  return createFsContentAdapter({
+    contentRoot: path5.resolve(root, "content")
+  });
+}
+function createDefaultAssetAdapter(options) {
+  const root = options?.projectRoot ?? process.cwd();
+  return createFsAssetAdapter({
+    assetsRoot: path5.resolve(root, "public/assets"),
+    publicUrlBase: "/assets"
+  });
+}
+function createDefaultSubmissionAdapter(options) {
+  const root = options?.projectRoot ?? process.cwd();
+  return createFsSubmissionAdapter({
+    submissionsRoot: path5.resolve(root, "content/submissions")
+  });
+}
+function installDefaultAdapterFactories() {
+  const factories = {
+    content: createDefaultContentAdapter,
+    asset: createDefaultAssetAdapter,
+    submission: createDefaultSubmissionAdapter
+  };
+  registerDefaultAdapterFactories(factories);
+}
+
+// src/runtime/getContent.ts
+var import_node_crypto5 = require("crypto");
+
+// src/runtime/getGlobal.ts
+var import_node_crypto3 = require("crypto");
+var computeRevision = (global) => {
+  const serialized = JSON.stringify(global);
+  return (0, import_node_crypto3.createHash)("sha256").update(serialized).digest("hex");
+};
+var wrapGlobalData = (global, revision) => {
+  const data = global.data;
+  const wrapped = {};
+  for (const key of Object.keys(data)) {
+    const origin = {
+      kind: "global",
+      globalName: global.name,
+      // Sentinel values: keep the shape stable for editable widgets that
+      // already read these props. The `__global__:` prefix surfaces the
+      // origin in any debug logging without ambiguity vs. real slugs.
+      pageSlug: `__global__:${global.name}`,
+      sectionId: global.name,
+      fieldPath: key,
+      // Globals have no draft/publish cycle in v1. Treat every preview
+      // read as a draft view — saves overwrite the live global directly.
+      source: "draft",
+      revision
+    };
+    wrapped[key] = {
+      __agntcmsPreview: true,
+      value: data[key],
+      origin
+    };
+  }
+  return wrapped;
+};
+function createGetGlobal(contentAdapter) {
+  return async (input) => {
+    const { name, mode } = input;
+    if (mode === "published") {
+      return contentAdapter.readGlobal(name);
+    }
+    const global = await contentAdapter.readGlobal(name);
+    if (global === null) return null;
+    const revision = computeRevision(global);
+    const wrappedData = wrapGlobalData(global, revision);
+    return {
+      name: global.name,
+      type: global.type,
+      data: wrappedData
+    };
+  };
+}
+
+// src/runtime/listPages.ts
+var toPublicSummary = (entry) => {
+  const result = { slug: entry.slug, seo: entry.seo };
+  if (entry.tags !== void 0) result.tags = entry.tags;
+  if (entry.excerpt !== void 0) result.excerpt = entry.excerpt;
+  if (entry.coverImage !== void 0) result.coverImage = entry.coverImage;
+  if (entry.publishedAt !== void 0) result.publishedAt = entry.publishedAt;
+  return result;
+};
+var compareEntries = (a, b, direction) => {
+  const aHasPublished = a.publishedAt !== void 0;
+  const bHasPublished = b.publishedAt !== void 0;
+  let primary;
+  if (aHasPublished && bHasPublished) {
+    primary = a.publishedAt.localeCompare(b.publishedAt);
+  } else if (aHasPublished && !bHasPublished) {
+    primary = 1;
+  } else if (!aHasPublished && bHasPublished) {
+    primary = -1;
+  } else {
+    primary = a.updatedAt.getTime() - b.updatedAt.getTime();
+  }
+  if (primary !== 0) {
+    return direction === "newest" ? -primary : primary;
+  }
+  return a.slug.localeCompare(b.slug);
+};
+var createListPages = ({
+  contentAdapter
+}) => {
+  return async (input) => {
+    const tag = input?.tag;
+    const limit = input?.limit;
+    const sort = input?.sort ?? "newest";
+    if (limit !== void 0 && limit <= 0) return [];
+    const all = await contentAdapter.listPageSummaries();
+    for (const entry of all) {
+      assertValidPageSummary(entry);
+    }
+    const filtered = tag === void 0 ? all : all.filter(
+      (entry) => (
+        // Tag matching is case-sensitive exact (ARCHITECTURE.md §4).
+        entry.tags !== void 0 && entry.tags.includes(tag)
+      )
+    );
+    const sorted = [...filtered].sort((a, b) => compareEntries(a, b, sort));
+    const capped = limit === void 0 ? sorted : sorted.slice(0, limit);
+    return capped.map(toPublicSummary);
+  };
+};
+
+// src/runtime/submitForm.ts
+var import_node_crypto4 = require("crypto");
+var CROCKFORD32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var defaultGenerateId = () => {
+  const bytes = (0, import_node_crypto4.randomBytes)(16);
+  let out = "";
+  for (let i = 0; i < 16; i++) {
+    out += CROCKFORD32[bytes[i] & 31];
+  }
+  return out;
+};
+var validateNonEmptyString = (value) => {
+  if (typeof value !== "string") return "must be a string";
+  if (value.trim() === "") return "must not be empty";
+  return null;
+};
+var validateNumber = (value, descriptor) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return "must be a finite number";
+  }
+  if (descriptor.min !== void 0 && value < descriptor.min) {
+    return `must be >= ${descriptor.min}`;
+  }
+  if (descriptor.max !== void 0 && value > descriptor.max) {
+    return `must be <= ${descriptor.max}`;
+  }
+  return null;
+};
+var validateBoolean = (value) => {
+  if (typeof value !== "boolean") return "must be true or false";
+  return null;
+};
+var validateSelect = (value, descriptor) => {
+  if (typeof value !== "string") return "must be a string";
+  if (!descriptor.options.some((opt) => opt.value === value)) {
+    return "must be one of the declared options";
+  }
+  return null;
+};
+var validateLinkPayload = (value) => {
+  if (value === null || typeof value !== "object") return "must be a link object";
+  const obj = value;
+  if (typeof obj["label"] !== "string") return "label must be a string";
+  if (obj["type"] === "internal") {
+    const slug = obj["slug"];
+    if (typeof slug !== "string") return "slug must be a string";
+    if (slug.trim() === "") return "slug must be a non-empty string";
+    return validateInternalSlug(slug);
+  }
+  if (obj["type"] === "external") {
+    const url = obj["url"];
+    if (typeof url !== "string") return "url must be a string";
+    if (url.trim() === "") return "url must be a non-empty string";
+    return validateExternalUrl(url);
+  }
+  if (obj["type"] === "email") {
+    const email = obj["email"];
+    if (typeof email !== "string") return "email must be a string";
+    if (email.trim() === "") return "email must be a non-empty string";
+    return validateEmail(email);
+  }
+  if (obj["type"] === "phone") {
+    const phone = obj["phone"];
+    if (typeof phone !== "string") return "phone must be a string";
+    if (phone.trim() === "") return "phone must be a non-empty string";
+    return validatePhone(phone);
+  }
+  return 'type must be "internal", "external", "email", or "phone"';
+};
+var validateAndNormalisePayload = (schema, payload) => {
+  const errors = {};
+  const normalised = {};
+  for (const [fieldName, descriptor] of Object.entries(schema)) {
+    if (!Object.prototype.hasOwnProperty.call(payload, fieldName)) {
+      errors[fieldName] = "is required";
+      continue;
+    }
+    const value = payload[fieldName];
+    let err = null;
+    switch (descriptor.kind) {
+      case "text":
+      case "richText": {
+        err = validateNonEmptyString(value);
+        if (!err) {
+          normalised[fieldName] = value.trim();
+        }
+        break;
+      }
+      case "number": {
+        err = validateNumber(value, descriptor);
+        if (!err) normalised[fieldName] = value;
+        break;
+      }
+      case "boolean": {
+        err = validateBoolean(value);
+        if (!err) normalised[fieldName] = value;
+        break;
+      }
+      case "select": {
+        err = validateSelect(value, descriptor);
+        if (!err) normalised[fieldName] = value;
+        break;
+      }
+      case "link": {
+        err = validateLinkPayload(value);
+        if (!err) {
+          const linkObj = value;
+          const label = typeof linkObj["label"] === "string" ? linkObj["label"] : "";
+          const normalisedLink = linkObj["type"] === "external" ? { type: "external", url: linkObj["url"], label } : linkObj["type"] === "email" ? { type: "email", email: linkObj["email"], label } : linkObj["type"] === "phone" ? { type: "phone", phone: linkObj["phone"], label } : { type: "internal", slug: linkObj["slug"], label };
+          normalised[fieldName] = normalisedLink;
+        }
+        break;
+      }
+      default: {
+        const _exhaustive = descriptor;
+        void _exhaustive;
+        err = "unsupported field type";
+      }
+    }
+    if (err) errors[fieldName] = err;
+  }
+  if (Object.keys(errors).length > 0) return { ok: false, errors };
+  return { ok: true, payload: normalised };
+};
+function createSubmitForm(deps) {
+  const { forms, submissionAdapter } = deps;
+  const generateId = deps.generateId ?? defaultGenerateId;
+  const now = deps.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  return async function submitForm(input) {
+    const def = forms.get(input.formName);
+    if (!def) {
+      return { ok: false, error: "unknown_form" };
+    }
+    if (def.honeypot !== void 0) {
+      const trapValue = input.payload[def.honeypot];
+      if (typeof trapValue === "string" && trapValue.length > 0) {
+        return { ok: true, stored: false, suppressed: "honeypot" };
+      }
+    }
+    const validated = validateAndNormalisePayload(def.schema, input.payload);
+    if (!validated.ok) {
+      return { ok: false, error: "validation_failed", errors: validated.errors };
+    }
+    const submission = {
+      formName: def.name,
+      payload: validated.payload,
+      submittedAt: now(),
+      id: generateId()
+    };
+    await submissionAdapter.store(submission);
+    return { ok: true, stored: true, id: submission.id };
+  };
+}
+
+// src/runtime/getContent.ts
+var isPlainObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+var looksLikeLink = (obj) => {
+  if (obj["type"] === "internal" || obj["type"] === "external") return true;
+  return typeof obj["href"] === "string" && typeof obj["label"] === "string" && obj["_id"] === void 0;
+};
+var normalizeLinks = (value) => {
+  if (Array.isArray(value)) {
+    let changed = false;
+    const next = value.map((entry) => {
+      const normalised = normalizeLinks(entry);
+      if (normalised !== entry) changed = true;
+      return normalised;
+    });
+    return changed ? next : value;
+  }
+  if (isPlainObject(value)) {
+    if (looksLikeLink(value)) {
+      return normalizeLinkValue(value);
+    }
+    let changed = false;
+    const next = {};
+    for (const key of Object.keys(value)) {
+      const normalised = normalizeLinks(value[key]);
+      if (normalised !== value[key]) changed = true;
+      next[key] = normalised;
+    }
+    return changed ? next : value;
+  }
+  return value;
+};
+var normalizeLinksInSections = (sections) => {
+  let changed = false;
+  const next = sections.map((section) => {
+    const normalisedData = normalizeLinks(section.data);
+    if (normalisedData === section.data) return section;
+    changed = true;
+    return {
+      id: section.id,
+      type: section.type,
+      data: normalisedData,
+      ...section.globalRef !== void 0 ? { globalRef: section.globalRef } : {}
+    };
+  });
+  return changed ? next : sections;
+};
+var computeRevision2 = (page) => {
+  const serialized = JSON.stringify(page);
+  return (0, import_node_crypto5.createHash)("sha256").update(serialized).digest("hex");
+};
+var withSections = (page, sections) => ({
+  ...page,
+  sections
+});
+var wrapSectionData = (section, pageSlug, source, revision) => {
+  const data = section.data;
+  const wrapped = {};
+  for (const key of Object.keys(data)) {
+    const origin = {
+      pageSlug,
+      sectionId: section.id,
+      fieldPath: key,
+      source,
+      revision
+    };
+    wrapped[key] = {
+      __agntcmsPreview: true,
+      value: data[key],
+      origin
+    };
+  }
+  return wrapped;
+};
+var resolveGlobalRefs = async (sections, contentAdapter) => {
+  if (!sections.some((s) => s.globalRef !== void 0)) return sections;
+  const resolved = await Promise.all(
+    sections.map(async (section) => {
+      if (section.globalRef === void 0) return section;
+      const global = await contentAdapter.readGlobal(section.globalRef);
+      if (global === null) {
+        console.warn(
+          `[agntcms] global "${section.globalRef}" referenced by section "${section.id}" not found \u2014 keeping section as-is`
+        );
+        return section;
+      }
+      return {
+        id: section.id,
+        type: global.type,
+        data: global.data,
+        globalRef: section.globalRef
+      };
+    })
+  );
+  return resolved;
+};
+var isInvalidSlugError = (err) => err instanceof Error && err.message.startsWith("invalid slug:");
+function createRuntime(options) {
+  const { contentAdapter } = options;
+  const getContent = async (input) => {
+    const { slug, mode } = input;
+    if (mode === "published") {
+      let page2;
+      try {
+        page2 = await contentAdapter.readPage(slug, "published");
+      } catch (err) {
+        if (isInvalidSlugError(err)) return null;
+        throw err;
+      }
+      if (page2 === null) return null;
+      assertValidPage(page2);
+      const resolved = await resolveGlobalRefs(page2.sections, contentAdapter);
+      const sections = normalizeLinksInSections(resolved);
+      if (sections === page2.sections) return page2;
+      return withSections(page2, sections);
+    }
+    let page;
+    let source = "draft";
+    try {
+      page = await contentAdapter.readPage(slug, "draft");
+    } catch (err) {
+      if (isInvalidSlugError(err)) return null;
+      throw err;
+    }
+    if (page === null) {
+      try {
+        page = await contentAdapter.readPage(slug, "published");
+      } catch (err) {
+        if (isInvalidSlugError(err)) return null;
+        throw err;
+      }
+      source = "published";
+    }
+    if (page === null) {
+      return null;
+    }
+    assertValidPage(page);
+    const resolvedSections = await resolveGlobalRefs(page.sections, contentAdapter);
+    const normalisedSections = normalizeLinksInSections(resolvedSections);
+    const revision = computeRevision2(withSections(page, normalisedSections));
+    const wrappedSections = normalisedSections.map((section) => ({
+      id: section.id,
+      type: section.type,
+      data: wrapSectionData(section, slug, source, revision),
+      // Preserve globalRef so the UI knows this section is backed by a global
+      // and can redirect saves to the global endpoint.
+      ...section.globalRef !== void 0 ? { globalRef: section.globalRef } : {}
+    }));
+    return withSections(page, wrappedSections);
+  };
+  const publishDraft = async (slug) => {
+    const draft = await contentAdapter.readPage(slug, "draft");
+    if (draft === null) {
+      throw new Error(`no draft to publish for slug: ${JSON.stringify(slug)}`);
+    }
+    assertValidPage(draft);
+    return contentAdapter.publishDraft(slug);
+  };
+  const getGlobal = createGetGlobal(contentAdapter);
+  const listPages = createListPages({ contentAdapter });
+  const noopAdapter = {
+    info: { kind: "fs" },
+    store: async () => {
+      throw new Error("submissionAdapter not configured; pass one to createRuntime");
+    },
+    list: async () => [],
+    read: async () => null
+  };
+  const submitForm = createSubmitForm({
+    forms: options.forms ?? emptyFormRegistry,
+    submissionAdapter: options.submissionAdapter ?? noopAdapter
+  });
+  return { getContent, publishDraft, getGlobal, submitForm, listPages };
+}
+var emptyFormRegistry = Object.freeze({
+  definitions: [],
+  get: () => void 0,
+  has: () => false
+});
+
+// src/runtime/rateLimit.ts
+var DEFAULT_MAX_BUCKETS = 1e4;
+function createRateLimit(options) {
+  const { perWindow, windowMs } = options;
+  if (!Number.isFinite(perWindow) || perWindow <= 0) {
+    throw new Error(`perWindow must be a positive number, got: ${perWindow}`);
+  }
+  if (!Number.isFinite(windowMs) || windowMs <= 0) {
+    throw new Error(`windowMs must be a positive number, got: ${windowMs}`);
+  }
+  const maxBuckets = options.maxBuckets ?? DEFAULT_MAX_BUCKETS;
+  if (!Number.isFinite(maxBuckets) || maxBuckets <= 0 || !Number.isInteger(maxBuckets)) {
+    throw new Error(`maxBuckets must be a positive integer, got: ${maxBuckets}`);
+  }
+  const now = options.now ?? Date.now;
+  const buckets = /* @__PURE__ */ new Map();
+  const keyOf = (ip, formName) => `${ip}:${formName}`;
+  const sweepExpired = (t) => {
+    for (const [k, b] of buckets) {
+      if (t >= b.resetAt) buckets.delete(k);
+    }
+  };
+  const evictOldest = () => {
+    let oldestKey = null;
+    let oldestResetAt = Number.POSITIVE_INFINITY;
+    for (const [k, b] of buckets) {
+      if (b.resetAt < oldestResetAt) {
+        oldestResetAt = b.resetAt;
+        oldestKey = k;
+      }
+    }
+    if (oldestKey !== null) buckets.delete(oldestKey);
+  };
+  return {
+    check: (ip, formName) => {
+      const key = keyOf(ip, formName);
+      const t = now();
+      const existing = buckets.get(key);
+      if (!existing || t >= existing.resetAt) {
+        if (!existing && buckets.size >= maxBuckets) {
+          sweepExpired(t);
+          while (buckets.size >= maxBuckets) {
+            evictOldest();
+          }
+        }
+        const bucket = { count: 1, resetAt: t + windowMs };
+        buckets.set(key, bucket);
+        return { allowed: true, count: 1, resetAt: bucket.resetAt };
+      }
+      existing.count += 1;
+      const allowed = existing.count <= perWindow;
+      return { allowed, count: existing.count, resetAt: existing.resetAt };
+    },
+    reset: () => {
+      buckets.clear();
+    }
+  };
+}
+
+// src/runtime/systemPages.ts
+var NOT_FOUND_PAGE_SLUG = "404";
+var SERVER_ERROR_PAGE_SLUG = "500";
+var SITEMAP_EXCLUDED_TERMINAL_SLUGS = /* @__PURE__ */ new Set([
+  NOT_FOUND_PAGE_SLUG,
+  SERVER_ERROR_PAGE_SLUG,
+  "not-found",
+  "_not-found"
+]);
+var SYSTEM_PAGE_ALIAS_TO_CANONICAL = /* @__PURE__ */ new Map([
+  ["not-found", NOT_FOUND_PAGE_SLUG],
+  ["_not-found", NOT_FOUND_PAGE_SLUG],
+  ["error-404", NOT_FOUND_PAGE_SLUG],
+  ["404-page", NOT_FOUND_PAGE_SLUG],
+  ["page-not-found", NOT_FOUND_PAGE_SLUG],
+  ["error-500", SERVER_ERROR_PAGE_SLUG],
+  ["500-page", SERVER_ERROR_PAGE_SLUG],
+  ["server-error", SERVER_ERROR_PAGE_SLUG]
+]);
+var getReservedPageSlugViolation = (slug) => {
+  const canonicalSlug = SYSTEM_PAGE_ALIAS_TO_CANONICAL.get(slug);
+  if (!canonicalSlug) return null;
+  const pageLabel = canonicalSlug === NOT_FOUND_PAGE_SLUG ? "404 page" : "500 page";
+  return {
+    slug,
+    canonicalSlug,
+    message: `Slug "${slug}" is reserved as an alias for the ${pageLabel}. Edit the canonical "${canonicalSlug}" page instead.`
+  };
+};
+var isSitemapEligibleSlug = (slug) => {
+  const terminal = slug.split("/").at(-1);
+  if (!terminal) return false;
+  return !SITEMAP_EXCLUDED_TERMINAL_SLUGS.has(terminal);
+};
+
+// src/storage/webhook/submissions.ts
+var URL_PATTERN = /^https?:\/\//;
+var DEFAULT_TIMEOUT_MS = 1e4;
+var createWebhookSubmissionAdapter = (options) => {
+  if (typeof options.url !== "string" || !URL_PATTERN.test(options.url)) {
+    throw new Error(
+      `webhook url must start with http:// or https://, got: ${JSON.stringify(options.url)}`
+    );
+  }
+  let parsedHost;
+  try {
+    parsedHost = new URL(options.url).host;
+  } catch {
+    throw new Error(
+      `webhook url is not a valid URL: ${JSON.stringify(options.url)}`
+    );
+  }
+  if (options.url.startsWith("http://") && options.headers !== void 0 && Object.keys(options.headers).length > 0) {
+    console.warn(
+      "[agntcms] webhook url uses http:// with custom headers \u2014 secrets will be transmitted in plaintext"
+    );
+  }
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || !Number.isInteger(timeoutMs)) {
+    throw new Error(
+      `webhook timeoutMs must be a positive integer (ms), got: ${timeoutMs}`
+    );
+  }
+  const doFetch = options.fetch ?? ((url, init) => (
+    // The DOM/Node fetch types differ; cast to the minimal shape we declared.
+    // Using `globalThis.fetch` keeps this neutral across Node, Edge, and
+    // jsdom test environments.
+    globalThis.fetch(url, init)
+  ));
+  const baseHeaders = {
+    "Content-Type": "application/json",
+    ...options.headers
+  };
+  const store = async (submission) => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let res;
+    try {
+      res = await doFetch(options.url, {
+        method: "POST",
+        headers: baseHeaders,
+        body: JSON.stringify(submission),
+        signal: controller.signal
+      });
+    } catch (err) {
+      const isAbort = controller.signal.aborted || err instanceof Error && err.name === "AbortError";
+      if (isAbort) {
+        console.error(
+          `[agntcms] webhook submission timed out after ${timeoutMs}ms`
+        );
+        throw new Error(`webhook request timed out after ${timeoutMs}ms`);
+      }
+      console.error(
+        `[agntcms] webhook submission failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+    if (!res.ok) {
+      let detail = "";
+      try {
+        detail = await res.text();
+      } catch {
+      }
+      console.error(
+        `[agntcms] webhook returned ${res.status}${detail ? `: ${detail.slice(0, 200)}` : ""}`
+      );
+      throw new Error(`webhook responded with status ${res.status}`);
+    }
+  };
+  const list = async (_formName) => {
+    throw new SubmissionsNotReadableError(
+      "webhook submission adapter has no local copy; configure an FS adapter to enable listing"
+    );
+  };
+  const read = async (_formName, _id) => {
+    throw new SubmissionsNotReadableError(
+      "webhook submission adapter has no local copy; configure an FS adapter to enable reading"
+    );
+  };
+  return { info: { kind: "webhook", host: parsedHost }, store, list, read };
+};
+
+// src/sections/defineSection.ts
+function builtInDefault(fieldName, descriptor) {
+  switch (descriptor.kind) {
+    case "image":
+      return { filename: "placeholder.png", alt: "Placeholder image" };
+    case "video":
+      return { url: "" };
+    case "richText":
+      return "Start writing here...";
+    case "text":
+      return fieldName.charAt(0).toUpperCase() + fieldName.slice(1).replace(/([A-Z])/g, " $1");
+    case "reference":
+      return { slug: "" };
+    case "link":
+      return { type: "internal", slug: "", label: "Learn more" };
+    case "button": {
+      const firstVariant = descriptor.variants[0]?.value ?? "";
+      return { label: "Get started", variant: firstVariant };
+    }
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    case "select":
+      return descriptor.options[0]?.value ?? "";
+    case "list":
+      return [];
+    case "formOverrides":
+      return {};
+    default: {
+      const _exhaustive = descriptor;
+      void _exhaustive;
+      return "";
+    }
+  }
+}
+function defineSection(input) {
+  const defaults = {};
+  for (const [key, descriptor] of Object.entries(input.schema)) {
+    defaults[key] = descriptor.default ?? builtInDefault(key, descriptor);
+  }
+  return {
+    name: input.name,
+    ...input.category !== void 0 ? { category: input.category } : {},
+    schema: input.schema,
+    component: input.component,
+    defaults,
+    // Conditional spread mirrors the `category` pattern — required so
+    // `exactOptionalPropertyTypes` does not see `layouts: undefined` being
+    // assigned to an optional-only property.
+    ...input.layouts !== void 0 ? { layouts: input.layouts } : {}
+  };
+}
+
+// src/sections/wrapAsSlot.ts
+function wrapAsSlot(_kind, value) {
+  return { value };
+}
+
+// src/sections/wrapSectionProps.ts
+var SLOT_KINDS = /* @__PURE__ */ new Set([
+  "text",
+  "richText",
+  "image",
+  "video",
+  "link",
+  "button",
+  "number",
+  "boolean",
+  "select",
+  "list"
+]);
+function wrapSectionProps(data, schema) {
+  if (schema === void 0) {
+    return { ...data };
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(data)) {
+    const descriptor = schema[key];
+    if (descriptor === void 0) {
+      out[key] = value;
+      continue;
+    }
+    if (!SLOT_KINDS.has(descriptor.kind)) {
+      out[key] = value;
+      continue;
+    }
+    out[key] = wrapAsSlot(descriptor.kind, value);
+  }
+  return out;
+}
+
+// src/react-server/GlobalSlot.tsx
+var import_client = require("@agntcms/next/client");
+var import_jsx_runtime = require("react/jsx-runtime");
+var isPreviewBrand = (v) => v !== null && typeof v === "object" && "__agntcmsPreview" in v;
+async function GlobalSlot(props) {
+  const { name, getGlobal, definitions, mode, fallback } = props;
+  const global = await getGlobal({ name, mode }).catch(() => null);
+  if (global === null) {
+    return renderFallback(fallback);
+  }
+  const definition = definitions.find((d) => d.name === global.type);
+  if (!definition) {
+    return renderFallback(fallback);
+  }
+  const Component = definition.component;
+  const dataRecord = global.data;
+  const inPreview = Object.values(dataRecord).some(isPreviewBrand);
+  const rawDefaults = definition.defaults ?? {};
+  const wrappedDefaults = inPreview ? Object.fromEntries(
+    Object.entries(rawDefaults).map(([key, value]) => [
+      key,
+      {
+        __agntcmsPreview: true,
+        value,
+        origin: {
+          kind: "global",
+          globalName: name,
+          pageSlug: `__global__:${name}`,
+          sectionId: name,
+          fieldPath: key,
+          source: "draft",
+          revision: ""
+        }
+      }
+    ])
+  ) : rawDefaults;
+  const mergedData = {
+    ...wrappedDefaults,
+    ...dataRecord
+  };
+  const slotProps = wrapSectionProps(mergedData, definition.schema);
+  if (mode === "published") {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, { ...slotProps });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_client.GlobalSaveProvider,
+    {
+      globalName: name,
+      globalType: global.type,
+      initialData: global.data,
+      children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, { ...slotProps })
+    }
+  );
+}
+function renderFallback(fallback) {
+  if (fallback === void 0 || fallback === null) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: fallback });
+}
+
+// src/forms/defineForm.ts
+var InvalidFormFieldError = class extends Error {
+  formName;
+  fieldName;
+  fieldKind;
+  constructor(formName, fieldName, fieldKind) {
+    super(
+      `Form "${formName}": field "${fieldName}" uses kind "${fieldKind}", which is not allowed in a form schema in v1. Allowed kinds: text, richText, number, boolean, select, link. Forbidden kinds: image, reference, list, formOverrides. See ARCHITECTURE.md \xA76.5.`
+    );
+    this.name = "InvalidFormFieldError";
+    this.formName = formName;
+    this.fieldName = fieldName;
+    this.fieldKind = fieldKind;
+  }
+};
+var HoneypotCollisionError = class extends Error {
+  formName;
+  fieldName;
+  reason;
+  constructor(formName, fieldName, reason = "collision") {
+    super(
+      reason === "empty" ? `Form "${formName}": honeypot name must be a non-empty string.` : `Form "${formName}": honeypot name "${fieldName}" collides with a real field. Choose a honeypot name that does not appear in the schema.`
+    );
+    this.name = "HoneypotCollisionError";
+    this.formName = formName;
+    this.fieldName = fieldName;
+    this.reason = reason;
+  }
+};
+var InvalidFormNameError = class extends Error {
+  constructor(name) {
+    super(
+      `Invalid form name ${JSON.stringify(name)}. Use letters, digits, hyphen, and underscore only (no path separators).`
+    );
+    this.name = "InvalidFormNameError";
+  }
+};
+var FORM_NAME_PATTERN2 = /^[a-zA-Z0-9_-]+$/;
+function defineForm(input) {
+  if (typeof input.name !== "string" || !FORM_NAME_PATTERN2.test(input.name)) {
+    throw new InvalidFormNameError(input.name);
+  }
+  for (const [fieldName, descriptor] of Object.entries(input.schema)) {
+    const kind = descriptor.kind;
+    if (FORM_FORBIDDEN_KINDS.has(kind)) {
+      throw new InvalidFormFieldError(input.name, fieldName, kind);
+    }
+  }
+  if (input.honeypot !== void 0) {
+    if (typeof input.honeypot !== "string" || input.honeypot === "") {
+      throw new HoneypotCollisionError(input.name, input.honeypot, "empty");
+    }
+    if (Object.prototype.hasOwnProperty.call(input.schema, input.honeypot)) {
+      throw new HoneypotCollisionError(input.name, input.honeypot, "collision");
+    }
+  }
+  return input.honeypot !== void 0 ? { name: input.name, schema: input.schema, honeypot: input.honeypot } : { name: input.name, schema: input.schema };
+}
+
+// src/forms/registry.ts
+var DuplicateFormNameError = class extends Error {
+  formName;
+  constructor(name) {
+    super(
+      `Form name "${name}" is registered more than once. Form names must be unique within a config.`
+    );
+    this.name = "DuplicateFormNameError";
+    this.formName = name;
+  }
+};
+function buildFormRegistry(definitions) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const def of definitions) {
+    if (byName.has(def.name)) {
+      throw new DuplicateFormNameError(def.name);
+    }
+    byName.set(def.name, def);
+  }
+  const registry = {
+    definitions,
+    get: (name) => byName.get(name),
+    has: (name) => byName.has(name)
+  };
+  return Object.freeze(registry);
+}
+
+// src/server.ts
+installDefaultAdapterFactories();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BooleanField,
+  ButtonField,
+  DuplicateFormNameError,
+  FormOverridesField,
+  GlobalSlot,
+  HoneypotCollisionError,
+  ImageField,
+  InvalidFormFieldError,
+  InvalidFormNameError,
+  LinkField,
+  ListField,
+  NOT_FOUND_PAGE_SLUG,
+  NumberField,
+  ReferenceField,
+  RichTextField,
+  SERVER_ERROR_PAGE_SLUG,
+  SelectField,
+  SubmissionsNotReadableError,
+  TextField,
+  VideoField,
+  buildFormRegistry,
+  createDefaultAssetAdapter,
+  createDefaultContentAdapter,
+  createDefaultSubmissionAdapter,
+  createFsAssetAdapter,
+  createFsContentAdapter,
+  createFsSubmissionAdapter,
+  createListPages,
+  createRateLimit,
+  createRuntime,
+  createSubmitForm,
+  createWebhookSubmissionAdapter,
+  defineForm,
+  defineSection,
+  getReservedPageSlugViolation,
+  hasUniqueSectionIds,
+  hrefOf,
+  isExternalLink,
+  isSitemapEligibleSlug,
+  linkAnchorAttrs,
+  normalizeLinkValue,
+  validateEmail,
+  validateExternalUrl,
+  validateInternalSlug,
+  validatePhone
+});