@nextlyhq/plugin-form-builder 0.0.2-alpha.6 → 0.0.2-alpha.62

package/dist/index.js

@@ -1,24 +1,327 @@
+import {
+  BUILT_IN_FORM_FIELD_TYPES,
+  DEFAULT_FORM_SETTINGS,
+  DEFAULT_NOTIFICATION_SETTINGS,
+  ENFORCED_VALIDATION_RULES,
+  applyFieldDefaults,
+  applyFormDefaults,
+  createFormConfig,
+  documentReachability,
+  downloadFile,
+  evaluateConditions,
+  evaluateSingleCondition,
+  exportAndDownload,
+  exportToCSV,
+  exportToJSON,
+  formatExportValue,
+  generateExportFilename,
+  getSupportedComparisonOperators,
+  isCheckboxFormField,
+  isEmailFormField,
+  isFileFormField,
+  isFormField,
+  isFormFieldType,
+  isKnownFormField,
+  isSelectFormField,
+  isTextFormField,
+  isValidComparisonOperator,
+  normalizeFormSettings,
+  parseFieldRef,
+  parseRedirectReference,
+  pickedDocumentField,
+  pluralize,
+  toTitleCase
+} from "./chunk-H5X3FKOZ.js";
+
 // src/plugin.ts
-import { getCollectionsHandler } from "nextly/runtime";
+import { createRequire } from "module";
+import { definePlugin } from "@nextlyhq/plugin-sdk";
 
 // src/collections/forms.ts
+import { NextlyError } from "@nextlyhq/plugin-sdk";
 import {
   text,
   textarea,
   select,
   checkbox,
+  date,
   group,
   json,
   relationship
 } from "nextly";
+
+// src/utils/redirect-target.ts
+import { previewUrlFromTemplate } from "nextly/config";
+var DEFAULT_REDIRECT_PATTERN = "/{slug}";
+function normalizeRedirectRelationships(option2) {
+  if (!option2) return {};
+  const entries = Array.isArray(option2) ? option2.map((collection) => [collection, DEFAULT_REDIRECT_PATTERN]) : Object.entries(option2);
+  return Object.fromEntries(
+    entries.filter(
+      ([, pattern]) => typeof pattern !== "string" || pattern.trim()
+    )
+  );
+}
+function applyRedirectPattern(pattern, document) {
+  if (typeof pattern === "function") {
+    const produced = pattern(document);
+    return produced ? produced : void 0;
+  }
+  return previewUrlFromTemplate(pattern)(document) ?? void 0;
+}
+
+// src/collections/access-defaults.ts
+var authenticated = ({ user }) => !!user;
+var administrative = ({ roles }) => roles.includes("admin") || roles.includes("super-admin");
+function accessWithDefaults(overrides, defaults = {}) {
+  return {
+    read: overrides?.read ?? defaults.read ?? authenticated,
+    create: overrides?.create ?? defaults.create ?? authenticated,
+    update: overrides?.update ?? authenticated,
+    // Deleting is administrative in both collections; the DB permission layer
+    // remains the backstop underneath it.
+    delete: overrides?.delete ?? administrative
+  };
+}
+
+// src/collections/forms.ts
+function withHostHooks(pluginHooks, hostHooks, trailing = {}) {
+  const host = { ...hostHooks };
+  const asList = (value) => Array.isArray(value) ? value : value === void 0 ? [] : [value];
+  const merged = { ...host };
+  for (const [phase, handlers] of Object.entries(
+    pluginHooks
+  )) {
+    merged[phase] = [...asList(handlers), ...asList(host[phase])];
+  }
+  for (const [phase, handlers] of Object.entries(trailing)) {
+    merged[phase] = [...asList(merged[phase]), ...asList(handlers)];
+  }
+  return merged;
+}
+function documentRedirectSettings(settings) {
+  if (typeof settings !== "object" || settings === null) return null;
+  const record = settings;
+  const field = pickedDocumentField(record);
+  return field ? { settings: record, field } : null;
+}
+function pageRedirectSettings(data, operation) {
+  if (!data) return null;
+  if (operation !== "create" && data.settings === void 0) return null;
+  return documentRedirectSettings(data.settings);
+}
+function formAcceptsSubmissions(data, originalData) {
+  return (data?.status ?? originalData?.status) === "published";
+}
+function storedSettings(value) {
+  if (typeof value === "string") {
+    try {
+      return documentRedirectSettings(JSON.parse(value));
+    } catch {
+      return null;
+    }
+  }
+  return documentRedirectSettings(value);
+}
+function storedRedirectReference(originalData, patterns) {
+  const picked = storedSettings(originalData?.settings);
+  if (!picked) return null;
+  const collections = Object.keys(patterns);
+  const reference = parseRedirectReference(
+    picked.settings[picked.field],
+    collections
+  );
+  if (!reference) return null;
+  return {
+    reference,
+    field: picked.field,
+    configured: collections.includes(reference.collection)
+  };
+}
+function normalizeStoredReference(settings, field, reference) {
+  const stored = settings[field];
+  if (typeof stored === "string") {
+    if (stored !== reference.id) settings[field] = reference.id;
+    return;
+  }
+  if (typeof stored !== "object" || stored === null || Array.isArray(stored)) {
+    return;
+  }
+  const record = stored;
+  if (record.relationTo !== reference.collection) {
+    settings[field] = { ...record, relationTo: reference.collection };
+  }
+}
+function namedRedirectReference(data, operation, patterns) {
+  const picked = pageRedirectSettings(data, operation);
+  if (!picked) return null;
+  const { settings, field } = picked;
+  const collections = Object.keys(patterns);
+  const reference = parseRedirectReference(settings[field], collections);
+  if (reference) normalizeStoredReference(settings, field, reference);
+  return {
+    settings,
+    field,
+    reference,
+    configured: reference !== null && collections.includes(reference.collection)
+  };
+}
+function wouldStrandVisitors(data, originalData, target, targetCollectionIsLocalized) {
+  return formAcceptsSubmissions(data, originalData) && documentReachability(target, targetCollectionIsLocalized) === "unreachable";
+}
+function publishesForm(data, originalData) {
+  if (data?.status !== "published") return false;
+  return originalData?.status !== "published";
+}
+function sameTarget(named, stored) {
+  if (!named.reference || !stored) return false;
+  return stored.field === named.field && stored.reference.collection === named.reference.collection && stored.reference.id === named.reference.id;
+}
+function judgeNamedReference(named, stored) {
+  if (sameTarget(named, stored) && named.reference) {
+    return {
+      reference: named.reference,
+      field: named.field,
+      chosen: false,
+      configured: named.configured
+    };
+  }
+  if (!named.reference || !named.configured) {
+    throw redirectRefusal(
+      "Choose a page to redirect to, or pick a different confirmation.",
+      named.field
+    );
+  }
+  return {
+    reference: named.reference,
+    field: named.field,
+    chosen: true,
+    configured: true
+  };
+}
+function redirectReferenceForWrite(context, patterns) {
+  const stored = storedRedirectReference(
+    context.originalData,
+    patterns
+  );
+  const named = namedRedirectReference(
+    context.data,
+    context.operation,
+    patterns
+  );
+  if (named) return judgeNamedReference(named, stored);
+  const data = context.data;
+  if (data?.settings !== void 0) return null;
+  return stored ? { ...stored, chosen: false } : null;
+}
+function assertPatternBuildsUrl(patterns, reference, field, target) {
+  let url2;
+  try {
+    url2 = applyRedirectPattern(patterns[reference.collection], target);
+  } catch {
+    return;
+  }
+  if (url2) return;
+  throw redirectRefusal(
+    `No URL could be built for that page from the pattern configured for "${reference.collection}". Choose another page, or ask a developer to check that collection's redirect pattern.`,
+    field
+  );
+}
+async function assertRedirectTargetUsable(context, patterns, localization) {
+  const write = redirectReferenceForWrite(context, patterns);
+  if (!write) return;
+  const { reference, field, chosen, configured } = write;
+  if (!configured) {
+    if (publishesForm(
+      context.data,
+      context.originalData
+    )) {
+      throw redirectRefusal(
+        `This form redirects to "${reference.collection}", which is no longer configured as a redirect target, so it has nowhere to send anyone. Choose another page, or pick a different confirmation.`,
+        field
+      );
+    }
+    return;
+  }
+  const nextly = context.req?.nextly;
+  if (!nextly) return;
+  if (context.executor) return;
+  const found = await readRedirectTarget(nextly, reference);
+  if (found.status === "unreadable") return;
+  if (found.status === "missing") {
+    if (!chosen && !publishesForm(
+      context.data,
+      context.originalData
+    )) {
+      return;
+    }
+    throw redirectRefusal(
+      `That page no longer exists in "${reference.collection}". Pick another.`,
+      field
+    );
+  }
+  const judged = chosen || publishesForm(
+    context.data,
+    context.originalData
+  );
+  if (judged && wouldStrandVisitors(
+    context.data,
+    context.originalData,
+    found.document,
+    localization[reference.collection]
+  )) {
+    throw redirectRefusal(
+      `That page is not published yet, and this form is. A visitor sent there would reach a "page not found". Publish the page, or save this form as a draft until you do.`,
+      field
+    );
+  }
+  if (chosen)
+    assertPatternBuildsUrl(patterns, reference, field, found.document);
+}
+async function readRedirectTarget(nextly, reference) {
+  try {
+    const row = await nextly.findByID({
+      collection: reference.collection,
+      id: reference.id
+    });
+    return row ? { status: "ok", document: row } : { status: "missing" };
+  } catch (error) {
+    return isMissingTarget(error) ? { status: "missing" } : { status: "unreadable" };
+  }
+}
+function isMissingTarget(error) {
+  return typeof error === "object" && error !== null && error.code === "NOT_FOUND";
+}
+function stampFirstPublish(context) {
+  const data = context.data;
+  if (!data) return;
+  const stored = context.originalData;
+  delete data.wentLiveAt;
+  if (recordedStamp(stored) !== void 0) return;
+  if (data.status === "published" || stored?.status === "published") {
+    data.wentLiveAt = /* @__PURE__ */ new Date();
+  }
+}
+function recordedStamp(stored) {
+  const value = stored?.wentLiveAt;
+  return value === null || value === "" ? void 0 : value;
+}
+function redirectRefusal(message, field) {
+  return NextlyError.validation({
+    errors: [{ path: `settings.${field}`, code: "REQUIRED", message }]
+  });
+}
 function formsCollection(pluginConfig) {
   const {
     slug,
     labels,
     fields: additionalFields,
     access: accessOverrides,
+    hooks: hookOverrides,
+    admin: adminOverrides,
     ...overrides
   } = pluginConfig.formOverrides;
+  const redirectCollections = Object.keys(pluginConfig.redirectRelationships);
   const settingsFields = [
     text({
       name: "submitButtonText",
@@ -35,7 +338,7 @@ function formsCollection(pluginConfig) {
       options: [
         { label: "Show Message", value: "message" },
         { label: "Redirect to URL", value: "redirect" },
-        ...pluginConfig.redirectRelationships.length > 0 ? [{ label: "Redirect to Page", value: "relationship" }] : []
+        ...redirectCollections.length > 0 ? [{ label: "Redirect to Page", value: "relationship" }] : []
       ],
       admin: {
         description: "What happens after a successful form submission"
@@ -65,12 +368,12 @@ function formsCollection(pluginConfig) {
       }
     })
   ];
-  if (pluginConfig.redirectRelationships.length > 0) {
+  if (redirectCollections.length > 0) {
     settingsFields.push(
       relationship({
         name: "redirectPage",
         label: "Redirect Page",
-        relationTo: pluginConfig.redirectRelationships,
+        relationTo: redirectCollections,
         admin: {
           description: "Select a page to redirect to after submission",
           condition: {
@@ -90,12 +393,18 @@ function formsCollection(pluginConfig) {
         description: "Allow the same user/IP to submit this form multiple times"
       }
     }),
+    checkbox({
+      name: "honeypotEnabled",
+      label: "Honeypot",
+      admin: {
+        description: "Per-form honeypot override; unset inherits the plugin default"
+      }
+    }),
     checkbox({
       name: "captchaEnabled",
       label: "Enable reCAPTCHA",
-      defaultValue: false,
       admin: {
-        description: "Protect this form with Google reCAPTCHA v3"
+        description: "Per-form reCAPTCHA override; unset inherits the plugin default"
       }
     }),
     text({
@@ -163,10 +472,10 @@ function formsCollection(pluginConfig) {
     // ============================================================
     json({
       name: "notifications",
-      label: "Email Integrations",
+      label: "Notifications",
       defaultValue: [],
       admin: {
-        description: "Email notification integrations. Managed by the Form Builder UI."
+        description: "Email notification rules. Managed by the Form Builder UI."
       }
     }),
     // ============================================================
@@ -186,6 +495,19 @@ function formsCollection(pluginConfig) {
         description: "Only published forms can receive submissions. Closed forms display a message instead."
       }
     }),
+    // NOT `firstPublishedAt`, which is the obvious name and the one to reach
+    // for next. The framework owns that name on collections it manages the
+    // publish lifecycle for, and a write naming it from a plugin collection is
+    // stripped on the way to the insert — silently, leaving the column null and
+    // every closed form reading as one that was never public.
+    date({
+      name: "wentLiveAt",
+      label: "First Published",
+      admin: {
+        readOnly: true,
+        description: "When this form first went live. Written once and never changed."
+      }
+    }),
     textarea({
       name: "closedMessage",
       label: "Closed Form Message",
@@ -227,50 +549,75 @@ function formsCollection(pluginConfig) {
           }
         }
       },
-      ...overrides.admin
+      ...adminOverrides
     },
     // Access control with sensible defaults
-    access: {
-      // Anyone can read forms (needed for frontend rendering)
-      read: accessOverrides?.read ?? true,
-      // Only authenticated users can create/update forms
-      create: accessOverrides?.create ?? (({ user }) => !!user),
-      update: accessOverrides?.update ?? (({ user }) => !!user),
-      // Only admins can delete forms (falls back to DB permissions)
-      delete: accessOverrides?.delete ?? (({ roles }) => roles.includes("admin") || roles.includes("super-admin"))
-    },
-    hooks: {
-      // Auto-generate slug from name if not provided
-      beforeValidate: [
-        (context) => {
-          const { data, operation } = context;
-          if (operation === "create" && data && !data.slug && data.name) {
-            data.slug = String(data.name).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-          }
-          if (data && (data.fields === void 0 || Array.isArray(data.fields) && data.fields.length === 0)) {
-            throw new Error("Form must have at least one field.");
+    // `read: true` — a form is public because a site renders it. The rest are
+    // the shared defaults.
+    access: accessWithDefaults(accessOverrides, { read: true }),
+    hooks: withHostHooks(
+      {
+        // Auto-generate slug from name if not provided
+        beforeValidate: [
+          (context) => {
+            const { data, operation } = context;
+            if (operation === "create" && data && !data.slug && data.name) {
+              data.slug = String(data.name).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+            }
+            const setsFields = operation === "create" || data?.fields !== void 0;
+            if (data && setsFields && (data.fields === void 0 || Array.isArray(data.fields) && data.fields.length === 0)) {
+              throw NextlyError.validation({
+                errors: [
+                  {
+                    path: "fields",
+                    code: "REQUIRED",
+                    message: "Form must have at least one field."
+                  }
+                ]
+              });
+            }
+            namedRedirectReference(
+              data,
+              operation,
+              pluginConfig.redirectRelationships
+            );
+            return data;
           }
-          return data;
-        }
-      ],
-      // Add virtual submission count field
-      afterRead: [
-        (context) => {
-          const { data } = context;
-          if (data) {
-            data.submissionCount = 0;
+        ]
+      },
+      hookOverrides,
+      {
+        // The last COLLECTION-level phase, after every host handler in it. A
+        // host `beforeValidate` may rewrite the payload once the earlier call
+        // has passed, so the check has to run again here.
+        //
+        // It is not the last mutating point in the write, and saying so would
+        // be false: `collection-mutation-service` runs FIELD-level
+        // `beforeChange` hooks after this one, and a host may contribute a
+        // field through `formOverrides.fields`. Nothing collection-level can
+        // sit after that — the next steps are hashing and the insert. What
+        // bounds the consequence is the submit path, which resolves an
+        // unusable target to NO redirect and logs it, never to a wrong one.
+        beforeChange: [
+          async (context) => {
+            await assertRedirectTargetUsable(
+              context,
+              pluginConfig.redirectRelationships,
+              pluginConfig.redirectTargetLocalization
+            );
+            stampFirstPublish(context);
+            return context.data;
           }
-          return data;
-        }
-      ]
-    },
+        ]
+      }
+    ),
     // Spread any additional overrides (excluding already used properties)
     ...overrides
   };
 }
 
 // src/collections/submissions.ts
-import { text as text2, textarea as textarea2, select as select2, json as json2, date, relationship as relationship2 } from "nextly";
+import { text as text2, textarea as textarea2, select as select2, json as json2, date as date2, relationship as relationship2 } from "nextly";
 function submissionsCollection(pluginConfig) {
   const {
     slug,
@@ -317,12 +664,23 @@ function submissionsCollection(pluginConfig) {
       options: [
         { label: "New", value: "new" },
         { label: "Read", value: "read" },
-        { label: "Archived", value: "archived" }
+        { label: "Archived", value: "archived" },
+        // Spam is stored and flagged, never silently dropped: a false
+        // positive stays reviewable and recoverable ("Not spam" = back to new).
+        { label: "Spam", value: "spam" }
       ],
       admin: {
         description: "Track whether this submission has been reviewed"
       }
     }),
+    text2({
+      name: "spamReason",
+      label: "Spam Reason",
+      admin: {
+        readOnly: true,
+        description: "Which spam check flagged this submission (empty for clean submissions)"
+      }
+    }),
     // ============================================================
     // Internal Notes
     // ============================================================
@@ -352,7 +710,7 @@ function submissionsCollection(pluginConfig) {
         description: "Browser/device information of the submitter"
       }
     }),
-    date({
+    date2({
       name: "submittedAt",
       label: "Submitted At",
       required: true,
@@ -360,6 +718,24 @@ function submissionsCollection(pluginConfig) {
         readOnly: true,
         description: "When the form was submitted"
       }
+    }),
+    // Honesty stamps for admin edits of submitted data: a corrected
+    // submission must never be indistinguishable from what the visitor sent.
+    date2({
+      name: "editedAt",
+      label: "Edited At",
+      admin: {
+        readOnly: true,
+        description: "When an admin last edited the submitted data"
+      }
+    }),
+    text2({
+      name: "editedBy",
+      label: "Edited By",
+      admin: {
+        readOnly: true,
+        description: "ID of the admin who last edited the submitted data"
+      }
     })
   ];
   let finalFields;
@@ -375,33 +751,47 @@ function submissionsCollection(pluginConfig) {
     labels,
     fields: finalFields,
     timestamps: true,
+    // Submissions carry visitor-entered answers plus ipAddress/userAgent, so the
+    // default `entry.*` events stay suppressed — otherwise every submission would
+    // be delivered to any endpoint subscribed to `entry.created` or `*`. Instead
+    // emit a curated `form.submission.created` carrying ONLY safe metadata (which
+    // form, when, and the status) — never the answers, IP, or user agent.
+    webhooks: {
+      record: false,
+      emit: {
+        event: "form.submission.created",
+        fields: ["form", "submittedAt", "status"]
+      }
+    },
     admin: {
       isPlugin: true,
       group: "Forms",
       order: 51,
       useAsTitle: "id",
       description: "View and manage form submissions",
-      // Custom components for submissions list
+      // Submissions are created by visitors submitting forms — a hand-typed
+      // "New Submission" would be fiction, so the admin never offers one.
+      disableCreate: true,
       components: {
-        // Filter dropdown to filter submissions by form
-        BeforeListTable: "@nextlyhq/plugin-form-builder/admin#SubmissionsFilter"
+        // The full submissions experience (per-form columns, status tabs,
+        // drawer detail, export) replaces the generic list.
+        views: {
+          List: {
+            Component: "@nextlyhq/plugin-form-builder/admin#SubmissionsView"
+          }
+        }
       },
       ...overrides.admin
     },
     // Access control with sensible defaults
     // Public can create (submit forms), but only authenticated users can read/update/delete
-    access: {
-      // Anyone can submit forms (public access)
-      create: accessOverrides?.create ?? true,
-      // Only authenticated users can view submissions
-      read: accessOverrides?.read ?? (({ user }) => !!user),
-      // Only authenticated users can update submissions (e.g., change status, add notes)
-      update: accessOverrides?.update ?? (({ user }) => !!user),
-      // Only admins can delete submissions (falls back to DB permissions)
-      delete: accessOverrides?.delete ?? (({ roles }) => roles.includes("admin") || roles.includes("super-admin"))
-    },
+    // `create: true` — a visitor submits without an account. Reading, updating
+    // and deleting are the shared defaults.
+    access: accessWithDefaults(accessOverrides, { create: true }),
     hooks: {
-      // Auto-set submittedAt timestamp on creation
+      // Auto-set submittedAt timestamp on creation. (The edit stamp for
+      // updates is registered in plugin.ts init — direct registry hooks are
+      // the path that runs for every API surface.)
       beforeValidate: [
         (context) => {
           const { data, operation } = context;
@@ -423,10 +813,24 @@ function submissionsCollection(pluginConfig) {
   };
 }
 
+// src/document-shapes.ts
+function asSubmissionDocument(row) {
+  return row;
+}
+function asSubmissionDocuments(rows) {
+  return rows;
+}
+function asFormDocument(row) {
+  return row;
+}
+
 // src/plugin.ts
+var { version: PLUGIN_VERSION } = createRequire(import.meta.url)(
+  "../package.json"
+);
 function resolveConfig(options) {
-  const formOverrides = options.formOverrides || options.collections?.forms || {};
-  const submissionOverrides = options.formSubmissionOverrides || options.collections?.submissions || {};
+  const formOverrides = options.formOverrides || {};
+  const submissionOverrides = options.formSubmissionOverrides || {};
   return {
     formOverrides: {
       ...formOverrides,
@@ -459,7 +863,13 @@ function resolveConfig(options) {
       time: options.fields?.time ?? true,
       hidden: options.fields?.hidden ?? true
     },
-    redirectRelationships: options.redirectRelationships || [],
+    redirectRelationships: normalizeRedirectRelationships(
+      options.redirectRelationships
+    ),
+    // Filled at `init` from each collection's own metadata. Empty until then,
+    // and a slug that stays absent reads as unknown rather than as not
+    // localized — see `ResolvedFormBuilderConfig`.
+    redirectTargetLocalization: {},
     beforeEmail: options.beforeEmail,
     notifications: {
       defaultFrom: options.notifications?.defaultFrom,
@@ -495,41 +905,236 @@ function formBuilder(options = {}) {
   const resolvedConfig = resolveConfig(options);
   const formsCol = formsCollection(resolvedConfig);
   const submissionsCol = submissionsCollection(resolvedConfig);
-  const plugin = {
+  const plugin = definePlugin({
     name: "@nextlyhq/plugin-form-builder",
-    version: "0.0.8",
-    collections: [formsCol, submissionsCol],
+    version: PLUGIN_VERSION,
+    nextly: ">=0.0.2-alpha.21",
+    // Identity metadata for the admin plugins page, mirroring package.json.
+    author: "Nextly",
+    homepage: "https://nextlyhq.com",
+    repository: "https://github.com/nextlyhq/nextly",
+    license: "MIT",
+    category: "forms",
+    tags: ["forms", "submissions", "email-notifications"],
+    // Declarative schema: the merged pipeline folds these into the
+    // app schema — no manual `setup()` append needed. Just register the plugin.
+    contributes: {
+      collections: [formsCol, submissionsCol],
+      // Custom permission — gates submission export beyond CRUD. The
+      // canonical example third-party plugin authors copy.
+      permissions: [
+        {
+          action: "export",
+          resource: "submissions",
+          label: "Export Submissions",
+          description: "Export form submissions as CSV/JSON",
+          // No `group`: the admin already files this under the plugin that
+          // declared it, so naming the plugin again would nest it inside
+          // itself. `group` is for a plugin with enough permissions to sort
+          // its own into headings, which one is not.
+          //
+          // `danger` because the point of the permission is to take
+          // submissions — names, emails, whatever a form asked for — out of
+          // the site in a file.
+          danger: true
+        }
+      ],
+      // HTTP route — exported at
+      // /api/plugins/@nextlyhq/plugin-form-builder/submissions/export. Secure by
+      // default: gated by the custom `export-submissions` permission. Reads
+      // via the secure-by-default service path as the authed user and
+      // resolves its OWN slug through `ctx.self`. The canonical
+      // contributes.routes example for third-party authors.
+      routes: [
+        {
+          method: "GET",
+          path: "/submissions/export",
+          requiredPermission: "export-submissions",
+          handler: async (req, ctx) => {
+            const declaredSlug = resolvedConfig.formSubmissionOverrides.slug;
+            const slug = ctx.self.collections[declaredSlug] ?? declaredSlug;
+            const url2 = new URL(req.url);
+            const format = url2.searchParams.get("format") ?? "json";
+            const formId = url2.searchParams.get("form");
+            const status = url2.searchParams.get("status");
+            const where = {};
+            if (formId) where.form = { equals: formId };
+            if (status) where.status = { equals: status };
+            else where.status = { not_equals: "spam" };
+            const opts = { as: "user", user: ctx.user ?? void 0 };
+            let form;
+            if (format === "csv") {
+              if (!formId) {
+                return Response.json(
+                  {
+                    error: {
+                      code: "VALIDATION_ERROR",
+                      message: "CSV export requires a form parameter."
+                    }
+                  },
+                  { status: 400 }
+                );
+              }
+              const formsSlugDeclared = resolvedConfig.formOverrides.slug;
+              const formsSlug = ctx.self.collections[formsSlugDeclared] ?? formsSlugDeclared;
+              const formResult = await ctx.services.collections.listEntries(
+                formsSlug,
+                { where: { id: { equals: formId } } },
+                opts
+              );
+              form = formResult.data[0];
+              if (!form) {
+                return Response.json(
+                  { error: { code: "NOT_FOUND", message: "Form not found." } },
+                  { status: 404 }
+                );
+              }
+            }
+            const MAX_EXPORT_ROWS = 5e4;
+            const items = [];
+            const pageSize = 200;
+            let truncated = false;
+            for (let page = 1; ; page += 1) {
+              const result = await ctx.services.collections.listEntries(
+                slug,
+                { where, pagination: { limit: pageSize, page } },
+                opts
+              );
+              items.push(...result.data);
+              const pageWasFull = result.data.length === pageSize;
+              if (items.length >= MAX_EXPORT_ROWS) {
+                truncated = pageWasFull || items.length > MAX_EXPORT_ROWS;
+                items.length = MAX_EXPORT_ROWS;
+                break;
+              }
+              if (!pageWasFull) break;
+            }
+            const truncationHeaders = truncated ? { "X-Export-Truncated": "true" } : {};
+            if (format !== "csv" || !form) {
+              return Response.json({ items }, { headers: truncationHeaders });
+            }
+            const csv = exportToCSV(
+              asSubmissionDocuments(items),
+              asFormDocument(form)
+            );
+            const filename = generateExportFilename(
+              typeof form.slug === "string" ? form.slug : "form",
+              "csv"
+            );
+            return new Response(csv, {
+              headers: {
+                "Content-Type": "text/csv; charset=utf-8",
+                "Content-Disposition": `attachment; filename="${filename}"`,
+                ...truncationHeaders
+              }
+            });
+          }
+        },
+        {
+          // The builder UI reads the host's resolved field enable/disable map
+          // from here, so the plugin option actually gates the type picker.
+          // Options resolve server-side only; this is the one channel the
+          // admin client has to them.
+          method: "GET",
+          path: "/builder-config",
+          // Derived from the forms slug like the menu entry: with an
+          // overridden slug, users hold read-<slug>, not read-forms.
+          requiredPermission: `read-${resolvedConfig.formOverrides.slug}`,
+          handler: (_req, ctx) => Promise.resolve(
+            Response.json({
+              fields: resolvedConfig.fields,
+              // Notification defaults the builder surfaces: defaultToEmail
+              // seeds a new form's first rule, defaultFrom renders as the
+              // inherited sender placeholder.
+              notifications: {
+                defaultFrom: resolvedConfig.notifications.defaultFrom,
+                defaultToEmail: resolvedConfig.notifications.defaultToEmail
+              },
+              // Spam defaults the Settings tab surfaces, so per-form
+              // override selects can show what "inherit" resolves to.
+              spamProtection: {
+                honeypot: resolvedConfig.spamProtection.honeypot,
+                recaptchaEnabled: resolvedConfig.spamProtection.recaptcha?.enabled ?? false
+              },
+              // Runtime-resolved collection slugs (through ctx.self, so a
+              // framework .rename() is honored too) — admin components
+              // never hardcode "forms"/"form-submissions".
+              // Names only. A pattern may be a function, which does not
+              // survive JSON and which the browser has no use for — the
+              // admin picks a document, the server builds the URL.
+              redirectCollections: Object.keys(
+                resolvedConfig.redirectRelationships
+              ),
+              slugs: {
+                forms: ctx.self.collections[resolvedConfig.formOverrides.slug] ?? resolvedConfig.formOverrides.slug,
+                submissions: ctx.self.collections[resolvedConfig.formSubmissionOverrides.slug] ?? resolvedConfig.formSubmissionOverrides.slug
+              }
+            })
+          )
+        }
+      ]
+    },
+    // Forms is a first-class destination, not a plugin detail: standalone
+    // placement gives it its own main-rail icon after Media, and its
+    // sub-sidebar lists the plugin's collections (Forms, Submissions) —
+    // no separate menu contribution, so "Forms" exists exactly once.
+    // Hosts preferring the Plugins section override placement in config.
+    // (The old admin.settings.component that rendered a second full builder
+    // at /admin/plugins/<slug> is gone; the collection Edit-view override
+    // is the single FormBuilderView mount.)
     admin: {
+      placement: "standalone",
+      after: "media",
       order: 50,
+      appearance: { icon: "FileText", label: "Forms" },
       description: "Create and manage forms with submission tracking"
     },
-    // -- Config transformer --------------------------------------------------
-    // Automatically adds plugin collections so users don't have to spread them.
-    config(config) {
-      const existing = config.collections || [];
-      const formsSlug = resolvedConfig.formOverrides.slug;
-      const submissionsSlug = resolvedConfig.formSubmissionOverrides.slug;
-      const toAdd = [];
-      if (!existing.some((c) => c.slug === formsSlug))
-        toAdd.push(formsCol);
-      if (!existing.some((c) => c.slug === submissionsSlug))
-        toAdd.push(submissionsCol);
-      return { ...config, collections: [...existing, ...toAdd] };
-    },
     // -- Init ----------------------------------------------------------------
     // Registers an afterCreate hook on submissions to send email notifications.
-    init(nextly) {
-      const submissionSlug = resolvedConfig.formSubmissionOverrides.slug;
-      const guardKey = `__formBuilder_afterCreate_${submissionSlug}`;
-      const g = globalThis;
-      if (g[guardKey]) return;
-      g[guardKey] = true;
-      nextly.infra.logger.info("Form Builder plugin initialized", {
+    async init(nextly) {
+      const declaredSubmissionsSlug = resolvedConfig.formSubmissionOverrides.slug;
+      const submissionSlug = nextly.self.collections[declaredSubmissionsSlug] ?? declaredSubmissionsSlug;
+      nextly.logger.info("Form Builder plugin initialized", {
         formsCollection: resolvedConfig.formOverrides.slug,
         submissionsCollection: submissionSlug,
         enabledFields: Object.entries(resolvedConfig.fields).filter(([, on]) => on).map(([name]) => name)
       });
+      for (const slug of Object.keys(
+        resolvedConfig.redirectTargetLocalization
+      )) {
+        delete resolvedConfig.redirectTargetLocalization[slug];
+      }
+      await Promise.all(
+        Object.keys(resolvedConfig.redirectRelationships).map(
+          async (declared) => {
+            const slug = nextly.self.collections[declared] ?? declared;
+            try {
+              const collection = await nextly.services.collections.getCollection(slug, {});
+              const localized = collection?.localized;
+              if (typeof localized === "boolean") {
+                resolvedConfig.redirectTargetLocalization[declared] = localized;
+              }
+            } catch {
+              nextly.logger.debug?.(
+                "Redirect target localization could not be read",
+                { collection: slug }
+              );
+            }
+          }
+        )
+      );
       nextly.__formBuilderConfig = resolvedConfig;
+      if (resolvedConfig.beforeEmail) {
+        nextly.filters.add(
+          "form-builder.beforeEmail",
+          (emails, ctx) => resolvedConfig.beforeEmail({
+            emails,
+            // Boundary: loose runtime documents → the user's typed contract.
+            form: asFormDocument(ctx.form),
+            submission: asSubmissionDocument(ctx.submission)
+          })
+        );
+      }
       nextly.hooks.on(
         "afterCreate",
         submissionSlug,
@@ -537,8 +1142,42 @@ function formBuilder(options = {}) {
           await handleSubmissionCreated(context, resolvedConfig, nextly);
         }
       );
+      nextly.hooks.on("beforeUpdate", submissionSlug, (context) => {
+        const ctx = context;
+        if (ctx.data && ctx.data.data !== void 0) {
+          ctx.data.editedAt = /* @__PURE__ */ new Date();
+          ctx.data.editedBy = ctx.user?.id ?? null;
+        }
+        return ctx.data;
+      });
+      const declaredFormsSlug = resolvedConfig.formOverrides.slug;
+      const formsSlug = nextly.self.collections[declaredFormsSlug] ?? declaredFormsSlug;
+      nextly.hooks.on("afterRead", formsSlug, async (context) => {
+        const data = context.data;
+        const records = Array.isArray(data) ? data : data ? [data] : [];
+        await Promise.all(
+          records.map(async (record) => {
+            const form = record;
+            if (typeof form.id !== "string") return;
+            try {
+              form.submissionCount = await nextly.services.collections.count(
+                submissionSlug,
+                {
+                  where: {
+                    form: { equals: form.id },
+                    status: { not_equals: "spam" }
+                  }
+                },
+                { as: "system" }
+              );
+            } catch {
+              form.submissionCount = 0;
+            }
+          })
+        );
+      });
     }
-  };
+  });
   return {
     plugin,
     collections: [formsCol, submissionsCol],
@@ -550,9 +1189,9 @@ function getFormBuilderConfig(nextly) {
   return nextly.__formBuilderConfig;
 }
 function resolveFieldRef(ref, data) {
-  const match = ref.match(/^\{\{(\w+)\}\}$/);
-  if (!match) return ref;
-  const value = data[match[1]];
+  const name = parseFieldRef(ref);
+  if (name === null) return ref;
+  const value = data[name];
   return typeof value === "string" ? value : "";
 }
 function collectAttachmentInputs(fields, submittedData) {
@@ -574,9 +1213,78 @@ function collectAttachmentInputs(fields, submittedData) {
   }
   return attachments;
 }
+function parseJsonColumn(value) {
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function normalizeAddressList(addresses) {
+  if (!Array.isArray(addresses)) return void 0;
+  const cleaned = addresses.map((address) => typeof address === "string" ? address.trim() : "").filter(Boolean);
+  return cleaned.length > 0 ? cleaned : void 0;
+}
+function buildNotificationEmails(input) {
+  const { notifications, submittedData, formName, submissionId, defaultFrom } = input;
+  const seen = /* @__PURE__ */ new Set();
+  const emails = [];
+  const skipped = [];
+  for (const notification of notifications) {
+    if (!notification.enabled) continue;
+    if (!notification.templateSlug) {
+      skipped.push({ notificationId: notification.id, reason: "no-template" });
+      continue;
+    }
+    const key = notification.id || JSON.stringify(notification);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    if (notification.condition && !evaluateSingleCondition(notification.condition, submittedData)) {
+      skipped.push({
+        notificationId: notification.id,
+        reason: "condition-unmet"
+      });
+      continue;
+    }
+    const to = (notification.recipientType === "field" ? resolveFieldRef(notification.to, submittedData) : notification.to).trim();
+    if (!to) {
+      skipped.push({
+        notificationId: notification.id,
+        reason: "empty-recipient"
+      });
+      continue;
+    }
+    const cc = normalizeAddressList(notification.cc);
+    const bcc = normalizeAddressList(notification.bcc);
+    const from = notification.senderEmail?.trim() || defaultFrom?.trim() || void 0;
+    const replyTo = notification.replyTo ? resolveFieldRef(notification.replyTo, submittedData).trim() || void 0 : void 0;
+    emails.push({
+      to,
+      templateSlug: notification.templateSlug,
+      variables: {
+        ...submittedData,
+        formName,
+        submissionId
+      },
+      providerId: notification.providerId,
+      from,
+      replyTo,
+      cc,
+      bcc,
+      notificationId: notification.id
+    });
+  }
+  return { emails, skipped };
+}
 async function handleSubmissionCreated(context, config, nextly) {
+  if (!config.notifications.enabled) return;
   const submission = context.data;
   if (!submission) return;
+  if (submission.status === "spam") return;
   const rawFormId = submission.form;
   let formId = null;
   if (typeof rawFormId === "string") {
@@ -592,46 +1300,59 @@ async function handleSubmissionCreated(context, config, nextly) {
   if (notifications.length === 0) return;
   const emailService = nextly.services.email;
   if (!emailService) return;
-  const submittedData = submission.data ?? {};
+  const submittedData = parseJsonColumn(submission.data);
   const formFields = Array.isArray(form.fields) ? form.fields : [];
   const fileAttachments = collectAttachmentInputs(formFields, submittedData);
-  const seen = /* @__PURE__ */ new Set();
-  for (const notification of notifications) {
-    if (!notification.enabled || !notification.templateSlug) continue;
-    const key = notification.id || `${notification.to}::${notification.templateSlug}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
+  const { emails, skipped } = buildNotificationEmails({
+    notifications,
+    submittedData,
+    formName: form.name,
+    submissionId: submission.id,
+    defaultFrom: config.notifications.defaultFrom
+  });
+  for (const skip of skipped) {
+    if (skip.reason === "empty-recipient") {
+      nextly.logger.warn?.(
+        "Form Builder: empty recipient, skipping notification",
+        { notificationId: skip.notificationId, formSlug: form.slug }
+      );
+    } else {
+      nextly.logger.debug?.("Form Builder: notification skipped", {
+        notificationId: skip.notificationId,
+        formSlug: form.slug,
+        reason: skip.reason
+      });
+    }
+  }
+  if (emails.length === 0) return;
+  const finalEmails = await nextly.filters.apply("form-builder.beforeEmail", emails, { form, submission });
+  for (const email2 of finalEmails) {
     try {
-      const to = notification.recipientType === "field" ? resolveFieldRef(notification.to, submittedData) : notification.to;
-      if (!to) {
-        nextly.infra.logger.warn?.(
-          "Form Builder: empty recipient, skipping notification",
-          { notificationId: notification.id, formSlug: form.slug }
-        );
-        continue;
-      }
-      const cc = Array.isArray(notification.cc) && notification.cc.length ? notification.cc : void 0;
-      const bcc = Array.isArray(notification.bcc) && notification.bcc.length ? notification.bcc : void 0;
       await emailService.sendWithTemplate(
-        notification.templateSlug,
-        to,
-        { ...submittedData, formName: form.name, submissionId: submission.id },
+        email2.templateSlug,
+        email2.to,
+        email2.variables,
         {
-          providerId: notification.providerId,
-          cc,
-          bcc,
+          providerId: email2.providerId,
+          from: email2.from,
+          replyTo: email2.replyTo,
+          cc: email2.cc,
+          bcc: email2.bcc,
           attachments: fileAttachments.length > 0 ? fileAttachments : void 0
         }
       );
-      nextly.infra.logger.info?.("Form Builder: notification sent", {
+      nextly.logger.info?.("Form Builder: notification sent", {
         formSlug: form.slug,
-        to,
-        templateSlug: notification.templateSlug,
+        to: email2.to,
+        templateSlug: email2.templateSlug,
+        notificationId: email2.notificationId,
         attachmentCount: fileAttachments.length
       });
     } catch (err) {
-      nextly.infra.logger.error?.("Form Builder: notification failed", {
-        notificationId: notification.id,
+      nextly.logger.error?.("Form Builder: notification failed", {
+        to: email2.to,
+        templateSlug: email2.templateSlug,
+        notificationId: email2.notificationId,
         error: err instanceof Error ? err.message : String(err)
       });
     }
@@ -639,27 +1360,14 @@ async function handleSubmissionCreated(context, config, nextly) {
 }
 async function fetchParentForm(config, formId, nextly) {
   try {
-    const handler = getCollectionsHandler();
-    if (!handler) {
-      nextly.infra.logger.warn?.(
-        "Form Builder: CollectionsHandler unavailable, skipping notifications"
-      );
-      return null;
-    }
-    const result = await handler.getEntry({
-      collectionName: config.formOverrides.slug,
-      entryId: formId,
-      overrideAccess: true
-    });
-    const fromData = result?.data;
-    if (fromData) return fromData;
-    const fromDoc = result?.doc;
-    if (fromDoc && typeof fromDoc === "object") {
-      return fromDoc;
-    }
-    return null;
+    const form = await nextly.services.collections.findEntryById(
+      config.formOverrides.slug,
+      formId,
+      { as: "system" }
+    );
+    return form;
   } catch (err) {
-    nextly.infra.logger.error?.("Form Builder: failed to fetch form", {
+    nextly.logger.error?.("Form Builder: failed to fetch form", {
       formId,
       error: err instanceof Error ? err.message : String(err)
     });
@@ -667,30 +1375,8 @@ async function fetchParentForm(config, formId, nextly) {
   }
 }
 
-// src/types.ts
-function isFormField(value) {
-  return typeof value === "object" && value !== null && "type" in value && "name" in value && "label" in value;
-}
-function isFormFieldType(field, type) {
-  return field.type === type;
-}
-function isTextFormField(field) {
-  return field.type === "text";
-}
-function isEmailFormField(field) {
-  return field.type === "email";
-}
-function isSelectFormField(field) {
-  return field.type === "select";
-}
-function isCheckboxFormField(field) {
-  return field.type === "checkbox";
-}
-function isFileFormField(field) {
-  return field.type === "file";
-}
-
 // src/config/validate-form.ts
+import { isPluginFieldTypeOnSurface } from "nextly";
 var RESERVED_FORM_SLUGS = [
   // API routes
   "api",
@@ -707,21 +1393,7 @@ var RESERVED_FORM_SLUGS = [
 var RESERVED_SLUGS_SET = new Set(RESERVED_FORM_SLUGS);
 var SLUG_PATTERN = /^[a-z][a-z0-9_-]*$/;
 var FIELD_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_]*$/;
-var VALID_FIELD_TYPES = [
-  "text",
-  "email",
-  "number",
-  "phone",
-  "url",
-  "textarea",
-  "select",
-  "checkbox",
-  "radio",
-  "file",
-  "date",
-  "time",
-  "hidden"
-];
+var VALID_FIELD_TYPES = BUILT_IN_FORM_FIELD_TYPES;
 var VALID_FIELD_TYPES_SET = new Set(VALID_FIELD_TYPES);
 function isReservedSlug(slug) {
   return RESERVED_SLUGS_SET.has(slug.toLowerCase());
@@ -937,7 +1609,8 @@ function validateField(field, path, errors, seenNames) {
     });
     return;
   }
-  if (typeof fieldType !== "string" || !VALID_FIELD_TYPES_SET.has(fieldType)) {
+  const isValidType = typeof fieldType === "string" && (VALID_FIELD_TYPES_SET.has(fieldType) || isPluginFieldTypeOnSurface(fieldType, "forms"));
+  if (!isValidType) {
     let fieldTypeRepr;
     if (typeof fieldType === "object" && fieldType !== null) {
       fieldTypeRepr = JSON.stringify(fieldType);
@@ -1017,6 +1690,17 @@ function validateSettings(settings, errors) {
       });
     }
   }
+  if (s.confirmationType === "relationship" && !namesADocument(s.redirectPage)) {
+    errors.push({
+      path: "settings.redirectPage",
+      message: "A page is required when confirmation type is 'relationship'",
+      code: "REDIRECT_PAGE_REQUIRED"
+    });
+  }
+}
+function namesADocument(value) {
+  if (typeof value === "string") return value.length > 0;
+  return parseRedirectReference(value, []) !== null;
 }
 function validateAccess(access, errors) {
   if (!access) {
@@ -1065,82 +1749,6 @@ ${errorMessages}`
   }
 }
 
-// src/config/defaults.ts
-var DEFAULT_FORM_SETTINGS = {
-  submitButtonText: "Submit",
-  confirmationType: "message",
-  successMessage: "Thank you for your submission!",
-  allowMultipleSubmissions: true
-};
-var DEFAULT_NOTIFICATION_SETTINGS = {
-  enabled: true,
-  replyTo: true
-};
-function toTitleCase(str) {
-  return str.replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
-}
-function pluralize(singular) {
-  if (singular.endsWith("y") && !/[aeiou]y$/i.test(singular)) {
-    return singular.slice(0, -1) + "ies";
-  }
-  if (singular.endsWith("s") || singular.endsWith("x") || singular.endsWith("z") || singular.endsWith("ch") || singular.endsWith("sh")) {
-    return singular + "es";
-  }
-  return singular + "s";
-}
-function applyFormDefaults(config) {
-  const singularLabel = config.labels?.singular || toTitleCase(config.slug);
-  return {
-    ...config,
-    // Generate labels from slug if not provided
-    labels: {
-      singular: singularLabel,
-      plural: config.labels?.plural || pluralize(singularLabel)
-    },
-    // Apply settings defaults
-    settings: {
-      submitButtonText: config.settings?.submitButtonText || DEFAULT_FORM_SETTINGS.submitButtonText,
-      confirmationType: config.settings?.confirmationType || DEFAULT_FORM_SETTINGS.confirmationType,
-      successMessage: config.settings?.successMessage || DEFAULT_FORM_SETTINGS.successMessage,
-      allowMultipleSubmissions: config.settings?.allowMultipleSubmissions ?? DEFAULT_FORM_SETTINGS.allowMultipleSubmissions,
-      // Preserve other settings that don't have defaults
-      redirectUrl: config.settings?.redirectUrl,
-      redirectRelation: config.settings?.redirectRelation,
-      captcha: config.settings?.captcha
-    },
-    // Apply notification defaults if notifications are configured
-    notifications: config.notifications ? {
-      enabled: config.notifications.enabled ?? DEFAULT_NOTIFICATION_SETTINGS.enabled,
-      recipients: config.notifications.recipients || [],
-      subject: config.notifications.subject || `New submission for ${singularLabel}`,
-      replyTo: config.notifications.replyTo ?? DEFAULT_NOTIFICATION_SETTINGS.replyTo,
-      template: config.notifications.template
-    } : void 0,
-    // Apply access defaults
-    access: {
-      // Default: anyone can submit the form
-      submit: config.access?.submit || (() => true),
-      // Default: only authenticated users can view submissions
-      read: config.access?.read || (({ req }) => !!req.user)
-    }
-  };
-}
-function applyFieldDefaults(field) {
-  const label = field.label || (field.name ? toTitleCase(field.name.replace(/([A-Z])/g, " $1").trim()) : "");
-  return {
-    ...field,
-    label,
-    required: field.required ?? false
-  };
-}
-function createFormConfig(slug, fields, options) {
-  return applyFormDefaults({
-    slug,
-    fields,
-    ...options
-  });
-}
-
 // src/config/field-helpers.ts
 var option = (label, value) => ({
   label,
@@ -1186,7 +1794,7 @@ var file = (config) => ({
   ...config,
   type: "file"
 });
-var date2 = (config) => ({
+var date3 = (config) => ({
   ...config,
   type: "date"
 });
@@ -1199,189 +1807,18 @@ var hidden = (config) => ({
   type: "hidden"
 });
 
-// src/utils/evaluate-conditions.ts
-function isEmptyValue(value) {
-  if (value === void 0 || value === null) {
-    return true;
-  }
-  if (typeof value === "string" && value.trim() === "") {
-    return true;
-  }
-  if (Array.isArray(value) && value.length === 0) {
-    return true;
-  }
-  return false;
-}
-function toNumber(value) {
-  if (typeof value === "number") {
-    return value;
-  }
-  if (typeof value === "string") {
-    const trimmed = value.trim();
-    if (trimmed === "") {
-      return NaN;
-    }
-    return Number(trimmed);
-  }
-  return NaN;
-}
-function toString(value) {
-  if (value === void 0 || value === null) {
-    return "";
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.join(", ");
-  }
-  if (typeof value === "object") {
-    return JSON.stringify(value);
-  }
-  return String(value);
-}
-function compareValues(operator, fieldValue, conditionValue) {
-  switch (operator) {
-    case "equals": {
-      if (Array.isArray(fieldValue)) {
-        if (Array.isArray(conditionValue)) {
-          if (fieldValue.length !== conditionValue.length) {
-            return false;
-          }
-          return fieldValue.every((v, i) => v === conditionValue[i]);
-        }
-        return fieldValue.includes(conditionValue);
-      }
-      return toString(fieldValue) === toString(conditionValue);
-    }
-    case "notEquals": {
-      if (Array.isArray(fieldValue)) {
-        if (Array.isArray(conditionValue)) {
-          if (fieldValue.length !== conditionValue.length) {
-            return true;
-          }
-          return !fieldValue.every((v, i) => v === conditionValue[i]);
-        }
-        return !fieldValue.includes(conditionValue);
-      }
-      return toString(fieldValue) !== toString(conditionValue);
-    }
-    case "contains": {
-      const fieldStr = toString(fieldValue).toLowerCase();
-      const conditionStr = toString(conditionValue).toLowerCase();
-      if (Array.isArray(fieldValue)) {
-        return fieldValue.some(
-          (v) => toString(v).toLowerCase().includes(conditionStr)
-        );
-      }
-      return fieldStr.includes(conditionStr);
-    }
-    case "isEmpty": {
-      return isEmptyValue(fieldValue);
-    }
-    case "isNotEmpty": {
-      return !isEmptyValue(fieldValue);
-    }
-    case "greaterThan": {
-      const fieldNum = toNumber(fieldValue);
-      const conditionNum = toNumber(conditionValue);
-      if (!Number.isNaN(fieldNum) && !Number.isNaN(conditionNum)) {
-        return fieldNum > conditionNum;
-      }
-      return toString(fieldValue) > toString(conditionValue);
-    }
-    case "lessThan": {
-      const fieldNum = toNumber(fieldValue);
-      const conditionNum = toNumber(conditionValue);
-      if (!Number.isNaN(fieldNum) && !Number.isNaN(conditionNum)) {
-        return fieldNum < conditionNum;
-      }
-      return toString(fieldValue) < toString(conditionValue);
-    }
-    default: {
-      console.warn(
-        `[evaluateConditions] Unknown comparison operator: ${String(operator)}`
-      );
-      return false;
-    }
-  }
-}
-function evaluateSingleCondition(condition, formData) {
-  const { field, comparison, value: conditionValue } = condition;
-  const fieldValue = getNestedValue(formData, field);
-  return compareValues(comparison, fieldValue, conditionValue);
-}
-function getNestedValue(obj, path) {
-  if (!path) {
-    return void 0;
-  }
-  if (!path.includes(".")) {
-    return obj[path];
-  }
-  const parts = path.split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current === void 0 || current === null) {
-      return void 0;
-    }
-    if (typeof current !== "object") {
-      return void 0;
-    }
-    current = current[part];
-  }
-  return current;
-}
-function evaluateConditions(logic, formData) {
-  if (!logic || !logic.enabled) {
-    return true;
-  }
-  const { action, operator, conditions } = logic;
-  if (!conditions || conditions.length === 0) {
-    return true;
-  }
-  const results = conditions.map(
-    (condition) => evaluateSingleCondition(condition, formData)
-  );
-  let conditionsMet;
-  if (operator === "OR") {
-    conditionsMet = results.some((result) => result);
-  } else {
-    conditionsMet = results.every((result) => result);
-  }
-  if (action === "hide") {
-    return !conditionsMet;
-  }
-  return conditionsMet;
-}
-function isValidComparisonOperator(operator) {
-  const validOperators = [
-    "equals",
-    "notEquals",
-    "contains",
-    "isEmpty",
-    "isNotEmpty",
-    "greaterThan",
-    "lessThan"
-  ];
-  return validOperators.includes(operator);
-}
-function getSupportedComparisonOperators() {
-  return [
-    "equals",
-    "notEquals",
-    "contains",
-    "isEmpty",
-    "isNotEmpty",
-    "greaterThan",
-    "lessThan"
-  ];
-}
-
 // src/utils/generate-schema.ts
 import { z } from "zod";
 function generateZodSchema(fields) {
   const schemaShape = {};
   for (const field of fields) {
+    if (!isKnownFormField(field)) {
+      schemaShape[field.name] = field.required ? z.unknown().refine(
+        (value) => value !== void 0 && value !== null && value !== "",
+        { message: `${field.label || field.name} is required` }
+      ) : z.unknown();
+      continue;
+    }
     if (field.type === "hidden" && !field.required) {
       schemaShape[field.name] = z.string().optional();
       continue;
@@ -1425,54 +1862,74 @@ function generateFieldSchema(field) {
       return z.unknown();
   }
 }
-function generateTextSchema(field) {
-  let schema = z.string();
-  if (field.validation?.minLength !== void 0) {
-    schema = schema.min(
-      field.validation.minLength,
-      field.validation.errorMessage || `Minimum ${field.validation.minLength} characters required`
-    );
-  }
-  if (field.validation?.maxLength !== void 0) {
-    schema = schema.max(
-      field.validation.maxLength,
-      field.validation.errorMessage || `Maximum ${field.validation.maxLength} characters allowed`
-    );
-  }
-  if (field.validation?.pattern) {
-    schema = schema.regex(
-      new RegExp(field.validation.pattern),
-      field.validation.errorMessage || "Invalid format"
-    );
+function customMessage(field) {
+  const enforced = ENFORCED_VALIDATION_RULES[field.type] ?? [];
+  if (!enforced.includes("message")) return void 0;
+  return field.validation?.errorMessage;
+}
+function enforcedValidation(field) {
+  const stored = field.validation ?? {};
+  return { ...stored, errorMessage: customMessage(field) };
+}
+var STRING_RULE_APPLIERS = {
+  minLength: (schema, validation) => validation.minLength === void 0 ? schema : schema.min(
+    validation.minLength,
+    validation.errorMessage || `Minimum ${validation.minLength} characters required`
+  ),
+  maxLength: (schema, validation) => validation.maxLength === void 0 ? schema : schema.max(
+    validation.maxLength,
+    validation.errorMessage || `Maximum ${validation.maxLength} characters allowed`
+  ),
+  pattern: (schema, validation, fallback) => validation.pattern ? schema.regex(
+    new RegExp(validation.pattern),
+    validation.errorMessage || fallback
+  ) : schema
+};
+var NUMBER_RULE_APPLIERS = {
+  min: (schema, validation) => validation.min === void 0 ? schema : schema.min(
+    validation.min,
+    validation.errorMessage || `Minimum value is ${validation.min}`
+  ),
+  max: (schema, validation) => validation.max === void 0 ? schema : schema.max(
+    validation.max,
+    validation.errorMessage || `Maximum value is ${validation.max}`
+  )
+};
+function overridesPattern(field) {
+  const enforced = ENFORCED_VALIDATION_RULES[field.type] ?? [];
+  if (!enforced.includes("pattern")) return false;
+  const validation = field.validation ?? {};
+  return Boolean(validation.pattern);
+}
+function applyStringRules(schema, field, patternMessage) {
+  const validation = enforcedValidation(field);
+  let constrained = schema;
+  for (const rule of ENFORCED_VALIDATION_RULES[field.type] ?? []) {
+    const apply = STRING_RULE_APPLIERS[rule];
+    if (apply) constrained = apply(constrained, validation, patternMessage);
   }
-  return applyRequired(schema, field.required, field.validation?.errorMessage);
+  return constrained;
+}
+function generateTextSchema(field) {
+  const schema = applyStringRules(z.string(), field, "Invalid format");
+  return applyRequired(schema, field.required, customMessage(field));
 }
 function generateEmailSchema(field) {
-  let schema = z.string().email(field.validation?.errorMessage || "Invalid email address");
-  if (field.validation?.pattern) {
-    schema = schema.regex(
-      new RegExp(field.validation.pattern),
-      field.validation.errorMessage || "Invalid email format"
-    );
-  }
-  return applyRequired(schema, field.required, field.validation?.errorMessage);
+  const schema = applyStringRules(
+    z.string().email(customMessage(field) || "Invalid email address"),
+    field,
+    "Invalid email format"
+  );
+  return applyRequired(schema, field.required, customMessage(field));
 }
 function generateNumberSchema(field) {
   let schema = z.number({
-    required_error: field.validation?.errorMessage || "This field is required",
-    invalid_type_error: "Must be a number"
+    error: (issue) => issue.input === void 0 ? customMessage(field) || "This field is required" : "Must be a number"
   });
-  if (field.validation?.min !== void 0) {
-    schema = schema.min(
-      field.validation.min,
-      field.validation.errorMessage || `Minimum value is ${field.validation.min}`
-    );
-  }
-  if (field.validation?.max !== void 0) {
-    schema = schema.max(
-      field.validation.max,
-      field.validation.errorMessage || `Maximum value is ${field.validation.max}`
-    );
+  const validation = enforcedValidation(field);
+  for (const rule of ENFORCED_VALIDATION_RULES[field.type] ?? []) {
+    const apply = NUMBER_RULE_APPLIERS[rule];
+    if (apply) schema = apply(schema, validation);
   }
   if (field.required) {
     return schema;
@@ -1480,45 +1937,24 @@ function generateNumberSchema(field) {
   return schema.optional().nullable();
 }
 function generatePhoneSchema(field) {
-  let schema = z.string();
-  if (field.validation?.pattern) {
-    schema = schema.regex(
-      new RegExp(field.validation.pattern),
-      field.validation.errorMessage || "Invalid phone number format"
-    );
-  } else {
-    schema = schema.regex(
-      /^[\d\s\-+()]+$/,
-      field.validation?.errorMessage || "Invalid phone number"
-    );
-  }
-  return applyRequired(schema, field.required, field.validation?.errorMessage);
+  const base = overridesPattern(field) ? z.string() : z.string().regex(
+    /^[\d\s\-+()]+$/,
+    customMessage(field) || "Invalid phone number"
+  );
+  const schema = applyStringRules(base, field, "Invalid phone number format");
+  return applyRequired(schema, field.required, customMessage(field));
 }
 function generateUrlSchema(field) {
-  let schema = z.string().url(field.validation?.errorMessage || "Invalid URL");
-  if (field.validation?.pattern) {
-    schema = schema.regex(
-      new RegExp(field.validation.pattern),
-      field.validation.errorMessage || "Invalid URL format"
-    );
-  }
-  return applyRequired(schema, field.required, field.validation?.errorMessage);
+  const schema = applyStringRules(
+    z.string().url(customMessage(field) || "Invalid URL"),
+    field,
+    "Invalid URL format"
+  );
+  return applyRequired(schema, field.required, customMessage(field));
 }
 function generateTextareaSchema(field) {
-  let schema = z.string();
-  if (field.validation?.minLength !== void 0) {
-    schema = schema.min(
-      field.validation.minLength,
-      field.validation.errorMessage || `Minimum ${field.validation.minLength} characters required`
-    );
-  }
-  if (field.validation?.maxLength !== void 0) {
-    schema = schema.max(
-      field.validation.maxLength,
-      field.validation.errorMessage || `Maximum ${field.validation.maxLength} characters allowed`
-    );
-  }
-  return applyRequired(schema, field.required, field.validation?.errorMessage);
+  const schema = applyStringRules(z.string(), field, "Invalid format");
+  return applyRequired(schema, field.required, customMessage(field));
 }
 function generateSelectSchema(field) {
   const validValues = field.options.map((opt) => opt.value);
@@ -1527,15 +1963,13 @@ function generateSelectSchema(field) {
     if (field.required) {
       return schema2.min(
         1,
-        field.validation?.errorMessage || "Please select at least one option"
+        customMessage(field) || "Please select at least one option"
       );
     }
     return schema2.optional();
   }
   const schema = z.enum(validValues, {
-    errorMap: () => ({
-      message: field.validation?.errorMessage || "Please select a valid option"
-    })
+    error: () => customMessage(field) || "Please select a valid option"
   });
   if (field.required) {
     return schema;
@@ -1546,7 +1980,7 @@ function generateCheckboxSchema(field) {
   const schema = z.boolean();
   if (field.required) {
     return schema.refine((val) => val === true, {
-      message: field.validation?.errorMessage || "This field is required"
+      message: customMessage(field) || "This field is required"
     });
   }
   return schema.optional();
@@ -1554,9 +1988,7 @@ function generateCheckboxSchema(field) {
 function generateRadioSchema(field) {
   const validValues = field.options.map((opt) => opt.value);
   const schema = z.enum(validValues, {
-    errorMap: () => ({
-      message: field.validation?.errorMessage || "Please select an option"
-    })
+    error: () => customMessage(field) || "Please select an option"
   });
   if (field.required) {
     return schema;
@@ -1569,42 +2001,42 @@ function generateFileSchema(field) {
     if (field.required) {
       return schema2.min(
         1,
-        field.validation?.errorMessage || "Please upload at least one file"
+        customMessage(field) || "Please upload at least one file"
       );
     }
     return schema2.optional();
   }
   const schema = z.string();
-  return applyRequired(schema, field.required, field.validation?.errorMessage);
+  return applyRequired(schema, field.required, customMessage(field));
 }
 function generateDateSchema(field) {
   let schema = z.string();
   schema = schema.refine(
     (val) => {
       if (!val) return true;
-      const date3 = new Date(val);
-      return !isNaN(date3.getTime());
+      const date4 = new Date(val);
+      return !isNaN(date4.getTime());
     },
-    { message: field.validation?.errorMessage || "Invalid date" }
+    { message: customMessage(field) || "Invalid date" }
   );
   if (field.min || field.max) {
     schema = schema.refine(
       (val) => {
         if (!val) return true;
-        const date3 = new Date(val);
-        if (field.min && date3 < new Date(field.min)) return false;
-        if (field.max && date3 > new Date(field.max)) return false;
+        const date4 = new Date(val);
+        if (field.min && date4 < new Date(field.min)) return false;
+        if (field.max && date4 > new Date(field.max)) return false;
         return true;
       },
       {
-        message: field.validation?.errorMessage || `Date must be between ${field.min || "any"} and ${field.max || "any"}`
+        message: customMessage(field) || `Date must be between ${field.min || "any"} and ${field.max || "any"}`
       }
     );
   }
   if (field.required) {
     return schema.refine(
       (val) => val !== void 0 && val !== null && val !== "",
-      { message: field.validation?.errorMessage || "This field is required" }
+      { message: customMessage(field) || "This field is required" }
     );
   }
   return schema.optional().or(z.literal(""));
@@ -1612,13 +2044,13 @@ function generateDateSchema(field) {
 function generateTimeSchema(field) {
   const schema = z.string().regex(
     /^([0-1]?[0-9]|2[0-3]):[0-5][0-9]$/,
-    field.validation?.errorMessage || "Invalid time format (HH:mm)"
+    customMessage(field) || "Invalid time format (HH:mm)"
   );
-  return applyRequired(schema, field.required, field.validation?.errorMessage);
+  return applyRequired(schema, field.required, customMessage(field));
 }
 function generateHiddenSchema(field) {
   const schema = z.string();
-  return applyRequired(schema, field.required, field.validation?.errorMessage);
+  return applyRequired(schema, field.required, customMessage(field));
 }
 function applyRequired(schema, required, errorMessage) {
   if (required) {
@@ -1633,7 +2065,7 @@ function transformFormData(data, fields) {
     if (value === void 0) {
       continue;
     }
-    transformed[field.name] = transformFieldValue(value, field);
+    transformed[field.name] = isKnownFormField(field) ? transformFieldValue(value, field) : value;
   }
   return transformed;
 }
@@ -1684,7 +2116,7 @@ function getValidationErrors(result) {
     return {};
   }
   const errors = {};
-  for (const error of result.error.errors) {
+  for (const error of result.error.issues) {
     const path = error.path.join(".");
     if (!errors[path]) {
       errors[path] = error.message;
@@ -1693,202 +2125,8 @@ function getValidationErrors(result) {
   return errors;
 }
 
-// src/utils/export-formats.ts
-var UTF8_BOM = "\uFEFF";
-function safeString(value) {
-  if (typeof value === "object" && value !== null) {
-    return JSON.stringify(value);
-  }
-  return String(value);
-}
-function formatExportValue(value, field) {
-  if (value === null || value === void 0) {
-    return "";
-  }
-  if (field) {
-    switch (field.type) {
-      case "checkbox":
-        return value ? "Yes" : "No";
-      case "select":
-        if (Array.isArray(value)) {
-          return value.join(", ");
-        }
-        return safeString(value);
-      case "file":
-        if (Array.isArray(value)) {
-          return value.map((v) => safeString(v)).join(", ");
-        }
-        return safeString(value);
-      case "date":
-        if (value instanceof Date) {
-          return value.toISOString().split("T")[0];
-        }
-        if (typeof value === "string") {
-          const parsed = new Date(value);
-          if (!isNaN(parsed.getTime())) {
-            return parsed.toISOString().split("T")[0];
-          }
-        }
-        return safeString(value);
-      case "time":
-        return safeString(value);
-      case "hidden":
-        return safeString(value);
-      default:
-        break;
-    }
-  }
-  if (Array.isArray(value)) {
-    return value.join(", ");
-  }
-  if (typeof value === "boolean") {
-    return value ? "Yes" : "No";
-  }
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-  return safeString(value);
-}
-function formatDate(date3, format = "iso") {
-  if (!date3) return "";
-  const d = typeof date3 === "string" ? new Date(date3) : date3;
-  if (isNaN(d.getTime())) {
-    return "";
-  }
-  return format === "iso" ? d.toISOString() : d.toLocaleString();
-}
-function escapeCSVValue(value, delimiter = ",") {
-  const needsQuoting = value.includes(delimiter) || value.includes('"') || value.includes("\n") || value.includes("\r");
-  if (!needsQuoting) {
-    return value;
-  }
-  const escaped = value.replace(/"/g, '""');
-  return `"${escaped}"`;
-}
-function exportToCSV(submissions, form, options = {}) {
-  const {
-    includeMetadata = true,
-    delimiter = ",",
-    includeBOM = true,
-    dateFormat = "iso"
-  } = options;
-  const exportableFields = form.fields;
-  const headers = [];
-  for (const field of exportableFields) {
-    headers.push(field.label);
-  }
-  if (includeMetadata) {
-    headers.push("ID", "Status", "Submitted At", "IP Address", "User Agent");
-  }
-  const rows = [];
-  for (const submission of submissions) {
-    const row = [];
-    const data = submission.data;
-    for (const field of exportableFields) {
-      const value = data[field.name];
-      const formatted = formatExportValue(value, field);
-      row.push(escapeCSVValue(formatted, delimiter));
-    }
-    if (includeMetadata) {
-      row.push(escapeCSVValue(submission.id, delimiter));
-      row.push(escapeCSVValue(submission.status, delimiter));
-      row.push(
-        escapeCSVValue(
-          formatDate(submission.submittedAt, dateFormat),
-          delimiter
-        )
-      );
-      row.push(escapeCSVValue(submission.ipAddress || "", delimiter));
-      row.push(escapeCSVValue(submission.userAgent || "", delimiter));
-    }
-    rows.push(row);
-  }
-  const escapedHeaders = headers.map((h) => escapeCSVValue(h, delimiter));
-  const lines = [
-    escapedHeaders.join(delimiter),
-    ...rows.map((row) => row.join(delimiter))
-  ];
-  const csvContent = lines.join("\r\n");
-  return includeBOM ? UTF8_BOM + csvContent : csvContent;
-}
-function exportToJSON(submissions, form, options = {}) {
-  const {
-    includeMetadata = true,
-    includeFormDefinition = true,
-    indent = 2
-  } = options;
-  const exportableFields = form.fields;
-  const formDefinition = includeFormDefinition ? {
-    id: form.id,
-    name: form.name,
-    slug: form.slug,
-    fields: exportableFields.map((f) => ({
-      name: f.name,
-      label: f.label,
-      type: f.type
-    }))
-  } : void 0;
-  const exportedSubmissions = submissions.map((submission) => {
-    const data = submission.data;
-    const fieldData = {};
-    for (const field of exportableFields) {
-      const value = data[field.name];
-      fieldData[field.name] = value;
-    }
-    if (includeMetadata) {
-      return {
-        ...fieldData,
-        _metadata: {
-          id: submission.id,
-          status: submission.status,
-          submittedAt: submission.submittedAt,
-          ipAddress: submission.ipAddress || null,
-          userAgent: submission.userAgent || null,
-          createdAt: submission.createdAt,
-          updatedAt: submission.updatedAt
-        }
-      };
-    }
-    return fieldData;
-  });
-  const exportData = {
-    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    totalSubmissions: submissions.length,
-    submissions: exportedSubmissions
-  };
-  if (formDefinition) {
-    exportData.form = formDefinition;
-  }
-  return JSON.stringify(exportData, null, indent);
-}
-function downloadFile(content, filename, mimeType) {
-  if (typeof window === "undefined" || typeof document === "undefined") {
-    throw new Error("downloadFile is only available in browser environments");
-  }
-  const blob = new Blob([content], { type: mimeType });
-  const url2 = URL.createObjectURL(blob);
-  const link = document.createElement("a");
-  link.href = url2;
-  link.download = filename;
-  document.body.appendChild(link);
-  link.click();
-  document.body.removeChild(link);
-  URL.revokeObjectURL(url2);
-}
-function generateExportFilename(formSlug, format) {
-  const date3 = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  return `${formSlug}-submissions-${date3}.${format}`;
-}
-function exportAndDownload(submissions, form, format, options) {
-  const filename = generateExportFilename(form.slug, format);
-  if (format === "csv") {
-    const content = exportToCSV(submissions, form, options);
-    downloadFile(content, filename, "text/csv;charset=utf-8");
-  } else {
-    const content = exportToJSON(submissions, form, options);
-    downloadFile(content, filename, "application/json");
-  }
-}
+// src/handlers/submit-form.ts
+import { formAvailability, NO_SUCH_FORM } from "nextly";
 
 // src/handlers/spam-detection.ts
 var rateLimitStore = /* @__PURE__ */ new Map();
@@ -2007,68 +2245,116 @@ async function submitForm(options, context) {
   const { formSlug, data, metadata } = options;
   const { pluginContext, pluginConfig } = context;
   const { collections } = pluginContext.services;
-  const { logger } = pluginContext.infra;
+  const { logger } = pluginContext;
   try {
     const form = await fetchFormBySlug(formSlug, pluginConfig, pluginContext);
     if (!form) {
       logger.warn?.("Form submission attempted for non-existent form", {
         formSlug
       });
-      return {
-        success: false,
-        error: "Form not found"
-      };
+      return { success: false, error: NO_SUCH_FORM };
     }
-    if (form.status !== "published") {
-      logger.info?.("Form submission rejected - form not published", {
+    const availability = formAvailability(form);
+    if (availability.kind !== "open") {
+      logger.info?.("Form submission rejected - form not accepting", {
         formSlug,
-        status: form.status
+        status: form.status,
+        availability: availability.kind
       });
       return {
         success: false,
-        error: "This form is not currently accepting submissions"
+        error: availability.kind === "closed" ? availability.message : NO_SUCH_FORM
       };
     }
-    const transformedData = transformFormData(data, form.fields);
-    const schema = generateZodSchema(form.fields);
-    const validationResult = schema.safeParse(transformedData);
-    if (!validationResult.success) {
-      const validationErrors = getValidationErrors(validationResult);
-      logger.debug?.("Form validation failed", {
-        formSlug,
-        errors: validationErrors
-      });
-      return {
-        success: false,
-        error: "Validation failed",
-        validationErrors
-      };
+    const settings = normalizeFormSettings(form.settings);
+    if (settings.allowMultipleSubmissions === false && !metadata?.ipAddress) {
+      logger.warn?.(
+        "Single-submission form received a submission without an IP \u2014 the restriction cannot apply",
+        { formSlug }
+      );
+    }
+    if (settings.allowMultipleSubmissions === false && metadata?.ipAddress) {
+      const existing = await collections.count(
+        pluginConfig.formSubmissionOverrides.slug,
+        {
+          where: {
+            form: { equals: form.id },
+            ipAddress: { equals: metadata.ipAddress },
+            status: { not_equals: "spam" }
+          }
+        },
+        { as: "system" }
+      );
+      if (existing > 0) {
+        logger.info?.("Repeat submission rejected (single-submission form)", {
+          formSlug,
+          ipAddress: metadata.ipAddress
+        });
+        return {
+          success: false,
+          error: "You have already submitted this form."
+        };
+      }
     }
-    sanitizeSubmissionData(validationResult.data, form.fields);
+    const declaredFieldNames = new Set(form.fields.map((field) => field.name));
+    const undeclaredData = Object.fromEntries(
+      Object.entries(data).filter(([key]) => !declaredFieldNames.has(key))
+    );
     const spamResult = await checkSpam({
-      data: transformedData,
+      data: undeclaredData,
       ipAddress: metadata?.ipAddress,
       formSlug,
       config: {
-        honeypot: pluginConfig.spamProtection.honeypot,
+        // Per-form overrides win where set; blank inherits the plugin config.
+        honeypot: settings.honeypotEnabled ?? pluginConfig.spamProtection.honeypot,
         rateLimit: pluginConfig.spamProtection.rateLimit,
-        recaptcha: pluginConfig.spamProtection.recaptcha
+        recaptcha: {
+          ...pluginConfig.spamProtection.recaptcha,
+          enabled: settings.captchaEnabled ?? pluginConfig.spamProtection.recaptcha?.enabled ?? false
+        }
       }
     });
-    if (spamResult.isSpam) {
-      logger.info?.("Spam submission detected and rejected", {
+    if (spamResult.isSpam && spamResult.reason === "rate_limit") {
+      logger.info?.("Spam submission rejected (rate limit)", {
+        formSlug,
+        ipAddress: metadata?.ipAddress
+      });
+      return { success: true };
+    }
+    const isContentSpam = spamResult.isSpam;
+    const transformedData = transformFormData(data, form.fields);
+    let storedData;
+    if (isContentSpam) {
+      logger.info?.("Spam submission detected \u2014 storing flagged", {
         formSlug,
         reason: spamResult.reason,
         ipAddress: metadata?.ipAddress
       });
-      return {
-        success: true
-      };
+      sanitizeSubmissionData(transformedData, form.fields);
+      storedData = transformedData;
+    } else {
+      const schema = generateZodSchema(form.fields);
+      const validationResult = schema.safeParse(transformedData);
+      if (!validationResult.success) {
+        const validationErrors = getValidationErrors(validationResult);
+        logger.debug?.("Form validation failed", {
+          formSlug,
+          errors: validationErrors
+        });
+        return {
+          success: false,
+          error: "Validation failed",
+          validationErrors
+        };
+      }
+      sanitizeSubmissionData(validationResult.data, form.fields);
+      storedData = validationResult.data;
     }
     const submissionData = {
       form: form.id,
-      data: validationResult.data,
-      status: "new",
+      data: storedData,
+      status: isContentSpam ? "spam" : "new",
+      spamReason: isContentSpam ? spamResult.reason ?? null : null,
       ipAddress: metadata?.ipAddress || null,
       userAgent: metadata?.userAgent || null,
       submittedAt: /* @__PURE__ */ new Date()
@@ -2076,17 +2362,37 @@ async function submitForm(options, context) {
     const submission = await collections.createEntry(
       pluginConfig.formSubmissionOverrides.slug,
       submissionData,
-      {}
-      // Empty context - submission creation is public
+      // Public form submission — create as system. No ambient user; an
+      // empty context already resolves to system, but be explicit.
+      { as: "system" }
     );
     logger.info?.("Form submission created successfully", {
       formSlug,
-      submissionId: submission.id
+      submissionId: submission.item.id,
+      flaggedAsSpam: isContentSpam
     });
-    const redirect = determineRedirectUrl(form);
+    if (submission.warnings) {
+      logger.warn?.("Form submission side effects failed", {
+        formSlug,
+        submissionId: submission.item.id,
+        warnings: submission.warnings
+      });
+    }
+    const redirect = await resolveRedirectUrl(
+      form,
+      pluginConfig,
+      pluginContext
+    );
+    if (isContentSpam) {
+      return { success: true, redirect };
+    }
     return {
       success: true,
-      submission,
+      // The created ROW, not the envelope around it. Through the shared
+      // conversion, which is where the unchecked step lives and says so; the
+      // integration test reads `submission.id` off the result because nothing
+      // at compile time will.
+      submission: asSubmissionDocument(submission.item),
       redirect
     };
   } catch (error) {
@@ -2105,39 +2411,109 @@ async function fetchFormBySlug(slug, pluginConfig, pluginContext) {
     const { collections } = pluginContext.services;
     const result = await collections.listEntries(
       pluginConfig.formOverrides.slug,
-      {
-        pagination: { limit: 100 }
-        // Fetch enough to find the form
-      },
-      {}
-      // Empty context for public access
-    );
-    if (!result.data || result.data.length === 0) {
-      return null;
-    }
-    const form = result.data.find(
-      (entry) => entry.slug === slug
+      { where: { slug: { equals: slug } }, pagination: { limit: 1 } },
+      { as: "system" }
     );
-    return form ? form : null;
+    const form = result.data?.[0];
+    return form ? asFormDocument(form) : null;
   } catch {
     return null;
   }
 }
-function determineRedirectUrl(form) {
-  if (!form.settings) {
+async function resolveRedirectUrl(form, pluginConfig, pluginContext) {
+  const settings = form.settings;
+  if (!settings) return void 0;
+  if (settings.confirmationType === "redirect" && settings.redirectUrl) {
+    return settings.redirectUrl;
+  }
+  const field = pickedDocumentField(settings);
+  if (!field) return void 0;
+  return urlForPickedDocument(
+    settings[field],
+    form,
+    pluginConfig,
+    pluginContext
+  );
+}
+async function urlForPickedDocument(stored, form, pluginConfig, pluginContext) {
+  const { logger } = pluginContext;
+  const patterns = pluginConfig.redirectRelationships;
+  const reference = parseRedirectReference(stored, Object.keys(patterns));
+  if (!reference) {
+    logger.warn?.("Form redirects to a page, but names no readable document", {
+      form: form.slug
+    });
+    return void 0;
+  }
+  const pattern = patterns[reference.collection];
+  if (!pattern) {
+    logger.warn?.(
+      "Form redirects to a collection that is not in redirectRelationships",
+      { form: form.slug, collection: reference.collection }
+    );
     return void 0;
   }
-  if (form.settings.confirmationType !== "redirect") {
+  const target = await readTarget(reference, form, pluginContext);
+  if (!target) return void 0;
+  if (documentReachability(
+    target,
+    pluginConfig.redirectTargetLocalization[reference.collection]
+  ) === "unreachable") {
+    logger.warn?.("Form redirects to a page that has never been published", {
+      form: form.slug,
+      collection: reference.collection,
+      target: reference.id
+    });
     return void 0;
   }
-  if (form.settings.redirectUrl) {
-    return form.settings.redirectUrl;
+  return buildUrl(pattern, target, reference.collection, form, pluginContext);
+}
+function buildUrl(pattern, target, collection, form, pluginContext) {
+  const { logger } = pluginContext;
+  try {
+    const url2 = applyRedirectPattern(pattern, target);
+    if (!url2) {
+      logger.warn?.(
+        "Form redirect pattern could not be filled from the target document",
+        { form: form.slug, collection }
+      );
+    }
+    return url2;
+  } catch (error) {
+    logger.warn?.("Form redirect pattern threw while building a URL", {
+      form: form.slug,
+      collection,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return void 0;
   }
-  if (form.settings.redirectRelation) {
-    const { relationTo, value } = form.settings.redirectRelation;
-    return `relationship://${relationTo}/${value}`;
+}
+async function readTarget(reference, form, pluginContext) {
+  const { logger } = pluginContext;
+  const context = {
+    form: form.slug,
+    collection: reference.collection,
+    id: reference.id
+  };
+  let row;
+  try {
+    row = await pluginContext.services.collections.findEntryById(
+      reference.collection,
+      reference.id,
+      { as: "system" }
+    );
+  } catch (error) {
+    logger.warn?.("Form redirect target could not be read", {
+      ...context,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return void 0;
   }
-  return void 0;
+  if (!row || typeof row !== "object") {
+    logger.warn?.("Form redirect target no longer exists", context);
+    return void 0;
+  }
+  return row;
 }
 async function validateSubmission(formSlug, data, context) {
   const { pluginContext, pluginConfig } = context;
@@ -2191,33 +2567,28 @@ async function getFormSubmissionStats(formSlug, context) {
     return null;
   }
   try {
-    const result = await collections.listEntries(
-      pluginConfig.formSubmissionOverrides.slug,
-      {
-        pagination: { limit: 1e3 }
-        // Reasonable limit for stats
-      },
-      {}
-    );
-    if (!result.data) {
-      return { total: 0, new: 0, read: 0, archived: 0 };
-    }
-    const submissions = result.data.filter(
-      (entry) => entry.form === form.id
-    );
-    const stats = {
-      total: submissions.length,
-      new: 0,
-      read: 0,
-      archived: 0
-    };
-    for (const sub of submissions) {
-      const status = sub.status;
-      if (status === "new") stats.new++;
-      else if (status === "read") stats.read++;
-      else if (status === "archived") stats.archived++;
-    }
-    return stats;
+    const submissionsSlug = pluginConfig.formSubmissionOverrides.slug;
+    const sys = { as: "system" };
+    const base = { form: { equals: form.id } };
+    const [total, newCount, read, archived] = await Promise.all([
+      collections.count(submissionsSlug, { where: base }, sys),
+      collections.count(
+        submissionsSlug,
+        { where: { ...base, status: { equals: "new" } } },
+        sys
+      ),
+      collections.count(
+        submissionsSlug,
+        { where: { ...base, status: { equals: "read" } } },
+        sys
+      ),
+      collections.count(
+        submissionsSlug,
+        { where: { ...base, status: { equals: "archived" } } },
+        sys
+      )
+    ]);
+    return { total, new: newCount, read, archived };
   } catch {
     return null;
   }
@@ -2404,6 +2775,7 @@ function getSupportedWebhookEvents() {
 // src/index.ts
 var formBuilderPlugin = formBuilder().plugin;
 export {
+  BUILT_IN_FORM_FIELD_TYPES,
   DEFAULT_FORM_SETTINGS,
   DEFAULT_NOTIFICATION_SETTINGS,
   RESERVED_FORM_SLUGS,
@@ -2415,7 +2787,7 @@ export {
   cleanupRateLimitStore,
   clearRateLimitStore,
   createFormConfig,
-  date2 as date,
+  date3 as date,
   downloadFile,
   email,
   evaluateConditions,
@@ -2443,6 +2815,7 @@ export {
   isFormAcceptingSubmissions,
   isFormField,
   isFormFieldType,
+  isKnownFormField,
   isRateLimited,
   isSelectFormField,
   isTextFormField,