@dyrected/core 2.8.3 → 2.9.0

package/dist/chunk-G43REXPX.js

@@ -1,3147 +0,0 @@
-import {
-  getConfigLogger
-} from "./chunk-FRSJJO27.js";
-
-// src/workflows.ts
-var WORKFLOW_HISTORY_COLLECTION = "__workflow_history";
-var LIFECYCLE_EVENTS_COLLECTION = "__lifecycle_events";
-var EDITOR_CAPABILITIES = ["entry.edit", "entry.submit"];
-var PUBLISHER_CAPABILITIES = ["entry.edit", "entry.submit", "entry.publish", "entry.unpublish"];
-function definePublishingWorkflow(options = {}) {
-  const editors = options.editors ?? ["editor"];
-  const publishers = options.publishers ?? ["publisher", "admin"];
-  return {
-    initialState: "draft",
-    draftState: "draft",
-    states: [
-      { name: "draft", label: "Draft", color: "neutral" },
-      { name: "in_review", label: "In review", color: "warning" },
-      { name: "published", label: "Published", color: "success", published: true }
-    ],
-    transitions: [
-      {
-        name: "submit",
-        label: "Submit for review",
-        from: "draft",
-        to: "in_review",
-        requiredCapabilities: ["entry.submit"]
-      },
-      {
-        name: "publish",
-        label: "Publish",
-        from: "in_review",
-        to: "published",
-        requiredCapabilities: ["entry.publish"]
-      },
-      {
-        name: "reject",
-        label: "Request changes",
-        from: "in_review",
-        to: "draft",
-        requiredCapabilities: ["entry.publish"],
-        requireComment: true
-      },
-      {
-        name: "unpublish",
-        label: "Unpublish",
-        from: "published",
-        to: "draft",
-        requiredCapabilities: ["entry.unpublish"],
-        unpublish: true
-      }
-    ],
-    roles: [
-      ...editors.map((role) => ({ role, capabilities: [...EDITOR_CAPABILITIES] })),
-      ...publishers.map((role) => ({ role, capabilities: [...PUBLISHER_CAPABILITIES] }))
-    ]
-  };
-}
-function publishingWorkflow() {
-  return definePublishingWorkflow();
-}
-function simplePublishingWorkflow() {
-  return {
-    initialState: "draft",
-    draftState: "draft",
-    states: [
-      { name: "draft", label: "Draft", color: "neutral" },
-      { name: "published", label: "Published", color: "success", published: true }
-    ],
-    transitions: [
-      { name: "publish", label: "Publish", from: ["draft", "published"], to: "published" },
-      { name: "unpublish", label: "Unpublish", from: "published", to: "draft", unpublish: true }
-    ]
-    // Intentionally no `roles`: this lightweight workflow (synthesized from
-    // `drafts: true`) does no capability-based gating. Draft visibility for a
-    // no-roles workflow is handled in `canViewWorkflowDraft`.
-  };
-}
-function publicMetadata(meta) {
-  const { availableTransitions: _availableTransitions, ...safe } = meta;
-  return safe;
-}
-function workflowCapabilities(workflow, user) {
-  const capabilities = new Set(Array.isArray(user?.capabilities) ? user.capabilities : []);
-  const roles = Array.isArray(user?.roles) ? user.roles : [];
-  for (const mapping of workflow.roles ?? []) {
-    if (roles.includes(mapping.role)) mapping.capabilities.forEach((capability) => capabilities.add(capability));
-  }
-  return capabilities;
-}
-function canViewWorkflowDraft(workflow, user) {
-  if (!user) return false;
-  const capabilities = workflowCapabilities(workflow, user);
-  if (capabilities.has("entry.edit")) return true;
-  if (workflow.transitions.some(
-    (transition) => (transition.requiredCapabilities ?? []).some((capability) => capabilities.has(capability))
-  )) {
-    return true;
-  }
-  if (!workflow.roles || workflow.roles.length === 0) return true;
-  return false;
-}
-function availableWorkflowTransitions(workflow, state, user) {
-  const capabilities = workflowCapabilities(workflow, user);
-  return workflow.transitions.filter((transition) => {
-    const from = Array.isArray(transition.from) ? transition.from : [transition.from];
-    return from.includes(state) && (transition.requiredCapabilities ?? []).every((item) => capabilities.has(item));
-  });
-}
-function initializeWorkflowDocument(data, workflow) {
-  return {
-    ...data,
-    __workflow: { state: workflow.initialState, revision: 1 }
-  };
-}
-function publishedStateName(workflow) {
-  return workflow.states.find((state) => state.published)?.name ?? workflow.states[workflow.states.length - 1]?.name ?? workflow.initialState;
-}
-function materializeWorkflowDocument(doc, workflow, user) {
-  const meta = doc.__workflow;
-  const publishedState = publishedStateName(workflow);
-  if (!meta) {
-    const { __published: _legacyPublished, __workflow: _legacyWorkflow, ...working2 } = doc;
-    const state = publishedStateName(workflow);
-    return {
-      ...working2,
-      _workflow: {
-        state,
-        revision: 1,
-        availableTransitions: availableWorkflowTransitions(workflow, state, user).map((item) => item.name)
-      }
-    };
-  }
-  const { __published, __workflow, ...working } = doc;
-  if (!canViewWorkflowDraft(workflow, user)) {
-    if (!__published || typeof __published !== "object") {
-      if (meta.state === publishedState) {
-        return { ...working, _workflow: publicMetadata(meta) };
-      }
-      return null;
-    }
-    return { id: doc.id, ...__published, _workflow: publicMetadata(meta) };
-  }
-  return {
-    ...working,
-    _workflow: {
-      ...meta,
-      availableTransitions: availableWorkflowTransitions(workflow, meta.state, user).map((item) => item.name)
-    }
-  };
-}
-function eventId() {
-  return globalThis.crypto?.randomUUID?.() ?? `evt_${Date.now()}_${Math.random().toString(36).slice(2)}`;
-}
-function createLifecycleEvent(args) {
-  return {
-    id: eventId(),
-    name: args.name,
-    collection: args.collection,
-    documentId: args.documentId,
-    occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
-    actorId: args.actorId,
-    payload: args.payload,
-    attempts: 0,
-    status: "pending"
-  };
-}
-async function persistEvent(db, event) {
-  await db.create({ collection: LIFECYCLE_EVENTS_COLLECTION, data: event });
-}
-async function dispatchLifecycleEvent(config, event) {
-  const db = config.db;
-  if (!db || !config.events?.handlers.length) return;
-  const maxAttempts = config.events.maxAttempts ?? 8;
-  const retryDelayMs = config.events.retryDelayMs ?? 1e3;
-  const attempts = event.attempts + 1;
-  try {
-    await db.update({
-      collection: LIFECYCLE_EVENTS_COLLECTION,
-      id: event.id,
-      data: { status: "processing", attempts }
-    });
-    for (const handler of config.events.handlers) await handler({ ...event, status: "processing", attempts });
-    await db.update({
-      collection: LIFECYCLE_EVENTS_COLLECTION,
-      id: event.id,
-      data: { status: "delivered", attempts, deliveredAt: (/* @__PURE__ */ new Date()).toISOString(), lastError: null }
-    });
-  } catch (error) {
-    const exhausted = attempts >= maxAttempts;
-    await db.update({
-      collection: LIFECYCLE_EVENTS_COLLECTION,
-      id: event.id,
-      data: {
-        status: "failed",
-        attempts,
-        lastError: error instanceof Error ? error.message : String(error),
-        nextAttemptAt: exhausted ? null : new Date(Date.now() + retryDelayMs * 2 ** (attempts - 1)).toISOString()
-      }
-    });
-  }
-}
-async function dispatchPendingLifecycleEvents(config, limit = 50) {
-  if (!config.db || !config.events?.handlers.length) return 0;
-  const maxAttempts = config.events.maxAttempts ?? 8;
-  const result = await config.db.find({
-    collection: LIFECYCLE_EVENTS_COLLECTION,
-    where: { status: { in: ["pending", "failed"] } },
-    sort: "occurredAt",
-    limit
-  });
-  const now2 = Date.now();
-  const due = result.docs.filter(
-    (doc) => Number(doc.attempts ?? 0) < maxAttempts && (!doc.nextAttemptAt || new Date(doc.nextAttemptAt).getTime() <= now2)
-  );
-  for (const event of due) await dispatchLifecycleEvent(config, event);
-  return due.length;
-}
-async function saveWorkflowDraft(args) {
-  const { config, collection, id, originalDoc, data, user } = args;
-  const db = config.db;
-  const workflow = collection.workflow;
-  if (!db.transaction) throw new Error(`The configured database adapter does not support workflow transactions.`);
-  const previous = originalDoc.__workflow;
-  const isLegacyPublishedDoc = !previous;
-  const baselineRevision = previous?.revision ?? 1;
-  const event = createLifecycleEvent({
-    name: "revision.created",
-    collection: collection.slug,
-    documentId: id,
-    actorId: user?.sub,
-    payload: {
-      revision: baselineRevision + 1,
-      previousRevision: isLegacyPublishedDoc ? baselineRevision : previous?.revision ?? null
-    }
-  });
-  const doc = await db.transaction(async (tx) => {
-    const nextMeta = {
-      ...previous ?? {},
-      state: isLegacyPublishedDoc ? workflow.draftState ?? workflow.initialState : originalDoc.__published ? workflow.draftState ?? workflow.initialState : previous.state,
-      revision: baselineRevision + 1,
-      ...isLegacyPublishedDoc ? { publishedRevision: baselineRevision } : {}
-    };
-    const updateData = {
-      ...data,
-      __workflow: nextMeta
-    };
-    if (isLegacyPublishedDoc) {
-      const { __workflow: _legacyWorkflow, __published: _legacyPublished, ...publishedSnapshot } = originalDoc;
-      updateData.__published = publishedSnapshot;
-    }
-    const updated = await tx.update({ collection: collection.slug, id, data: updateData });
-    await persistEvent(tx, event);
-    return updated;
-  });
-  void dispatchLifecycleEvent(config, event);
-  return { doc, event };
-}
-async function createWorkflowDocument(args) {
-  const { config, collection, data, user } = args;
-  const db = config.db;
-  if (!db.transaction) throw new Error(`The configured database adapter does not support workflow transactions.`);
-  let event;
-  const doc = await db.transaction(async (tx) => {
-    const created = await tx.create({ collection: collection.slug, data });
-    event = createLifecycleEvent({
-      name: "revision.created",
-      collection: collection.slug,
-      documentId: created.id,
-      actorId: user?.sub,
-      payload: { revision: 1, previousRevision: null }
-    });
-    await persistEvent(tx, event);
-    return created;
-  });
-  void dispatchLifecycleEvent(config, event);
-  return { doc, event };
-}
-async function transitionWorkflow(args) {
-  const { config, collection, id, transitionName, expectedRevision, comment, user, req } = args;
-  const db = config.db;
-  const workflow = collection.workflow;
-  if (!db.transaction) throw new Error(`The configured database adapter does not support workflow transactions.`);
-  const original = await db.findOne({ collection: collection.slug, id });
-  if (!original) throw Object.assign(new Error("Not Found"), { statusCode: 404 });
-  const meta = original.__workflow;
-  if (!meta) throw Object.assign(new Error("Entry has no workflow metadata"), { statusCode: 409 });
-  if (expectedRevision !== void 0 && expectedRevision !== meta.revision) {
-    throw Object.assign(new Error("This entry changed since it was loaded. Refresh before transitioning it."), {
-      statusCode: 409
-    });
-  }
-  const transition = workflow.transitions.find((item) => item.name === transitionName);
-  const fromStates = transition ? Array.isArray(transition.from) ? transition.from : [transition.from] : [];
-  if (!transition || !fromStates.includes(meta.state)) {
-    throw Object.assign(new Error(`Transition "${transitionName}" is not valid from "${meta.state}".`), {
-      statusCode: 409
-    });
-  }
-  if (!availableWorkflowTransitions(workflow, meta.state, user).some((item) => item.name === transition.name)) {
-    throw Object.assign(new Error(`You do not have permission to perform "${transition.label}".`), { statusCode: 403 });
-  }
-  if (transition.requireComment && !comment?.trim()) {
-    throw Object.assign(new Error(`A comment is required for "${transition.label}".`), { statusCode: 400 });
-  }
-  const hookContext = { transition, from: meta.state, to: transition.to, doc: original, user, comment, req, db };
-  for (const hook of workflow.hooks?.beforeTransition ?? []) await hook(hookContext);
-  const events = [
-    createLifecycleEvent({
-      name: "workflow.transitioned",
-      collection: collection.slug,
-      documentId: id,
-      actorId: user?.sub,
-      payload: { transition: transition.name, from: meta.state, to: transition.to, revision: meta.revision, comment }
-    })
-  ];
-  const targetState = workflow.states.find((state) => state.name === transition.to);
-  if (targetState.published) {
-    events.push(
-      createLifecycleEvent({
-        name: "entry.published",
-        collection: collection.slug,
-        documentId: id,
-        actorId: user?.sub,
-        payload: { revision: meta.revision }
-      })
-    );
-  } else if (transition.unpublish) {
-    events.push(
-      createLifecycleEvent({
-        name: "entry.unpublished",
-        collection: collection.slug,
-        documentId: id,
-        actorId: user?.sub,
-        payload: { revision: meta.publishedRevision }
-      })
-    );
-  }
-  const updated = await db.transaction(async (tx) => {
-    const locked = await tx.findOne({ collection: collection.slug, id });
-    if (!locked) throw Object.assign(new Error("Not Found"), { statusCode: 404 });
-    const lockedMeta = locked.__workflow;
-    if (lockedMeta.revision !== meta.revision || lockedMeta.state !== meta.state || expectedRevision !== void 0 && lockedMeta.revision !== expectedRevision) {
-      throw Object.assign(new Error("This entry changed since it was loaded. Refresh before transitioning it."), {
-        statusCode: 409
-      });
-    }
-    const now2 = (/* @__PURE__ */ new Date()).toISOString();
-    const { __published: _published, __workflow: _workflow, id: _id, ...working } = locked;
-    const nextMeta = {
-      ...lockedMeta,
-      state: transition.to,
-      ...targetState.published ? { publishedRevision: lockedMeta.revision, publishedAt: now2, publishedBy: user?.sub } : {},
-      ...transition.unpublish ? { publishedRevision: void 0, publishedAt: void 0, publishedBy: void 0 } : {}
-    };
-    const data = { __workflow: nextMeta };
-    if (targetState.published) data.__published = working;
-    if (transition.unpublish) data.__published = null;
-    const next = await tx.update({ collection: collection.slug, id, data });
-    await tx.create({
-      collection: WORKFLOW_HISTORY_COLLECTION,
-      data: {
-        collection: collection.slug,
-        documentId: id,
-        transition: transition.name,
-        from: lockedMeta.state,
-        to: transition.to,
-        revision: lockedMeta.revision,
-        comment: comment ?? null,
-        actorId: user?.sub ?? null,
-        createdAt: now2
-      }
-    });
-    for (const event of events) await persistEvent(tx, event);
-    if (collection.audit) {
-      await tx.create({
-        collection: "__audit",
-        data: {
-          collection: collection.slug,
-          documentId: id,
-          operation: "workflow.transition",
-          user: user?.sub ?? null,
-          timestamp: now2,
-          changes: JSON.stringify({
-            transition: transition.name,
-            from: lockedMeta.state,
-            to: transition.to,
-            revision: lockedMeta.revision
-          })
-        }
-      });
-    }
-    return next;
-  });
-  for (const event of events) void dispatchLifecycleEvent(config, event);
-  for (const hook of workflow.hooks?.afterTransition ?? []) {
-    try {
-      await hook({ ...hookContext, doc: updated, event: events[0] });
-    } catch (error) {
-      try {
-        const { getConfigLogger: getConfigLogger2, getObservabilityRuntime } = await import("./observability-KCMTV7GO.js");
-        getObservabilityRuntime(config)?.recordWorkflowHookFailure({
-          collection: collection.slug,
-          transition: transition.name
-        });
-        getConfigLogger2(config, "workflow").error({
-          err: error,
-          msg: "afterTransition hook failed",
-          collection: collection.slug,
-          transition: transition.name,
-          documentId: id
-        });
-      } catch {
-        console.error("afterTransition hook failed:", error);
-      }
-    }
-  }
-  return updated;
-}
-
-// src/utils/admin-auth.ts
-function getAdminAuthCollection(config) {
-  const adminCollection = resolveAdminAuthCollection(config.collections, config.adminAuth?.collectionSlug);
-  return adminCollection ?? null;
-}
-function resolveAdminAuthCollection(collections, collectionSlug) {
-  const adminsCollection = collections.find((collection) => collection.slug === "__admins");
-  if (adminsCollection) return adminsCollection;
-  if (collectionSlug) {
-    const requestedCollection = collections.find((collection) => collection.slug === collectionSlug);
-    if (requestedCollection) return requestedCollection;
-  }
-  return collections.find((collection) => collection.auth);
-}
-function getPublicAdminAuthConfig(adminAuth, collections) {
-  const providers = (adminAuth?.providers ?? []).map((provider) => ({
-    id: provider.id,
-    type: provider.type,
-    displayName: provider.displayName || humanizeProviderName(provider.id, provider.type),
-    autoRedirect: provider.autoRedirect
-  }));
-  const resolvedCollectionSlug = collections ? resolveAdminAuthCollection(collections, adminAuth?.collectionSlug)?.slug : adminAuth?.collectionSlug;
-  return {
-    mode: adminAuth?.mode ?? "local",
-    collectionSlug: resolvedCollectionSlug,
-    provisioningMode: adminAuth?.provisioningMode,
-    providers
-  };
-}
-function humanizeProviderName(id, type) {
-  const cleaned = id.replace(/[-_]+/g, " ").trim();
-  if (!cleaned) return type.toUpperCase();
-  return cleaned.replace(/\b\w/g, (char) => char.toUpperCase());
-}
-
-// src/utils/jexl-helpers.ts
-import jexl from "jexl";
-function slugify(val) {
-  if (val === void 0 || val === null) return "";
-  return String(val).normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/[^a-z0-9\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
-}
-function lower(val) {
-  if (val === void 0 || val === null) return "";
-  return String(val).toLowerCase();
-}
-function upper(val) {
-  if (val === void 0 || val === null) return "";
-  return String(val).toUpperCase();
-}
-function trim(val) {
-  if (val === void 0 || val === null) return "";
-  return String(val).trim();
-}
-function capitalize(val) {
-  if (val === void 0 || val === null) return "";
-  const str = String(val).trim();
-  if (!str) return "";
-  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
-}
-function truncate(val, length2, ellipsis = "...") {
-  if (val === void 0 || val === null) return "";
-  const str = String(val);
-  const maxLen = typeof length2 === "number" && length2 > 0 ? length2 : 100;
-  if (str.length <= maxLen) return str;
-  return str.slice(0, maxLen).trim() + String(ellipsis ?? "...");
-}
-function readingTime(val, wpm = 200) {
-  if (val === void 0 || val === null) return 1;
-  const str = String(val).trim();
-  if (!str) return 1;
-  const words = str.split(/\s+/).filter(Boolean).length;
-  return Math.max(1, Math.ceil(words / (typeof wpm === "number" && wpm > 0 ? wpm : 200)));
-}
-function wordCount(val) {
-  if (val === void 0 || val === null) return 0;
-  const str = String(val).trim();
-  if (!str) return 0;
-  return str.split(/\s+/).filter(Boolean).length;
-}
-function replace(val, search, replacement) {
-  if (val === void 0 || val === null) return "";
-  return String(val).replace(new RegExp(String(search || ""), "g"), String(replacement ?? ""));
-}
-function startsWith(str, prefix) {
-  if (str === void 0 || str === null) return false;
-  return String(str).startsWith(String(prefix ?? ""));
-}
-function endsWith(str, suffix) {
-  if (str === void 0 || str === null) return false;
-  return String(str).endsWith(String(suffix ?? ""));
-}
-function now() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-function today() {
-  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-}
-function formatDate(val, style = "short") {
-  if (!val) return "";
-  const d = new Date(val);
-  if (Number.isNaN(d.getTime())) return "";
-  const styleStr = String(style).toLowerCase();
-  if (styleStr === "iso" || styleStr === "date") return d.toISOString().slice(0, 10);
-  if (styleStr === "datetime" || styleStr === "full") return d.toISOString();
-  return d.toLocaleDateString("en-US", {
-    year: "numeric",
-    month: "short",
-    day: "numeric"
-  });
-}
-function addDays(val, days) {
-  const d = val ? new Date(val) : /* @__PURE__ */ new Date();
-  if (Number.isNaN(d.getTime())) return "";
-  const daysNum = typeof days === "number" ? days : Number(days) || 0;
-  d.setDate(d.getDate() + daysNum);
-  return d.toISOString();
-}
-function diffDays(dateA, dateB) {
-  const dA = dateA ? new Date(dateA) : /* @__PURE__ */ new Date();
-  const dB = dateB ? new Date(dateB) : /* @__PURE__ */ new Date();
-  if (Number.isNaN(dA.getTime()) || Number.isNaN(dB.getTime())) return 0;
-  const diffMs = Math.abs(dA.getTime() - dB.getTime());
-  return Math.floor(diffMs / (1e3 * 60 * 60 * 24));
-}
-function isPast(val) {
-  if (!val) return false;
-  const d = new Date(val);
-  if (Number.isNaN(d.getTime())) return false;
-  return d.getTime() < Date.now();
-}
-function isFuture(val) {
-  if (!val) return false;
-  const d = new Date(val);
-  if (Number.isNaN(d.getTime())) return false;
-  return d.getTime() > Date.now();
-}
-function includes(arrOrStr, item) {
-  if (Array.isArray(arrOrStr)) {
-    return arrOrStr.includes(item);
-  }
-  if (typeof arrOrStr === "string") {
-    return arrOrStr.includes(String(item ?? ""));
-  }
-  return false;
-}
-function join(arr, separator = ", ") {
-  if (!Array.isArray(arr)) return "";
-  return arr.filter((item) => item !== void 0 && item !== null).join(String(separator));
-}
-function first(arr) {
-  if (Array.isArray(arr)) return arr[0] ?? null;
-  return null;
-}
-function last(arr) {
-  if (Array.isArray(arr)) return arr[arr.length - 1] ?? null;
-  return null;
-}
-function compact(arr) {
-  if (!Array.isArray(arr)) return [];
-  return arr.filter((item) => item !== void 0 && item !== null && item !== "");
-}
-function unique(arr) {
-  if (!Array.isArray(arr)) return [];
-  return Array.from(new Set(arr));
-}
-function length(val) {
-  if (Array.isArray(val) || typeof val === "string") return val.length;
-  if (val && typeof val === "object") return Object.keys(val).length;
-  return 0;
-}
-function round(val, decimals = 0) {
-  const num = Number(val);
-  if (Number.isNaN(num)) return 0;
-  const dec = typeof decimals === "number" ? decimals : Number(decimals) || 0;
-  const factor = Math.pow(10, dec);
-  return Math.round(num * factor) / factor;
-}
-function clamp(val, minVal, maxVal) {
-  const num = Number(val) || 0;
-  const min = Number(minVal) || 0;
-  const max = Number(maxVal) || 0;
-  return Math.min(Math.max(num, min), max);
-}
-function defaultValue(val, fallback) {
-  if (val === void 0 || val === null || val === "") return fallback;
-  return val;
-}
-function coalesce(...args) {
-  for (const arg of args) {
-    if (arg !== void 0 && arg !== null && arg !== "") return arg;
-  }
-  return null;
-}
-function isEmpty(val) {
-  if (val === void 0 || val === null || val === "") return true;
-  if (Array.isArray(val)) return val.length === 0;
-  if (typeof val === "object") return Object.keys(val).length === 0;
-  return false;
-}
-function get(obj, path, fallback = null) {
-  if (!obj || typeof obj !== "object") return fallback;
-  const pathStr = String(path || "").trim();
-  if (!pathStr) return fallback;
-  const parts = pathStr.split(".");
-  let curr = obj;
-  for (const part of parts) {
-    if (curr === void 0 || curr === null) return fallback;
-    curr = curr[part];
-  }
-  return curr === void 0 || curr === null ? fallback : curr;
-}
-function registerJexlHelpers(jexlInstance = jexl) {
-  const helpers = {
-    // Strings
-    slugify,
-    lower,
-    upper,
-    trim,
-    capitalize,
-    truncate,
-    readingTime,
-    wordCount,
-    replace,
-    startsWith,
-    endsWith,
-    // Dates
-    now,
-    today,
-    formatDate,
-    addDays,
-    diffDays,
-    isPast,
-    isFuture,
-    // Arrays
-    includes,
-    join,
-    first,
-    last,
-    compact,
-    unique,
-    length,
-    // Math
-    round,
-    clamp,
-    // Objects & Logical
-    default: defaultValue,
-    coalesce,
-    isEmpty,
-    get
-  };
-  for (const [name, fn] of Object.entries(helpers)) {
-    try {
-      jexlInstance.addFunction(name, fn);
-    } catch {
-    }
-  }
-}
-registerJexlHelpers(jexl);
-var BUILTIN_JEXL_HELPERS = [
-  // Strings
-  "slugify",
-  "lower",
-  "upper",
-  "trim",
-  "capitalize",
-  "truncate",
-  "readingTime",
-  "wordCount",
-  "replace",
-  "startsWith",
-  "endsWith",
-  // Dates
-  "now",
-  "today",
-  "formatDate",
-  "addDays",
-  "diffDays",
-  "isPast",
-  "isFuture",
-  // Arrays
-  "includes",
-  "join",
-  "first",
-  "last",
-  "compact",
-  "unique",
-  "length",
-  // Math
-  "round",
-  "clamp",
-  // Objects & Logical
-  "default",
-  "coalesce",
-  "isEmpty",
-  "get"
-];
-
-// src/utils/declarative-hooks.ts
-import jexl2 from "jexl";
-registerJexlHelpers(jexl2);
-var SURFACE_ROOTS = {
-  "collection.beforeRead": ["req", "user", "query", ...BUILTIN_JEXL_HELPERS],
-  "collection.afterRead": ["req", "user", "doc", ...BUILTIN_JEXL_HELPERS],
-  "collection.beforeChange": ["req", "user", "data", "doc", "operation", ...BUILTIN_JEXL_HELPERS],
-  "global.beforeRead": ["req", "user", "query", ...BUILTIN_JEXL_HELPERS],
-  "global.afterRead": ["req", "user", "doc", ...BUILTIN_JEXL_HELPERS],
-  "global.beforeChange": ["req", "user", "data", "doc", "operation", ...BUILTIN_JEXL_HELPERS],
-  "field.beforeChange": ["value", "data", "originalDoc", "user", ...BUILTIN_JEXL_HELPERS],
-  "field.admin.onChange": ["value", "siblingData", "data", ...BUILTIN_JEXL_HELPERS]
-};
-var ACCESS_ROOTS = ["user", "req", "doc", "data", "id", "config", ...BUILTIN_JEXL_HELPERS];
-var ADMIN_CONDITION_RESERVED_ROOTS = ["data", "siblingData", "user", "id", ...BUILTIN_JEXL_HELPERS];
-var PREVIEW_URL_RESERVED_ROOTS = ["siteUrl", "id", ...BUILTIN_JEXL_HELPERS];
-var COMPILE_CACHE = /* @__PURE__ */ new Map();
-function compileExpression(expression) {
-  const cached = COMPILE_CACHE.get(expression);
-  if (cached) return cached;
-  const compiled = jexl2.compile(expression);
-  const next = { ast: compiled._ast };
-  COMPILE_CACHE.set(expression, next);
-  return next;
-}
-function isPlainObject(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function quoteSegment(value) {
-  return `["${value.replace(/"/g, '\\"')}"]`;
-}
-function fieldSegment(field, index) {
-  return typeof field.name === "string" && field.name.length > 0 ? `fields${quoteSegment(field.name)}` : `fields[${index}]`;
-}
-function blockSegment(block, index) {
-  return typeof block.slug === "string" && block.slug.length > 0 ? `blocks${quoteSegment(block.slug)}` : `blocks[${index}]`;
-}
-function collectionSegment(collection, index) {
-  return typeof collection.slug === "string" && collection.slug.length > 0 ? `collections${quoteSegment(collection.slug)}` : `collections[${index}]`;
-}
-function globalSegment(global, index) {
-  return typeof global.slug === "string" && global.slug.length > 0 ? `globals${quoteSegment(global.slug)}` : `globals[${index}]`;
-}
-function colorize(value, code, enabled) {
-  return enabled ? `\x1B[${code}m${value}\x1B[0m` : value;
-}
-function collectRootIdentifiers(node, roots, seen) {
-  if (!node || typeof node !== "object" || seen.has(node)) return;
-  seen.add(node);
-  const candidate = node;
-  if (candidate.type === "Identifier") {
-    if (candidate.from) {
-      collectRootIdentifiers(candidate.from, roots, seen);
-      return;
-    }
-    if (typeof candidate.value === "string" && candidate.value !== "null") {
-      roots.add(candidate.value);
-    }
-    return;
-  }
-  if (Array.isArray(node)) {
-    for (const entry of node) collectRootIdentifiers(entry, roots, seen);
-    return;
-  }
-  for (const value of Object.values(node)) {
-    if (Array.isArray(value)) {
-      for (const entry of value) collectRootIdentifiers(entry, roots, seen);
-      continue;
-    }
-    if (value && typeof value === "object") {
-      collectRootIdentifiers(value, roots, seen);
-    }
-  }
-}
-function getInvalidRoots(expression, allowedRoots) {
-  const { ast } = compileExpression(expression);
-  const roots = /* @__PURE__ */ new Set();
-  collectRootIdentifiers(ast, roots, /* @__PURE__ */ new Set());
-  const allowed = new Set(allowedRoots);
-  return [...roots].filter((root) => !allowed.has(root));
-}
-function validateDeclarativeHookExpression(expression, surface, path) {
-  try {
-    const invalidRoots = getInvalidRoots(expression, SURFACE_ROOTS[surface]);
-    if (invalidRoots.length === 0) return [];
-    return [
-      {
-        path,
-        surface,
-        expression,
-        message: `uses unsupported context ${invalidRoots.map((root) => `"${root}"`).join(", ")}. Allowed context: ${SURFACE_ROOTS[surface].map((root) => `"${root}"`).join(", ")}`
-      }
-    ];
-  } catch (error) {
-    return [
-      {
-        path,
-        surface,
-        expression,
-        message: `has invalid syntax: ${error.message}`
-      }
-    ];
-  }
-}
-function validateDeclarativeAccessExpression(expression, surface, path) {
-  try {
-    const invalidRoots = getInvalidRoots(expression, ACCESS_ROOTS);
-    if (invalidRoots.length === 0) return [];
-    return [
-      {
-        path,
-        surface,
-        expression,
-        message: `uses unsupported context ${invalidRoots.map((root) => `"${root}"`).join(", ")}. Allowed context: ${ACCESS_ROOTS.map((root) => `"${root}"`).join(", ")}`
-      }
-    ];
-  } catch (error) {
-    return [
-      {
-        path,
-        surface,
-        expression,
-        message: `has invalid syntax: ${error.message}`
-      }
-    ];
-  }
-}
-function validateAdminConditionExpression(expression, path, allowedRoots) {
-  try {
-    const invalidRoots = getInvalidRoots(expression, allowedRoots);
-    if (invalidRoots.length === 0) return [];
-    return [
-      {
-        path,
-        surface: "field.admin.condition",
-        expression,
-        message: `uses unsupported context ${invalidRoots.map((root) => `"${root}"`).join(", ")}. Allowed context: ${allowedRoots.map((root) => `"${root}"`).join(", ")}`
-      }
-    ];
-  } catch (error) {
-    return [
-      {
-        path,
-        surface: "field.admin.condition",
-        expression,
-        message: `has invalid syntax: ${error.message}`
-      }
-    ];
-  }
-}
-function validatePreviewUrlExpression(expression, path, allowedRoots) {
-  try {
-    const invalidRoots = getInvalidRoots(expression, allowedRoots);
-    if (invalidRoots.length === 0) return [];
-    return [
-      {
-        path,
-        surface: "collection.admin.previewUrl",
-        expression,
-        message: `uses unsupported context ${invalidRoots.map((root) => `"${root}"`).join(", ")}. Allowed context: ${allowedRoots.map((root) => `"${root}"`).join(", ")}`
-      }
-    ];
-  } catch (error) {
-    return [
-      {
-        path,
-        surface: "collection.admin.previewUrl",
-        expression,
-        message: `has invalid syntax: ${error.message}`
-      }
-    ];
-  }
-}
-function assertValidDeclarativeHookExpression(expression, surface, path) {
-  const issues = validateDeclarativeHookExpression(expression, surface, path);
-  if (issues.length === 0) return;
-  throw new Error(`Invalid declarative hook at ${path}: ${issues[0].message}`);
-}
-function assertValidDeclarativeHookResult(result, surface, path) {
-  if (isPlainObject(result)) return;
-  throw new Error(`Invalid declarative hook result at ${path}: ${surface} expressions must return an object`);
-}
-function collectFieldIssues(fields, path, issues) {
-  fields.forEach((field, index) => {
-    const fieldPath = `${path}.${fieldSegment(field, index)}`;
-    field.hooks?.beforeChange?.forEach((hook, hookIndex) => {
-      if (typeof hook !== "string") return;
-      issues.push(
-        ...validateDeclarativeHookExpression(
-          hook,
-          "field.beforeChange",
-          `${fieldPath}.hooks.beforeChange[${hookIndex}]`
-        )
-      );
-    });
-    field.hooks?.afterRead?.forEach((hook, hookIndex) => {
-      if (typeof hook !== "string") return;
-      issues.push({
-        path: `${fieldPath}.hooks.afterRead[${hookIndex}]`,
-        surface: "unsupported",
-        expression: hook,
-        message: "declarative strings are not supported on field hooks.afterRead"
-      });
-    });
-    if (typeof field.admin?.hooks?.onChange === "string") {
-      issues.push(
-        ...validateDeclarativeHookExpression(
-          field.admin.hooks.onChange,
-          "field.admin.onChange",
-          `${fieldPath}.admin.hooks.onChange`
-        )
-      );
-    }
-    if (typeof field.admin?.hooks?.options === "string") {
-      issues.push({
-        path: `${fieldPath}.admin.hooks.options`,
-        surface: "unsupported",
-        expression: field.admin.hooks.options,
-        message: "declarative strings are not supported on field admin.hooks.options"
-      });
-    }
-    if (Array.isArray(field.fields)) {
-      collectFieldIssues(field.fields, fieldPath, issues);
-    }
-    if (Array.isArray(field.blocks)) {
-      field.blocks.forEach((block, blockIndex) => {
-        if (!Array.isArray(block.fields)) return;
-        collectFieldIssues(block.fields, `${fieldPath}.${blockSegment(block, blockIndex)}`, issues);
-      });
-    }
-  });
-}
-function collectFieldNames(fields) {
-  return fields.flatMap(
-    (field) => typeof field.name === "string" && field.name.length > 0 ? [field.name] : []
-  );
-}
-function collectAdminConditionIssues(fields, path, rootFieldNames, issues) {
-  const scopeFieldNames = collectFieldNames(fields);
-  const allowedRoots = [.../* @__PURE__ */ new Set([...ADMIN_CONDITION_RESERVED_ROOTS, ...rootFieldNames, ...scopeFieldNames])];
-  fields.forEach((field, index) => {
-    const fieldPath = `${path}.${fieldSegment(field, index)}`;
-    if (typeof field.admin?.condition === "string") {
-      issues.push(
-        ...validateAdminConditionExpression(
-          field.admin.condition,
-          `${fieldPath}.admin.condition`,
-          allowedRoots
-        )
-      );
-    }
-    if (Array.isArray(field.fields)) {
-      collectAdminConditionIssues(field.fields, fieldPath, rootFieldNames, issues);
-    }
-    if (Array.isArray(field.blocks)) {
-      field.blocks.forEach((block, blockIndex) => {
-        if (!Array.isArray(block.fields)) return;
-        collectAdminConditionIssues(
-          block.fields,
-          `${fieldPath}.${blockSegment(block, blockIndex)}`,
-          rootFieldNames,
-          issues
-        );
-      });
-    }
-  });
-}
-function collectFieldAccessIssues(fields, path, issues) {
-  fields.forEach((field, index) => {
-    const fieldPath = `${path}.${fieldSegment(field, index)}`;
-    if (typeof field.access?.read === "string") {
-      issues.push(...validateDeclarativeAccessExpression(field.access.read, "field.access", `${fieldPath}.access.read`));
-    }
-    if (typeof field.access?.create === "string") {
-      issues.push(
-        ...validateDeclarativeAccessExpression(field.access.create, "field.access", `${fieldPath}.access.create`)
-      );
-    }
-    if (typeof field.access?.update === "string") {
-      issues.push(
-        ...validateDeclarativeAccessExpression(field.access.update, "field.access", `${fieldPath}.access.update`)
-      );
-    }
-    if (Array.isArray(field.fields)) {
-      collectFieldAccessIssues(field.fields, fieldPath, issues);
-    }
-    if (Array.isArray(field.blocks)) {
-      field.blocks.forEach((block, blockIndex) => {
-        if (!Array.isArray(block.fields)) return;
-        collectFieldAccessIssues(
-          block.fields,
-          `${fieldPath}.${blockSegment(block, blockIndex)}`,
-          issues
-        );
-      });
-    }
-  });
-}
-function collectHookIssues(hooks, scope, path, issues) {
-  if (!hooks) return;
-  const supported = {
-    beforeRead: `${scope}.beforeRead`,
-    afterRead: `${scope}.afterRead`,
-    beforeChange: `${scope}.beforeChange`
-  };
-  for (const [key, value] of Object.entries(hooks)) {
-    if (!Array.isArray(value)) continue;
-    value.forEach((hook, index) => {
-      if (typeof hook !== "string") return;
-      const surface = supported[key];
-      if (!surface) {
-        issues.push({
-          path: `${path}.${key}[${index}]`,
-          surface: "unsupported",
-          expression: hook,
-          message: `declarative strings are not supported on ${scope} hooks.${key}`
-        });
-        return;
-      }
-      issues.push(...validateDeclarativeHookExpression(hook, surface, `${path}.${key}[${index}]`));
-    });
-  }
-}
-function collectDeclarativeHookValidationIssues(config) {
-  const issues = [];
-  config.blocks?.forEach((block, blockIndex) => {
-    if (!Array.isArray(block.fields)) return;
-    collectFieldIssues(
-      block.fields,
-      blockSegment(block, blockIndex),
-      issues
-    );
-  });
-  config.collections.forEach((collection, collectionIndex) => {
-    const collectionPath = collectionSegment(collection, collectionIndex);
-    collectHookIssues(
-      collection.hooks,
-      "collection",
-      `${collectionPath}.hooks`,
-      issues
-    );
-    collectFieldIssues(collection.fields, collectionPath, issues);
-  });
-  config.globals?.forEach((global, globalIndex) => {
-    const globalPath = globalSegment(global, globalIndex);
-    collectHookIssues(
-      global.hooks,
-      "global",
-      `${globalPath}.hooks`,
-      issues
-    );
-    collectFieldIssues(global.fields, globalPath, issues);
-  });
-  return issues;
-}
-function collectDeclarativeAccessValidationIssues(config) {
-  const issues = [];
-  Object.entries(config.accessPolicies ?? {}).forEach(([name, value]) => {
-    if (typeof value !== "string") return;
-    issues.push(
-      ...validateDeclarativeAccessExpression(value, "config.accessPolicy", `accessPolicies.${name}`)
-    );
-  });
-  config.blocks?.forEach((block, blockIndex) => {
-    if (!Array.isArray(block.fields)) return;
-    collectFieldAccessIssues(
-      block.fields,
-      blockSegment(block, blockIndex),
-      issues
-    );
-  });
-  config.collections.forEach((collection, collectionIndex) => {
-    const collectionPath = collectionSegment(collection, collectionIndex);
-    if (typeof collection.access?.read === "string") {
-      issues.push(
-        ...validateDeclarativeAccessExpression(
-          collection.access.read,
-          "collection.access",
-          `${collectionPath}.access.read`
-        )
-      );
-    }
-    if (typeof collection.access?.create === "string") {
-      issues.push(
-        ...validateDeclarativeAccessExpression(
-          collection.access.create,
-          "collection.access",
-          `${collectionPath}.access.create`
-        )
-      );
-    }
-    if (typeof collection.access?.update === "string") {
-      issues.push(
-        ...validateDeclarativeAccessExpression(
-          collection.access.update,
-          "collection.access",
-          `${collectionPath}.access.update`
-        )
-      );
-    }
-    if (typeof collection.access?.delete === "string") {
-      issues.push(
-        ...validateDeclarativeAccessExpression(
-          collection.access.delete,
-          "collection.access",
-          `${collectionPath}.access.delete`
-        )
-      );
-    }
-    if (typeof collection.access?.readAudit === "string") {
-      issues.push(
-        ...validateDeclarativeAccessExpression(
-          collection.access.readAudit,
-          "collection.access",
-          `${collectionPath}.access.readAudit`
-        )
-      );
-    }
-    collectFieldAccessIssues(collection.fields, collectionPath, issues);
-  });
-  config.globals?.forEach((global, globalIndex) => {
-    const globalPath = globalSegment(global, globalIndex);
-    if (typeof global.access?.read === "string") {
-      issues.push(
-        ...validateDeclarativeAccessExpression(global.access.read, "global.access", `${globalPath}.access.read`)
-      );
-    }
-    if (typeof global.access?.update === "string") {
-      issues.push(
-        ...validateDeclarativeAccessExpression(
-          global.access.update,
-          "global.access",
-          `${globalPath}.access.update`
-        )
-      );
-    }
-    collectFieldAccessIssues(global.fields, globalPath, issues);
-  });
-  return issues;
-}
-function collectAdminConditionValidationIssues(config) {
-  const issues = [];
-  config.blocks?.forEach((block, blockIndex) => {
-    if (!Array.isArray(block.fields)) return;
-    collectAdminConditionIssues(
-      block.fields,
-      blockSegment(block, blockIndex),
-      collectFieldNames(block.fields),
-      issues
-    );
-  });
-  config.collections.forEach((collection, collectionIndex) => {
-    const collectionPath = collectionSegment(collection, collectionIndex);
-    const rootFieldNames = collectFieldNames(collection.fields);
-    collectAdminConditionIssues(collection.fields, collectionPath, rootFieldNames, issues);
-  });
-  config.globals?.forEach((global, globalIndex) => {
-    const globalPath = globalSegment(global, globalIndex);
-    const rootFieldNames = collectFieldNames(global.fields);
-    collectAdminConditionIssues(global.fields, globalPath, rootFieldNames, issues);
-  });
-  return issues;
-}
-function collectPreviewUrlValidationIssues(config) {
-  const issues = [];
-  config.collections.forEach((collection, collectionIndex) => {
-    if (typeof collection.admin?.previewUrl !== "string") return;
-    const collectionPath = collectionSegment(collection, collectionIndex);
-    const allowedRoots = [
-      .../* @__PURE__ */ new Set([...PREVIEW_URL_RESERVED_ROOTS, ...collectFieldNames(collection.fields)])
-    ];
-    issues.push(
-      ...validatePreviewUrlExpression(
-        collection.admin.previewUrl,
-        `${collectionPath}.admin.previewUrl`,
-        allowedRoots
-      )
-    );
-  });
-  return issues;
-}
-function assertValidAdminConditionsInConfig(config, source = "config") {
-  const diagnostics = collectAdminConditionValidationIssues(config).map((issue) => ({
-    severity: "error",
-    source: "adminCondition",
-    path: issue.path,
-    surface: issue.surface,
-    message: issue.message,
-    expression: issue.expression
-  }));
-  if (diagnostics.length === 0) return;
-  throw new ConfigValidationError(source, diagnostics);
-}
-function assertValidPreviewUrlsInConfig(config, source = "config") {
-  const diagnostics = collectPreviewUrlValidationIssues(config).map((issue) => ({
-    severity: "error",
-    source: "previewUrl",
-    path: issue.path,
-    surface: issue.surface,
-    message: issue.message,
-    expression: issue.expression
-  }));
-  if (diagnostics.length === 0) return;
-  throw new ConfigValidationError(source, diagnostics);
-}
-function collectConfigDiagnostics(config) {
-  const hookIssues = collectDeclarativeHookValidationIssues(config).map((issue) => ({
-    severity: "error",
-    source: "declarativeHook",
-    path: issue.path,
-    surface: issue.surface,
-    message: issue.message,
-    expression: issue.expression
-  }));
-  const accessIssues = collectDeclarativeAccessValidationIssues(config).map((issue) => ({
-    severity: "error",
-    source: "declarativeAccess",
-    path: issue.path,
-    surface: issue.surface,
-    message: issue.message,
-    expression: issue.expression
-  }));
-  const adminConditionIssues = collectAdminConditionValidationIssues(config).map((issue) => ({
-    severity: "error",
-    source: "adminCondition",
-    path: issue.path,
-    surface: issue.surface,
-    message: issue.message,
-    expression: issue.expression
-  }));
-  const previewUrlIssues = collectPreviewUrlValidationIssues(config).map((issue) => ({
-    severity: "error",
-    source: "previewUrl",
-    path: issue.path,
-    surface: issue.surface,
-    message: issue.message,
-    expression: issue.expression
-  }));
-  return [...hookIssues, ...accessIssues, ...adminConditionIssues, ...previewUrlIssues];
-}
-function formatConfigDiagnostics(source, diagnostics, options = {}) {
-  const color = options.color ?? false;
-  const header = `${colorize("Config validation failed", 31, color)} in ${colorize(source, 36, color)}`;
-  const docLink = `${colorize("   Learn how to write declarative rules:", 90, color)} ${colorize("https://docs.dyrected.com/docs/features/admin/form-and-field-hooks", 34, color)}`;
-  const lines = diagnostics.flatMap((issue, index) => [
-    `${colorize(`${index + 1}.`, 31, color)} ${colorize(issue.path, 1, color)}`,
-    `   ${issue.message}`,
-    `   ${colorize("surface:", 90, color)} ${issue.surface}`
-  ]);
-  return `${header}
-${lines.join("\n")}
-
-${docLink}`;
-}
-var ConfigValidationError = class extends Error {
-  diagnostics;
-  source;
-  constructor(source, diagnostics) {
-    super(formatConfigDiagnostics(source, diagnostics));
-    this.name = "ConfigValidationError";
-    this.source = source;
-    this.diagnostics = diagnostics;
-  }
-};
-function isConfigValidationError(error) {
-  return error instanceof ConfigValidationError;
-}
-function assertValidDeclarativeHooksInConfig(config, source = "config") {
-  const diagnostics = collectDeclarativeHookValidationIssues(config).map((issue) => ({
-    severity: "error",
-    source: "declarativeHook",
-    path: issue.path,
-    surface: issue.surface,
-    message: issue.message,
-    expression: issue.expression
-  }));
-  if (diagnostics.length === 0) return;
-  throw new ConfigValidationError(source, diagnostics);
-}
-function assertValidDeclarativeAccessInConfig(config, source = "config") {
-  const diagnostics = collectDeclarativeAccessValidationIssues(config).map((issue) => ({
-    severity: "error",
-    source: "declarativeAccess",
-    path: issue.path,
-    surface: issue.surface,
-    message: issue.message,
-    expression: issue.expression
-  }));
-  if (diagnostics.length === 0) return;
-  throw new ConfigValidationError(source, diagnostics);
-}
-
-// src/auth/token.ts
-import { SignJWT, jwtVerify, decodeJwt } from "jose";
-import { TextEncoder } from "util";
-function getSecret() {
-  const secret = process.env.DYRECTED_JWT_SECRET;
-  if (!secret) {
-    throw new Error(
-      "[dyrected/core] DYRECTED_JWT_SECRET is not set. Add it to your environment variables to enable auth collections."
-    );
-  }
-  return new TextEncoder().encode(secret);
-}
-var DEFAULT_EXPIRY = "7d";
-async function signCollectionToken(payload, expiresIn = DEFAULT_EXPIRY) {
-  return new SignJWT({ ...payload }).setProtectedHeader({ alg: "HS256" }).setIssuedAt().setExpirationTime(expiresIn).sign(getSecret());
-}
-async function verifyCollectionToken(token) {
-  const { payload } = await jwtVerify(token, getSecret());
-  return payload;
-}
-function decodeCollectionToken(token) {
-  try {
-    return decodeJwt(token);
-  } catch {
-    return null;
-  }
-}
-
-// src/auth/sessions.ts
-var AUTH_SESSIONS_COLLECTION = "__auth_sessions";
-async function issueAuthSessionToken(args) {
-  const sessionId = createSessionId();
-  const now2 = (/* @__PURE__ */ new Date()).toISOString();
-  const db = args.config.db;
-  if (db) {
-    await db.create({
-      collection: AUTH_SESSIONS_COLLECTION,
-      data: {
-        id: sessionId,
-        userId: args.userId,
-        email: args.email,
-        collection: args.collection,
-        authSource: args.authSource ?? "local",
-        providerId: args.providerId,
-        lastIp: args.ip,
-        lastSeenAt: now2,
-        revokedAt: null,
-        expiresAt: null
-      }
-    });
-  }
-  const token = await signCollectionToken(
-    {
-      sub: args.userId,
-      email: args.email,
-      collection: args.collection,
-      authSource: args.authSource,
-      providerId: args.providerId,
-      sid: sessionId
-    },
-    args.expiresIn
-  );
-  const payload = decodeCollectionToken(token);
-  const expiresAt = payload?.exp != null ? new Date(payload.exp * 1e3).toISOString() : null;
-  if (db && expiresAt) {
-    await db.update({
-      collection: AUTH_SESSIONS_COLLECTION,
-      id: sessionId,
-      data: {
-        expiresAt,
-        lastSeenAt: now2,
-        lastIp: args.ip
-      }
-    });
-  }
-  return token;
-}
-async function getAuthSession(config, sessionId) {
-  const db = config.db;
-  if (!db) return null;
-  return await db.findOne({
-    collection: AUTH_SESSIONS_COLLECTION,
-    id: sessionId
-  });
-}
-function isAuthSessionActive(session) {
-  if (!session) return false;
-  if (session.revokedAt) return false;
-  if (session.expiresAt && new Date(session.expiresAt).getTime() <= Date.now()) {
-    return false;
-  }
-  return true;
-}
-async function touchAuthSession(config, sessionId, args) {
-  const db = config.db;
-  if (!db) return;
-  await db.update({
-    collection: AUTH_SESSIONS_COLLECTION,
-    id: sessionId,
-    data: {
-      lastSeenAt: (/* @__PURE__ */ new Date()).toISOString(),
-      ...args.ip ? { lastIp: args.ip } : {}
-    }
-  });
-}
-async function revokeAuthSession(config, sessionId) {
-  const db = config.db;
-  if (!db) return;
-  await db.update({
-    collection: AUTH_SESSIONS_COLLECTION,
-    id: sessionId,
-    data: {
-      revokedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }
-  });
-}
-async function revokeAllAuthSessions(config, args) {
-  const db = config.db;
-  if (!db) return 0;
-  let page = 1;
-  let revoked = 0;
-  while (true) {
-    const result = await db.find({
-      collection: AUTH_SESSIONS_COLLECTION,
-      where: {
-        userId: { equals: args.userId },
-        collection: { equals: args.collection }
-      },
-      page,
-      limit: 100
-    });
-    for (const session of result.docs) {
-      if (session.revokedAt) continue;
-      await revokeAuthSession(config, session.id);
-      revoked += 1;
-    }
-    if (!result.hasNextPage) break;
-    page += 1;
-  }
-  return revoked;
-}
-function createSessionId() {
-  return globalThis.crypto?.randomUUID?.() ? globalThis.crypto.randomUUID() : `sess_${Date.now()}_${Math.random().toString(36).slice(2)}`;
-}
-
-// src/utils/block-references.ts
-function mergeUniqueBlocks(blocks) {
-  const seen = /* @__PURE__ */ new Map();
-  for (const block of blocks) {
-    const existing = seen.get(block.slug);
-    if (existing && existing !== block) {
-      throw new Error(
-        `Duplicate block slug "${block.slug}" found in the reusable block registry. Block slugs must be unique.`
-      );
-    }
-    if (!existing) seen.set(block.slug, block);
-  }
-  return Array.from(seen.values());
-}
-function buildRegistry(blocks) {
-  return new Map(blocks.map((block) => [block.slug, block]));
-}
-function resolveField(field, registry, blockCache) {
-  const next = { ...field };
-  if (next.fields) {
-    next.fields = next.fields.map(
-      (child) => resolveField(child, registry, blockCache)
-    );
-  }
-  if (next.type !== "blocks") return next;
-  const hasInlineBlocks = Array.isArray(next.blocks) && next.blocks.length > 0;
-  const hasReferences = Array.isArray(next.blockReferences) && next.blockReferences.length > 0;
-  if (hasInlineBlocks && hasReferences) {
-    throw new Error(
-      `Blocks field "${next.name ?? "(unnamed)"}" cannot define both "blocks" and "blockReferences". Use one or the other.`
-    );
-  }
-  if (hasReferences) {
-    next.blocks = next.blockReferences.map((slug) => {
-      const block = registry.get(slug);
-      if (!block) {
-        throw new Error(
-          `Unknown block reference "${slug}" on blocks field "${next.name ?? "(unnamed)"}". Add it to defineConfig({ blocks: [...] }).`
-        );
-      }
-      return resolveBlock(block, registry, blockCache);
-    });
-    return next;
-  }
-  if (hasInlineBlocks) {
-    next.blocks = next.blocks.map(
-      (block) => resolveBlock(block, registry, blockCache)
-    );
-  }
-  return next;
-}
-function resolveBlock(block, registry, blockCache) {
-  const cached = blockCache.get(block);
-  if (cached) return cached;
-  const resolved = {
-    ...block,
-    fields: []
-  };
-  blockCache.set(block, resolved);
-  resolved.fields = block.fields.map(
-    (field) => resolveField(field, registry, blockCache)
-  );
-  return resolved;
-}
-function resolveFields(fields, registry, blockCache) {
-  return fields.map((field) => resolveField(field, registry, blockCache));
-}
-function normalizeSchemaFragment(fragment) {
-  const reusableBlocks = mergeUniqueBlocks(fragment.blocks ?? []);
-  const registry = buildRegistry(reusableBlocks);
-  const blockCache = /* @__PURE__ */ new WeakMap();
-  const resolvedBlocks = reusableBlocks.map(
-    (block) => resolveBlock(block, registry, blockCache)
-  );
-  const resolvedCollections = (fragment.collections ?? []).map(
-    (collection) => ({
-      ...collection,
-      fields: resolveFields(collection.fields ?? [], registry, blockCache)
-    })
-  );
-  const resolvedGlobals = (fragment.globals ?? []).map((global) => ({
-    ...global,
-    fields: resolveFields(global.fields ?? [], registry, blockCache)
-  }));
-  return {
-    ...fragment,
-    ...fragment.blocks ? { blocks: resolvedBlocks } : {},
-    ...fragment.collections ? { collections: resolvedCollections } : {},
-    ...fragment.globals ? { globals: resolvedGlobals } : {}
-  };
-}
-function mergeDynamicConfig(baseConfig, dynamic) {
-  const normalizedDynamic = normalizeSchemaFragment({
-    ...dynamic,
-    blocks: [...baseConfig.blocks ?? [], ...dynamic.blocks ?? []]
-  });
-  return {
-    ...baseConfig,
-    ...normalizedDynamic.blocks ? { blocks: normalizedDynamic.blocks } : {},
-    ...dynamic.accessPolicies ? {
-      accessPolicies: {
-        ...baseConfig.accessPolicies ?? {},
-        ...dynamic.accessPolicies
-      }
-    } : {},
-    ...dynamic.admin ? { admin: { ...baseConfig.admin, ...dynamic.admin } } : {},
-    ...dynamic.adminAuth ? { adminAuth: { ...baseConfig.adminAuth, ...dynamic.adminAuth } } : {},
-    collections: normalizedDynamic.collections ? [...baseConfig.collections, ...normalizedDynamic.collections] : baseConfig.collections,
-    globals: normalizedDynamic.globals ? [...baseConfig.globals, ...normalizedDynamic.globals] : baseConfig.globals
-  };
-}
-
-// src/utils/config.ts
-var AUDIT_COLLECTION_SLUG = "__audit";
-var SYSTEM_FIELDS = [
-  {
-    name: "createdAt",
-    type: "date",
-    label: "Created At",
-    admin: { readOnly: true, hidden: true }
-  },
-  {
-    name: "updatedAt",
-    type: "date",
-    label: "Updated At",
-    admin: { readOnly: true, hidden: true }
-  },
-  {
-    name: "createdBy",
-    type: "text",
-    label: "Created By",
-    admin: { readOnly: true, hidden: true }
-  },
-  {
-    name: "updatedBy",
-    type: "text",
-    label: "Updated By",
-    admin: { readOnly: true, hidden: true }
-  }
-];
-var AUDIT_COLLECTION = {
-  slug: AUDIT_COLLECTION_SLUG,
-  labels: { singular: "Audit Log", plural: "Audit Logs" },
-  fields: [
-    { name: "collection", type: "text", label: "Collection", required: true },
-    { name: "documentId", type: "text", label: "Document ID" },
-    {
-      name: "operation",
-      type: "select",
-      label: "Operation",
-      options: ["create", "update", "delete"],
-      required: true
-    },
-    { name: "user", type: "text", label: "User ID" },
-    { name: "timestamp", type: "date", label: "Timestamp", required: true },
-    { name: "changes", type: "json", label: "Changes" }
-  ],
-  access: {
-    read: () => false,
-    create: () => false,
-    update: () => false,
-    delete: () => false
-  },
-  admin: { hidden: true }
-};
-var WORKFLOW_HISTORY_COLLECTION_CONFIG = {
-  slug: WORKFLOW_HISTORY_COLLECTION,
-  labels: { singular: "Workflow transition", plural: "Workflow transitions" },
-  fields: [
-    { name: "collection", type: "text", required: true },
-    { name: "documentId", type: "text", required: true },
-    { name: "transition", type: "text", required: true },
-    { name: "from", type: "text", required: true },
-    { name: "to", type: "text", required: true },
-    { name: "revision", type: "number", required: true },
-    { name: "comment", type: "textarea" },
-    { name: "actorId", type: "text" },
-    { name: "createdAt", type: "date", required: true }
-  ],
-  access: {
-    read: ({ user }) => !!user,
-    create: () => false,
-    update: () => false,
-    delete: () => false
-  },
-  admin: { hidden: true }
-};
-var LIFECYCLE_EVENTS_COLLECTION_CONFIG = {
-  slug: LIFECYCLE_EVENTS_COLLECTION,
-  labels: { singular: "Lifecycle event", plural: "Lifecycle events" },
-  fields: [
-    { name: "name", type: "text", required: true },
-    { name: "collection", type: "text", required: true },
-    { name: "documentId", type: "text", required: true },
-    { name: "occurredAt", type: "date", required: true },
-    { name: "actorId", type: "text" },
-    { name: "payload", type: "json", required: true },
-    { name: "attempts", type: "number", required: true },
-    {
-      name: "status",
-      type: "select",
-      options: ["pending", "processing", "delivered", "failed"],
-      required: true
-    },
-    { name: "nextAttemptAt", type: "date" },
-    { name: "deliveredAt", type: "date" },
-    { name: "lastError", type: "textarea" }
-  ],
-  access: {
-    read: ({ user }) => !!user?.roles?.includes("admin"),
-    create: () => false,
-    update: () => false,
-    delete: () => false
-  },
-  admin: { hidden: true }
-};
-var AUTH_SESSIONS_COLLECTION_CONFIG = {
-  slug: AUTH_SESSIONS_COLLECTION,
-  labels: { singular: "Auth session", plural: "Auth sessions" },
-  fields: [
-    { name: "userId", type: "text", required: true },
-    { name: "email", type: "email", required: true },
-    { name: "collection", type: "text", required: true },
-    { name: "authSource", type: "text" },
-    { name: "providerId", type: "text" },
-    { name: "lastIp", type: "text" },
-    { name: "lastSeenAt", type: "date" },
-    { name: "expiresAt", type: "date" },
-    { name: "revokedAt", type: "date" }
-  ],
-  access: {
-    read: () => false,
-    create: () => false,
-    update: () => false,
-    delete: () => false
-  },
-  admin: { hidden: true }
-};
-function normalizeConfig(config) {
-  const schemaAwareConfig = normalizeSchemaFragment(config);
-  assertValidDeclarativeHooksInConfig(schemaAwareConfig, "config");
-  assertValidDeclarativeAccessInConfig(schemaAwareConfig, "config");
-  assertValidAdminConditionsInConfig(schemaAwareConfig, "config");
-  assertValidPreviewUrlsInConfig(schemaAwareConfig, "config");
-  const collections = schemaAwareConfig?.collections || [];
-  const globals = schemaAwareConfig?.globals || [];
-  const needsAudit = collections.some((col) => col.audit);
-  const needsWorkflow = collections.some((col) => col.workflow || col.drafts);
-  const needsAuthSessions = collections.some((col) => !!col.auth);
-  const adminAuthCollectionSlug = getAdminAuthCollection({
-    collections,
-    adminAuth: schemaAwareConfig.adminAuth
-  })?.slug;
-  const normalizedCollections = collections.map((col) => {
-    let fields = col.fields || [];
-    const existingFieldNames = new Set(fields.map((f) => f.name));
-    if (col.auth) {
-      if (!existingFieldNames.has("email")) {
-        fields = [
-          ...fields,
-          {
-            name: "email",
-            type: "email",
-            label: "Email",
-            required: true,
-            unique: true,
-            promoted: true,
-            access: {
-              update: "!id"
-            }
-          }
-        ];
-      }
-      if (!existingFieldNames.has("password")) {
-        fields = [
-          ...fields,
-          {
-            name: "password",
-            type: "text",
-            label: "Password",
-            required: true,
-            access: {
-              update: "!id || user.id == id"
-            }
-          }
-        ];
-      }
-      if (!existingFieldNames.has("roles")) {
-        fields = [
-          ...fields,
-          {
-            name: "roles",
-            type: "select",
-            label: "Roles",
-            defaultValue: [],
-            options: [
-              { value: "admin", label: "Admin" },
-              { value: "editor", label: "Editor" },
-              { value: "viewer", label: "Viewer" }
-            ],
-            access: {
-              update: "user.roles && 'admin' in user.roles"
-            }
-          }
-        ];
-      }
-      if (!existingFieldNames.has("status")) {
-        fields = [
-          ...fields,
-          {
-            name: "status",
-            type: "select",
-            label: "Status",
-            defaultValue: "active",
-            options: [
-              { value: "active", label: "Active" },
-              { value: "pending", label: "Pending" }
-            ],
-            access: {
-              update: "user.roles && 'admin' in user.roles && user.id != id"
-            },
-            admin: {
-              condition: `!(data.roles && "admin" in data.roles)`
-            }
-          }
-        ];
-      }
-      fields = fields.map((field) => {
-        if (field.name === "email") {
-          return {
-            ...field,
-            // Email is the login identifier. Keep the integrity constraints
-            // auth relies on even when the field is explicitly redefined, so a
-            // custom `email` field can never silently drop uniqueness.
-            required: true,
-            unique: true,
-            promoted: true,
-            access: {
-              ...field.access || {},
-              update: "!id"
-            }
-          };
-        }
-        if (field.name === "password") {
-          return {
-            ...field,
-            // Password is required to authenticate; enforce it regardless of
-            // how the field was declared.
-            required: true,
-            admin: { ...field.admin || {} },
-            access: {
-              ...field.access || {},
-              update: "!id || user.id == id"
-            }
-          };
-        }
-        if (field.name === "roles") {
-          return {
-            ...field,
-            access: {
-              ...field.access || {},
-              // Must be an admin; cannot edit own roles (no self-elevation).
-              update: "user.roles && 'admin' in user.roles && user.id != id"
-            }
-          };
-        }
-        if (field.name === "status") {
-          return {
-            ...field,
-            access: {
-              ...field.access || {},
-              update: "user.roles && 'admin' in user.roles && user.id != id"
-            }
-          };
-        }
-        return field;
-      });
-    }
-    if (adminAuthCollectionSlug && col.slug === adminAuthCollectionSlug && schemaAwareConfig.adminAuth?.mode === "external") {
-      const externalAdminFields = [
-        {
-          name: "authProvider",
-          type: "text",
-          label: "Auth Provider",
-          admin: { readOnly: true, hidden: true }
-        },
-        {
-          name: "externalSubject",
-          type: "text",
-          label: "External Subject",
-          admin: { readOnly: true, hidden: true }
-        },
-        {
-          name: "authSource",
-          type: "text",
-          label: "Auth Source",
-          admin: { readOnly: true, hidden: true }
-        },
-        {
-          name: "lastLoginAt",
-          type: "date",
-          label: "Last Login At",
-          admin: { readOnly: true, hidden: true }
-        }
-      ];
-      for (const field of externalAdminFields) {
-        if (!existingFieldNames.has(field.name)) {
-          fields = [...fields, field];
-        }
-      }
-    }
-    const updatedFieldNames = new Set(fields.map((f) => f.name));
-    const fieldsToInject = SYSTEM_FIELDS.filter((f) => !updatedFieldNames.has(f.name));
-    const workflow = col.workflow || (col.drafts ? simplePublishingWorkflow() : void 0);
-    return {
-      ...col,
-      workflow,
-      fields: [...fields, ...fieldsToInject]
-    };
-  });
-  const hasAuditCollection = normalizedCollections.some((col) => col.slug === AUDIT_COLLECTION_SLUG);
-  const systemCollections = [];
-  if (needsAudit && !hasAuditCollection) systemCollections.push(AUDIT_COLLECTION);
-  if (needsWorkflow && !normalizedCollections.some((col) => col.slug === WORKFLOW_HISTORY_COLLECTION)) {
-    systemCollections.push(WORKFLOW_HISTORY_COLLECTION_CONFIG);
-  }
-  if (needsWorkflow && !normalizedCollections.some((col) => col.slug === LIFECYCLE_EVENTS_COLLECTION)) {
-    systemCollections.push(LIFECYCLE_EVENTS_COLLECTION_CONFIG);
-  }
-  if (needsAuthSessions && !normalizedCollections.some((col) => col.slug === AUTH_SESSIONS_COLLECTION)) {
-    systemCollections.push(AUTH_SESSIONS_COLLECTION_CONFIG);
-  }
-  return {
-    ...schemaAwareConfig,
-    collections: [...normalizedCollections, ...systemCollections],
-    globals
-  };
-}
-
-// src/utils/hooks.ts
-import jexl3 from "jexl";
-async function runCollectionHooks(hooks, args, options = {}) {
-  if (!hooks || hooks.length === 0) {
-    return args.data ?? args.doc ?? args.query ?? void 0;
-  }
-  const payloadKey = args.data !== void 0 ? "data" : args.doc !== void 0 ? "doc" : "query" in args ? "query" : void 0;
-  let currentPayload = payloadKey === void 0 ? void 0 : args[payloadKey];
-  for (const hook of hooks) {
-    try {
-      const hookArgs = {
-        ...args,
-        ...payloadKey !== void 0 ? { [payloadKey]: currentPayload } : {}
-      };
-      const result = typeof hook === "string" ? await (() => {
-        if (options.surface) {
-          assertValidDeclarativeHookExpression(
-            hook,
-            options.surface,
-            options.path ?? options.surface
-          );
-        }
-        return jexl3.eval(hook, hookArgs);
-      })() : await hook(hookArgs);
-      if (result !== void 0) {
-        if (typeof hook === "string" && options.surface) {
-          assertValidDeclarativeHookResult(
-            result,
-            options.surface,
-            options.path ?? options.surface
-          );
-        }
-        currentPayload = typeof hook === "string" && currentPayload && typeof currentPayload === "object" && !Array.isArray(currentPayload) && result && typeof result === "object" && !Array.isArray(result) ? {
-          ...currentPayload,
-          ...result
-        } : result;
-      }
-    } catch (err) {
-      if (options.isolated) {
-        getConfigLogger(void 0, "hooks").error({
-          err,
-          msg: "Side-effect hook failed after a successful write"
-        });
-      } else {
-        throw err;
-      }
-    }
-  }
-  return currentPayload;
-}
-async function executeFieldBeforeChange(fields, data, originalDoc, user, db, pathPrefix = "") {
-  if (!data || typeof data !== "object") return data;
-  const result = { ...data };
-  for (const field of fields) {
-    if (!field.name) continue;
-    const fieldPath = pathPrefix ? `${pathPrefix}.${field.name}` : field.name;
-    const value = result[field.name];
-    const origValue = originalDoc?.[field.name];
-    let updatedValue = value;
-    if (field.hooks?.beforeChange) {
-      for (const hook of field.hooks.beforeChange) {
-        const hookArgs = {
-          value: updatedValue,
-          originalDoc: originalDoc ?? void 0,
-          data: result,
-          user,
-          db
-        };
-        updatedValue = typeof hook === "string" ? await (() => {
-          assertValidDeclarativeHookExpression(
-            hook,
-            "field.beforeChange",
-            fieldPath
-          );
-          return jexl3.eval(hook, hookArgs);
-        })() : await hook(hookArgs);
-      }
-      result[field.name] = updatedValue;
-    }
-    if (updatedValue !== void 0 && updatedValue !== null) {
-      if (field.type === "object" && field.fields) {
-        result[field.name] = await executeFieldBeforeChange(
-          field.fields,
-          updatedValue,
-          origValue,
-          user,
-          db,
-          fieldPath
-        );
-      } else if (field.type === "array" && field.fields && Array.isArray(updatedValue)) {
-        const arrayResult = [];
-        for (let i = 0; i < updatedValue.length; i++) {
-          const item = updatedValue[i];
-          const origItem = Array.isArray(origValue) ? origValue[i] : null;
-          arrayResult.push(
-            await executeFieldBeforeChange(
-              field.fields,
-              item,
-              origItem,
-              user,
-              db,
-              fieldPath
-            )
-          );
-        }
-        result[field.name] = arrayResult;
-      } else if (field.type === "blocks" && field.blocks && Array.isArray(updatedValue)) {
-        const blocksResult = [];
-        for (let i = 0; i < updatedValue.length; i++) {
-          const blockData = updatedValue[i];
-          const origBlock = Array.isArray(origValue) ? origValue[i] : null;
-          const blockConfig = field.blocks.find(
-            (b) => b.slug === blockData.blockType
-          );
-          if (blockConfig) {
-            blocksResult.push(
-              await executeFieldBeforeChange(
-                blockConfig.fields,
-                blockData,
-                origBlock,
-                user,
-                db,
-                fieldPath
-              )
-            );
-          } else {
-            blocksResult.push(blockData);
-          }
-        }
-        result[field.name] = blocksResult;
-      }
-    }
-  }
-  return result;
-}
-async function executeFieldAfterRead(fields, doc, user, db) {
-  if (!doc || typeof doc !== "object") return doc;
-  const result = { ...doc };
-  for (const field of fields) {
-    if (!field.name) continue;
-    const value = result[field.name];
-    let updatedValue = value;
-    if (field.hooks?.afterRead) {
-      for (const hook of field.hooks.afterRead) {
-        const typedHook = hook;
-        const hookArgs = {
-          value: updatedValue,
-          doc: result,
-          user,
-          db
-        };
-        updatedValue = await typedHook(hookArgs);
-      }
-      result[field.name] = updatedValue;
-    }
-    if (updatedValue !== void 0 && updatedValue !== null) {
-      if (field.type === "object" && field.fields) {
-        result[field.name] = await executeFieldAfterRead(
-          field.fields,
-          updatedValue,
-          user,
-          db
-        );
-      } else if (field.type === "array" && field.fields && Array.isArray(updatedValue)) {
-        const arrayResult = [];
-        for (const item of updatedValue) {
-          arrayResult.push(
-            await executeFieldAfterRead(
-              field.fields,
-              item,
-              user,
-              db
-            )
-          );
-        }
-        result[field.name] = arrayResult;
-      } else if (field.type === "blocks" && field.blocks && Array.isArray(updatedValue)) {
-        const blocksResult = [];
-        for (const blockData of updatedValue) {
-          const typedBlock = blockData;
-          const blockConfig = field.blocks.find(
-            (b) => b.slug === typedBlock.blockType
-          );
-          if (blockConfig) {
-            blocksResult.push(
-              await executeFieldAfterRead(
-                blockConfig.fields,
-                typedBlock,
-                user,
-                db
-              )
-            );
-          } else {
-            blocksResult.push(blockData);
-          }
-        }
-        result[field.name] = blocksResult;
-      }
-    }
-  }
-  return result;
-}
-
-// src/utils/openapi.ts
-function getCollectionLabels(collection) {
-  return collection.labels || { singular: collection.slug, plural: collection.slug };
-}
-function getCollectionTag(collection) {
-  return `Collection: ${getCollectionLabels(collection).plural}`;
-}
-function getGlobalTag(global) {
-  return `Global: ${global.label || global.slug}`;
-}
-function generateOpenApi(config) {
-  const spec = {
-    openapi: "3.0.0",
-    info: {
-      title: "Dyrected API",
-      version: "1.0.0",
-      description: "Automatically generated OpenAPI specification for the Dyrected project."
-    },
-    components: {
-      schemas: {
-        WorkflowMetadata: {
-          type: "object",
-          required: ["state", "revision"],
-          properties: {
-            state: { type: "string" },
-            revision: { type: "integer", minimum: 1 },
-            publishedRevision: { type: "integer", minimum: 1 },
-            publishedAt: { type: "string", format: "date-time" },
-            publishedBy: { type: "string" },
-            availableTransitions: { type: "array", items: { type: "string" } }
-          }
-        },
-        WorkflowTransitionRequest: {
-          type: "object",
-          properties: {
-            expectedRevision: { type: "integer", minimum: 1 },
-            comment: { type: "string" }
-          }
-        },
-        WorkflowHistoryEntry: {
-          type: "object",
-          required: [
-            "collection",
-            "documentId",
-            "transition",
-            "from",
-            "to",
-            "revision",
-            "createdAt"
-          ],
-          properties: {
-            id: { type: "string" },
-            collection: { type: "string" },
-            documentId: { type: "string" },
-            transition: { type: "string" },
-            from: { type: "string" },
-            to: { type: "string" },
-            revision: { type: "integer" },
-            comment: { type: "string", nullable: true },
-            actorId: { type: "string", nullable: true },
-            createdAt: { type: "string", format: "date-time" }
-          }
-        },
-        AuditEntry: {
-          type: "object",
-          required: ["collection", "operation", "timestamp"],
-          properties: {
-            id: { type: "string" },
-            collection: { type: "string" },
-            documentId: { type: "string", nullable: true },
-            operation: { type: "string" },
-            user: { type: "string", nullable: true },
-            timestamp: { type: "string", format: "date-time" },
-            changes: {
-              oneOf: [
-                { type: "string" },
-                { type: "object", additionalProperties: true },
-                { type: "null" }
-              ]
-            }
-          }
-        },
-        Error: {
-          type: "object",
-          properties: {
-            message: { type: "string" },
-            errors: {
-              type: "array",
-              items: { type: "object", additionalProperties: true }
-            }
-          }
-        },
-        AuthCredentials: {
-          type: "object",
-          required: ["email", "password"],
-          properties: {
-            email: { type: "string", format: "email" },
-            password: { type: "string" }
-          }
-        },
-        TokenResponse: {
-          type: "object",
-          properties: {
-            token: { type: "string" },
-            user: { type: "object", additionalProperties: true }
-          }
-        }
-      },
-      securitySchemes: {
-        ApiKeyAuth: {
-          type: "apiKey",
-          in: "header",
-          name: "x-api-key"
-        }
-      }
-    },
-    paths: {},
-    security: [{ ApiKeyAuth: [] }]
-  };
-  spec.paths["/api/schemas"] = {
-    get: {
-      tags: ["System"],
-      summary: "Get the serialized Dyrected schema",
-      security: [],
-      responses: {
-        200: { description: "Collection and global schema definitions" }
-      }
-    }
-  };
-  spec.paths["/api/openapi.json"] = {
-    get: {
-      tags: ["System"],
-      summary: "Get the OpenAPI specification",
-      security: [],
-      responses: { 200: { description: "OpenAPI 3.0 document" } }
-    }
-  };
-  spec.paths["/api/docs"] = {
-    get: {
-      tags: ["System"],
-      summary: "Open interactive API documentation",
-      security: [],
-      responses: { 200: { description: "Swagger UI HTML" } }
-    }
-  };
-  spec.paths["/api/dyrected/options/{collection}/{field}"] = {
-    get: {
-      tags: ["System"],
-      summary: "Resolve dynamic field options",
-      parameters: [
-        {
-          name: "collection",
-          in: "path",
-          required: true,
-          schema: { type: "string" }
-        },
-        {
-          name: "field",
-          in: "path",
-          required: true,
-          schema: { type: "string" }
-        }
-      ],
-      responses: { 200: { description: "Resolved option items" } }
-    }
-  };
-  spec.paths["/api/preferences/{key}"] = {
-    get: {
-      tags: ["Preferences"],
-      summary: "Get an authenticated user preference",
-      parameters: [
-        { name: "key", in: "path", required: true, schema: { type: "string" } }
-      ],
-      responses: { 200: { description: "Preference value" } }
-    },
-    put: {
-      tags: ["Preferences"],
-      summary: "Set an authenticated user preference",
-      parameters: [
-        { name: "key", in: "path", required: true, schema: { type: "string" } }
-      ],
-      requestBody: {
-        required: true,
-        content: { "application/json": { schema: { type: "object" } } }
-      },
-      responses: { 200: { description: "Updated preference" } }
-    }
-  };
-  spec.paths["/api/preview-token"] = {
-    post: {
-      tags: ["Preview"],
-      summary: "Create a preview token",
-      responses: { 200: { description: "Short-lived preview token" } }
-    }
-  };
-  spec.paths["/api/preview-data"] = {
-    get: {
-      tags: ["Preview"],
-      summary: "Resolve preview data from a token",
-      security: [],
-      parameters: [
-        {
-          name: "token",
-          in: "query",
-          required: true,
-          schema: { type: "string" }
-        }
-      ],
-      responses: { 200: { description: "Preview document data" } }
-    }
-  };
-  spec.paths["/api/audit"] = {
-    get: {
-      tags: ["Audit"],
-      summary: "Get audit entries across all readable audited collections",
-      parameters: [
-        {
-          name: "limit",
-          in: "query",
-          schema: { type: "integer", default: 50, maximum: 100 }
-        },
-        { name: "page", in: "query", schema: { type: "integer", default: 1 } },
-        {
-          name: "where",
-          in: "query",
-          schema: { type: "string" },
-          description: "JSON filter"
-        },
-        {
-          name: "sort",
-          in: "query",
-          schema: { type: "string", default: "-timestamp" }
-        }
-      ],
-      responses: {
-        200: {
-          description: "Audit entries",
-          content: {
-            "application/json": {
-              schema: {
-                type: "object",
-                properties: {
-                  docs: {
-                    type: "array",
-                    items: { $ref: "#/components/schemas/AuditEntry" }
-                  },
-                  total: { type: "integer" },
-                  limit: { type: "integer" },
-                  page: { type: "integer" }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  };
-  for (const collection of config.collections) {
-    spec.components.schemas[collection.slug] = collectionToSchema(collection);
-  }
-  for (const global of config.globals) {
-    spec.components.schemas[global.slug] = globalToSchema(global);
-  }
-  for (const collection of config.collections) {
-    const slug = collection.slug;
-    const path = `/api/collections/${slug}`;
-    const labels = getCollectionLabels(collection);
-    const collectionTag = getCollectionTag(collection);
-    spec.paths[path] = {
-      get: {
-        tags: [collectionTag],
-        summary: `Find ${labels.plural}`,
-        parameters: [
-          {
-            name: "limit",
-            in: "query",
-            schema: { type: "integer", default: 10 }
-          },
-          {
-            name: "page",
-            in: "query",
-            schema: { type: "integer", default: 1 }
-          },
-          {
-            name: "where",
-            in: "query",
-            schema: { type: "string" },
-            description: "JSON filter"
-          },
-          {
-            name: "search",
-            in: "query",
-            schema: { type: "string" },
-            description: "Free-text search across configured searchable fields"
-          },
-          {
-            name: "sort",
-            in: "query",
-            schema: { type: "string" },
-            description: "Sort field (e.g. -createdAt)"
-          }
-        ],
-        responses: {
-          200: {
-            description: "Success",
-            content: {
-              "application/json": {
-                schema: {
-                  type: "object",
-                  properties: {
-                    docs: {
-                      type: "array",
-                      items: { $ref: `#/components/schemas/${slug}` }
-                    },
-                    total: { type: "integer" },
-                    limit: { type: "integer" },
-                    page: { type: "integer" }
-                  }
-                }
-              }
-            }
-          }
-        }
-      },
-      post: {
-        tags: [collectionTag],
-        summary: `Create ${labels.singular}`,
-        requestBody: {
-          required: true,
-          content: {
-            "application/json": {
-              schema: { $ref: `#/components/schemas/${slug}` }
-            }
-          }
-        },
-        responses: {
-          201: {
-            description: "Created",
-            content: {
-              "application/json": {
-                schema: { $ref: `#/components/schemas/${slug}` }
-              }
-            }
-          }
-        }
-      }
-    };
-    spec.paths[`${path}/{id}`] = {
-      get: {
-        tags: [collectionTag],
-        summary: `Get a single ${labels.singular}`,
-        parameters: [
-          {
-            name: "id",
-            in: "path",
-            required: true,
-            schema: { type: "string" }
-          }
-        ],
-        responses: {
-          200: {
-            description: "Success",
-            content: {
-              "application/json": {
-                schema: { $ref: `#/components/schemas/${slug}` }
-              }
-            }
-          }
-        }
-      },
-      patch: {
-        tags: [collectionTag],
-        summary: `Update ${labels.singular}`,
-        parameters: [
-          {
-            name: "id",
-            in: "path",
-            required: true,
-            schema: { type: "string" }
-          }
-        ],
-        requestBody: {
-          required: true,
-          content: {
-            "application/json": {
-              schema: { $ref: `#/components/schemas/${slug}` }
-            }
-          }
-        },
-        responses: {
-          200: {
-            description: "Updated",
-            content: {
-              "application/json": {
-                schema: { $ref: `#/components/schemas/${slug}` }
-              }
-            }
-          }
-        }
-      },
-      delete: {
-        tags: [collectionTag],
-        summary: `Delete ${labels.singular}`,
-        parameters: [
-          {
-            name: "id",
-            in: "path",
-            required: true,
-            schema: { type: "string" }
-          }
-        ],
-        responses: {
-          204: { description: "Deleted" }
-        }
-      }
-    };
-    spec.paths[`${path}/delete-many`] = {
-      delete: {
-        tags: [collectionTag],
-        summary: `Delete multiple ${labels.plural}`,
-        requestBody: {
-          required: true,
-          content: {
-            "application/json": {
-              schema: {
-                type: "object",
-                required: ["ids"],
-                properties: {
-                  ids: { type: "array", items: { type: "string" } }
-                }
-              }
-            }
-          }
-        },
-        responses: { 200: { description: "Deleted and failed document IDs" } }
-      }
-    };
-    if (collection.audit) {
-      spec.paths[`${path}/__audit`] = {
-        get: {
-          tags: [collectionTag],
-          summary: `Get ${labels.singular} audit entries`,
-          parameters: [
-            {
-              name: "limit",
-              in: "query",
-              schema: { type: "integer", default: 50, maximum: 100 }
-            },
-            {
-              name: "page",
-              in: "query",
-              schema: { type: "integer", default: 1 }
-            },
-            {
-              name: "where",
-              in: "query",
-              schema: { type: "string" },
-              description: "JSON filter"
-            },
-            {
-              name: "sort",
-              in: "query",
-              schema: { type: "string", default: "-timestamp" }
-            }
-          ],
-          responses: {
-            200: {
-              description: "Audit entries for this collection",
-              content: {
-                "application/json": {
-                  schema: {
-                    type: "object",
-                    properties: {
-                      docs: {
-                        type: "array",
-                        items: { $ref: "#/components/schemas/AuditEntry" }
-                      },
-                      total: { type: "integer" },
-                      limit: { type: "integer" },
-                      page: { type: "integer" }
-                    }
-                  }
-                }
-              }
-            },
-            403: { description: "Collection read access denied" },
-            404: { description: "Audit is not enabled for this collection" }
-          }
-        }
-      };
-    }
-    if (collection.upload) {
-      spec.paths[`${path}/media`] = {
-        get: {
-          tags: [collectionTag],
-          summary: `List ${labels.plural}`,
-          responses: { 200: { description: "Paginated media documents" } }
-        },
-        post: {
-          tags: [collectionTag],
-          summary: `Upload ${labels.singular}`,
-          requestBody: {
-            required: true,
-            content: {
-              "multipart/form-data": {
-                schema: {
-                  type: "object",
-                  required: ["file"],
-                  properties: { file: { type: "string", format: "binary" } }
-                }
-              }
-            }
-          },
-          responses: { 201: { description: "Uploaded media document" } }
-        }
-      };
-      spec.paths[`${path}/media/{filename}`] = {
-        get: {
-          tags: [collectionTag],
-          summary: `Serve ${labels.singular} bytes`,
-          parameters: [
-            {
-              name: "filename",
-              in: "path",
-              required: true,
-              schema: { type: "string" }
-            }
-          ],
-          security: [],
-          responses: {
-            200: { description: "Stored file" },
-            404: { description: "File not found" }
-          }
-        }
-      };
-    }
-    if (collection.auth) {
-      const publicAuthPost = (summary) => ({
-        tags: [collectionTag],
-        summary,
-        security: [],
-        requestBody: {
-          required: true,
-          content: {
-            "application/json": {
-              schema: { type: "object", additionalProperties: true }
-            }
-          }
-        },
-        responses: {
-          200: { description: "Success" },
-          400: { description: "Invalid request" }
-        }
-      });
-      spec.paths[`${path}/login`] = {
-        post: {
-          ...publicAuthPost(`Log in to ${labels.plural}`),
-          requestBody: {
-            required: true,
-            content: {
-              "application/json": {
-                schema: { $ref: "#/components/schemas/AuthCredentials" }
-              }
-            }
-          },
-          responses: {
-            200: {
-              description: "Authenticated",
-              content: {
-                "application/json": {
-                  schema: { $ref: "#/components/schemas/TokenResponse" }
-                }
-              }
-            },
-            401: { description: "Invalid credentials" }
-          }
-        }
-      };
-      spec.paths[`${path}/logout`] = {
-        post: {
-          tags: [collectionTag],
-          summary: `Log out of ${labels.plural}`,
-          parameters: [
-            {
-              name: "allSessions",
-              in: "query",
-              required: false,
-              schema: { type: "boolean" },
-              description: "Revoke every active session for this account instead of only the current one."
-            }
-          ],
-          responses: { 200: { description: "Logged out" } }
-        }
-      };
-      spec.paths[`${path}/init`] = {
-        get: {
-          tags: [collectionTag],
-          summary: `Get ${labels.plural} initialization state`,
-          security: [],
-          responses: { 200: { description: "Initialization state" } }
-        }
-      };
-      spec.paths[`${path}/first-user`] = {
-        post: publicAuthPost(`Register the first ${labels.singular}`)
-      };
-      spec.paths[`${path}/me`] = {
-        get: {
-          tags: [collectionTag],
-          summary: `Get the current ${labels.singular}`,
-          responses: { 200: { description: "Authenticated user" } }
-        }
-      };
-      spec.paths[`${path}/refresh-token`] = {
-        post: {
-          tags: [collectionTag],
-          summary: "Refresh an authentication token",
-          responses: {
-            200: {
-              description: "Refreshed token for the current active session"
-            }
-          }
-        }
-      };
-      spec.paths[`${path}/forgot-password`] = {
-        post: publicAuthPost("Request a password reset")
-      };
-      spec.paths[`${path}/reset-password`] = {
-        post: publicAuthPost("Reset a password")
-      };
-      spec.paths[`${path}/invite`] = {
-        post: {
-          tags: [collectionTag],
-          summary: `Invite a ${labels.singular}`,
-          responses: { 200: { description: "Invitation sent" } }
-        }
-      };
-      spec.paths[`${path}/accept-invite`] = {
-        post: publicAuthPost("Accept an invitation")
-      };
-      spec.paths[`${path}/{id}/change-password`] = {
-        post: {
-          tags: [collectionTag],
-          summary: `Change a ${labels.singular} password`,
-          parameters: [
-            {
-              name: "id",
-              in: "path",
-              required: true,
-              schema: { type: "string" }
-            }
-          ],
-          responses: {
-            200: {
-              description: "Password changed and active sessions revoked"
-            }
-          }
-        }
-      };
-    }
-    if (collection.workflow) {
-      spec.paths[`${path}/{id}/transitions/{transition}`] = {
-        post: {
-          tags: [collectionTag],
-          summary: `Transition ${labels.singular} workflow`,
-          parameters: [
-            {
-              name: "id",
-              in: "path",
-              required: true,
-              schema: { type: "string" }
-            },
-            {
-              name: "transition",
-              in: "path",
-              required: true,
-              schema: {
-                type: "string",
-                enum: collection.workflow.transitions.map((item) => item.name)
-              }
-            }
-          ],
-          requestBody: {
-            content: {
-              "application/json": {
-                schema: {
-                  $ref: "#/components/schemas/WorkflowTransitionRequest"
-                }
-              }
-            }
-          },
-          responses: {
-            200: {
-              description: "Transition applied",
-              content: {
-                "application/json": {
-                  schema: { $ref: `#/components/schemas/${slug}` }
-                }
-              }
-            },
-            400: { description: "Required transition input is missing" },
-            403: { description: "Transition capability denied" },
-            409: { description: "Invalid state or stale revision" }
-          }
-        }
-      };
-      spec.paths[`${path}/{id}/workflow-history`] = {
-        get: {
-          tags: [collectionTag],
-          summary: `Get ${labels.singular} workflow history`,
-          parameters: [
-            {
-              name: "id",
-              in: "path",
-              required: true,
-              schema: { type: "string" }
-            },
-            {
-              name: "limit",
-              in: "query",
-              schema: { type: "integer", default: 50, maximum: 100 }
-            }
-          ],
-          responses: {
-            200: {
-              description: "Workflow transition history",
-              content: {
-                "application/json": {
-                  schema: {
-                    type: "object",
-                    properties: {
-                      docs: {
-                        type: "array",
-                        items: {
-                          $ref: "#/components/schemas/WorkflowHistoryEntry"
-                        }
-                      },
-                      total: { type: "integer" },
-                      limit: { type: "integer" },
-                      page: { type: "integer" }
-                    }
-                  }
-                }
-              }
-            },
-            403: { description: "Collection read access denied" }
-          }
-        }
-      };
-    }
-  }
-  for (const global of config.globals) {
-    const slug = global.slug;
-    const path = `/api/globals/${slug}`;
-    const globalTag = getGlobalTag(global);
-    spec.paths[path] = {
-      get: {
-        tags: [globalTag],
-        summary: `Get ${global.label || slug}`,
-        responses: {
-          200: {
-            description: "Success",
-            content: {
-              "application/json": {
-                schema: { $ref: `#/components/schemas/${slug}` }
-              }
-            }
-          }
-        }
-      },
-      patch: {
-        tags: [globalTag],
-        summary: `Update ${global.label || slug}`,
-        requestBody: {
-          required: true,
-          content: {
-            "application/json": {
-              schema: { $ref: `#/components/schemas/${slug}` }
-            }
-          }
-        },
-        responses: {
-          200: {
-            description: "Updated",
-            content: {
-              "application/json": {
-                schema: { $ref: `#/components/schemas/${slug}` }
-              }
-            }
-          }
-        }
-      }
-    };
-  }
-  if (config.storage) {
-    spec.paths["/api/media/{filename}"] = {
-      get: {
-        tags: ["Media"],
-        summary: "Serve a stored file",
-        security: [],
-        parameters: [
-          {
-            name: "filename",
-            in: "path",
-            required: true,
-            schema: { type: "string" }
-          }
-        ],
-        responses: {
-          200: { description: "Stored file bytes" },
-          404: { description: "File not found" }
-        }
-      }
-    };
-  }
-  return spec;
-}
-function collectionToSchema(collection) {
-  const { properties, required } = fieldsToProperties(collection.fields);
-  return {
-    type: "object",
-    properties: {
-      id: { type: "string" },
-      createdAt: { type: "string", format: "date-time" },
-      updatedAt: { type: "string", format: "date-time" },
-      ...collection.workflow ? { _workflow: { $ref: "#/components/schemas/WorkflowMetadata" } } : {},
-      ...properties
-    },
-    required: ["id", ...required]
-  };
-}
-function globalToSchema(global) {
-  const { properties, required } = fieldsToProperties(global.fields);
-  return {
-    type: "object",
-    properties,
-    required
-  };
-}
-function fieldsToProperties(fields) {
-  const props = {};
-  const required = [];
-  for (const field of fields) {
-    if (field.type === "row") {
-      const nested = fieldsToProperties(field.fields || []);
-      Object.assign(props, nested.properties);
-      required.push(...nested.required);
-      continue;
-    }
-    if (!field.name) continue;
-    props[field.name] = fieldToSchema(field);
-    if (field.required) {
-      required.push(field.name);
-    }
-  }
-  return { properties: props, required };
-}
-function fieldToSchema(field) {
-  let schema;
-  switch (field.type) {
-    case "text":
-    case "textarea":
-    case "email":
-      schema = { type: "string" };
-      break;
-    case "url":
-      schema = {
-        oneOf: [
-          { type: "string" },
-          { type: "object", additionalProperties: true }
-        ]
-      };
-      break;
-    case "icon":
-      schema = { type: "string" };
-      break;
-    case "number":
-      schema = { type: "number" };
-      break;
-    case "boolean":
-      schema = { type: "boolean" };
-      break;
-    case "date":
-      schema = { type: "string", format: "date" };
-      break;
-    case "datetime":
-      schema = { type: "string", format: "date-time" };
-      break;
-    case "time":
-      schema = { type: "string", format: "time" };
-      break;
-    case "select":
-    case "radio":
-      schema = {
-        type: "string",
-        enum: Array.isArray(field.options) ? field.options.map((o) => typeof o === "string" ? o : o.value) : void 0
-      };
-      break;
-    case "multiSelect":
-      schema = {
-        type: "array",
-        items: {
-          type: "string",
-          enum: Array.isArray(field.options) ? field.options.map((o) => typeof o === "string" ? o : o.value) : void 0
-        }
-      };
-      break;
-    case "relationship":
-    case "image": {
-      const valueSchema = {
-        type: "string",
-        description: `ID of a ${field.relationTo} record`
-      };
-      schema = field.hasMany ? { type: "array", items: valueSchema } : valueSchema;
-      break;
-    }
-    case "join":
-      schema = {
-        type: "array",
-        readOnly: true,
-        items: { type: "object", additionalProperties: true }
-      };
-      break;
-    case "object": {
-      const { properties, required } = fieldsToProperties(field.fields || []);
-      schema = { type: "object", properties, required };
-      break;
-    }
-    case "array": {
-      const { properties, required } = fieldsToProperties(field.fields || []);
-      schema = {
-        type: "array",
-        items: { type: "object", properties, required }
-      };
-      break;
-    }
-    case "json":
-    case "richText":
-      schema = { type: "object", additionalProperties: true };
-      break;
-    case "blocks":
-      schema = {
-        type: "array",
-        items: {
-          oneOf: field.blocks?.map((block) => {
-            const { properties, required } = fieldsToProperties(block.fields);
-            return {
-              type: "object",
-              properties: {
-                blockType: { type: "string", enum: [block.slug] },
-                ...properties
-              },
-              required: ["blockType", ...required]
-            };
-          })
-        }
-      };
-      break;
-    default:
-      schema = { type: "string" };
-  }
-  if (field.label) schema.description = field.label;
-  return schema;
-}
-
-export {
-  signCollectionToken,
-  verifyCollectionToken,
-  issueAuthSessionToken,
-  getAuthSession,
-  isAuthSessionActive,
-  touchAuthSession,
-  revokeAuthSession,
-  revokeAllAuthSessions,
-  WORKFLOW_HISTORY_COLLECTION,
-  LIFECYCLE_EVENTS_COLLECTION,
-  definePublishingWorkflow,
-  publishingWorkflow,
-  simplePublishingWorkflow,
-  workflowCapabilities,
-  canViewWorkflowDraft,
-  availableWorkflowTransitions,
-  initializeWorkflowDocument,
-  publishedStateName,
-  materializeWorkflowDocument,
-  createLifecycleEvent,
-  dispatchLifecycleEvent,
-  dispatchPendingLifecycleEvents,
-  saveWorkflowDraft,
-  createWorkflowDocument,
-  transitionWorkflow,
-  getAdminAuthCollection,
-  resolveAdminAuthCollection,
-  getPublicAdminAuthConfig,
-  mergeDynamicConfig,
-  slugify,
-  lower,
-  upper,
-  trim,
-  capitalize,
-  truncate,
-  readingTime,
-  wordCount,
-  replace,
-  startsWith,
-  endsWith,
-  now,
-  today,
-  formatDate,
-  addDays,
-  diffDays,
-  isPast,
-  isFuture,
-  includes,
-  join,
-  first,
-  last,
-  compact,
-  unique,
-  length,
-  round,
-  clamp,
-  defaultValue,
-  coalesce,
-  isEmpty,
-  get,
-  registerJexlHelpers,
-  BUILTIN_JEXL_HELPERS,
-  validateDeclarativeHookExpression,
-  validateDeclarativeAccessExpression,
-  validateAdminConditionExpression,
-  validatePreviewUrlExpression,
-  assertValidDeclarativeHookExpression,
-  assertValidDeclarativeHookResult,
-  collectDeclarativeHookValidationIssues,
-  collectDeclarativeAccessValidationIssues,
-  collectAdminConditionValidationIssues,
-  collectPreviewUrlValidationIssues,
-  assertValidAdminConditionsInConfig,
-  assertValidPreviewUrlsInConfig,
-  collectConfigDiagnostics,
-  formatConfigDiagnostics,
-  ConfigValidationError,
-  isConfigValidationError,
-  assertValidDeclarativeHooksInConfig,
-  assertValidDeclarativeAccessInConfig,
-  normalizeConfig,
-  runCollectionHooks,
-  executeFieldBeforeChange,
-  executeFieldAfterRead,
-  generateOpenApi
-};