@nexpress/core 0.1.0

package/dist/chunk-VGTPQXNQ.js

@@ -0,0 +1,2790 @@
+import {
+  getI18nConfig
+} from "./chunk-4ZLMEKFX.js";
+import {
+  NP_DEFAULT_SITE_ID,
+  getCollectionConfig,
+  getCollectionRegistration,
+  getCollectionTable
+} from "./chunk-FZ7O6DWI.js";
+import {
+  getCurrentSiteId
+} from "./chunk-SBCVAC2Z.js";
+import {
+  NpError,
+  NpForbiddenError,
+  NpNotFoundError,
+  NpValidationError
+} from "./chunk-ZCINJSS4.js";
+import {
+  reportError
+} from "./chunk-WV272MPW.js";
+import {
+  deleteMedia,
+  getMediaById,
+  getStorageAdapter,
+  listMedia,
+  uploadMedia
+} from "./chunk-473S4TER.js";
+import {
+  enqueueJob
+} from "./chunk-V2UNHGAP.js";
+import {
+  getLogger,
+  getScopedLogger
+} from "./chunk-JJL74ZPK.js";
+import {
+  getDb
+} from "./chunk-XANPEOJC.js";
+import {
+  NP_GLOBAL_PLUGIN_SITE_ID,
+  npComments,
+  npMediaRefs,
+  npPluginStorage,
+  npPlugins,
+  npReactions,
+  npReports,
+  npRevisions,
+  npSettings,
+  npSlugHistory
+} from "./chunk-M43PGOQY.js";
+
+// src/plugins/context.ts
+import { and, eq as eq2, gt, isNull, like, or } from "drizzle-orm";
+
+// src/collections/pipeline.ts
+import { randomUUID } from "crypto";
+import { asc, count, desc, eq, inArray, sql as sql2 } from "drizzle-orm";
+
+// src/collections/slug.ts
+function slugify(value) {
+  return value.toLowerCase().normalize("NFKD").replace(/[\u0300-\u036f]/g, "").normalize("NFC").replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-+|-+$/g, "").slice(0, 96);
+}
+function applySlugField(config, data, originalDoc) {
+  if (!config.slugField) return;
+  const existingSlug = typeof data.slug === "string" ? data.slug.trim() : "";
+  if (existingSlug.length > 0) {
+    data.slug = slugify(existingSlug) || existingSlug;
+    return;
+  }
+  if (originalDoc && typeof originalDoc.slug === "string" && originalDoc.slug.length > 0) {
+    data.slug = originalDoc.slug;
+    return;
+  }
+  const useField = typeof config.slugField === "object" && config.slugField.useField ? config.slugField.useField : "title";
+  const source = data[useField];
+  const candidate = typeof source === "string" ? slugify(source) : "";
+  if (candidate.length === 0) {
+    throw new NpValidationError("Slug generation failed", [
+      {
+        field: "slug",
+        message: `Cannot derive a slug \u2014 provide "slug" or a non-empty "${useField}".`
+      }
+    ]);
+  }
+  data.slug = candidate;
+}
+
+// src/collections/validation.ts
+import { z } from "zod";
+function buildZodSchema(fields) {
+  const shape = {};
+  for (const field of fields) {
+    if (field.type === "row" || field.type === "collapsible") {
+      Object.assign(shape, buildZodSchema(field.fields).shape);
+      continue;
+    }
+    if (field.type === "group") {
+      const schema = buildZodSchema(field.fields);
+      shape[field.name] = applyOptionality(schema, field.required);
+      continue;
+    }
+    shape[field.name] = applyOptionality(buildFieldSchema(field), field.required);
+  }
+  return z.object(shape);
+}
+function getCollectionZodSchema(config) {
+  const base = buildZodSchema(config.fields).extend({
+    // Phase 21.17 — per-doc visibility flag. Optional on writes;
+    // the pipeline lets the column default to "public" when the
+    // caller doesn't specify. Allowed values are the same
+    // codegen enum from `getBaseColumns`.
+    visibility: z.enum(["public", "private"]).optional()
+  });
+  if (config.i18n) {
+    return base.extend({
+      locale: z.string().min(1).optional(),
+      translationGroupId: z.string().uuid().optional()
+    });
+  }
+  return base;
+}
+function buildFieldSchema(field) {
+  switch (field.type) {
+    case "text": {
+      let schema = z.string();
+      if (field.minLength !== void 0) schema = schema.min(field.minLength);
+      if (field.maxLength !== void 0) schema = schema.max(field.maxLength);
+      return schema;
+    }
+    case "textarea": {
+      let schema = z.string();
+      if (field.minLength !== void 0) schema = schema.min(field.minLength);
+      if (field.maxLength !== void 0) schema = schema.max(field.maxLength);
+      return schema;
+    }
+    case "email":
+      return z.string().email();
+    case "number": {
+      let schema = z.number();
+      if (field.integerOnly) schema = schema.int();
+      if (field.min !== void 0) schema = schema.min(field.min);
+      if (field.max !== void 0) schema = schema.max(field.max);
+      return schema;
+    }
+    case "checkbox":
+      return z.boolean();
+    case "select":
+      return createEnumSchema(field.options.map((option) => option.value));
+    case "radio":
+      return createEnumSchema(field.options.map((option) => option.value));
+    case "relationship":
+      return field.hasMany ? z.array(z.string().uuid()) : z.string().uuid();
+    case "upload":
+      return z.string().uuid();
+    case "date":
+      return z.coerce.date();
+    case "richText":
+    case "blocks":
+    case "json":
+      return z.unknown();
+    case "array": {
+      let schema = z.array(buildZodSchema(field.fields));
+      if (field.minRows !== void 0) schema = schema.min(field.minRows);
+      if (field.maxRows !== void 0) schema = schema.max(field.maxRows);
+      return schema;
+    }
+    default:
+      return z.unknown();
+  }
+}
+function applyOptionality(schema, required) {
+  return required ? schema : schema.optional().nullable();
+}
+function createEnumSchema(values) {
+  const [first, ...rest] = values;
+  if (!first) {
+    return z.string();
+  }
+  return z.enum([first, ...rest]);
+}
+
+// src/collections/search.ts
+import { sql } from "drizzle-orm";
+function buildSearchVector(config, data) {
+  const parts = [];
+  for (const field of config.fields) {
+    if (field.type === "text" || field.type === "textarea") {
+      const value = data[field.name];
+      if (typeof value === "string") parts.push(value);
+    }
+    if (field.type === "richText") {
+      const value = data[field.name];
+      if (value) parts.push(extractPlainText(value));
+    }
+  }
+  return parts.join(" ");
+}
+var TITLE_LIKE_NAMES = /* @__PURE__ */ new Set(["title", "name"]);
+function buildSearchVectorParts(config, data) {
+  const parts = { a: "", b: "", c: "", d: "" };
+  const append = (bucket, value) => {
+    parts[bucket] = parts[bucket] ? `${parts[bucket]} ${value}` : value;
+  };
+  for (const field of config.fields) {
+    if (field.type === "text" || field.type === "textarea" || field.type === "email") {
+      const value = data[field.name];
+      if (typeof value !== "string" || value.length === 0) continue;
+      if (TITLE_LIKE_NAMES.has(field.name)) {
+        append("a", value);
+      } else {
+        append("b", value);
+      }
+    }
+    if (field.type === "richText") {
+      const value = data[field.name];
+      if (!value) continue;
+      const text = extractPlainText(value);
+      if (text.length > 0) append("c", text);
+    }
+  }
+  return parts;
+}
+function buildWeightedSearchVectorSql(config, data) {
+  const parts = buildSearchVectorParts(config, data);
+  const chunks = [];
+  if (parts.a)
+    chunks.push(sql`setweight(to_tsvector('english', ${parts.a}), 'A')`);
+  if (parts.b)
+    chunks.push(sql`setweight(to_tsvector('english', ${parts.b}), 'B')`);
+  if (parts.c)
+    chunks.push(sql`setweight(to_tsvector('english', ${parts.c}), 'C')`);
+  if (parts.d)
+    chunks.push(sql`setweight(to_tsvector('english', ${parts.d}), 'D')`);
+  if (chunks.length === 0) {
+    return sql`''::tsvector`;
+  }
+  if (chunks.length === 1) {
+    return chunks[0];
+  }
+  return sql.join(chunks, sql` || `);
+}
+function extractPlainText(content) {
+  if (!content || typeof content !== "object") return "";
+  const root = content.root;
+  if (!root?.children) return "";
+  const parts = [];
+  walkNodes(root.children, parts);
+  return parts.join(" ");
+}
+function walkNodes(nodes, parts) {
+  for (const node of nodes) {
+    if (!node || typeof node !== "object") continue;
+    const n = node;
+    if (typeof n.text === "string") {
+      parts.push(n.text);
+    }
+    if (Array.isArray(n.children)) {
+      walkNodes(n.children, parts);
+    }
+  }
+}
+
+// src/collections/pipeline.ts
+function actorUserOrNull(actor) {
+  return actor.kind === "staff" ? actor.user : null;
+}
+function actorUserId(actor) {
+  return actor.kind === "staff" ? actor.user.id : null;
+}
+function actorPrincipal(actor) {
+  switch (actor.kind) {
+    case "staff":
+      return { kind: "staff", user: actor.user };
+    case "member":
+      return { kind: "member", memberId: actor.memberId };
+    default: {
+      const _exhaustive = actor;
+      void _exhaustive;
+      throw new Error("actorPrincipal: unhandled SaveActor kind");
+    }
+  }
+}
+async function runPostCommit(label, context, fn) {
+  try {
+    await fn();
+  } catch (err) {
+    const { getLogger: getLogger2 } = await import("./logger-S7REWDNE.js");
+    getLogger2().error(
+      `post-commit ${label} failed \u2014 document persisted, follow-up skipped`,
+      {
+        collection: context.collection,
+        documentId: context.documentId,
+        operation: context.operation,
+        label,
+        error: err instanceof Error ? err.message : String(err),
+        stack: err instanceof Error ? err.stack : void 0
+      }
+    );
+  }
+}
+async function saveDocument(collection, docId, data, user, options) {
+  return saveDocumentImpl(collection, docId, data, { kind: "staff", user }, options);
+}
+async function updateMemberDocument(collection, docId, data, memberId, options) {
+  const memberOptions = { ...options ?? {} };
+  delete memberOptions.status;
+  const config = getCollectionConfig(collection);
+  if (!config.community?.memberWrite?.update) {
+    throw new NpForbiddenError(collection, "update");
+  }
+  const table = getCollectionTable(collection);
+  const dbForGate = getDb();
+  const originalDoc = await getDocumentByIdInternal(dbForGate, table, collection, docId);
+  if (!originalDoc) {
+    throw new NpNotFoundError(collection, docId);
+  }
+  const authorId = originalDoc.memberAuthorId ?? null;
+  if (authorId !== memberId) {
+    throw new NpForbiddenError(collection, "update");
+  }
+  const { assertNotBanned } = await import("./can-YLUHRJAB.js");
+  await assertNotBanned(memberId);
+  const moderation = await runMemberDocModeration({
+    collection,
+    data,
+    memberId,
+    targetId: docId
+  });
+  if (moderation.flaggedBy.length > 0) {
+    memberOptions.status = "pending";
+  }
+  const result = await saveDocumentImpl(
+    collection,
+    docId,
+    data,
+    { kind: "member", memberId },
+    memberOptions
+  );
+  const { recordAuditEvent } = await import("./audit-54XLVCWD.js");
+  await recordAuditEvent({
+    actor: { kind: "member", memberId },
+    action: moderation.flaggedBy.length > 0 ? "document.flag" : "document.update",
+    targetType: collection,
+    targetId: docId,
+    payload: {
+      collectionSlug: collection,
+      event: "update",
+      ...moderation.flaggedBy.length > 0 ? { sources: moderation.flaggedBy } : {},
+      ...moderation.profanityVerdict ? { profanityVerdict: moderation.profanityVerdict } : {},
+      ...moderation.spamVerdict ? { spamVerdict: moderation.spamVerdict } : {}
+    }
+  });
+  const resultStatus = result.doc.status;
+  if (resultStatus === "published") {
+    const { extractMentionHandlesFromDocData, fanOutMentionNotifications } = await import("./mentions-2IHFVSHW.js");
+    const previousHandles = new Set(extractMentionHandlesFromDocData(originalDoc));
+    await fanOutMentionNotifications({
+      actorMemberId: memberId,
+      kind: "document.mention",
+      data,
+      previousHandles,
+      payload: {
+        collectionSlug: collection,
+        documentId: docId
+      }
+    });
+  }
+  return result;
+}
+async function createMemberDocument(collection, data, memberId, options) {
+  const config = getCollectionConfig(collection);
+  if (!config.community?.memberWrite?.create) {
+    throw new NpForbiddenError(collection, "create");
+  }
+  const { assertNotBanned } = await import("./can-YLUHRJAB.js");
+  await assertNotBanned(memberId);
+  const defaultStatus = config.community?.memberWrite?.defaultStatus === "pending" ? "pending" : "published";
+  const moderation = await runMemberDocModeration({
+    collection,
+    data,
+    memberId,
+    targetId: ""
+  });
+  const flaggedBy = moderation.flaggedBy;
+  const spamStatus = flaggedBy.length > 0 ? "pending" : defaultStatus;
+  const memberOptions = { ...options ?? {}, status: spamStatus };
+  const result = await saveDocumentImpl(
+    collection,
+    null,
+    data,
+    { kind: "member", memberId },
+    memberOptions
+  );
+  const { applyReputation } = await import("./reputation-JRL2YQHM.js");
+  const { recordAuditEvent } = await import("./audit-54XLVCWD.js");
+  const documentId = getRecordId(result.doc);
+  await recordAuditEvent({
+    actor: { kind: "member", memberId },
+    action: flaggedBy.length > 0 ? "document.flag" : "document.create",
+    targetType: collection,
+    targetId: documentId,
+    payload: {
+      collectionSlug: collection,
+      event: "create",
+      ...flaggedBy.length > 0 ? { sources: flaggedBy } : {},
+      ...moderation.profanityVerdict ? { profanityVerdict: moderation.profanityVerdict } : {},
+      ...moderation.spamVerdict ? { spamVerdict: moderation.spamVerdict } : {}
+    }
+  });
+  if (spamStatus === "published") {
+    await applyReputation(memberId, {
+      kind: "document.created",
+      collectionSlug: collection,
+      documentId,
+      memberId
+    });
+  }
+  if (spamStatus === "published") {
+    const { fanOutMentionNotifications } = await import("./mentions-2IHFVSHW.js");
+    await fanOutMentionNotifications({
+      actorMemberId: memberId,
+      kind: "document.mention",
+      data,
+      payload: {
+        collectionSlug: collection,
+        documentId
+      }
+    });
+  }
+  return result;
+}
+async function runMemberDocModeration(input) {
+  const { collection, data, memberId, targetId } = input;
+  const config = getCollectionConfig(collection);
+  const { getSpamAdapter } = await import("./spam-adapter-XX3G737Z.js");
+  const { getProfanityAdapter } = await import("./profanity-adapter-NU2JQSLX.js");
+  const { getLogger: getLogger2 } = await import("./logger-S7REWDNE.js");
+  const moderationText = buildSearchVector(config, data);
+  const ctx = {
+    memberId,
+    targetType: collection,
+    targetId,
+    parentId: null
+  };
+  let profanityVerdict = null;
+  try {
+    const verdict = await getProfanityAdapter().check(moderationText, ctx);
+    if (verdict.kind === "reject") {
+      throw new NpValidationError("Invalid input", [
+        {
+          field: "body",
+          message: verdict.reason ?? "Submission contains prohibited language"
+        }
+      ]);
+    }
+    if (verdict.kind === "flag") {
+      profanityVerdict = {
+        reason: verdict.reason ?? null,
+        metadata: verdict.metadata ?? null
+      };
+    }
+  } catch (err) {
+    if (err instanceof NpValidationError) throw err;
+    getLogger2().warn("profanity adapter threw on doc write \u2014 treating as pass", {
+      error: err instanceof Error ? err.message : String(err),
+      collection,
+      memberId
+    });
+  }
+  let spamVerdict = null;
+  try {
+    const verdict = await getSpamAdapter().check(moderationText, ctx);
+    if (verdict.kind === "reject") {
+      throw new NpValidationError("Invalid input", [
+        {
+          field: "body",
+          message: verdict.reason ?? "Submission rejected"
+        }
+      ]);
+    }
+    if (verdict.kind === "flag") {
+      spamVerdict = {
+        reason: verdict.reason ?? null,
+        metadata: verdict.metadata ?? null
+      };
+    }
+  } catch (err) {
+    if (err instanceof NpValidationError) throw err;
+    getLogger2().warn("spam adapter threw on doc write \u2014 treating as pass", {
+      error: err instanceof Error ? err.message : String(err),
+      collection,
+      memberId
+    });
+  }
+  const flaggedBy = [];
+  if (profanityVerdict) flaggedBy.push("profanity");
+  if (spamVerdict) flaggedBy.push("spam");
+  return { flaggedBy, profanityVerdict, spamVerdict };
+}
+async function initSaveContext(collection, docId, data, actor, options) {
+  const config = getCollectionConfig(collection);
+  const registration = getCollectionRegistration(collection);
+  const table = getCollectionTable(collection);
+  const db = getDb();
+  const validatedData = toRecord(getCollectionZodSchema(config).parse(data));
+  const operation = docId ? "update" : "create";
+  const originalDoc = docId ? await getDocumentByIdInternal(db, table, collection, docId) : null;
+  return {
+    collection,
+    docId,
+    validatedData,
+    actor,
+    options,
+    config,
+    registration,
+    table,
+    db,
+    operation,
+    originalDoc,
+    userForHooks: actorUserOrNull(actor),
+    principal: actorPrincipal(actor)
+  };
+}
+async function validateActorAccess(ctx) {
+  if (ctx.actor.kind === "staff") {
+    await assertWriteAccess(
+      ctx.config,
+      ctx.collection,
+      ctx.operation,
+      ctx.actor.user,
+      ctx.validatedData,
+      ctx.originalDoc
+    );
+    return;
+  }
+  const { assertNotBanned } = await import("./can-YLUHRJAB.js");
+  if (ctx.operation === "create") {
+    if (!ctx.config.community?.memberWrite?.create) {
+      throw new NpForbiddenError(ctx.collection, "create");
+    }
+    await assertNotBanned(ctx.actor.memberId);
+    return;
+  }
+  if (!ctx.originalDoc) {
+    throw new NpNotFoundError(ctx.collection, ctx.docId ?? "unknown");
+  }
+  if (!ctx.config.community?.memberWrite?.update) {
+    throw new NpForbiddenError(ctx.collection, "update");
+  }
+  const authorId = ctx.originalDoc.memberAuthorId ?? null;
+  if (authorId !== ctx.actor.memberId) {
+    throw new NpForbiddenError(ctx.collection, "update");
+  }
+  await assertNotBanned(ctx.actor.memberId);
+}
+async function prepareDocumentForWrite(c) {
+  c.hookData = await runHooks(
+    c.operation === "create" ? c.config.hooks?.beforeCreate : c.config.hooks?.beforeUpdate,
+    {
+      data: c.validatedData,
+      user: c.userForHooks,
+      principal: c.principal,
+      collection: c.collection,
+      originalDoc: c.originalDoc
+    }
+  );
+  applySlugField(c.config, c.hookData, c.originalDoc);
+  let i18nResolved = null;
+  if (c.config.i18n) {
+    const i18n = getI18nConfig();
+    if (!i18n) {
+      throw new Error(
+        `Collection "${c.collection}" is i18n-enabled but the framework has no i18n config (setI18nConfig was never called).`
+      );
+    }
+    if (c.operation === "create") {
+      const requestedLocale = c.hookData.locale;
+      const locale = typeof requestedLocale === "string" && requestedLocale.length > 0 ? requestedLocale : i18n.defaultLocale;
+      if (!i18n.locales.includes(locale)) {
+        throw new NpValidationError("Invalid input", [
+          {
+            field: "locale",
+            message: `Locale "${locale}" is not configured. Allowed: ${i18n.locales.join(", ")}.`
+          }
+        ]);
+      }
+      const requestedGroup = c.hookData.translationGroupId;
+      const translationGroupId = typeof requestedGroup === "string" && requestedGroup.length > 0 ? requestedGroup : randomUUID();
+      i18nResolved = { locale, translationGroupId };
+    } else {
+      const original = c.originalDoc;
+      if (!original?.locale || !original.translationGroupId) {
+        throw new Error(
+          `i18n collection "${c.collection}" doc ${c.docId} is missing locale/translationGroupId. The row predates i18n opt-in; backfill required.`
+        );
+      }
+      i18nResolved = {
+        locale: original.locale,
+        translationGroupId: original.translationGroupId
+      };
+    }
+  }
+  c.prepared = prepareDocumentData(c.config.fields, c.hookData);
+  if (c.options?.status) {
+    c.prepared.mainData.status = c.options.status;
+  }
+  if (i18nResolved) {
+    c.prepared.mainData.locale = i18nResolved.locale;
+    c.prepared.mainData.translationGroupId = i18nResolved.translationGroupId;
+  }
+  if (c.operation === "create") {
+    const resolved = await getCurrentSiteId();
+    c.prepared.mainData.siteId = resolved ?? NP_DEFAULT_SITE_ID;
+  } else {
+    const original = c.originalDoc;
+    c.prepared.mainData.siteId = original?.siteId ?? NP_DEFAULT_SITE_ID;
+  }
+  if (c.actor.kind === "member") {
+    if (c.operation === "create") {
+      c.prepared.mainData.memberAuthorId = c.actor.memberId;
+    } else {
+      delete c.prepared.mainData.memberAuthorId;
+    }
+  }
+  c.now = /* @__PURE__ */ new Date();
+  const desiredStatus = c.prepared.mainData.status;
+  const publishedAtValue = c.prepared.mainData.publishedAt;
+  if (desiredStatus === "published" && publishedAtValue instanceof Date && publishedAtValue > c.now) {
+    c.prepared.mainData.status = "scheduled";
+  }
+  c.searchVector = buildWeightedSearchVectorSql(c.config, c.hookData);
+  const nextStatus = c.prepared.mainData.status ?? (c.operation === "update" ? c.originalDoc?.status ?? "published" : "published");
+  const previousStatus = c.originalDoc?.status;
+  const wasPublished = previousStatus === "published";
+  const willBePublished = nextStatus === "published";
+  c.publishTransition = !wasPublished && willBePublished;
+  c.unpublishTransition = wasPublished && !willBePublished;
+}
+async function persistDocumentTx(ctx) {
+  await runHook(
+    ctx.operation === "create" ? "content:beforeCreate" : "content:beforeUpdate",
+    {
+      collection: ctx.collection,
+      data: ctx.hookData,
+      originalDoc: ctx.originalDoc,
+      user: ctx.userForHooks,
+      principal: ctx.principal,
+      operation: ctx.operation
+    }
+  );
+  if (ctx.publishTransition) {
+    await runHook("content:beforePublish", {
+      collection: ctx.collection,
+      data: ctx.hookData,
+      originalDoc: ctx.originalDoc,
+      user: ctx.userForHooks,
+      principal: ctx.principal
+    });
+  }
+  if (ctx.unpublishTransition) {
+    await runHook("content:beforeUnpublish", {
+      collection: ctx.collection,
+      data: ctx.hookData,
+      originalDoc: ctx.originalDoc,
+      user: ctx.userForHooks,
+      principal: ctx.principal
+    });
+  }
+  return ctx.db.transaction(async (tx) => {
+    const persistedDoc = ctx.operation === "update" ? await updateMainDocument(
+      tx,
+      ctx.table,
+      ctx.collection,
+      ctx.docId,
+      ctx.prepared.mainData,
+      ctx.searchVector,
+      ctx.config,
+      ctx.userForHooks,
+      ctx.now
+    ) : await createMainDocument(
+      tx,
+      ctx.table,
+      ctx.prepared.mainData,
+      ctx.searchVector,
+      ctx.config,
+      ctx.userForHooks,
+      ctx.now
+    );
+    const persistedDocId = getRecordId(persistedDoc);
+    await syncChildTables(tx, ctx.registration.childTables, ctx.prepared.childRows, persistedDocId);
+    await syncJoinTables(tx, ctx.registration.joinTables, ctx.prepared.joinRows, persistedDocId);
+    await syncMediaRefsForDocument(tx, ctx.collection, persistedDocId, ctx.config.fields, ctx.hookData);
+    if (ctx.operation === "update" && ctx.config.slugField && ctx.originalDoc && typeof ctx.originalDoc.slug === "string" && typeof persistedDoc.slug === "string" && ctx.originalDoc.slug.length > 0 && ctx.originalDoc.slug !== persistedDoc.slug) {
+      const siteId = persistedDoc.siteId ?? NP_DEFAULT_SITE_ID;
+      await tx.insert(npSlugHistory).values({
+        siteId,
+        collection: ctx.collection,
+        documentId: String(persistedDocId),
+        oldSlug: ctx.originalDoc.slug,
+        newSlug: persistedDoc.slug
+      });
+    }
+    if (ctx.config.versions) {
+      const docStatus = persistedDoc.status;
+      const revisionStatus = docStatus === "published" ? "published" : "draft";
+      const maxRevisions = typeof ctx.config.versions === "object" && ctx.config.versions.max !== void 0 ? ctx.config.versions.max : void 0;
+      await insertRevision(
+        tx,
+        ctx.collection,
+        persistedDocId,
+        ctx.operation,
+        ctx.hookData,
+        ctx.originalDoc,
+        ctx.userForHooks,
+        revisionStatus,
+        maxRevisions
+      );
+    }
+    return persistedDoc;
+  });
+}
+async function firePostCommitHooks(ctx, savedDoc) {
+  const savedDocId = getRecordId(savedDoc);
+  const postCommitCtx = {
+    collection: ctx.collection,
+    documentId: savedDocId,
+    operation: ctx.operation
+  };
+  await runPostCommit(
+    "enqueue:content:afterSave",
+    postCommitCtx,
+    () => enqueueJob("content:afterSave", {
+      collection: ctx.collection,
+      documentId: savedDocId,
+      operation: ctx.operation,
+      userId: actorUserId(ctx.actor)
+    })
+  );
+  const pluginHookName = ctx.operation === "create" ? "content:afterCreate" : "content:afterUpdate";
+  await runPostCommit(
+    `hook:${pluginHookName}`,
+    postCommitCtx,
+    () => runHook(pluginHookName, {
+      collection: ctx.collection,
+      doc: savedDoc,
+      operation: ctx.operation,
+      user: ctx.userForHooks,
+      principal: ctx.principal
+    })
+  );
+  if (ctx.publishTransition) {
+    await runPostCommit(
+      "hook:content:afterPublish",
+      postCommitCtx,
+      () => runHook("content:afterPublish", {
+        collection: ctx.collection,
+        doc: savedDoc,
+        operation: ctx.operation,
+        user: ctx.userForHooks,
+        principal: ctx.principal
+      })
+    );
+  }
+}
+async function saveDocumentImpl(collection, docId, data, actor, options) {
+  const ctxBase = await initSaveContext(collection, docId, data, actor, options);
+  await validateActorAccess(ctxBase);
+  const ctx = ctxBase;
+  await prepareDocumentForWrite(ctx);
+  const savedDoc = await persistDocumentTx(ctx);
+  await firePostCommitHooks(ctx, savedDoc);
+  return { doc: savedDoc, operation: ctx.operation };
+}
+async function autosaveRevision(collection, documentId, data, user) {
+  const config = getCollectionConfig(collection);
+  const registration = getCollectionRegistration(collection);
+  const table = getCollectionTable(collection);
+  const db = getDb();
+  const drafts = config.versions?.drafts;
+  if (!drafts) {
+    throw new NpValidationError("Autosave not available", [
+      {
+        field: "collection",
+        message: `Collection "${collection}" has versions.drafts disabled \u2014 autosave is unavailable.`
+      }
+    ]);
+  }
+  const autosaveEnabled = typeof drafts === "object" && drafts.autosave === true;
+  if (!autosaveEnabled) {
+    throw new NpValidationError("Autosave disabled", [
+      {
+        field: "collection",
+        message: `Autosave is not enabled for "${collection}" \u2014 set versions.drafts.autosave = true.`
+      }
+    ]);
+  }
+  const originalDoc = await getDocumentByIdInternal(db, table, collection, documentId);
+  if (!originalDoc) {
+    throw new NpNotFoundError(collection, documentId);
+  }
+  await assertWriteAccess(config, collection, "update", user, data, originalDoc);
+  const [latestAutosave] = await db.select({
+    id: npRevisions.id,
+    version: npRevisions.version,
+    snapshot: npRevisions.snapshot,
+    createdAt: npRevisions.createdAt
+  }).from(npRevisions).where(
+    sql2`${eq(npRevisions.collection, collection)} and ${eq(npRevisions.documentId, documentId)} and ${eq(npRevisions.status, "autosave")}`
+  ).orderBy(desc(npRevisions.version)).limit(1);
+  if (latestAutosave && stableJson(latestAutosave.snapshot) === stableJson(data)) {
+    return {
+      id: latestAutosave.id,
+      version: latestAutosave.version,
+      status: "autosave",
+      createdAt: latestAutosave.createdAt,
+      reused: true
+    };
+  }
+  const maxRevisions = typeof config.versions === "object" && config.versions.max !== void 0 ? config.versions.max : void 0;
+  const inserted = await db.transaction(async (tx) => {
+    const [revisionCount] = await tx.select({ total: count() }).from(npRevisions).where(
+      sql2`${eq(npRevisions.collection, collection)} and ${eq(npRevisions.documentId, documentId)}`
+    );
+    const nextVersion = Number(revisionCount?.total ?? 0) + 1;
+    const createdAt = /* @__PURE__ */ new Date();
+    await tx.insert(npRevisions).values({
+      collection,
+      documentId,
+      version: nextVersion,
+      status: "autosave",
+      snapshot: data,
+      changedFields: getChangedFields(data, originalDoc, "update"),
+      authorId: user.id,
+      createdAt
+    });
+    if (maxRevisions !== void 0 && maxRevisions > 0 && nextVersion > maxRevisions) {
+      const overflow = nextVersion - maxRevisions;
+      const toDelete = await tx.select({ id: npRevisions.id }).from(npRevisions).where(
+        sql2`${eq(npRevisions.collection, collection)} and ${eq(npRevisions.documentId, documentId)}`
+      ).orderBy(asc(npRevisions.version)).limit(overflow);
+      if (toDelete.length > 0) {
+        const ids = toDelete.map((r) => r.id);
+        await tx.delete(npRevisions).where(sql2`${npRevisions.id} = any(${ids}::uuid[])`);
+      }
+    }
+    const [row] = await tx.select({ id: npRevisions.id }).from(npRevisions).where(
+      sql2`${eq(npRevisions.collection, collection)} and ${eq(npRevisions.documentId, documentId)} and ${eq(npRevisions.version, nextVersion)}`
+    ).limit(1);
+    return { id: row?.id ?? "", version: nextVersion, createdAt };
+  });
+  void registration;
+  return { ...inserted, status: "autosave", reused: false };
+}
+function stableJson(value) {
+  return JSON.stringify(value, (_key, val) => {
+    if (val && typeof val === "object" && !Array.isArray(val)) {
+      const sorted = {};
+      for (const k of Object.keys(val).sort()) {
+        sorted[k] = val[k];
+      }
+      return sorted;
+    }
+    return val;
+  });
+}
+async function deleteDocument(collection, docId, user) {
+  return deleteDocumentImpl(collection, docId, { kind: "staff", user });
+}
+async function deleteMemberDocument(collection, docId, memberId) {
+  const table = getCollectionTable(collection);
+  const db = getDb();
+  const original = await getDocumentByIdInternal(db, table, collection, docId);
+  const wasPublished = typeof original?.status === "string" && original.status === "published";
+  await deleteDocumentImpl(collection, docId, { kind: "member", memberId });
+  const { applyReputation } = await import("./reputation-JRL2YQHM.js");
+  const { recordAuditEvent } = await import("./audit-54XLVCWD.js");
+  await recordAuditEvent({
+    actor: { kind: "member", memberId },
+    action: "document.delete",
+    targetType: collection,
+    targetId: docId,
+    payload: {
+      collectionSlug: collection,
+      // Capture the status that was in effect at delete time so a
+      // mod re-reading the audit log can tell "they deleted a
+      // pending submission" from "they retracted a published
+      // post."
+      previousStatus: typeof original?.status === "string" ? original.status : null
+    }
+  });
+  if (wasPublished) {
+    await applyReputation(memberId, {
+      kind: "document.deleted",
+      collectionSlug: collection,
+      documentId: docId,
+      memberId
+    });
+  }
+}
+async function promoteMemberDocument(collection, docId, staffUserId) {
+  const table = getCollectionTable(collection);
+  const db = getDb();
+  const originalDoc = await getDocumentByIdInternal(db, table, collection, docId);
+  if (!originalDoc) {
+    throw new NpNotFoundError(collection, docId);
+  }
+  const status = originalDoc.status;
+  if (status !== "pending") {
+    throw new NpValidationError("Invalid input", [
+      {
+        field: "status",
+        message: `Cannot promote: document is ${status ?? "unknown"}, expected pending`
+      }
+    ]);
+  }
+  const memberAuthorId = originalDoc.memberAuthorId ?? null;
+  if (!memberAuthorId) {
+    throw new NpValidationError("Invalid input", [
+      {
+        field: "memberAuthorId",
+        message: "Cannot promote: document is not member-authored"
+      }
+    ]);
+  }
+  const requestSiteId = await getCurrentSiteId() ?? NP_DEFAULT_SITE_ID;
+  const now = /* @__PURE__ */ new Date();
+  const updated = await db.update(table).set({ status: "published", updatedAt: now, updatedBy: staffUserId }).where(
+    sql2`${eq(getTableColumn(table, "id"), docId)} and ${eq(getTableColumn(table, "status"), "pending")} and ${eq(getTableColumn(table, "siteId"), requestSiteId)}`
+  ).returning();
+  if (updated.length === 0) {
+    throw new NpValidationError("Invalid input", [
+      {
+        field: "status",
+        message: "Cannot promote: row is no longer pending (concurrent change)"
+      }
+    ]);
+  }
+  const persistedDoc = toRecord(updated[0]);
+  const { applyReputation } = await import("./reputation-JRL2YQHM.js");
+  const { recordAuditEvent } = await import("./audit-54XLVCWD.js");
+  await recordAuditEvent({
+    actor: { kind: "staff", userId: staffUserId },
+    action: "document.promote",
+    targetType: collection,
+    targetId: docId,
+    payload: {
+      collectionSlug: collection,
+      memberAuthorId,
+      previousStatus: "pending"
+    }
+  });
+  await applyReputation(memberAuthorId, {
+    kind: "document.created",
+    collectionSlug: collection,
+    documentId: docId,
+    memberId: memberAuthorId
+  });
+  return { doc: persistedDoc, operation: "update" };
+}
+async function deleteDocumentImpl(collection, docId, actor) {
+  const config = getCollectionConfig(collection);
+  const registration = getCollectionRegistration(collection);
+  const table = getCollectionTable(collection);
+  const db = getDb();
+  const originalDoc = await getDocumentByIdInternal(db, table, collection, docId);
+  if (!originalDoc) {
+    throw new NpNotFoundError(collection, docId);
+  }
+  if (actor.kind === "staff") {
+    if (config.access?.delete) {
+      const allowed = await config.access.delete({ user: actor.user, doc: originalDoc });
+      if (!allowed) {
+        throw new NpForbiddenError(collection, "delete");
+      }
+    }
+  } else {
+    if (!config.community?.memberWrite?.delete) {
+      throw new NpForbiddenError(collection, "delete");
+    }
+    const authorId = originalDoc.memberAuthorId ?? null;
+    if (authorId !== actor.memberId) {
+      throw new NpForbiddenError(collection, "delete");
+    }
+    const { assertNotBanned } = await import("./can-YLUHRJAB.js");
+    await assertNotBanned(actor.memberId);
+  }
+  const userForHooks = actorUserOrNull(actor);
+  const principal = actorPrincipal(actor);
+  await runHooks(config.hooks?.beforeDelete, {
+    data: originalDoc,
+    user: userForHooks,
+    principal,
+    collection,
+    originalDoc
+  });
+  await runHook("content:beforeDelete", {
+    collection,
+    doc: originalDoc,
+    user: userForHooks,
+    principal
+  });
+  await db.transaction(async (tx) => {
+    await deleteChildTables(tx, registration.childTables, docId);
+    await deleteJoinTables(tx, registration.joinTables, docId);
+    await tx.delete(npMediaRefs).where(
+      sql2`${eq(getTableColumn(npMediaRefs, "collection"), collection)} and ${eq(getTableColumn(npMediaRefs, "documentId"), docId)}`
+    );
+    const commentIdRows = await tx.select({
+      id: getTableColumn(npComments, "id")
+    }).from(npComments).where(
+      sql2`${eq(getTableColumn(npComments, "targetType"), collection)} and ${eq(getTableColumn(npComments, "targetId"), docId)}`
+    );
+    if (commentIdRows.length > 0) {
+      const commentIds = commentIdRows.map((row) => row.id);
+      await tx.delete(npReactions).where(
+        sql2`${eq(getTableColumn(npReactions, "targetType"), "comment")} and ${inArray(getTableColumn(npReactions, "targetId"), commentIds)}`
+      );
+      await tx.delete(npReports).where(
+        sql2`${eq(getTableColumn(npReports, "targetType"), "comment")} and ${inArray(getTableColumn(npReports, "targetId"), commentIds)}`
+      );
+    }
+    await tx.delete(npComments).where(
+      sql2`${eq(getTableColumn(npComments, "targetType"), collection)} and ${eq(getTableColumn(npComments, "targetId"), docId)}`
+    );
+    await tx.delete(npReactions).where(
+      sql2`${eq(getTableColumn(npReactions, "targetType"), collection)} and ${eq(getTableColumn(npReactions, "targetId"), docId)}`
+    );
+    await tx.delete(npReports).where(
+      sql2`${eq(getTableColumn(npReports, "targetType"), collection)} and ${eq(getTableColumn(npReports, "targetId"), docId)}`
+    );
+    await tx.delete(table).where(eq(getTableColumn(table, "id"), docId));
+  });
+  const postCommitCtx = { collection, documentId: docId, operation: "delete" };
+  await runPostCommit(
+    "enqueue:content:afterDelete",
+    postCommitCtx,
+    () => enqueueJob("content:afterDelete", {
+      collection,
+      documentId: docId,
+      userId: actorUserId(actor)
+    })
+  );
+  await runPostCommit(
+    "hook:content:afterDelete",
+    postCommitCtx,
+    () => runHook("content:afterDelete", {
+      collection,
+      documentId: docId,
+      user: userForHooks,
+      principal
+    })
+  );
+}
+async function findDocuments(collection, options, user) {
+  const config = getCollectionConfig(collection);
+  const table = getCollectionTable(collection);
+  const db = getDb();
+  const page = normalizePage(options.page);
+  const limit = normalizeLimit(options.limit);
+  const offset = (page - 1) * limit;
+  await assertReadAccess(config, collection, user ?? null);
+  let effectiveWhere = options.where ?? {};
+  if (config.i18n && options.locale) {
+    effectiveWhere = { ...effectiveWhere, locale: options.locale };
+  }
+  if (effectiveWhere.siteId === void 0) {
+    const resolved = await getCurrentSiteId();
+    effectiveWhere = {
+      ...effectiveWhere,
+      siteId: resolved ?? NP_DEFAULT_SITE_ID
+    };
+  } else if (effectiveWhere.siteId === "*") {
+    const { siteId: _siteId, ...rest } = effectiveWhere;
+    void _siteId;
+    effectiveWhere = rest;
+  }
+  if (effectiveWhere.visibility === void 0 && !user) {
+    effectiveWhere = { ...effectiveWhere, visibility: "public" };
+  } else if (effectiveWhere.visibility === "*") {
+    const { visibility: _vis, ...rest } = effectiveWhere;
+    void _vis;
+    effectiveWhere = rest;
+  }
+  const effectiveOptions = {
+    ...options,
+    where: effectiveWhere
+  };
+  const conditions = buildQueryConditions(table, effectiveOptions);
+  const whereClause = combineConditions(conditions);
+  const docs = await executeFindQuery(db, table, options, whereClause, limit, offset);
+  const totalResult = await (whereClause ? db.select({ total: count() }).from(table).where(whereClause) : db.select({ total: count() }).from(table).limit(1));
+  const totalDocs = Number(totalResult[0]?.total ?? 0);
+  const totalPages = totalDocs === 0 ? 0 : Math.ceil(totalDocs / limit);
+  return {
+    // Runtime rows are `Record<string, unknown>`; the generic `T`
+    // is a structural promise — generated wrapper functions narrow
+    // it to the per-collection document shape. We don't validate
+    // at runtime (Drizzle has already shaped the row to the table
+    // schema, which the generator derived from the same field
+    // configs T was generated from).
+    docs,
+    totalDocs,
+    totalPages,
+    page,
+    limit,
+    hasNextPage: page < totalPages,
+    hasPrevPage: page > 1 && totalDocs > 0
+  };
+}
+async function getDocumentById(collection, id, user) {
+  const config = getCollectionConfig(collection);
+  const table = getCollectionTable(collection);
+  const db = getDb();
+  const doc = await getDocumentByIdOptional(db, table, id);
+  if (!doc) {
+    return null;
+  }
+  const requestSiteId = await getCurrentSiteId() ?? NP_DEFAULT_SITE_ID;
+  const docSiteId = typeof doc.siteId === "string" && doc.siteId.length > 0 ? doc.siteId : NP_DEFAULT_SITE_ID;
+  if (docSiteId !== requestSiteId) {
+    throw new NpForbiddenError(collection, "cross-site");
+  }
+  if (config.access?.read) {
+    const allowed = await config.access.read({ user: user ?? null, doc });
+    if (!allowed) {
+      throw new NpForbiddenError(collection, "read");
+    }
+  }
+  return doc;
+}
+async function assertWriteAccess(config, collection, operation, user, data, originalDoc) {
+  const access = operation === "create" ? config.access?.create : config.access?.update;
+  if (!access) {
+    return;
+  }
+  const allowed = await access({ user, doc: originalDoc ?? void 0, data });
+  if (!allowed) {
+    throw new NpForbiddenError(collection, operation);
+  }
+}
+async function assertReadAccess(config, collection, user) {
+  if (!config.access?.read) {
+    return;
+  }
+  const allowed = await config.access.read({ user });
+  if (!allowed) {
+    throw new NpForbiddenError(collection, "read");
+  }
+}
+async function runHooks(hooks, args) {
+  let nextData = args.data;
+  for (const hook of hooks ?? []) {
+    nextData = await hook({
+      ...args,
+      data: nextData
+    });
+  }
+  return nextData;
+}
+async function createMainDocument(tx, table, mainData, searchVectorSql, config, user, now) {
+  const values = {
+    id: randomUUID(),
+    status: "published",
+    ...mainData,
+    createdBy: user?.id ?? null,
+    updatedBy: user?.id ?? null,
+    // Phase 10.7 — composed setweight() tsvector so titles
+    // outrank body matches at query time. The 11.x
+    // to_tsvector wrap (so colon-containing content doesn't
+    // crash the cast) is preserved inside each setweight call
+    // by buildWeightedSearchVectorSql.
+    searchVector: searchVectorSql
+  };
+  if (config.timestamps !== false) {
+    values.createdAt = now;
+    values.updatedAt = now;
+  }
+  const [created] = await tx.insert(table).values(values).returning();
+  return toRecord(created);
+}
+async function updateMainDocument(tx, table, collection, docId, mainData, searchVectorSql, config, user, now) {
+  if (!docId) {
+    throw new NpNotFoundError(collection, "unknown");
+  }
+  const values = {
+    ...mainData,
+    updatedBy: user?.id ?? null,
+    // Phase 10.7 — see createMainDocument: weighted setweight()
+    // tsvector preserves the 11.x to_tsvector safety AND adds
+    // title boost.
+    searchVector: searchVectorSql
+  };
+  if (config.timestamps !== false) {
+    values.updatedAt = now;
+  }
+  const [updated] = await tx.update(table).set(values).where(eq(getTableColumn(table, "id"), docId)).returning();
+  if (!updated) {
+    throw new NpNotFoundError(collection, docId);
+  }
+  return toRecord(updated);
+}
+async function syncChildTables(tx, childTables, childRows, documentId) {
+  for (const [fieldPath, rows] of Object.entries(childRows)) {
+    const table = resolveRelatedTable(childTables, fieldPath);
+    if (!table) {
+      continue;
+    }
+    const pgTable = table;
+    const parentColumnName = findParentColumnName(pgTable, ["parentId"]);
+    await tx.delete(pgTable).where(eq(getTableColumn(pgTable, parentColumnName), documentId));
+    if (rows.length === 0) {
+      continue;
+    }
+    const values = rows.map((row, index) => ({
+      id: randomUUID(),
+      ...row,
+      [parentColumnName]: documentId,
+      order: index
+    }));
+    await tx.insert(pgTable).values(values);
+  }
+}
+async function syncJoinTables(tx, joinTables, joinRows, documentId) {
+  for (const [fieldPath, ids] of Object.entries(joinRows)) {
+    const table = resolveRelatedTable(joinTables, fieldPath);
+    if (!table) {
+      continue;
+    }
+    const pgTable = table;
+    const parentColumnName = findParentColumnName(pgTable, ["parentId"]);
+    await tx.delete(pgTable).where(eq(getTableColumn(pgTable, parentColumnName), documentId));
+    if (ids.length === 0) {
+      continue;
+    }
+    const values = ids.map((targetId, index) => ({
+      id: randomUUID(),
+      [parentColumnName]: documentId,
+      targetId,
+      order: index
+    }));
+    await tx.insert(pgTable).values(values);
+  }
+}
+async function deleteChildTables(tx, childTables, documentId) {
+  for (const table of Object.values(childTables ?? {})) {
+    const pgTable = table;
+    const parentColumnName = findParentColumnName(pgTable, ["parentId"]);
+    await tx.delete(pgTable).where(eq(getTableColumn(pgTable, parentColumnName), documentId));
+  }
+}
+async function deleteJoinTables(tx, joinTables, documentId) {
+  for (const table of Object.values(joinTables ?? {})) {
+    const pgTable = table;
+    const parentColumnName = findParentColumnName(pgTable, ["parentId"]);
+    await tx.delete(pgTable).where(eq(getTableColumn(pgTable, parentColumnName), documentId));
+  }
+}
+async function insertRevision(tx, collection, documentId, operation, data, originalDoc, user, status, maxRevisions) {
+  const revisionConditions = sql2`${eq(npRevisions.collection, collection)} and ${eq(npRevisions.documentId, documentId)}`;
+  const [revisionCount] = await tx.select({ total: count() }).from(npRevisions).where(revisionConditions);
+  await tx.insert(npRevisions).values({
+    collection,
+    documentId,
+    version: Number(revisionCount?.total ?? 0) + 1,
+    status,
+    snapshot: data,
+    changedFields: getChangedFields(data, originalDoc, operation),
+    // `authorId` references np_users; member-authored revisions
+    // store null and the audit log carries the actual member id.
+    authorId: user?.id ?? null,
+    createdAt: /* @__PURE__ */ new Date()
+  });
+  if (maxRevisions !== void 0 && maxRevisions > 0) {
+    const currentCount = Number(revisionCount?.total ?? 0) + 1;
+    const overflow = currentCount - maxRevisions;
+    if (overflow > 0) {
+      const toDelete = await tx.select({ id: npRevisions.id }).from(npRevisions).where(revisionConditions).orderBy(asc(npRevisions.version)).limit(overflow);
+      if (toDelete.length > 0) {
+        const ids = toDelete.map((r) => r.id);
+        await tx.delete(npRevisions).where(sql2`${npRevisions.id} = any(${ids}::uuid[])`);
+      }
+    }
+  }
+}
+function buildQueryConditions(table, options) {
+  const conditions = [];
+  if (options.where) {
+    for (const [field, value] of Object.entries(options.where)) {
+      if (value === void 0) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        if (value.length === 0) {
+          conditions.push(sql2`false`);
+        } else {
+          conditions.push(inArray(getTableColumn(table, field), value));
+        }
+        continue;
+      }
+      conditions.push(eq(getTableColumn(table, field), value));
+    }
+  }
+  if (options.search) {
+    conditions.push(
+      sql2`${getTableColumn(table, "searchVector")} @@ plainto_tsquery('english', ${options.search})`
+    );
+  }
+  return conditions;
+}
+async function executeFindQuery(db, table, options, whereClause, limit, offset) {
+  if (options.search) {
+    const query = whereClause ? db.select().from(table).where(whereClause).orderBy(
+      sql2`ts_rank(${getTableColumn(table, "searchVector")}, plainto_tsquery('english', ${options.search})) DESC`
+    ).limit(limit).offset(offset) : db.select().from(table).orderBy(
+      sql2`ts_rank(${getTableColumn(table, "searchVector")}, plainto_tsquery('english', ${options.search})) DESC`
+    ).limit(limit).offset(offset);
+    return await query;
+  }
+  const orderClause = getSortOrderClause(table, options.sort);
+  if (whereClause && orderClause) {
+    return await db.select().from(table).where(whereClause).orderBy(orderClause).limit(limit).offset(offset);
+  }
+  if (whereClause) {
+    return await db.select().from(table).where(whereClause).limit(limit).offset(offset);
+  }
+  if (orderClause) {
+    return await db.select().from(table).orderBy(orderClause).limit(limit).offset(offset);
+  }
+  return await db.select().from(table).limit(limit).offset(offset);
+}
+function getSortOrderClause(table, sortValue) {
+  const sort = sortValue?.trim();
+  if (!sort) {
+    return void 0;
+  }
+  const isDescending = sort.startsWith("-");
+  const field = isDescending ? sort.slice(1) : sort;
+  const column = getTableColumn(table, field);
+  return isDescending ? desc(column) : asc(column);
+}
+async function getDocumentByIdInternal(db, table, collection, id, options) {
+  const doc = await getDocumentByIdOptional(db, table, id);
+  if (!doc) {
+    throw new NpNotFoundError(collection, id);
+  }
+  if (!options?.allowCrossSite) {
+    const requestSiteId = await getCurrentSiteId() ?? NP_DEFAULT_SITE_ID;
+    const docSiteId = typeof doc.siteId === "string" && doc.siteId.length > 0 ? doc.siteId : NP_DEFAULT_SITE_ID;
+    if (docSiteId !== requestSiteId) {
+      throw new NpForbiddenError(collection, "cross-site");
+    }
+  }
+  return doc;
+}
+async function getDocumentByIdOptional(db, table, id) {
+  const [doc] = await db.select().from(table).where(eq(getTableColumn(table, "id"), id)).limit(1);
+  return doc ? toRecord(doc) : null;
+}
+function prepareDocumentData(fields, data) {
+  const prepared = {
+    mainData: {},
+    childRows: {},
+    joinRows: {}
+  };
+  collectPreparedDocumentData(fields, data, prepared, []);
+  if (typeof data.slug === "string") {
+    prepared.mainData.slug = data.slug;
+  }
+  if (typeof data.locale === "string") {
+    prepared.mainData.locale = data.locale;
+  }
+  if (typeof data.translationGroupId === "string") {
+    prepared.mainData.translationGroupId = data.translationGroupId;
+  }
+  if (typeof data.siteId === "string") {
+    prepared.mainData.siteId = data.siteId;
+  }
+  if (typeof data.visibility === "string") {
+    prepared.mainData.visibility = data.visibility;
+  }
+  return prepared;
+}
+function collectPreparedDocumentData(fields, data, prepared, prefix) {
+  for (const field of fields) {
+    if (field.type === "row" || field.type === "collapsible") {
+      collectPreparedDocumentData(field.fields, data, prepared, prefix);
+      continue;
+    }
+    if (field.type === "group") {
+      const groupValue = toOptionalRecord(data[field.name]);
+      if (groupValue) {
+        collectPreparedDocumentData(field.fields, groupValue, prepared, [...prefix, field.name]);
+      }
+      continue;
+    }
+    const fieldPath = [...prefix, field.name];
+    const fieldKey = fieldPath.join(".");
+    const value = data[field.name];
+    if (field.type === "array") {
+      prepared.childRows[fieldKey] = normalizeChildRows(field.fields, value);
+      continue;
+    }
+    if (field.type === "relationship" && field.hasMany) {
+      prepared.joinRows[fieldKey] = normalizeJoinIds(value);
+      continue;
+    }
+    prepared.mainData[getFlattenedFieldName(prefix, field.name)] = value ?? null;
+  }
+}
+function normalizeChildRows(fields, value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((item) => {
+    const row = toOptionalRecord(item) ?? {};
+    const prepared = {
+      mainData: {},
+      childRows: {},
+      joinRows: {}
+    };
+    collectPreparedDocumentData(fields, row, prepared, []);
+    return prepared.mainData;
+  });
+}
+function normalizeJoinIds(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((item) => typeof item === "string");
+}
+async function syncMediaRefsForDocument(tx, collection, documentId, fields, data) {
+  const refs = extractMediaIdsFromFields(fields, data, []);
+  if (refs.length === 0) {
+    await tx.delete(npMediaRefs).where(
+      sql2`${eq(getTableColumn(npMediaRefs, "collection"), collection)} and ${eq(getTableColumn(npMediaRefs, "documentId"), documentId)}`
+    );
+    return;
+  }
+  await tx.delete(npMediaRefs).where(
+    sql2`${eq(getTableColumn(npMediaRefs, "collection"), collection)} and ${eq(getTableColumn(npMediaRefs, "documentId"), documentId)}`
+  );
+  const values = refs.map((ref) => ({
+    id: randomUUID(),
+    mediaId: ref.mediaId,
+    collection,
+    documentId,
+    field: ref.field
+  }));
+  await tx.insert(npMediaRefs).values(values);
+}
+function extractMediaIdsFromFields(fields, data, prefix) {
+  const refs = [];
+  for (const field of fields) {
+    if (field.type === "row" || field.type === "collapsible") {
+      refs.push(...extractMediaIdsFromFields(field.fields, data, prefix));
+      continue;
+    }
+    if (field.type === "group") {
+      const groupData = toOptionalRecord(data[field.name]);
+      if (groupData) {
+        refs.push(...extractMediaIdsFromFields(field.fields, groupData, [...prefix, field.name]));
+      }
+      continue;
+    }
+    const fieldPath = [...prefix, field.name].join(".");
+    if (field.type === "upload") {
+      const mediaId = data[field.name];
+      if (typeof mediaId === "string" && mediaId.length > 0) {
+        refs.push({ mediaId, field: fieldPath });
+      }
+      continue;
+    }
+    if (field.type === "richText") {
+      const richTextValue = data[field.name];
+      if (richTextValue && typeof richTextValue === "object") {
+        refs.push(...extractMediaIdsFromLexicalJson(richTextValue, fieldPath));
+      }
+      continue;
+    }
+    if (field.type === "array") {
+      const arrayValue = data[field.name];
+      if (Array.isArray(arrayValue)) {
+        for (const item of arrayValue) {
+          const itemRecord = toOptionalRecord(item);
+          if (itemRecord) {
+            refs.push(
+              ...extractMediaIdsFromFields(field.fields, itemRecord, [...prefix, field.name])
+            );
+          }
+        }
+      }
+      continue;
+    }
+    if (field.type === "blocks") {
+      const blocksValue = data[field.name];
+      if (Array.isArray(blocksValue)) {
+        for (const block of blocksValue) {
+          const blockRecord = toOptionalRecord(block);
+          if (blockRecord) {
+            extractBlockMediaIds(blockRecord, fieldPath, refs);
+          }
+        }
+      }
+      continue;
+    }
+  }
+  return refs;
+}
+function extractMediaIdsFromLexicalJson(node, fieldPath) {
+  const refs = [];
+  if (!node || typeof node !== "object") {
+    return refs;
+  }
+  const record = node;
+  if (record.type === "image" || record.type === "upload") {
+    const mediaId = record.mediaId ?? record.value;
+    if (typeof mediaId === "string" && mediaId.length > 0) {
+      refs.push({ mediaId, field: fieldPath });
+    }
+  }
+  const children = record.children ?? toOptionalRecord(record.root)?.children;
+  if (Array.isArray(children)) {
+    for (const child of children) {
+      refs.push(...extractMediaIdsFromLexicalJson(child, fieldPath));
+    }
+  }
+  return refs;
+}
+function extractBlockMediaIds(block, fieldPath, refs) {
+  for (const [key, value] of Object.entries(block)) {
+    if (key === "blockType" || key === "id") {
+      continue;
+    }
+    if (typeof value === "string" && isUuid(value)) {
+      refs.push({ mediaId: value, field: `${fieldPath}.${key}` });
+    }
+  }
+}
+function isUuid(value) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+function getChangedFields(data, originalDoc, operation) {
+  if (operation === "create" || !originalDoc) {
+    return Object.keys(data);
+  }
+  return Object.keys(data).filter((field) => !Object.is(data[field], originalDoc[field]));
+}
+function combineConditions(conditions) {
+  if (conditions.length === 0) {
+    return void 0;
+  }
+  return sql2`${sql2.join(conditions, sql2` and `)}`;
+}
+function resolveRelatedTable(tables, fieldPath) {
+  return tables?.[fieldPath] ?? tables?.[fieldPath.split(".").at(-1) ?? fieldPath];
+}
+function findParentColumnName(table, preferred) {
+  const keys = Object.keys(table);
+  for (const key of preferred) {
+    if (keys.includes(key)) {
+      return key;
+    }
+  }
+  const derived = keys.find(
+    (key) => key !== "id" && key !== "targetId" && key !== "order" && key.endsWith("Id")
+  );
+  if (!derived) {
+    throw new Error("Unable to resolve parent column for related table.");
+  }
+  return derived;
+}
+function getTableColumn(table, key) {
+  const column = table[key];
+  if (!column) {
+    throw new Error(`Column '${key}' not found on table.`);
+  }
+  return column;
+}
+function getRecordId(record) {
+  const id = record.id;
+  if (typeof id !== "string") {
+    throw new Error("Expected saved document to include a string id.");
+  }
+  return id;
+}
+function toRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Expected object record.");
+  }
+  return value;
+}
+function toOptionalRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function normalizePage(page) {
+  if (!page || page < 1) {
+    return 1;
+  }
+  return Math.floor(page);
+}
+function normalizeLimit(limit) {
+  if (!limit || limit < 1) {
+    return 10;
+  }
+  return Math.floor(limit);
+}
+function getFlattenedFieldName(prefix, name) {
+  if (prefix.length === 0) {
+    return toCamelCase(name);
+  }
+  return `${prefix.map(toPascalCase).join("")}${toPascalCase(name)}`.replace(
+    /^./u,
+    (char) => char.toLowerCase()
+  );
+}
+function toCamelCase(value) {
+  const parts = splitName(value);
+  const [first = "", ...rest] = parts;
+  return `${first}${rest.map(toPascalCase).join("")}`;
+}
+function toPascalCase(value) {
+  return splitName(value).map(capitalize).join("");
+}
+function splitName(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^a-zA-Z0-9]+/).map((part) => part.toLowerCase()).filter(Boolean);
+}
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+// src/plugins/context.ts
+async function resolveStorageSiteId() {
+  return await getCurrentSiteId() ?? NP_GLOBAL_PLUGIN_SITE_ID;
+}
+async function resolveSettingsSiteId() {
+  return await getCurrentSiteId() ?? NP_DEFAULT_SITE_ID;
+}
+var pluginPrincipal = (pluginId) => ({
+  id: `plugin:${pluginId}`,
+  email: `${pluginId}@plugins.local`,
+  name: `plugin/${pluginId}`,
+  role: "admin",
+  tokenVersion: 0
+});
+var pluginCache = /* @__PURE__ */ new Map();
+function cacheKey(pluginId, key) {
+  return `${pluginId}:${key}`;
+}
+function assertCap(pluginId, capabilities, required) {
+  if (!capabilities.includes(required)) {
+    throw new NpForbiddenError(
+      `plugin:${pluginId}`,
+      `capability "${required}" not declared in manifest`
+    );
+  }
+}
+async function loadOptionalNextCache() {
+  try {
+    const moduleId = "next/cache";
+    const mod = await import(moduleId);
+    return mod;
+  } catch {
+    return null;
+  }
+}
+function createPluginRuntimeContext(options) {
+  const { pluginId, capabilities, allowedHosts, config, registration, lookupRegistration } = options;
+  const db = () => getDb();
+  const principal = pluginPrincipal(pluginId);
+  const pluginLog = getScopedLogger({ pluginId });
+  return {
+    pluginId,
+    config,
+    capabilities,
+    content: {
+      async find(collection, query) {
+        assertCap(pluginId, capabilities, "content:read");
+        return findDocuments(collection, query ?? {}, principal);
+      },
+      async findOne(collection, id) {
+        assertCap(pluginId, capabilities, "content:read");
+        const doc = await getDocumentById(collection, id, principal);
+        return doc ?? null;
+      },
+      async create(collection, data) {
+        assertCap(pluginId, capabilities, "content:write");
+        const result = await saveDocument(collection, null, data, principal);
+        return result.doc;
+      },
+      async update(collection, id, data) {
+        assertCap(pluginId, capabilities, "content:write");
+        const result = await saveDocument(collection, id, data, principal);
+        return result.doc;
+      },
+      async delete(collection, id) {
+        assertCap(pluginId, capabilities, "content:delete");
+        await deleteDocument(collection, id, principal);
+      },
+      async count(collection) {
+        assertCap(pluginId, capabilities, "content:read");
+        const result = await findDocuments(collection, { limit: 1 }, principal);
+        return result.totalDocs;
+      }
+    },
+    media: {
+      async list(query) {
+        assertCap(pluginId, capabilities, "media:read");
+        return listMedia({
+          page: query?.page,
+          limit: query?.limit,
+          mimeType: query?.mimeType,
+          folderId: query?.folder
+        });
+      },
+      async getById(id) {
+        assertCap(pluginId, capabilities, "media:read");
+        return getMediaById(id);
+      },
+      async getUrl(id) {
+        assertCap(pluginId, capabilities, "media:read");
+        const media = await getMediaById(id);
+        if (!media || typeof media.storageKey !== "string") return "";
+        const adapter = getStorageAdapter();
+        return adapter.getUrl(media.storageKey);
+      },
+      async upload(file, metadata) {
+        assertCap(pluginId, capabilities, "media:write");
+        const buffer = Buffer.from(file instanceof ArrayBuffer ? new Uint8Array(file) : file);
+        return uploadMedia(
+          {
+            buffer,
+            originalFilename: metadata.filename,
+            mimeType: metadata.mimeType
+          },
+          // `uploaded_by` is a nullable FK to `np_users.id`. The
+          // previous `plugin:<id>` synthetic value violated the FK
+          // and threw at insert time, leaving the storage object
+          // orphaned. (#62) Plugin attribution lives in the audit
+          // log + plugin-storage layer; the uploader column is for
+          // staff-user provenance only.
+          null,
+          metadata.folder
+        );
+      },
+      async delete(id) {
+        assertCap(pluginId, capabilities, "media:delete");
+        const result = await deleteMedia(id);
+        if (!result.deleted && result.references && result.references.length > 0) {
+          throw new NpError(
+            `[plugin:${pluginId}] media.delete: ${id} is referenced by ${result.references.length} document(s).`,
+            "CONFLICT",
+            409
+          );
+        }
+      }
+    },
+    storage: {
+      // Phase 17 — every storage call resolves the current
+      // site at call time and uses it as part of the composite
+      // PK `(plugin_id, site_id, key)`. Background workers and
+      // scripts (no site resolver) fall back to the
+      // `_global_` sentinel so legacy single-site callers keep
+      // their existing keyspace.
+      async get(key) {
+        assertCap(pluginId, capabilities, "storage:kv");
+        const siteId = await resolveStorageSiteId();
+        const now = /* @__PURE__ */ new Date();
+        const rows = await db().select().from(npPluginStorage).where(
+          and(
+            eq2(npPluginStorage.pluginId, pluginId),
+            eq2(npPluginStorage.siteId, siteId),
+            eq2(npPluginStorage.key, key),
+            or(isNull(npPluginStorage.expiresAt), gt(npPluginStorage.expiresAt, now))
+          )
+        ).limit(1);
+        const row = rows[0];
+        return row?.value ?? null;
+      },
+      async set(key, value, opts) {
+        assertCap(pluginId, capabilities, "storage:kv");
+        const siteId = await resolveStorageSiteId();
+        const expiresAt = opts?.ttl && opts.ttl > 0 ? new Date(Date.now() + opts.ttl * 1e3) : null;
+        await db().insert(npPluginStorage).values({
+          pluginId,
+          siteId,
+          key,
+          value,
+          expiresAt,
+          updatedAt: /* @__PURE__ */ new Date()
+        }).onConflictDoUpdate({
+          target: [npPluginStorage.pluginId, npPluginStorage.siteId, npPluginStorage.key],
+          set: { value, expiresAt, updatedAt: /* @__PURE__ */ new Date() }
+        });
+      },
+      async delete(key) {
+        assertCap(pluginId, capabilities, "storage:kv");
+        const siteId = await resolveStorageSiteId();
+        await db().delete(npPluginStorage).where(
+          and(
+            eq2(npPluginStorage.pluginId, pluginId),
+            eq2(npPluginStorage.siteId, siteId),
+            eq2(npPluginStorage.key, key)
+          )
+        );
+      },
+      async list(prefix) {
+        assertCap(pluginId, capabilities, "storage:kv");
+        const siteId = await resolveStorageSiteId();
+        const now = /* @__PURE__ */ new Date();
+        const where = prefix ? and(
+          eq2(npPluginStorage.pluginId, pluginId),
+          eq2(npPluginStorage.siteId, siteId),
+          like(npPluginStorage.key, `${prefix}%`),
+          or(isNull(npPluginStorage.expiresAt), gt(npPluginStorage.expiresAt, now))
+        ) : and(
+          eq2(npPluginStorage.pluginId, pluginId),
+          eq2(npPluginStorage.siteId, siteId),
+          or(isNull(npPluginStorage.expiresAt), gt(npPluginStorage.expiresAt, now))
+        );
+        const rows = await db().select({ key: npPluginStorage.key }).from(npPluginStorage).where(where);
+        return rows.map((row) => row.key);
+      },
+      async has(key) {
+        assertCap(pluginId, capabilities, "storage:kv");
+        const siteId = await resolveStorageSiteId();
+        const now = /* @__PURE__ */ new Date();
+        const rows = await db().select({ key: npPluginStorage.key }).from(npPluginStorage).where(
+          and(
+            eq2(npPluginStorage.pluginId, pluginId),
+            eq2(npPluginStorage.siteId, siteId),
+            eq2(npPluginStorage.key, key),
+            or(isNull(npPluginStorage.expiresAt), gt(npPluginStorage.expiresAt, now))
+          )
+        ).limit(1);
+        return rows.length > 0;
+      }
+    },
+    cache: {
+      // The cache namespace is in-memory today (a process-
+      // scoped Map). The interface is `Promise<...>` so a
+      // future Redis-backed implementation can swap in
+      // without breaking plugin authors; the sync
+      // implementations return resolved promises directly so
+      // the require-await rule stays happy.
+      get(key) {
+        const entry = pluginCache.get(cacheKey(pluginId, key));
+        if (!entry) return Promise.resolve(null);
+        if (entry.expiresAt !== null && entry.expiresAt <= Date.now()) {
+          pluginCache.delete(cacheKey(pluginId, key));
+          return Promise.resolve(null);
+        }
+        return Promise.resolve(entry.value);
+      },
+      set(key, value, ttl) {
+        pluginCache.set(cacheKey(pluginId, key), {
+          value,
+          expiresAt: ttl && ttl > 0 ? Date.now() + ttl * 1e3 : null
+        });
+        return Promise.resolve();
+      },
+      invalidate(key) {
+        pluginCache.delete(cacheKey(pluginId, key));
+        return Promise.resolve();
+      },
+      invalidateAll() {
+        const prefix = `${pluginId}:`;
+        for (const key of pluginCache.keys()) {
+          if (key.startsWith(prefix)) pluginCache.delete(key);
+        }
+        return Promise.resolve();
+      }
+    },
+    settings: {
+      async getSite() {
+        assertCap(pluginId, capabilities, "settings:read");
+        const siteId = await resolveSettingsSiteId();
+        const rows = await db().select().from(npSettings).where(and(eq2(npSettings.siteId, siteId), eq2(npSettings.key, "site")));
+        const row = rows[0];
+        if (!row || !row.value || typeof row.value !== "object" || Array.isArray(row.value)) {
+          return {};
+        }
+        return row.value;
+      },
+      async getPlugin() {
+        const { getPluginConfig } = await import("./config-2GDU7PCK.js");
+        const value = await getPluginConfig(pluginId);
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+          return value;
+        }
+        return {};
+      },
+      async setPlugin(data) {
+        const { setPluginConfig } = await import("./config-2GDU7PCK.js");
+        const { getPluginRegistration: getPluginRegistration2 } = await import("./host-OBOI4MJK.js");
+        const reg = getPluginRegistration2(pluginId);
+        if (reg?.configSchema) {
+          await setPluginConfig(pluginId, data, null);
+          return;
+        }
+        const siteId = await getCurrentSiteId() ?? NP_DEFAULT_SITE_ID;
+        const now = /* @__PURE__ */ new Date();
+        await db().insert(npSettings).values({
+          siteId,
+          key: `plugin.config:${pluginId}`,
+          value: { __npVersion: 1, __npSettings: data },
+          updatedAt: now,
+          updatedBy: null
+        }).onConflictDoUpdate({
+          target: [npSettings.siteId, npSettings.key],
+          set: {
+            value: { __npVersion: 1, __npSettings: data },
+            updatedAt: now,
+            updatedBy: null
+          }
+        });
+      }
+    },
+    theme: {
+      async getTokens() {
+        assertCap(pluginId, capabilities, "theme:read");
+        const siteId = await resolveSettingsSiteId();
+        const rows = await db().select().from(npSettings).where(and(eq2(npSettings.siteId, siteId), eq2(npSettings.key, "theme")));
+        const row = rows[0];
+        if (!row || !row.value || typeof row.value !== "object" || Array.isArray(row.value)) {
+          return {};
+        }
+        return row.value;
+      },
+      async setTokens(partial) {
+        assertCap(pluginId, capabilities, "theme:write");
+        const siteId = await resolveSettingsSiteId();
+        const rows = await db().select().from(npSettings).where(and(eq2(npSettings.siteId, siteId), eq2(npSettings.key, "theme")));
+        const existing = rows[0] && rows[0].value && typeof rows[0].value === "object" && !Array.isArray(rows[0].value) ? rows[0].value : {};
+        const merged = { ...existing, ...partial };
+        await db().insert(npSettings).values({ siteId, key: "theme", value: merged, updatedAt: /* @__PURE__ */ new Date() }).onConflictDoUpdate({
+          target: [npSettings.siteId, npSettings.key],
+          set: { value: merged, updatedAt: /* @__PURE__ */ new Date() }
+        });
+      }
+    },
+    http: {
+      async fetch(url, opts) {
+        assertCap(pluginId, capabilities, "network:fetch");
+        let target;
+        try {
+          target = new URL(url);
+        } catch {
+          throw new NpError(
+            `[plugin:${pluginId}] http.fetch: invalid URL "${url}"`,
+            "INVALID_URL",
+            400
+          );
+        }
+        const hostMatches = allowedHosts.some((pattern) => {
+          if (pattern === target.hostname) return true;
+          if (pattern.startsWith("*.") && target.hostname.endsWith(pattern.slice(1))) return true;
+          return false;
+        });
+        if (!hostMatches) {
+          throw new NpForbiddenError(
+            `plugin:${pluginId}`,
+            `http.fetch to "${target.hostname}" blocked; add it to manifest.allowedHosts`
+          );
+        }
+        const timeoutMs = opts?.timeoutMs ?? 1e4;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+          let body;
+          if (opts?.body !== void 0 && opts.body !== null) {
+            if (typeof opts.body === "string") {
+              body = opts.body;
+            } else if (opts.body instanceof Uint8Array) {
+              body = opts.body;
+            } else {
+              body = JSON.stringify(opts.body);
+            }
+          }
+          const response = await globalThis.fetch(url, {
+            method: opts?.method ?? (body !== void 0 ? "POST" : "GET"),
+            headers: opts?.headers,
+            body,
+            signal: controller.signal
+          });
+          const headers = {};
+          response.headers.forEach((v, k) => {
+            headers[k] = v;
+          });
+          const contentType = response.headers.get("content-type") ?? "";
+          let parsedBody = void 0;
+          if (contentType.includes("application/json")) {
+            parsedBody = await response.json().catch(() => void 0);
+          } else if (contentType.startsWith("text/")) {
+            parsedBody = await response.text();
+          }
+          return {
+            ok: response.ok,
+            status: response.status,
+            headers,
+            body: parsedBody
+          };
+        } finally {
+          clearTimeout(timeout);
+        }
+      }
+    },
+    log: {
+      debug(message, data) {
+        pluginLog.debug(message, data);
+      },
+      info(message, data) {
+        pluginLog.info(message, data);
+      },
+      warn(message, data) {
+        pluginLog.warn(message, data);
+      },
+      error(message, data) {
+        pluginLog.error(message, data);
+      }
+    },
+    errors: {
+      // Plugin-side error reporting with pluginId auto-tagged. The host
+      // already auto-reports thrown hook handlers (in `dispatchHookHandler`),
+      // so plugins typically only need this when *catching* an error
+      // internally — e.g. a non-fatal upstream failure they want to log to
+      // Sentry but recover from.
+      report(error, context) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        return reportError(err, {
+          tags: { source: "plugin", pluginId, ...context?.tags },
+          extra: context?.extra,
+          user: context?.user
+        });
+      }
+    },
+    next: {
+      async revalidatePath(path) {
+        const mod = await loadOptionalNextCache();
+        mod?.revalidatePath?.(path);
+      },
+      async revalidateTag(tag) {
+        const mod = await loadOptionalNextCache();
+        const fn = mod?.revalidateTag;
+        if (typeof fn !== "function") return;
+        if (fn.length >= 2) {
+          fn(tag, "default");
+        } else {
+          fn(tag);
+        }
+      }
+    },
+    actions: {
+      register(actionName, handler) {
+        registration.actions.set(actionName, handler);
+      },
+      async dispatch(targetPluginId, actionName, data) {
+        const target = lookupRegistration(targetPluginId);
+        const action = target?.actions.get(actionName);
+        if (!action) {
+          return {
+            ok: false,
+            error: `Action "${actionName}" not found on plugin "${targetPluginId}"`
+          };
+        }
+        return action(data);
+      }
+    }
+  };
+}
+
+// src/plugins/enabled-gate.ts
+import { eq as eq3 } from "drizzle-orm";
+var DEFAULT_TTL_MS = 5e3;
+var cache = /* @__PURE__ */ new Map();
+var inflight = /* @__PURE__ */ new Map();
+var generation = /* @__PURE__ */ new Map();
+var ttlMs = DEFAULT_TTL_MS;
+function currentGeneration(pluginId) {
+  return generation.get(pluginId) ?? 0;
+}
+async function fetchEnabled(pluginId) {
+  if (fetchOverride) return fetchOverride(pluginId);
+  try {
+    const db = getDb();
+    const rows = await db.select({ enabled: npPlugins.enabled }).from(npPlugins).where(eq3(npPlugins.id, pluginId)).limit(1);
+    const row = rows[0];
+    if (row && typeof row.enabled === "boolean") {
+      return row.enabled;
+    }
+    return true;
+  } catch {
+    return true;
+  }
+}
+async function isPluginEnabled(pluginId) {
+  const now = Date.now();
+  const cached = cache.get(pluginId);
+  if (cached && cached.expiresAt > now) {
+    return cached.enabled;
+  }
+  const existing = inflight.get(pluginId);
+  if (existing) return existing;
+  const fetchGeneration = currentGeneration(pluginId);
+  const promise = fetchEnabled(pluginId).then((enabled) => {
+    if (currentGeneration(pluginId) === fetchGeneration) {
+      cache.set(pluginId, { enabled, expiresAt: Date.now() + ttlMs });
+    }
+    return enabled;
+  }).finally(() => {
+    if (inflight.get(pluginId) === promise) {
+      inflight.delete(pluginId);
+    }
+  });
+  inflight.set(pluginId, promise);
+  return promise;
+}
+function invalidatePluginEnabled(pluginId) {
+  cache.delete(pluginId);
+  inflight.delete(pluginId);
+  generation.set(pluginId, currentGeneration(pluginId) + 1);
+}
+var fetchOverride = null;
+
+// src/plugins/compat.ts
+var FRAMEWORK_VERSION_FROM_PACKAGE = "0.1.0";
+var frameworkVersion = FRAMEWORK_VERSION_FROM_PACKAGE;
+function getFrameworkVersion() {
+  return frameworkVersion;
+}
+function parse(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-.]+))?(?:\+[0-9A-Za-z-.]+)?$/.exec(version);
+  if (!match) return null;
+  const [, majorStr, minorStr, patchStr, prerelease] = match;
+  return {
+    major: Number.parseInt(majorStr ?? "0", 10),
+    minor: Number.parseInt(minorStr ?? "0", 10),
+    patch: Number.parseInt(patchStr ?? "0", 10),
+    prerelease: prerelease ?? null
+  };
+}
+function compareSemver(a, b) {
+  const pa = parse(a);
+  const pb = parse(b);
+  if (!pa || !pb) {
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+  if (pa.major !== pb.major) return pa.major < pb.major ? -1 : 1;
+  if (pa.minor !== pb.minor) return pa.minor < pb.minor ? -1 : 1;
+  if (pa.patch !== pb.patch) return pa.patch < pb.patch ? -1 : 1;
+  if (pa.prerelease === pb.prerelease) return 0;
+  if (pa.prerelease === null) return 1;
+  if (pb.prerelease === null) return -1;
+  return pa.prerelease < pb.prerelease ? -1 : 1;
+}
+function checkNexpressCompat(manifest, framework = getFrameworkVersion()) {
+  const min = manifest.nexpress?.minVersion;
+  if (!min) {
+    return { compatible: true };
+  }
+  if (compareSemver(framework, min) < 0) {
+    return {
+      compatible: false,
+      reason: `requires NexPress >= ${min}, host is ${framework}`
+    };
+  }
+  const max = manifest.nexpress?.maxVersion;
+  if (max && compareSemver(framework, max) > 0) {
+    return {
+      compatible: false,
+      reason: `requires NexPress <= ${max}, host is ${framework}`
+    };
+  }
+  return { compatible: true };
+}
+function topoSort(plugins) {
+  const skipped = [];
+  let eligible = [...plugins];
+  while (true) {
+    const eligibleIds2 = new Set(eligible.map((p) => p.id));
+    const stillEligible = [];
+    let dropped = false;
+    for (const plugin of eligible) {
+      const missing = plugin.requires.filter((dep) => !eligibleIds2.has(dep));
+      if (missing.length > 0) {
+        skipped.push({
+          id: plugin.id,
+          reason: `missing required plugin(s): ${missing.join(", ")}`
+        });
+        dropped = true;
+        continue;
+      }
+      stillEligible.push(plugin);
+    }
+    eligible = stillEligible;
+    if (!dropped) break;
+  }
+  const eligibleIds = new Set(eligible.map((p) => p.id));
+  const indegree = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  for (const plugin of eligible) {
+    indegree.set(plugin.id, 0);
+    dependents.set(plugin.id, []);
+  }
+  for (const plugin of eligible) {
+    for (const dep of plugin.requires) {
+      if (!eligibleIds.has(dep)) continue;
+      indegree.set(plugin.id, (indegree.get(plugin.id) ?? 0) + 1);
+      dependents.get(dep).push(plugin.id);
+    }
+  }
+  const queue = eligible.filter((p) => (indegree.get(p.id) ?? 0) === 0);
+  const ordered = [];
+  const byId = new Map(eligible.map((p) => [p.id, p]));
+  while (queue.length > 0) {
+    const next = queue.shift();
+    ordered.push(next);
+    for (const dependent of dependents.get(next.id) ?? []) {
+      const updated = (indegree.get(dependent) ?? 0) - 1;
+      indegree.set(dependent, updated);
+      if (updated === 0) {
+        const plugin = byId.get(dependent);
+        if (plugin) queue.push(plugin);
+      }
+    }
+  }
+  if (ordered.length !== eligible.length) {
+    for (const plugin of eligible) {
+      if (!ordered.includes(plugin)) {
+        skipped.push({
+          id: plugin.id,
+          reason: "dependency cycle \u2014 refusing to load"
+        });
+      }
+    }
+  }
+  return { ordered, skipped };
+}
+
+// src/plugins/host.ts
+function hookCapabilityFor(hookName) {
+  const namespace = hookName.split(":")[0];
+  if (!namespace) return null;
+  return `hooks:${namespace}`;
+}
+function assertCapability(pluginId, requirement, declared) {
+  if (declared.includes(requirement)) return;
+  throw new Error(
+    `[plugin:${pluginId}] declares capabilities ${JSON.stringify(declared)} but is registering something that requires "${requirement}". Add "${requirement}" to the plugin manifest's capabilities array.`
+  );
+}
+var pluginRegistry = /* @__PURE__ */ new Map();
+var globalHooks = /* @__PURE__ */ new Map();
+var globalRoutes = [];
+var DEFAULT_HOOK_PRIORITY = 100;
+function normalizeHookValue(value) {
+  if (typeof value === "function") {
+    return { handler: value, priority: DEFAULT_HOOK_PRIORITY };
+  }
+  if (value && typeof value === "object") {
+    const v = value;
+    if (typeof v.handler !== "function") return null;
+    return {
+      handler: v.handler,
+      priority: typeof v.priority === "number" ? v.priority : DEFAULT_HOOK_PRIORITY,
+      timeoutMs: typeof v.timeoutMs === "number" && v.timeoutMs > 0 ? v.timeoutMs : void 0
+    };
+  }
+  return null;
+}
+function insertSortedByPriority(list, entry) {
+  list.push(entry);
+  list.sort((a, b) => a.priority - b.priority);
+}
+async function loadPluginConfig(pluginId) {
+  const { getPluginConfig } = await import("./config-2GDU7PCK.js");
+  const value = await getPluginConfig(pluginId);
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return {};
+}
+async function buildCtxFor(pluginId) {
+  const registration = pluginRegistry.get(pluginId);
+  if (!registration) {
+    throw new Error(`[plugin:${pluginId}] attempted to build ctx before registration.`);
+  }
+  const config = await loadPluginConfig(pluginId);
+  return createPluginRuntimeContext({
+    pluginId,
+    capabilities: registration.capabilities,
+    allowedHosts: registration.allowedHosts,
+    config,
+    registration,
+    lookupRegistration: (id) => pluginRegistry.get(id)
+  });
+}
+function isResolvedPlugin(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  if (!candidate.manifest || typeof candidate.manifest !== "object") return false;
+  const manifest = candidate.manifest;
+  return typeof manifest.id === "string" && Array.isArray(manifest.capabilities);
+}
+function registerHookHandler(registration, hookName, handler) {
+  if (!registration.hooks.has(hookName)) {
+    registration.hooks.set(hookName, []);
+  }
+  insertSortedByPriority(registration.hooks.get(hookName), handler);
+  if (!globalHooks.has(hookName)) {
+    globalHooks.set(hookName, []);
+  }
+  insertSortedByPriority(globalHooks.get(hookName), handler);
+}
+function createPluginContext(pluginId, registration) {
+  return {
+    addCollection: () => {
+      throw new Error(
+        `[plugin:${pluginId}] Runtime collection registration not supported in v1. Add collections to nexpress.config.ts.`
+      );
+    },
+    addBlock: () => {
+      throw new Error(
+        `[plugin:${pluginId}] Runtime block registration not supported in v1. Add blocks to nexpress.config.ts.`
+      );
+    },
+    addHook: (collection, event, hook) => {
+      const hookName = `content:${event}`;
+      const requirement = hookCapabilityFor(hookName);
+      if (requirement) {
+        assertCapability(pluginId, requirement, registration.capabilities);
+      }
+      registerHookHandler(registration, hookName, {
+        pluginId,
+        priority: DEFAULT_HOOK_PRIORITY,
+        handler: async (data) => {
+          if (typeof data.collection === "string" && data.collection !== collection) {
+            return;
+          }
+          await hook({ data, collection });
+        }
+      });
+    }
+  };
+}
+async function loadResolvedPlugin(plugin) {
+  const { manifest } = plugin;
+  const previous = pluginRegistry.get(manifest.id);
+  if (previous) {
+    for (const [hookName, list] of previous.hooks) {
+      const global = globalHooks.get(hookName);
+      if (!global) continue;
+      const filtered = global.filter((h) => !list.includes(h));
+      if (filtered.length === 0) globalHooks.delete(hookName);
+      else globalHooks.set(hookName, filtered);
+    }
+    for (const route of previous.routes) {
+      const idx = globalRoutes.indexOf(route);
+      if (idx !== -1) globalRoutes.splice(idx, 1);
+    }
+  }
+  const registration = {
+    id: manifest.id,
+    name: manifest.name,
+    version: manifest.version,
+    description: manifest.description,
+    capabilities: [...manifest.capabilities],
+    allowedHosts: [...manifest.allowedHosts ?? []],
+    admin: plugin.admin,
+    hooks: /* @__PURE__ */ new Map(),
+    routes: [],
+    actions: /* @__PURE__ */ new Map(),
+    schedules: /* @__PURE__ */ new Map(),
+    configSchema: plugin.configSchema,
+    configVersion: plugin.configVersion,
+    configMigrate: plugin.configMigrate,
+    pageRoutes: normalizePageRoutes(plugin)
+  };
+  pluginRegistry.set(manifest.id, registration);
+  if (registration.configSchema !== void 0 && plugin.admin?.settings?.fields && plugin.admin.settings.fields.length > 0) {
+    getLogger().warn("Plugin declares both configSchema and admin.settings.fields", {
+      pluginId: manifest.id,
+      note: "Auto-form wins; admin.settings.fields is ignored at render time. Remove admin.settings.fields when migrating to configSchema."
+    });
+  }
+  const scheduledRaw = plugin.scheduled;
+  if (Array.isArray(scheduledRaw)) {
+    for (const entry of scheduledRaw) {
+      if (!entry || typeof entry !== "object") continue;
+      const e = entry;
+      if (typeof e.id !== "string" || e.id.length === 0) continue;
+      if (typeof e.cron !== "string" || e.cron.length === 0) continue;
+      if (typeof e.handler !== "function") continue;
+      registration.schedules.set(e.id, {
+        pluginId: manifest.id,
+        taskId: e.id,
+        cron: e.cron,
+        description: typeof e.description === "string" ? e.description : void 0,
+        handler: e.handler
+      });
+    }
+  }
+  for (const [hookName, rawValue] of Object.entries(plugin.hooks ?? {})) {
+    const normalized = normalizeHookValue(rawValue);
+    if (!normalized) continue;
+    const requirement = hookCapabilityFor(hookName);
+    if (requirement) {
+      assertCapability(manifest.id, requirement, registration.capabilities);
+    }
+    const userHandler = normalized.handler;
+    registerHookHandler(registration, hookName, {
+      pluginId: manifest.id,
+      priority: normalized.priority,
+      timeoutMs: normalized.timeoutMs,
+      handler: async (data) => {
+        const collection = typeof data.collection === "string" ? data.collection : void 0;
+        const ctx = await buildCtxFor(manifest.id);
+        return await userHandler({ hook: hookName, data, collection, ctx });
+      }
+    });
+  }
+  for (const route of plugin.routes ?? []) {
+    if (typeof route.handler !== "function") continue;
+    assertCapability(manifest.id, "api:route", registration.capabilities);
+    const userHandler = route.handler;
+    const wrapped = async (req) => {
+      const ctx = await buildCtxFor(manifest.id);
+      return userHandler(req, ctx);
+    };
+    const auth = route.auth === true;
+    const method = route.method.toUpperCase();
+    if (!auth && method !== "GET" && method !== "HEAD" && method !== "OPTIONS") {
+      getLogger().warn("Plugin registered a public mutating route", {
+        pluginId: manifest.id,
+        path: route.path,
+        method,
+        note: "Plugins are responsible for their own auth on `auth: false` routes. The framework rate-limits the plugin catch-all to 30 req/min/IP; verify the handler enforces signature / token checks before mutating state."
+      });
+    }
+    const entry = {
+      pluginId: manifest.id,
+      path: route.path,
+      method,
+      auth,
+      handler: wrapped
+    };
+    registration.routes.push(entry);
+    globalRoutes.push(entry);
+  }
+  const i18nBundles = plugin.i18n;
+  if (i18nBundles && typeof i18nBundles === "object") {
+    const { addStrings } = await import("./strings-VAE47B2C.js");
+    for (const [locale, bundle] of Object.entries(i18nBundles)) {
+      if (bundle && typeof bundle === "object") {
+        addStrings(locale, bundle);
+      }
+    }
+  }
+  const pluginTemplates = plugin.templates;
+  if (pluginTemplates && typeof pluginTemplates === "object") {
+    const { registerPluginTemplates } = await import("./templates-IFVJMCJ6.js");
+    registerPluginTemplates(manifest.id, pluginTemplates);
+  }
+  const setup = plugin.setup;
+  if (typeof setup === "function") {
+    const ctx = await buildCtxFor(manifest.id);
+    await setup(ctx);
+  }
+}
+async function loadLegacyPlugin(plugin) {
+  const registration = {
+    id: plugin.id,
+    name: plugin.name,
+    capabilities: ["hooks:content"],
+    allowedHosts: [],
+    hooks: /* @__PURE__ */ new Map(),
+    routes: [],
+    actions: /* @__PURE__ */ new Map(),
+    schedules: /* @__PURE__ */ new Map(),
+    // Legacy `init()` plugins predate the page-routes contract;
+    // they always register zero routes. Kept as a literal `[]` so
+    // the registration shape is consistent across the two paths
+    // and `getPluginPageRoutes()` doesn't need to special-case
+    // legacy entries.
+    pageRoutes: []
+  };
+  pluginRegistry.set(plugin.id, registration);
+  if (plugin.init) {
+    const ctx = createPluginContext(plugin.id, registration);
+    await plugin.init(ctx);
+  }
+}
+async function loadPlugins(plugins) {
+  const filtered = [];
+  for (const plugin of plugins) {
+    if (isResolvedPlugin(plugin)) {
+      const compat = checkNexpressCompat(plugin.manifest);
+      if (!compat.compatible) {
+        getLogger().warn("Skipping incompatible plugin", {
+          pluginId: plugin.manifest.id,
+          reason: compat.reason
+        });
+        continue;
+      }
+    }
+    filtered.push(plugin);
+  }
+  const legacy = [];
+  const resolved = [];
+  for (const plugin of filtered) {
+    if (isResolvedPlugin(plugin)) {
+      resolved.push(plugin);
+    } else {
+      legacy.push(plugin);
+    }
+  }
+  const sortInput = resolved.map((plugin) => ({
+    id: plugin.manifest.id,
+    requires: plugin.manifest.requires ?? [],
+    plugin
+  }));
+  const { ordered, skipped } = topoSort(sortInput);
+  for (const entry of skipped) {
+    getLogger().warn("Skipping plugin with unsatisfied dependency", {
+      pluginId: entry.id,
+      reason: entry.reason
+    });
+  }
+  for (const plugin of legacy) {
+    try {
+      await loadLegacyPlugin(plugin);
+    } catch (err) {
+      pluginRegistry.delete(plugin.id);
+      getLogger().error("Plugin failed to load \u2014 skipped", {
+        pluginId: plugin.id,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  for (const entry of ordered) {
+    try {
+      await loadResolvedPlugin(entry.plugin);
+    } catch (err) {
+      const pluginId = entry.plugin.manifest.id;
+      pluginRegistry.delete(pluginId);
+      getLogger().error("Plugin failed to load \u2014 skipped", {
+        pluginId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+}
+async function dispatchHookHandler(hookName, handler, data) {
+  try {
+    const result = handler.handler(data);
+    if (handler.timeoutMs === void 0 || !(result instanceof Promise)) {
+      const value = await result;
+      return { ok: true, value };
+    }
+    let timer;
+    const timeoutPromise = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        reject(
+          new Error(
+            `Plugin hook handler timed out after ${handler.timeoutMs}ms`
+          )
+        );
+      }, handler.timeoutMs);
+    });
+    try {
+      const value = await Promise.race([result, timeoutPromise]);
+      return { ok: true, value };
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    getLogger().error("Plugin hook handler threw", {
+      pluginId: handler.pluginId,
+      hook: hookName,
+      timeoutMs: handler.timeoutMs,
+      message: err.message,
+      stack: err.stack
+    });
+    void reportError(err, {
+      tags: { source: "plugin-hook", pluginId: handler.pluginId, hook: hookName }
+    });
+    return { ok: false };
+  }
+}
+async function runHook(hookName, data) {
+  const handlers = globalHooks.get(hookName);
+  if (!handlers || handlers.length === 0) return;
+  for (const handler of handlers) {
+    if (!await isPluginEnabled(handler.pluginId)) continue;
+    await dispatchHookHandler(hookName, handler, data);
+  }
+}
+async function runHookAndCollect(hookName, data) {
+  const handlers = globalHooks.get(hookName);
+  if (!handlers || handlers.length === 0) return [];
+  const results = [];
+  for (const handler of handlers) {
+    if (!await isPluginEnabled(handler.pluginId)) continue;
+    const outcome = await dispatchHookHandler(hookName, handler, data);
+    if (outcome.ok && outcome.value !== void 0 && outcome.value !== null) {
+      results.push(outcome.value);
+    }
+  }
+  return results;
+}
+function getPluginRoutes() {
+  return globalRoutes;
+}
+function getPluginPageRoutes() {
+  const out = [];
+  for (const [pluginId, registration] of pluginRegistry) {
+    for (const route of registration.pageRoutes) {
+      out.push({ pluginId, route });
+    }
+  }
+  return out;
+}
+function normalizePageRoutes(plugin) {
+  const raw = plugin.pageRoutes;
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object") continue;
+    const r = entry;
+    if (typeof r.pattern !== "string" || r.pattern.length === 0) continue;
+    if (typeof r.component !== "function") {
+      if (typeof r.component !== "object" || r.component === null) continue;
+    }
+    out.push({
+      pattern: r.pattern,
+      component: r.component,
+      metadata: r.metadata,
+      surface: r.surface === "member" ? "member" : "site",
+      locale: r.locale === "none" ? "none" : "auto"
+    });
+  }
+  return out;
+}
+function getPluginRegistration(pluginId) {
+  return pluginRegistry.get(pluginId);
+}
+function getAllPluginIds() {
+  return [...pluginRegistry.keys()];
+}
+function getPluginAdminExtension(pluginId) {
+  return pluginRegistry.get(pluginId)?.admin;
+}
+function getCollectionTabsForSlug(collectionSlug) {
+  const result = [];
+  for (const registration of pluginRegistry.values()) {
+    const tabs = registration.admin?.collectionTabs;
+    if (!tabs || tabs.length === 0) continue;
+    for (const tab of tabs) {
+      const matches = tab.collections === "*" || Array.isArray(tab.collections) && tab.collections.includes(collectionSlug);
+      if (!matches) continue;
+      result.push({
+        pluginId: registration.id,
+        pluginName: registration.name,
+        id: tab.id,
+        label: tab.label,
+        widgets: tab.widgets,
+        actions: tab.actions,
+        description: tab.description
+      });
+    }
+  }
+  return result;
+}
+function getDashboardWidgetsFromPlugins() {
+  const result = [];
+  for (const registration of pluginRegistry.values()) {
+    const widgets = registration.admin?.dashboardWidgets;
+    if (!widgets || widgets.length === 0) continue;
+    for (const widget of widgets) {
+      result.push({
+        pluginId: registration.id,
+        pluginName: registration.name,
+        id: widget.id,
+        label: widget.label,
+        kind: widget.kind,
+        actionId: widget.actionId,
+        description: widget.description,
+        priority: widget.priority
+      });
+    }
+  }
+  return result.map((widget, index) => ({ widget, index })).sort((a, b) => {
+    const ap = a.widget.priority ?? Number.POSITIVE_INFINITY;
+    const bp = b.widget.priority ?? Number.POSITIVE_INFINITY;
+    if (ap !== bp) return ap - bp;
+    return a.index - b.index;
+  }).map(({ widget }) => widget);
+}
+async function dispatchPluginAction(pluginId, actionId, data) {
+  const registration = pluginRegistry.get(pluginId);
+  if (!registration) {
+    return { ok: false, error: `Plugin "${pluginId}" is not registered` };
+  }
+  if (!await isPluginEnabled(pluginId)) {
+    return { ok: false, error: `Plugin "${pluginId}" is disabled` };
+  }
+  const handler = registration.actions.get(actionId);
+  if (!handler) {
+    return { ok: false, error: `Action "${actionId}" not found on plugin "${pluginId}"` };
+  }
+  return handler(data);
+}
+async function schedulePluginTask(pluginId, taskId) {
+  const { enqueueJob: enqueueJob2 } = await import("./queue-XE5BC75T.js");
+  await enqueueJob2("plugin:scheduledTask", { pluginId, taskId });
+}
+function getRegisteredPluginSchedules() {
+  const out = [];
+  for (const reg of pluginRegistry.values()) {
+    for (const schedule of reg.schedules.values()) {
+      out.push(schedule);
+    }
+  }
+  return out;
+}
+async function runPluginScheduledTask(pluginId, taskId) {
+  const registration = pluginRegistry.get(pluginId);
+  if (!registration) {
+    throw new Error(`Plugin "${pluginId}" is not registered`);
+  }
+  if (!await isPluginEnabled(pluginId)) {
+    getLogger().debug("Skipping plugin scheduled task \u2014 plugin disabled", {
+      pluginId,
+      taskId
+    });
+    return;
+  }
+  const entry = registration.schedules.get(taskId);
+  if (!entry) {
+    throw new Error(`Plugin "${pluginId}" has no scheduled task with id "${taskId}"`);
+  }
+  const ctx = await buildCtxFor(pluginId);
+  await entry.handler(ctx);
+}
+function resetPlugins() {
+  pluginRegistry.clear();
+  globalHooks.clear();
+  globalRoutes.length = 0;
+}
+
+export {
+  buildSearchVector,
+  buildSearchVectorParts,
+  buildWeightedSearchVectorSql,
+  buildZodSchema,
+  getCollectionZodSchema,
+  isPluginEnabled,
+  invalidatePluginEnabled,
+  getFrameworkVersion,
+  compareSemver,
+  checkNexpressCompat,
+  loadPlugins,
+  runHook,
+  runHookAndCollect,
+  getPluginRoutes,
+  getPluginPageRoutes,
+  getPluginRegistration,
+  getAllPluginIds,
+  getPluginAdminExtension,
+  getCollectionTabsForSlug,
+  getDashboardWidgetsFromPlugins,
+  dispatchPluginAction,
+  schedulePluginTask,
+  getRegisteredPluginSchedules,
+  runPluginScheduledTask,
+  resetPlugins,
+  saveDocument,
+  updateMemberDocument,
+  createMemberDocument,
+  autosaveRevision,
+  deleteDocument,
+  deleteMemberDocument,
+  promoteMemberDocument,
+  findDocuments,
+  getDocumentById
+};
+//# sourceMappingURL=chunk-VGTPQXNQ.js.map