@nexpress/core 0.1.0

package/dist/index.js

@@ -0,0 +1,2205 @@
+import {
+  getPluginConfig,
+  getPluginConfigWithStatus,
+  introspectThemeSettingsSchema,
+  pluginConfigCacheTag,
+  setPluginConfig
+} from "./chunk-QO7LAQZH.js";
+import {
+  getPluginTemplatesForCollection,
+  registerPluginTemplates,
+  resetPluginTemplates
+} from "./chunk-CRUQBZUF.js";
+import {
+  verifyStartupSafety
+} from "./chunk-2YDGE7YX.js";
+import {
+  InMemoryRateLimiter,
+  getOptionalRateLimiter,
+  getRateLimiter,
+  setRateLimiter
+} from "./chunk-2G264RCD.js";
+import {
+  clearCustomRoutes,
+  getCustomRoutes,
+  registerCustomRoute
+} from "./chunk-X5KKBOUS.js";
+import {
+  DEFAULT_SITE_SEO_SETTINGS,
+  buildArticleJsonLd,
+  buildAtomFeed,
+  buildDiscussionForumPostingJsonLd,
+  buildPageMetadata,
+  buildPersonJsonLd,
+  buildSitemap,
+  buildWebSiteJsonLd,
+  getSiteSeoSettings,
+  renderAtomFeed,
+  renderSitemapIndexXml,
+  renderSitemapXml,
+  validateSeoSettingsPatch
+} from "./chunk-DP2PREDU.js";
+import {
+  ARGON2_OPTIONS,
+  authenticated,
+  consumeMemberEmailVerifyToken,
+  consumeMemberPasswordReset,
+  consumePasswordResetToken,
+  createMemberEmailVerifyToken,
+  createPasswordResetToken,
+  fromArctic,
+  getMemberFromTokenPayload,
+  getOAuthProvider,
+  hashPassword,
+  invalidateAllMemberSessions,
+  invalidateAllSessions,
+  isAdmin,
+  isEditorOrAbove,
+  isOwnerOrAdmin,
+  isTokenVerificationError,
+  issueOAuthState,
+  listMemberIdentities,
+  listOAuthProviders,
+  listUserIdentities,
+  registerOAuthProvider,
+  requestMemberPasswordReset,
+  requestPasswordReset,
+  resetOAuthProviders,
+  resolveMemberOAuthLogin,
+  resolveOAuthLogin,
+  revokeMemberIdentity,
+  revokeUserIdentity,
+  sha256,
+  signMemberToken,
+  signToken,
+  verifyCsrf,
+  verifyMemberToken,
+  verifyOAuthState,
+  verifyPassword,
+  verifyToken,
+  verifyTokenFull
+} from "./chunk-OK5HOCQI.js";
+import {
+  DEFAULT_REACTION_KINDS,
+  addReaction,
+  assertReactableExists,
+  countReactions,
+  createComment,
+  createTranslation,
+  deleteComment,
+  fileReport,
+  findTranslations,
+  follow,
+  getMemberProfile,
+  getMemberProfiles,
+  getRevision,
+  getSearchAdapter,
+  getTranslationProgress,
+  grantMemberRole,
+  hideComment,
+  isFollowing,
+  issueBan,
+  listBansForMember,
+  listComments,
+  listFollowing,
+  listMemberReactions,
+  listMemberRoleGrants,
+  listPendingMemberDocs,
+  listReports,
+  listRevisions,
+  principalCan,
+  purgeMemberContent,
+  reindexCollection,
+  removeReaction,
+  renderCommentMarkdown,
+  resetSearchAdapter,
+  resolveReport,
+  restoreComment,
+  restoreRevision,
+  revokeBan,
+  revokeMemberRole,
+  searchCollections,
+  setSearchAdapter,
+  staffDeleteComment,
+  staffHideComment,
+  staffRestoreComment,
+  unfollow,
+  unresolvedReportCount,
+  updateComment
+} from "./chunk-6YI5K2TI.js";
+import {
+  buildDigestEmail,
+  runDigestSweep
+} from "./chunk-VNIHXQ7W.js";
+import {
+  getMutedTargetIds,
+  isMuted,
+  listMutes,
+  muteMember,
+  unmuteMember
+} from "./chunk-NUCGHWCF.js";
+import {
+  getMemberNotificationPrefs,
+  isNotificationKindEnabled,
+  listNotificationKinds,
+  recordDigestSent,
+  registerNotificationKind,
+  setMemberNotificationPrefs
+} from "./chunk-CTSQ7BRI.js";
+import {
+  MENTION_HANDLE_RE,
+  assertOwnsNotification,
+  createNotification,
+  extractMentionHandles,
+  extractMentionHandlesFromDocData,
+  extractMentionHandlesFromRichText,
+  fanOutMentionNotifications,
+  listNotifications,
+  markAllNotificationsRead,
+  markNotificationsRead,
+  resolveMentionedMembers,
+  unreadNotificationCount
+} from "./chunk-UGQSQO5B.js";
+import {
+  applyReputation,
+  getReputationAdapter,
+  resetReputationAdapter,
+  setReputationAdapter
+} from "./chunk-THX3SHYA.js";
+import {
+  getSpamAdapter,
+  resetSpamAdapter,
+  setSpamAdapter
+} from "./chunk-JKXAPSU4.js";
+import {
+  getProfanityAdapter,
+  resetProfanityAdapter,
+  setProfanityAdapter
+} from "./chunk-KU5M27ZC.js";
+import {
+  publishScheduledDocuments
+} from "./chunk-XPVQIHAQ.js";
+import {
+  assertNotBanned,
+  getCommunityRole,
+  listCommunityRoles,
+  memberCan,
+  registerCommunityRole,
+  resetCommunityRoles,
+  withMemberWrite
+} from "./chunk-55FU6WED.js";
+import {
+  autosaveRevision,
+  buildSearchVector,
+  buildSearchVectorParts,
+  buildWeightedSearchVectorSql,
+  buildZodSchema,
+  checkNexpressCompat,
+  compareSemver,
+  createMemberDocument,
+  deleteDocument,
+  deleteMemberDocument,
+  dispatchPluginAction,
+  findDocuments,
+  getAllPluginIds,
+  getCollectionTabsForSlug,
+  getCollectionZodSchema,
+  getDashboardWidgetsFromPlugins,
+  getDocumentById,
+  getFrameworkVersion,
+  getPluginAdminExtension,
+  getPluginPageRoutes,
+  getPluginRegistration,
+  getPluginRoutes,
+  getRegisteredPluginSchedules,
+  invalidatePluginEnabled,
+  isPluginEnabled,
+  loadPlugins,
+  promoteMemberDocument,
+  resetPlugins,
+  runHook,
+  runHookAndCollect,
+  runPluginScheduledTask,
+  saveDocument,
+  schedulePluginTask,
+  updateMemberDocument
+} from "./chunk-VGTPQXNQ.js";
+import {
+  can
+} from "./chunk-EQ2Z3KMD.js";
+import {
+  listAuditEvents,
+  recordAuditEvent
+} from "./chunk-RIPHIRPP.js";
+import {
+  DEFAULT_COMMUNITY_SETTINGS,
+  getCommunitySettings,
+  updateCommunitySettings,
+  validateCommunitySettingsPatch
+} from "./chunk-PPBWRKO2.js";
+import {
+  createDbConnection,
+  generateDocumentsModule,
+  generateDrizzleSchema,
+  generateTypeScript
+} from "./chunk-TFJ4MKPH.js";
+import {
+  npMediaFoldersRelations,
+  npMediaRefsRelations,
+  npMediaRelations,
+  npNavigationRelations,
+  npRevisionsRelations,
+  npSessionsRelations,
+  npSettingsRelations,
+  npUsersRelations
+} from "./chunk-PPAS4SZR.js";
+import {
+  formatDate,
+  formatNumber,
+  formatRelativeTime,
+  getCurrentLocale,
+  getLocaleDirection,
+  resetIntlFormatterCache,
+  resolveLocale
+} from "./chunk-MEJAHXIO.js";
+import {
+  addStrings,
+  clearStringOverrideCacheForSite,
+  deleteStringOverride,
+  getAllStrings,
+  getStringOverride,
+  getStringOverridesForSite,
+  getStrings,
+  listStringOverridesForSite,
+  loadStringOverridesForSite,
+  resetStringOverrideCache,
+  resetStrings,
+  resetTranslationCache,
+  setStringOverride,
+  setStrings,
+  t,
+  tSync
+} from "./chunk-QVJ2HCAX.js";
+import {
+  getI18nConfig,
+  resetI18nConfig,
+  setI18nConfig
+} from "./chunk-4ZLMEKFX.js";
+import {
+  NP_DEFAULT_SITE_ID,
+  createSite,
+  deleteSite,
+  ensureDefaultSite,
+  getAllCollectionSlugs,
+  getCollectionConfig,
+  getCollectionRegistration,
+  getCollectionTable,
+  getDefaultSite,
+  getSiteByHostname,
+  getSiteById,
+  getSiteUsageSummary,
+  listSites,
+  registerCollection,
+  resolveSiteForHostname,
+  updateSite
+} from "./chunk-FZ7O6DWI.js";
+import {
+  getCurrentSiteId,
+  resetCurrentSiteResolver,
+  setCurrentSiteResolver,
+  withCurrentSite
+} from "./chunk-SBCVAC2Z.js";
+import {
+  NpAuthError,
+  NpConflictError,
+  NpError,
+  NpForbiddenError,
+  NpNotFoundError,
+  NpRateLimitError,
+  NpSiteContextMissingError,
+  NpValidationError
+} from "./chunk-ZCINJSS4.js";
+import {
+  PAUSE_SYNC_INTERVAL_MS,
+  PgBossAdapter,
+  WORKER_HEARTBEAT_INTERVAL_MS,
+  WORKER_STALE_THRESHOLD_MS,
+  buildInviteEmail,
+  buildResetEmail,
+  configureBuiltinJobContext,
+  countAliveWorkers,
+  getAllJobHandlers,
+  getJobHandler,
+  getJobsPauseState,
+  listWorkerHealth,
+  markWorkerStopped,
+  purgeStaleWorkers,
+  recordHeartbeat,
+  registerBuiltinHandlers,
+  registerJobHandler,
+  setJobsPauseState,
+  startProducer,
+  startWorker,
+  stopProducer,
+  stopWorker
+} from "./chunk-ISLYFQWL.js";
+import {
+  DEFAULT_JOB_LOG_RETENTION_MS,
+  countJobLogs,
+  getCurrentJobId,
+  listJobLogs,
+  pruneJobLogsOlderThan,
+  recordJobLog,
+  runInJobContext
+} from "./chunk-DK2JBJH7.js";
+import {
+  NoopEmailAdapter,
+  getEmailAdapter,
+  resetEmailAdapter,
+  setEmailAdapter
+} from "./chunk-LSHHRDVR.js";
+import {
+  getErrorReporter,
+  noopErrorReporter,
+  reportError,
+  resetErrorReporter,
+  setErrorReporter
+} from "./chunk-WV272MPW.js";
+import {
+  extractMediaIds
+} from "./chunk-S27S42QY.js";
+import {
+  getMediaUrl
+} from "./chunk-BHK3AD3Q.js";
+import {
+  DEFAULT_IMAGE_SIZES,
+  cleanupDeletedMedia,
+  deleteMedia,
+  getMediaById,
+  getStorageAdapter,
+  listMedia,
+  processImage,
+  processMediaImage,
+  setStorageAdapter,
+  uploadMedia
+} from "./chunk-473S4TER.js";
+import {
+  enqueueJob,
+  getJobQueue,
+  getOptionalJobQueue,
+  setJobQueue
+} from "./chunk-V2UNHGAP.js";
+import "./chunk-OROPGO65.js";
+import {
+  consoleLogger,
+  getLogger,
+  getScopedLogger,
+  resetLogger,
+  setLogger
+} from "./chunk-JJL74ZPK.js";
+import {
+  getDb,
+  setDb
+} from "./chunk-XANPEOJC.js";
+import {
+  NP_GLOBAL_PLUGIN_SITE_ID,
+  npAuditEvents,
+  npBanKindEnum,
+  npBanScopeEnum,
+  npBans,
+  npCommentStatusEnum,
+  npComments,
+  npFollows,
+  npJobLogs,
+  npMedia,
+  npMediaFolders,
+  npMediaRefs,
+  npMediaStatusEnum,
+  npMemberIdentities,
+  npMemberMutes,
+  npMemberRoleScopeEnum,
+  npMemberRoles,
+  npMemberSessions,
+  npMemberStatusEnum,
+  npMembers,
+  npNavigation,
+  npNotifications,
+  npPasswordResetPurposeEnum,
+  npPluginStorage,
+  npPlugins,
+  npReactions,
+  npReports,
+  npRevisionStatusEnum,
+  npRevisions,
+  npSessions,
+  npSettings,
+  npSiteMemberships,
+  npSites,
+  npSlugHistory,
+  npStringOverrides,
+  npUserOAuthIdentities,
+  npUserRoleEnum,
+  npUsers,
+  npWorkerHeartbeats
+} from "./chunk-M43PGOQY.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/config/types.ts
+var ROLE_HIERARCHY = {
+  viewer: 0,
+  author: 1,
+  moderator: 1,
+  editor: 2,
+  admin: 3
+};
+
+// src/config/define-config.ts
+import { ZodError } from "zod";
+
+// src/config/validation.ts
+import { z } from "zod";
+var functionSchema = z.custom(
+  (value) => typeof value === "function"
+);
+var fieldBaseSchema = z.object({
+  name: z.string().min(1),
+  label: z.string().min(1).optional(),
+  required: z.boolean().optional(),
+  defaultValue: z.unknown().optional(),
+  hidden: z.boolean().optional(),
+  admin: z.object({
+    description: z.string().min(1).optional(),
+    placeholder: z.string().optional(),
+    readOnly: z.boolean().optional(),
+    condition: functionSchema.optional(),
+    width: z.string().optional()
+  }).optional(),
+  validate: functionSchema.optional()
+});
+var optionSchema = z.object({
+  label: z.string().min(1),
+  value: z.string().min(1)
+});
+var fieldSchema = z.lazy(
+  () => z.discriminatedUnion("type", [
+    fieldBaseSchema.extend({
+      type: z.literal("text"),
+      minLength: z.number().int().nonnegative().optional(),
+      maxLength: z.number().int().nonnegative().optional(),
+      unique: z.boolean().optional()
+    }),
+    fieldBaseSchema.extend({
+      type: z.literal("textarea"),
+      minLength: z.number().int().nonnegative().optional(),
+      maxLength: z.number().int().nonnegative().optional(),
+      rows: z.number().int().positive().optional()
+    }),
+    fieldBaseSchema.extend({
+      type: z.literal("number"),
+      min: z.number().optional(),
+      max: z.number().optional(),
+      step: z.number().positive().optional(),
+      integerOnly: z.boolean().optional()
+    }),
+    fieldBaseSchema.extend({
+      type: z.literal("richText"),
+      editor: z.object({ features: z.array(z.string()).optional() }).optional()
+    }),
+    fieldBaseSchema.extend({
+      type: z.literal("blocks"),
+      allowedBlocks: z.array(z.string().min(1)).optional(),
+      minRows: z.number().int().nonnegative().optional(),
+      maxRows: z.number().int().nonnegative().optional()
+    }),
+    fieldBaseSchema.extend({
+      type: z.literal("checkbox"),
+      defaultValue: z.boolean().optional()
+    }),
+    fieldBaseSchema.extend({
+      type: z.literal("date"),
+      pickerOptions: z.object({
+        format: z.string().optional(),
+        includeTime: z.boolean().optional()
+      }).optional()
+    }),
+    fieldBaseSchema.extend({
+      type: z.literal("upload"),
+      relationTo: z.string().min(1)
+    }),
+    fieldBaseSchema.extend({
+      type: z.literal("relationship"),
+      relationTo: z.union([z.string().min(1), z.array(z.string().min(1)).min(1)]),
+      hasMany: z.boolean().optional(),
+      filterOptions: z.record(z.string(), z.unknown()).optional()
+    }),
+    fieldBaseSchema.extend({
+      type: z.literal("select"),
+      options: z.array(optionSchema).min(1),
+      hasMany: z.boolean().optional()
+    }),
+    fieldBaseSchema.extend({
+      type: z.literal("radio"),
+      options: z.array(optionSchema).min(1)
+    }),
+    fieldBaseSchema.extend({
+      type: z.literal("email")
+    }),
+    fieldBaseSchema.extend({
+      type: z.literal("json")
+    }),
+    fieldBaseSchema.extend({
+      type: z.literal("array"),
+      fields: z.array(fieldSchema).min(1),
+      minRows: z.number().int().nonnegative().optional(),
+      maxRows: z.number().int().nonnegative().optional()
+    }),
+    fieldBaseSchema.extend({
+      type: z.literal("group"),
+      fields: z.array(fieldSchema).min(1)
+    }),
+    z.object({
+      type: z.literal("row"),
+      fields: z.array(fieldSchema).min(1)
+    }),
+    z.object({
+      type: z.literal("collapsible"),
+      label: z.string().min(1),
+      fields: z.array(fieldSchema).min(1)
+    })
+  ])
+);
+var imageSizeSchema = z.object({
+  name: z.string().min(1),
+  width: z.number().positive(),
+  height: z.number().positive().optional(),
+  crop: z.enum(["center", "top", "bottom", "left", "right"]).optional()
+});
+var storageSchema = z.discriminatedUnion("adapter", [
+  z.object({
+    adapter: z.literal("local"),
+    local: z.object({
+      directory: z.string().min(1),
+      baseUrl: z.string().min(1)
+    })
+  }),
+  z.object({
+    adapter: z.literal("s3"),
+    s3: z.object({
+      bucket: z.string().min(1),
+      region: z.string().min(1),
+      endpoint: z.string().url().optional()
+    })
+  })
+]);
+var pluginEntrySchema = z.unknown();
+var npConfigSchema = z.object({
+  site: z.object({
+    name: z.string().min(1),
+    url: z.string().url()
+  }),
+  db: z.object({
+    connectionString: z.string(),
+    pool: z.object({
+      max: z.number().int().positive().optional()
+    }).optional()
+  }),
+  storage: storageSchema.optional(),
+  collections: z.array(z.lazy(() => collectionConfigSchema)),
+  blocks: z.array(z.unknown()).optional(),
+  editor: z.object({
+    features: z.array(z.string().min(1)).optional()
+  }).optional(),
+  images: z.object({
+    sizes: z.array(imageSizeSchema).optional(),
+    format: z.enum(["webp", "avif", "jpeg", "png"]).optional(),
+    quality: z.number().int().min(1).max(100).optional()
+  }).optional(),
+  auth: z.object({
+    secret: z.string().min(1),
+    tokenExpiration: z.number().int().positive().optional(),
+    refreshTokenExpiration: z.number().int().positive().optional(),
+    maxLoginAttempts: z.number().int().positive().optional(),
+    lockoutDuration: z.number().int().positive().optional()
+  }).optional(),
+  plugins: z.array(pluginEntrySchema).optional(),
+  typescript: z.unknown().optional(),
+  themes: z.array(z.unknown()).optional(),
+  i18n: z.object({
+    locales: z.array(z.string().min(1).max(35)).min(1),
+    defaultLocale: z.string().min(1)
+  }).refine((val) => val.locales.includes(val.defaultLocale), {
+    message: "defaultLocale must be one of the declared locales",
+    path: ["defaultLocale"]
+  }).optional()
+});
+var collectionConfigSchema = z.object({
+  slug: z.string().min(1).max(63).regex(/^[a-z][a-z0-9-]*$/),
+  labels: z.object({
+    singular: z.string().min(1),
+    plural: z.string().min(1)
+  }),
+  slugField: z.union([
+    z.boolean(),
+    z.object({
+      useField: z.string().min(1).optional(),
+      unique: z.boolean().optional()
+    })
+  ]).optional(),
+  i18n: z.boolean().optional(),
+  fields: z.array(fieldSchema).min(1),
+  access: z.object({
+    create: functionSchema.optional(),
+    read: functionSchema.optional(),
+    update: functionSchema.optional(),
+    delete: functionSchema.optional()
+  }).optional(),
+  hooks: z.object({
+    beforeCreate: z.array(functionSchema).optional(),
+    afterCreate: z.array(functionSchema).optional(),
+    beforeUpdate: z.array(functionSchema).optional(),
+    afterUpdate: z.array(functionSchema).optional(),
+    beforeDelete: z.array(functionSchema).optional(),
+    afterDelete: z.array(functionSchema).optional(),
+    beforeRead: z.array(functionSchema).optional(),
+    afterRead: z.array(functionSchema).optional()
+  }).optional(),
+  versions: z.object({
+    drafts: z.union([
+      z.boolean(),
+      z.object({
+        autosave: z.boolean().optional(),
+        autosaveInterval: z.number().int().positive().optional()
+      })
+    ]).optional(),
+    max: z.number().int().positive().optional()
+  }).optional(),
+  community: z.object({
+    comments: z.boolean().optional(),
+    memberWrite: z.object({
+      create: z.boolean().optional(),
+      update: z.boolean().optional(),
+      delete: z.boolean().optional(),
+      defaultStatus: z.enum(["published", "pending"]).optional()
+    }).optional()
+  }).optional(),
+  timestamps: z.boolean().optional(),
+  admin: z.object({
+    listColumns: z.array(z.string().min(1)).optional(),
+    defaultSort: z.string().min(1).optional(),
+    group: z.string().min(1).optional(),
+    hidden: z.boolean().optional(),
+    description: z.string().optional(),
+    components: z.object({
+      listView: z.string().optional(),
+      editView: z.string().optional(),
+      createView: z.string().optional()
+    }).optional()
+  }).optional(),
+  upload: z.object({
+    maxFileSize: z.number().positive().optional(),
+    allowedMimeTypes: z.array(z.string().min(1)).optional(),
+    imageSizes: z.array(
+      z.object({
+        name: z.string().min(1),
+        width: z.number().positive(),
+        height: z.number().positive().optional(),
+        crop: z.enum(["center", "top", "bottom", "left", "right"]).optional()
+      })
+    ).optional()
+  }).optional()
+});
+
+// src/config/define-config.ts
+function defineConfig(config) {
+  try {
+    npConfigSchema.parse(config);
+  } catch (err) {
+    if (err instanceof ZodError) {
+      throw new Error(formatConfigError(err), { cause: err });
+    }
+    throw err;
+  }
+  if (config.i18n === void 0) {
+    const localized = config.collections.find((c) => c.i18n === true);
+    if (localized) {
+      throw new Error(
+        `Collection "${localized.slug}" sets i18n: true but the top-level config has no \`i18n\` block. Add \`i18n: { locales: [...], defaultLocale: "..." }\` to nexpress.config.ts.`
+      );
+    }
+  }
+  return config;
+}
+var FRIENDLY_HINTS = {
+  "auth.secret": "Set `NP_SECRET` in `.env` (\u226532 random chars) \u2014 `pnpm run setup` will generate one for you.",
+  "site.url": "Set `SITE_URL` in `.env` to your public origin \u2014 `pnpm run setup` collects it.",
+  "db.connectionString": "Set `DATABASE_URL` in `.env` to your Postgres connection string \u2014 `pnpm run setup` will write it.",
+  "storage.s3.bucket": "Set `NP_S3_BUCKET` in `.env` (or switch storage to local).",
+  "storage.s3.region": "Set `NP_S3_REGION` in `.env`."
+};
+function formatConfigError(err) {
+  const lines = err.issues.map((issue) => {
+    const path = issue.path.join(".");
+    const hint = FRIENDLY_HINTS[path];
+    if (hint) return `  \u2022 ${path}: ${hint}`;
+    return `  \u2022 ${path || "<root>"}: ${issue.message}`;
+  });
+  return [
+    "Invalid NexPress config \u2014 boot aborted before any service starts.",
+    "",
+    ...lines,
+    "",
+    "If this is your first run, `pnpm run setup` writes a working `.env`."
+  ].join("\n");
+}
+
+// src/config/define-collection.ts
+function defineCollection(config) {
+  return config;
+}
+
+// src/content/helpers.ts
+import { and as and2, desc, eq as eq2 } from "drizzle-orm";
+
+// src/theme/defaults.ts
+var DEFAULT_THEME = {
+  colors: {
+    primary: "oklch(0.546 0.245 262.881)",
+    primaryForeground: "oklch(0.985 0.001 106.423)",
+    background: "oklch(1 0 0)",
+    foreground: "oklch(0.145 0.004 285.823)",
+    muted: "oklch(0.967 0.001 286.375)",
+    mutedForeground: "oklch(0.556 0.007 286.618)",
+    border: "oklch(0.922 0.004 286.32)",
+    card: "oklch(1 0 0)",
+    cardForeground: "oklch(0.145 0.004 285.823)",
+    accent: "oklch(0.967 0.001 286.375)",
+    accentForeground: "oklch(0.145 0.004 285.823)",
+    destructive: "oklch(0.577 0.245 27.325)",
+    destructiveForeground: "oklch(0.985 0.001 106.423)"
+  },
+  typography: {
+    fontHeading: "system-ui, -apple-system, sans-serif",
+    fontBody: "system-ui, -apple-system, sans-serif",
+    fontMono: "ui-monospace, 'Cascadia Code', monospace",
+    fontSizeBase: "1rem",
+    lineHeight: "1.625",
+    fontSizeSm: "0.875rem",
+    fontSizeLg: "1.125rem",
+    fontSizeXl: "1.25rem",
+    fontSize2xl: "1.5rem",
+    fontSize3xl: "1.875rem",
+    fontSize4xl: "2.25rem"
+  },
+  shape: {
+    radiusSm: "0.25rem",
+    radiusMd: "0.375rem",
+    radiusLg: "0.5rem",
+    radiusFull: "9999px",
+    shadowSm: "0 1px 2px 0 rgb(0 0 0 / 0.05)",
+    shadowMd: "0 4px 6px -1px rgb(0 0 0 / 0.1)",
+    shadowLg: "0 10px 15px -3px rgb(0 0 0 / 0.1)"
+  }
+};
+
+// src/themes/registry.ts
+import { and, eq } from "drizzle-orm";
+var registry = /* @__PURE__ */ new Map();
+function registerThemes(themes) {
+  for (const theme of themes) {
+    if (!theme?.manifest?.id) {
+      throw new Error("Theme is missing manifest.id");
+    }
+    registry.set(theme.manifest.id, theme);
+    const impl = theme.impl;
+    if (impl?.i18n && typeof impl.i18n === "object") {
+      for (const [locale, bundle] of Object.entries(impl.i18n)) {
+        if (bundle && typeof bundle === "object") {
+          addStrings(locale, bundle);
+        }
+      }
+    }
+  }
+}
+function getRegisteredThemes() {
+  return Array.from(registry.values());
+}
+function getThemeById(id) {
+  return registry.get(id);
+}
+function resetThemes() {
+  registry.clear();
+}
+async function getActiveThemeId() {
+  const db = getDb();
+  const siteId = await getCurrentSiteId() ?? NP_DEFAULT_SITE_ID;
+  const rows = await db.select().from(npSettings).where(and(eq(npSettings.siteId, siteId), eq(npSettings.key, "activeTheme"))).limit(1);
+  const row = rows[0];
+  if (!row) return null;
+  return typeof row.value === "string" ? row.value : null;
+}
+async function getActiveTheme() {
+  const id = await getActiveThemeId();
+  if (id) {
+    const theme = registry.get(id);
+    if (theme) return theme;
+  }
+  const first = registry.values().next();
+  return first.done ? null : first.value;
+}
+async function setActiveThemeId(id, updatedBy = null) {
+  if (!registry.has(id)) {
+    throw new NpValidationError("Invalid input", [
+      {
+        field: "themeId",
+        message: `Unknown theme '${id}'. Register it in nexpress.config.ts first.`
+      }
+    ]);
+  }
+  const db = getDb();
+  const now = /* @__PURE__ */ new Date();
+  const siteId = await getCurrentSiteId() ?? NP_DEFAULT_SITE_ID;
+  await db.insert(npSettings).values({ siteId, key: "activeTheme", value: id, updatedAt: now, updatedBy }).onConflictDoUpdate({
+    target: [npSettings.siteId, npSettings.key],
+    set: { value: id, updatedAt: now, updatedBy }
+  });
+}
+async function getThemeTemplateSummaries(collectionSlug) {
+  const summaries = /* @__PURE__ */ new Map();
+  const { getPluginTemplatesForCollection: getPluginTemplatesForCollection2 } = await import("./templates-IFVJMCJ6.js");
+  for (const [id, value] of getPluginTemplatesForCollection2(collectionSlug)) {
+    const def = value;
+    summaries.set(id, {
+      id,
+      label: typeof def.label === "string" ? def.label : id,
+      description: typeof def.description === "string" ? def.description : void 0
+    });
+  }
+  const active = await getActiveTheme();
+  if (active) {
+    const impl = active.impl;
+    const set = impl.templates?.[collectionSlug];
+    if (set) {
+      for (const [id, def] of Object.entries(set)) {
+        summaries.set(id, {
+          id,
+          label: typeof def.label === "string" ? def.label : id,
+          description: typeof def.description === "string" ? def.description : void 0
+        });
+      }
+    }
+  }
+  return [...summaries.values()];
+}
+async function resolveTemplateComponent(collectionSlug, templateId) {
+  const active = await getActiveTheme();
+  if (active) {
+    const impl = active.impl;
+    const themeEntry = impl.templates?.[collectionSlug]?.[templateId];
+    if (themeEntry) return themeEntry;
+  }
+  const { getPluginTemplatesForCollection: getPluginTemplatesForCollection2 } = await import("./templates-IFVJMCJ6.js");
+  const pluginEntry = getPluginTemplatesForCollection2(collectionSlug).get(templateId);
+  return pluginEntry ?? null;
+}
+
+// src/content/helpers.ts
+async function resolveSiteId() {
+  return await getCurrentSiteId() ?? NP_DEFAULT_SITE_ID;
+}
+async function getTheme() {
+  const db = getDb();
+  const siteId = await resolveSiteId();
+  const rows = await db.select().from(npSettings).where(and2(eq2(npSettings.siteId, siteId), eq2(npSettings.key, "theme"))).limit(1);
+  const active = await getActiveTheme();
+  const themeOverlay = active?.impl?.tokens;
+  const dbOverlay = rows[0]?.value;
+  if (!themeOverlay && !dbOverlay) return DEFAULT_THEME;
+  return mergeThemeTokens(DEFAULT_THEME, themeOverlay, dbOverlay);
+}
+function mergeThemeTokens(base, ...overlays) {
+  const result = {
+    colors: { ...base.colors },
+    typography: { ...base.typography },
+    shape: { ...base.shape }
+  };
+  for (const overlay of overlays) {
+    if (!overlay) continue;
+    if (overlay.colors) Object.assign(result.colors, overlay.colors);
+    if (overlay.typography) Object.assign(result.typography, overlay.typography);
+    if (overlay.shape) Object.assign(result.shape, overlay.shape);
+  }
+  return result;
+}
+async function getNavigation(location = "header") {
+  const db = getDb();
+  const siteId = await resolveSiteId();
+  const rows = await db.select().from(npNavigation).where(
+    and2(eq2(npNavigation.siteId, siteId), eq2(npNavigation.location, location))
+  ).limit(1);
+  if (rows.length === 0 || !rows[0]) {
+    return [];
+  }
+  return resolveNavItemUrls(rows[0].items);
+}
+async function resolveNavItemUrls(items) {
+  const refsByCollection = collectPageRefs(items);
+  const docByKey = /* @__PURE__ */ new Map();
+  await Promise.all(
+    [...refsByCollection.entries()].map(async ([collection, ids]) => {
+      try {
+        await Promise.all(
+          ids.map(async (id) => {
+            const result = await findDocuments(collection, {
+              where: { id, status: "published" },
+              limit: 1
+            });
+            const doc = result.docs[0];
+            if (doc) docByKey.set(`${collection}\0${id}`, doc);
+          })
+        );
+      } catch {
+      }
+    })
+  );
+  return items.map((item) => mapNavItem(item, docByKey));
+}
+function collectPageRefs(items) {
+  const out = /* @__PURE__ */ new Map();
+  const walk = (arr) => {
+    for (const item of arr) {
+      if (item.type === "page" && item.pageId) {
+        const slug = item.collectionSlug ?? "pages";
+        const ids = out.get(slug) ?? [];
+        ids.push(item.pageId);
+        out.set(slug, ids);
+      }
+      if (item.children) walk(item.children);
+    }
+  };
+  walk(items);
+  return out;
+}
+function mapNavItem(item, docByKey) {
+  const children = item.children ? item.children.map((child) => mapNavItem(child, docByKey)) : void 0;
+  const withChildren = children ? { ...item, children } : item;
+  if (item.type === "page" && item.pageId) {
+    const collection = item.collectionSlug ?? "pages";
+    const doc = docByKey.get(`${collection}\0${item.pageId}`);
+    let url = "#";
+    if (doc) {
+      try {
+        const config = getCollectionConfig(collection);
+        const path = config.seo?.urlPath?.(doc);
+        if (path) url = path;
+      } catch {
+      }
+    }
+    return { ...withChildren, url };
+  }
+  if (item.type === "collection" && item.collection) {
+    const slug = item.collection.replace(/^\/+/, "");
+    const url = slug ? `/${slug}` : "#";
+    return { ...withChildren, url };
+  }
+  return withChildren;
+}
+async function getPageBySlug(slug, options) {
+  const where = { slug: slug || "/" };
+  if (!options?.draft) {
+    where.status = "published";
+  }
+  const result = await findDocuments("pages", {
+    where,
+    locale: options?.locale,
+    limit: 1
+  });
+  return result.docs[0] ?? null;
+}
+async function getPostBySlug(slug, options) {
+  const where = { slug };
+  if (!options?.draft) {
+    where.status = "published";
+  }
+  const result = await findDocuments("posts", {
+    where,
+    limit: 1
+  });
+  return result.docs[0] ?? null;
+}
+async function findPosts(options, user) {
+  return findDocuments("posts", options, user);
+}
+async function getAllPageSlugs() {
+  const result = await findDocuments("pages", {
+    limit: 1e4
+  });
+  return result.docs.map((doc) => doc.slug).filter(Boolean);
+}
+var SLUG_REDIRECT_MAX_HOPS = 5;
+async function findSlugRedirect(collection, oldSlug) {
+  if (!oldSlug || oldSlug.length === 0) return null;
+  const db = getDb();
+  const siteId = await resolveSiteId();
+  const seen = /* @__PURE__ */ new Set([oldSlug]);
+  let currentOld = oldSlug;
+  let resolved = null;
+  for (let hop = 0; hop < SLUG_REDIRECT_MAX_HOPS; hop++) {
+    const [latest] = await db.select().from(npSlugHistory).where(
+      and2(
+        eq2(npSlugHistory.siteId, siteId),
+        eq2(npSlugHistory.collection, collection),
+        eq2(npSlugHistory.oldSlug, currentOld)
+      )
+    ).orderBy(desc(npSlugHistory.createdAt)).limit(1);
+    if (!latest) break;
+    const next = latest.newSlug;
+    if (next === oldSlug || seen.has(next)) {
+      break;
+    }
+    resolved = next;
+    seen.add(next);
+    currentOld = next;
+  }
+  return resolved;
+}
+async function getSetting(key) {
+  const db = getDb();
+  const siteId = await resolveSiteId();
+  const rows = await db.select().from(npSettings).where(and2(eq2(npSettings.siteId, siteId), eq2(npSettings.key, key))).limit(1);
+  if (rows.length === 0 || !rows[0]) {
+    return null;
+  }
+  return rows[0].value;
+}
+
+// src/storage/local.ts
+import { createReadStream, createWriteStream } from "fs";
+import { access, mkdir, unlink, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+var LocalStorageAdapter = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  async upload(key, data, _) {
+    const filePath = this.resolvePath(key);
+    await mkdir(dirname(filePath), { recursive: true });
+    if (Buffer.isBuffer(data)) {
+      await writeFile(filePath, data);
+      return;
+    }
+    await pipeline(Readable.fromWeb(data), createWriteStream(filePath));
+  }
+  getStream(key) {
+    return Promise.resolve(
+      Readable.toWeb(createReadStream(this.resolvePath(key)))
+    );
+  }
+  getUrl(key) {
+    const base = this.normalizeBaseUrl(this.config.baseUrl);
+    if (base.startsWith("/")) {
+      return Promise.resolve(`${base}/${key}`);
+    }
+    return Promise.resolve(new URL(key, `${base}/`).toString());
+  }
+  async delete(key) {
+    await unlink(this.resolvePath(key));
+  }
+  async exists(key) {
+    try {
+      await access(this.resolvePath(key));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  resolvePath(key) {
+    return join(this.config.directory, key);
+  }
+  normalizeBaseUrl(baseUrl) {
+    return baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  }
+};
+
+// src/storage/s3.ts
+import { Readable as Readable2 } from "stream";
+var s3ModulePromise = null;
+var S3StorageAdapter = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  clientPromise = null;
+  async upload(key, data, metadata) {
+    const [{ PutObjectCommand }, client] = await Promise.all([
+      loadS3Module(),
+      this.getClient()
+    ]);
+    await client.send(
+      new PutObjectCommand({
+        Bucket: this.config.bucket,
+        Key: key,
+        Body: Buffer.isBuffer(data) ? data : Readable2.fromWeb(data),
+        ContentType: metadata.contentType,
+        ContentLength: metadata.contentLength,
+        Metadata: {
+          originalFilename: metadata.originalFilename
+        }
+      })
+    );
+  }
+  async getStream(key) {
+    const [{ GetObjectCommand }, client] = await Promise.all([
+      loadS3Module(),
+      this.getClient()
+    ]);
+    const response = await client.send(
+      new GetObjectCommand({
+        Bucket: this.config.bucket,
+        Key: key
+      })
+    );
+    return toReadableStream(response.Body);
+  }
+  getUrl(key) {
+    if (this.config.endpoint) {
+      return Promise.resolve(
+        new URL(
+          key,
+          `${normalizeUrl(this.config.endpoint)}/${this.config.bucket}/`
+        ).toString()
+      );
+    }
+    return Promise.resolve(
+      new URL(
+        key,
+        `https://${this.config.bucket}.s3.${this.config.region}.amazonaws.com/`
+      ).toString()
+    );
+  }
+  async delete(key) {
+    const [{ DeleteObjectCommand }, client] = await Promise.all([
+      loadS3Module(),
+      this.getClient()
+    ]);
+    await client.send(
+      new DeleteObjectCommand({
+        Bucket: this.config.bucket,
+        Key: key
+      })
+    );
+  }
+  async exists(key) {
+    const [{ HeadObjectCommand }, client] = await Promise.all([
+      loadS3Module(),
+      this.getClient()
+    ]);
+    try {
+      await client.send(
+        new HeadObjectCommand({
+          Bucket: this.config.bucket,
+          Key: key
+        })
+      );
+      return true;
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  getClient() {
+    if (!this.clientPromise) {
+      this.clientPromise = this.createClient();
+    }
+    return this.clientPromise;
+  }
+  async createClient() {
+    const { S3Client } = await loadS3Module();
+    return new S3Client({
+      region: this.config.region,
+      endpoint: this.config.endpoint,
+      credentials: this.config.credentials,
+      forcePathStyle: Boolean(this.config.endpoint)
+    });
+  }
+};
+async function loadS3Module() {
+  s3ModulePromise ??= import("@aws-sdk/client-s3");
+  return s3ModulePromise;
+}
+function toReadableStream(body) {
+  if (hasTransformToWebStream(body)) {
+    return body.transformToWebStream();
+  }
+  if (body instanceof Readable2) {
+    return Readable2.toWeb(body);
+  }
+  throw new Error("S3 object body is not a readable stream.");
+}
+function hasTransformToWebStream(value) {
+  return typeof value === "object" && value !== null && "transformToWebStream" in value && typeof value.transformToWebStream === "function";
+}
+function isNotFoundError(error) {
+  return typeof error === "object" && error !== null && ("name" in error && error.name === "NotFound" || "$metadata" in error && typeof error.$metadata === "object" && error.$metadata !== null && "httpStatusCode" in error.$metadata && error.$metadata.httpStatusCode === 404);
+}
+function normalizeUrl(value) {
+  return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+
+// src/storage/index.ts
+function createStorageAdapter(config) {
+  if (!config) {
+    throw new Error("Storage configuration is required.");
+  }
+  if (config.adapter === "local") {
+    if (!config.local) {
+      throw new Error("Local storage configuration is required.");
+    }
+    return new LocalStorageAdapter(config.local);
+  }
+  if (!config.s3) {
+    throw new Error("S3 storage configuration is required.");
+  }
+  const s3Config = config.s3;
+  return new S3StorageAdapter(s3Config);
+}
+
+// src/email/smtp.ts
+var SmtpEmailAdapter = class {
+  kind = "smtp";
+  options;
+  transporter = null;
+  constructor(options) {
+    this.options = options;
+  }
+  async ensureTransporter() {
+    if (this.transporter) return this.transporter;
+    let nodemailer;
+    try {
+      const moduleId = "nodemailer";
+      nodemailer = await import(moduleId);
+    } catch (error) {
+      const cause = error instanceof Error ? error.message : String(error);
+      throw new NpError(
+        `Could not load \`nodemailer\` \u2014 add it to the app's dependencies to use the SMTP adapter. Cause: ${cause}`,
+        "EMAIL_ADAPTER_MISSING_DEPENDENCY",
+        500
+      );
+    }
+    const { host, port, user, pass } = this.options;
+    const secure = this.options.secure ?? port === 465;
+    this.transporter = nodemailer.createTransport({
+      host,
+      port,
+      secure,
+      auth: user && pass ? { user, pass } : void 0
+    });
+    return this.transporter;
+  }
+  async send(message) {
+    const transporter = await this.ensureTransporter();
+    try {
+      await transporter.sendMail({
+        from: message.from ?? this.options.from,
+        to: message.to,
+        subject: message.subject,
+        text: message.text,
+        html: message.html
+      });
+    } catch (error) {
+      const cause = error instanceof Error ? error.message : String(error);
+      throw new NpError(
+        `Failed to deliver email via SMTP: ${cause}`,
+        "EMAIL_DELIVERY_FAILED",
+        502
+      );
+    }
+  }
+};
+
+// src/theme/sanitize.ts
+function sanitizeTokenValue(value) {
+  return value.replace(/[;{}]/g, "").replace(/url\s*\(/gi, "").replace(/expression\s*\(/gi, "").replace(/@import/gi, "").slice(0, 200);
+}
+
+// src/themes/requirements.ts
+function flattenTopLevelFields(fields) {
+  const out = /* @__PURE__ */ new Map();
+  for (const f of fields) {
+    if (f.type === "row" || f.type === "collapsible") {
+      for (const [name, child] of flattenTopLevelFields(f.fields)) {
+        out.set(name, child);
+      }
+      continue;
+    }
+    if ("name" in f && typeof f.name === "string") {
+      out.set(f.name, f);
+    }
+  }
+  return out;
+}
+function relationToMatches(expected, actual) {
+  const expectedList = Array.isArray(expected) ? expected : [expected];
+  const actualList = Array.isArray(actual) ? actual : [actual];
+  return expectedList.every((e) => actualList.includes(e));
+}
+function checkThemeRequirements(manifest, collections) {
+  const result = {
+    themeId: manifest.id,
+    hasMismatches: false,
+    hasHardMismatches: false,
+    missingCollections: [],
+    missingFields: [],
+    typeConflicts: [],
+    relationConflicts: []
+  };
+  const requires = manifest.requires?.collections;
+  if (!requires) return result;
+  const bySlug = new Map(collections.map((c) => [c.slug, c]));
+  for (const [slug, req] of Object.entries(requires)) {
+    const collection = bySlug.get(slug);
+    if (!collection) {
+      result.missingCollections.push({
+        collection: slug,
+        createIfAbsent: req.createIfAbsent ?? false
+      });
+      continue;
+    }
+    if (!req.fields) continue;
+    const fieldMap = flattenTopLevelFields(collection.fields);
+    for (const [fieldName, fieldReq] of Object.entries(req.fields)) {
+      const hard = fieldReq.hard ?? true;
+      const actual = fieldMap.get(fieldName);
+      if (!actual) {
+        result.missingFields.push({
+          collection: slug,
+          field: fieldName,
+          expected: fieldReq,
+          hard
+        });
+        continue;
+      }
+      if (actual.type !== fieldReq.type) {
+        result.typeConflicts.push({
+          collection: slug,
+          field: fieldName,
+          expected: fieldReq.type,
+          actual: actual.type,
+          hard
+        });
+        continue;
+      }
+      if (fieldReq.type === "relationship" && fieldReq.relationTo && actual.type === "relationship") {
+        if (!relationToMatches(
+          fieldReq.relationTo,
+          actual.relationTo
+        )) {
+          result.relationConflicts.push({
+            collection: slug,
+            field: fieldName,
+            expected: fieldReq.relationTo,
+            actual: actual.relationTo,
+            hard
+          });
+        }
+      }
+    }
+  }
+  const hardMismatches = result.missingCollections.length > 0 || result.missingFields.some((m) => m.hard) || result.typeConflicts.some((c) => c.hard) || result.relationConflicts.some((c) => c.hard);
+  const anyMismatches = result.missingCollections.length > 0 || result.missingFields.length > 0 || result.typeConflicts.length > 0 || result.relationConflicts.length > 0;
+  result.hasHardMismatches = hardMismatches;
+  result.hasMismatches = anyMismatches;
+  return result;
+}
+
+// src/themes/settings.ts
+import { and as and3, eq as eq3 } from "drizzle-orm";
+var DEFAULT_SITE = "default";
+function settingsKey(themeId) {
+  return `theme.settings:${themeId}`;
+}
+function isVersionedSettings(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.__npVersion === "number" && Number.isFinite(candidate.__npVersion) && "__npSettings" in candidate;
+}
+function applyMigration(manifest, rawValue, fromVersion) {
+  const target = manifest.settingsVersion ?? 1;
+  if (fromVersion >= target) return rawValue;
+  const migrate = manifest.settingsMigrate;
+  if (typeof migrate !== "function") return rawValue;
+  try {
+    return migrate(rawValue, fromVersion);
+  } catch {
+    return rawValue;
+  }
+}
+function defaultsFrom(fields) {
+  const out = {};
+  for (const f of fields) {
+    if (f.default !== void 0) {
+      out[f.name] = f.default;
+      continue;
+    }
+    if (f.type === "object") {
+      out[f.name] = defaultsFrom(f.fields);
+    }
+    if (f.type === "array") {
+      out[f.name] = [];
+    }
+  }
+  return out;
+}
+async function getThemeSettings(themeId) {
+  const result = await getThemeSettingsWithStatus(themeId);
+  return result.value;
+}
+async function getThemeSettingsWithStatus(themeId) {
+  const theme = themeId ? getThemeById(themeId) : await getActiveTheme();
+  if (!theme) {
+    return { themeId: null, value: {}, hasPersisted: false };
+  }
+  const schema = theme.manifest.settingsSchema;
+  if (!schema) {
+    return { themeId: theme.manifest.id, value: {}, hasPersisted: false };
+  }
+  const db = getDb();
+  const siteId = await getCurrentSiteId() ?? DEFAULT_SITE;
+  const rows = await db.select().from(npSettings).where(
+    and3(
+      eq3(npSettings.siteId, siteId),
+      eq3(npSettings.key, settingsKey(theme.manifest.id))
+    )
+  ).limit(1);
+  const fields = introspectThemeSettingsSchema(schema);
+  const defaults = defaultsFrom(fields);
+  const row = rows[0];
+  if (!row) {
+    const parsed2 = schema.safeParse(defaults);
+    return {
+      themeId: theme.manifest.id,
+      value: parsed2.success ? parsed2.data : defaults,
+      hasPersisted: false
+    };
+  }
+  const versioned = isVersionedSettings(row.value) ? row.value : null;
+  const storedVersion = versioned ? versioned.__npVersion : 1;
+  const rawValue = versioned ? versioned.__npSettings : row.value;
+  const valueToParse = applyMigration(theme.manifest, rawValue, storedVersion);
+  const parsed = schema.safeParse(valueToParse);
+  if (parsed.success) {
+    return {
+      themeId: theme.manifest.id,
+      value: parsed.data,
+      hasPersisted: true
+    };
+  }
+  return {
+    themeId: theme.manifest.id,
+    value: defaults,
+    hasPersisted: true,
+    parseError: parsed.error.message
+  };
+}
+async function setThemeSettings(themeId, value, updatedBy = null) {
+  const theme = getThemeById(themeId);
+  if (!theme) {
+    throw new NpValidationError("Invalid input", [
+      {
+        field: "themeId",
+        message: `Unknown theme '${themeId}'. Register it in nexpress.config.ts first.`
+      }
+    ]);
+  }
+  const schema = theme.manifest.settingsSchema;
+  if (!schema) {
+    throw new NpValidationError("Invalid input", [
+      {
+        field: "themeId",
+        message: `Theme '${themeId}' does not declare a settingsSchema.`
+      }
+    ]);
+  }
+  const parsed = schema.safeParse(value);
+  if (!parsed.success) {
+    throw new NpValidationError(
+      "Settings failed validation",
+      parsed.error.issues.map((i) => ({
+        field: i.path.join("."),
+        message: i.message
+      }))
+    );
+  }
+  const wrapped = {
+    __npVersion: theme.manifest.settingsVersion ?? 1,
+    __npSettings: parsed.data
+  };
+  const db = getDb();
+  const now = /* @__PURE__ */ new Date();
+  const siteId = await getCurrentSiteId() ?? DEFAULT_SITE;
+  await db.insert(npSettings).values({
+    siteId,
+    key: settingsKey(themeId),
+    value: wrapped,
+    updatedAt: now,
+    updatedBy
+  }).onConflictDoUpdate({
+    target: [npSettings.siteId, npSettings.key],
+    set: { value: wrapped, updatedAt: now, updatedBy }
+  });
+  return parsed.data;
+}
+async function activeThemeContributesSeo() {
+  const theme = await getActiveTheme();
+  if (!theme) return false;
+  const impl = theme.impl;
+  if (!impl?.seo) return false;
+  return Boolean(impl.seo.sitemapEntries || impl.seo.feedEntries);
+}
+
+// src/themes/nav-locations.ts
+function extractNavLocationsFromImpl(impl) {
+  const shape = impl;
+  const declared = shape?.navLocations;
+  if (!declared || typeof declared !== "object") return [];
+  const out = [];
+  for (const [key, raw] of Object.entries(declared)) {
+    if (!raw || typeof raw !== "object") continue;
+    if (typeof raw.label !== "string") continue;
+    out.push({
+      key,
+      label: raw.label,
+      description: typeof raw.description === "string" ? raw.description : void 0,
+      maxItems: typeof raw.maxItems === "number" ? raw.maxItems : void 0
+    });
+  }
+  return out;
+}
+async function getActiveThemeNavLocations() {
+  const theme = await getActiveTheme();
+  if (!theme) return [];
+  return extractNavLocationsFromImpl(theme.impl);
+}
+
+// src/themes/error-seo.ts
+function extractNotFoundComponent(impl) {
+  const shape = impl;
+  return typeof shape?.notFound === "function" ? shape.notFound : null;
+}
+function extractErrorComponent(impl) {
+  const shape = impl;
+  return typeof shape?.error === "function" ? shape.error : null;
+}
+function extractMembersNotFoundComponent(impl) {
+  const shape = impl;
+  const memberLevel = shape?.members?.notFound;
+  if (typeof memberLevel === "function") return memberLevel;
+  return typeof shape?.notFound === "function" ? shape.notFound : null;
+}
+function extractSeoHooks(impl) {
+  const shape = impl;
+  const seo = shape?.seo;
+  if (!seo || typeof seo !== "object") return {};
+  const out = {};
+  if (typeof seo.sitemapEntries === "function") {
+    out.sitemapEntries = seo.sitemapEntries;
+  }
+  if (typeof seo.feedEntries === "function") {
+    out.feedEntries = seo.feedEntries;
+  }
+  if (typeof seo.robotsTxt === "function") {
+    out.robotsTxt = seo.robotsTxt;
+  }
+  return out;
+}
+async function getActiveThemeNotFound() {
+  const theme = await getActiveTheme();
+  if (!theme) return null;
+  return extractNotFoundComponent(theme.impl);
+}
+async function getActiveThemeError() {
+  const theme = await getActiveTheme();
+  if (!theme) return null;
+  return extractErrorComponent(theme.impl);
+}
+async function getActiveThemeMembersNotFound() {
+  const theme = await getActiveTheme();
+  if (!theme) return null;
+  return extractMembersNotFoundComponent(theme.impl);
+}
+async function getActiveThemeSeoHooks() {
+  const theme = await getActiveTheme();
+  if (!theme) return {};
+  return extractSeoHooks(theme.impl);
+}
+
+// src/sites/memberships.ts
+import { and as and4, eq as eq4 } from "drizzle-orm";
+async function listSiteMemberships(siteId) {
+  const db = getDb();
+  const rows = await db.select().from(npSiteMemberships).where(eq4(npSiteMemberships.siteId, siteId));
+  return rows.map((row) => ({
+    siteId: row.siteId,
+    userId: row.userId,
+    role: row.role,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  }));
+}
+async function listMembershipsForUser(userId) {
+  const db = getDb();
+  const rows = await db.select().from(npSiteMemberships).where(eq4(npSiteMemberships.userId, userId));
+  return rows.map((row) => ({
+    siteId: row.siteId,
+    userId: row.userId,
+    role: row.role,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  }));
+}
+async function getMembership(siteId, userId) {
+  const db = getDb();
+  const [row] = await db.select().from(npSiteMemberships).where(
+    and4(
+      eq4(npSiteMemberships.siteId, siteId),
+      eq4(npSiteMemberships.userId, userId)
+    )
+  ).limit(1);
+  if (!row) return null;
+  return {
+    siteId: row.siteId,
+    userId: row.userId,
+    role: row.role,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+async function grantSiteMembership(siteId, userId, role) {
+  const db = getDb();
+  const now = /* @__PURE__ */ new Date();
+  const [row] = await db.insert(npSiteMemberships).values({ siteId, userId, role, createdAt: now, updatedAt: now }).onConflictDoUpdate({
+    target: [npSiteMemberships.siteId, npSiteMemberships.userId],
+    set: { role, updatedAt: now }
+  }).returning();
+  if (!row) throw new Error("Failed to grant membership");
+  return {
+    siteId: row.siteId,
+    userId: row.userId,
+    role: row.role,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+async function revokeSiteMembership(siteId, userId) {
+  const db = getDb();
+  await db.delete(npSiteMemberships).where(
+    and4(
+      eq4(npSiteMemberships.siteId, siteId),
+      eq4(npSiteMemberships.userId, userId)
+    )
+  );
+}
+async function setSuperAdmin(userId, isSuperAdmin2) {
+  const db = getDb();
+  const result = await db.update(npUsers).set({ isSuperAdmin: isSuperAdmin2, updatedAt: /* @__PURE__ */ new Date() }).where(eq4(npUsers.id, userId)).returning({ id: npUsers.id });
+  if (result.length === 0) {
+    throw new NpValidationError("Invalid input", [
+      { field: "userId", message: `User "${userId}" not found` }
+    ]);
+  }
+}
+var ROLE_RANK = {
+  viewer: 0,
+  author: 1,
+  moderator: 2,
+  editor: 3,
+  admin: 4
+};
+async function resolveUserRoleOnSite(user, siteId) {
+  const db = getDb();
+  const [row] = await db.select({ isSuperAdmin: npUsers.isSuperAdmin, role: npUsers.role }).from(npUsers).where(eq4(npUsers.id, user.id)).limit(1);
+  if (!row) return user.role;
+  if (row.isSuperAdmin) return "admin";
+  const membership = await getMembership(siteId, user.id);
+  if (membership) return membership.role;
+  return row.role;
+}
+async function hasRoleOnSite(user, minRole, siteId) {
+  const targetSite = siteId ?? await getCurrentSiteId() ?? NP_DEFAULT_SITE_ID;
+  const role = await resolveUserRoleOnSite(user, targetSite);
+  return ROLE_RANK[role] >= ROLE_RANK[minRole];
+}
+async function isSuperAdmin(user) {
+  const db = getDb();
+  const [row] = await db.select({ isSuperAdmin: npUsers.isSuperAdmin }).from(npUsers).where(eq4(npUsers.id, user.id)).limit(1);
+  return Boolean(row?.isSuperAdmin);
+}
+
+// src/plugins/persistence.ts
+import { eq as eq5 } from "drizzle-orm";
+function toState(row) {
+  return {
+    id: row.id,
+    enabled: row.enabled,
+    installedAt: row.installedAt,
+    updatedAt: row.updatedAt
+  };
+}
+async function listPluginStates(db) {
+  const rows = await db.select().from(npPlugins);
+  return rows.map(toState);
+}
+async function getPluginState(db, id) {
+  const rows = await db.select().from(npPlugins).where(eq5(npPlugins.id, id)).limit(1);
+  return rows[0] ? toState(rows[0]) : null;
+}
+async function syncPluginRegistrations(db, pluginIds) {
+  if (pluginIds.length === 0) return;
+  const now = /* @__PURE__ */ new Date();
+  await db.insert(npPlugins).values(
+    pluginIds.map((id) => ({
+      id,
+      enabled: true,
+      installedAt: now,
+      updatedAt: now
+    }))
+  ).onConflictDoNothing({ target: npPlugins.id });
+}
+async function updatePluginState(db, id, patch) {
+  const values = {
+    updatedAt: /* @__PURE__ */ new Date()
+  };
+  if (patch.enabled !== void 0) {
+    values.enabled = patch.enabled;
+  }
+  const rows = await db.update(npPlugins).set(values).where(eq5(npPlugins.id, id)).returning();
+  if (patch.enabled !== void 0) {
+    invalidatePluginEnabled(id);
+  }
+  return rows[0] ? toState(rows[0]) : null;
+}
+export {
+  ARGON2_OPTIONS,
+  DEFAULT_COMMUNITY_SETTINGS,
+  DEFAULT_IMAGE_SIZES,
+  DEFAULT_JOB_LOG_RETENTION_MS,
+  DEFAULT_REACTION_KINDS,
+  DEFAULT_SITE_SEO_SETTINGS,
+  DEFAULT_THEME,
+  InMemoryRateLimiter,
+  LocalStorageAdapter,
+  MENTION_HANDLE_RE,
+  NP_DEFAULT_SITE_ID,
+  NP_GLOBAL_PLUGIN_SITE_ID,
+  NoopEmailAdapter,
+  NpAuthError,
+  NpConflictError,
+  NpError,
+  NpForbiddenError,
+  NpNotFoundError,
+  NpRateLimitError,
+  NpSiteContextMissingError,
+  NpValidationError,
+  PAUSE_SYNC_INTERVAL_MS,
+  PgBossAdapter,
+  ROLE_HIERARCHY,
+  S3StorageAdapter,
+  SmtpEmailAdapter,
+  WORKER_HEARTBEAT_INTERVAL_MS,
+  WORKER_STALE_THRESHOLD_MS,
+  activeThemeContributesSeo,
+  addReaction,
+  addStrings,
+  applyReputation,
+  assertNotBanned,
+  assertOwnsNotification,
+  assertReactableExists,
+  authenticated,
+  autosaveRevision,
+  buildArticleJsonLd,
+  buildAtomFeed,
+  buildDigestEmail,
+  buildDiscussionForumPostingJsonLd,
+  buildInviteEmail,
+  buildPageMetadata,
+  buildPersonJsonLd,
+  buildResetEmail,
+  buildSearchVector,
+  buildSearchVectorParts,
+  buildSitemap,
+  buildWebSiteJsonLd,
+  buildWeightedSearchVectorSql,
+  buildZodSchema,
+  can,
+  checkNexpressCompat,
+  checkThemeRequirements,
+  cleanupDeletedMedia,
+  clearCustomRoutes,
+  clearStringOverrideCacheForSite,
+  collectionConfigSchema,
+  compareSemver,
+  configureBuiltinJobContext,
+  consoleLogger,
+  consumeMemberEmailVerifyToken,
+  consumeMemberPasswordReset,
+  consumePasswordResetToken,
+  countAliveWorkers,
+  countJobLogs,
+  countReactions,
+  createComment,
+  createDbConnection,
+  createMemberDocument,
+  createMemberEmailVerifyToken,
+  createNotification,
+  createPasswordResetToken,
+  createSite,
+  createStorageAdapter,
+  createTranslation,
+  defineCollection,
+  defineConfig,
+  deleteComment,
+  deleteDocument,
+  deleteMedia,
+  deleteMemberDocument,
+  deleteSite,
+  deleteStringOverride,
+  dispatchPluginAction,
+  enqueueJob,
+  ensureDefaultSite,
+  extractErrorComponent,
+  extractMediaIds,
+  extractMembersNotFoundComponent,
+  extractMentionHandles,
+  extractMentionHandlesFromDocData,
+  extractMentionHandlesFromRichText,
+  extractNotFoundComponent,
+  extractSeoHooks,
+  fanOutMentionNotifications,
+  fileReport,
+  findDocuments,
+  findPosts,
+  findSlugRedirect,
+  findTranslations,
+  follow,
+  formatDate,
+  formatNumber,
+  formatRelativeTime,
+  fromArctic,
+  generateDocumentsModule,
+  generateDrizzleSchema,
+  generateTypeScript,
+  getActiveTheme,
+  getActiveThemeError,
+  getActiveThemeId,
+  getActiveThemeMembersNotFound,
+  getActiveThemeNavLocations,
+  getActiveThemeNotFound,
+  getActiveThemeSeoHooks,
+  getAllCollectionSlugs,
+  getAllJobHandlers,
+  getAllPageSlugs,
+  getAllPluginIds,
+  getAllStrings,
+  getCollectionConfig,
+  getCollectionRegistration,
+  getCollectionTable,
+  getCollectionTabsForSlug,
+  getCollectionZodSchema,
+  getCommunityRole,
+  getCommunitySettings,
+  getCurrentJobId,
+  getCurrentLocale,
+  getCurrentSiteId,
+  getCustomRoutes,
+  getDashboardWidgetsFromPlugins,
+  getDb,
+  getDefaultSite,
+  getDocumentById,
+  getEmailAdapter,
+  getErrorReporter,
+  getFrameworkVersion,
+  getI18nConfig,
+  getJobHandler,
+  getJobQueue,
+  getJobsPauseState,
+  getLocaleDirection,
+  getLogger,
+  getMediaById,
+  getMediaUrl,
+  getMemberFromTokenPayload,
+  getMemberNotificationPrefs,
+  getMemberProfile,
+  getMemberProfiles,
+  getMembership,
+  getMutedTargetIds,
+  getNavigation,
+  getOAuthProvider,
+  getOptionalJobQueue,
+  getOptionalRateLimiter,
+  getPageBySlug,
+  getPluginAdminExtension,
+  getPluginConfig,
+  getPluginConfigWithStatus,
+  getPluginPageRoutes,
+  getPluginRegistration,
+  getPluginRoutes,
+  getPluginState,
+  getPluginTemplatesForCollection,
+  getPostBySlug,
+  getProfanityAdapter,
+  getRateLimiter,
+  getRegisteredPluginSchedules,
+  getRegisteredThemes,
+  getReputationAdapter,
+  getRevision,
+  getScopedLogger,
+  getSearchAdapter,
+  getSetting,
+  getSiteByHostname,
+  getSiteById,
+  getSiteSeoSettings,
+  getSiteUsageSummary,
+  getSpamAdapter,
+  getStorageAdapter,
+  getStringOverride,
+  getStringOverridesForSite,
+  getStrings,
+  getTheme,
+  getThemeById,
+  getThemeSettings,
+  getThemeSettingsWithStatus,
+  getThemeTemplateSummaries,
+  getTranslationProgress,
+  grantMemberRole,
+  grantSiteMembership,
+  hasRoleOnSite,
+  hashPassword,
+  hideComment,
+  introspectThemeSettingsSchema,
+  invalidateAllMemberSessions,
+  invalidateAllSessions,
+  invalidatePluginEnabled,
+  isAdmin,
+  isEditorOrAbove,
+  isFollowing,
+  isMuted,
+  isNotificationKindEnabled,
+  isOwnerOrAdmin,
+  isPluginEnabled,
+  isSuperAdmin,
+  isTokenVerificationError,
+  issueBan,
+  issueOAuthState,
+  listAuditEvents,
+  listBansForMember,
+  listComments,
+  listCommunityRoles,
+  listFollowing,
+  listJobLogs,
+  listMedia,
+  listMemberIdentities,
+  listMemberReactions,
+  listMemberRoleGrants,
+  listMembershipsForUser,
+  listMutes,
+  listNotificationKinds,
+  listNotifications,
+  listOAuthProviders,
+  listPendingMemberDocs,
+  listPluginStates,
+  listReports,
+  listRevisions,
+  listSiteMemberships,
+  listSites,
+  listStringOverridesForSite,
+  listUserIdentities,
+  listWorkerHealth,
+  loadPlugins,
+  loadStringOverridesForSite,
+  markAllNotificationsRead,
+  markNotificationsRead,
+  markWorkerStopped,
+  memberCan,
+  muteMember,
+  noopErrorReporter,
+  npAuditEvents,
+  npBanKindEnum,
+  npBanScopeEnum,
+  npBans,
+  npCommentStatusEnum,
+  npComments,
+  npConfigSchema,
+  npFollows,
+  npJobLogs,
+  npMedia,
+  npMediaFolders,
+  npMediaFoldersRelations,
+  npMediaRefs,
+  npMediaRefsRelations,
+  npMediaRelations,
+  npMediaStatusEnum,
+  npMemberIdentities,
+  npMemberMutes,
+  npMemberRoleScopeEnum,
+  npMemberRoles,
+  npMemberSessions,
+  npMemberStatusEnum,
+  npMembers,
+  npNavigation,
+  npNavigationRelations,
+  npNotifications,
+  npPasswordResetPurposeEnum,
+  npPluginStorage,
+  npPlugins,
+  npReactions,
+  npReports,
+  npRevisionStatusEnum,
+  npRevisions,
+  npRevisionsRelations,
+  npSessions,
+  npSessionsRelations,
+  npSettings,
+  npSettingsRelations,
+  npSiteMemberships,
+  npSites,
+  npSlugHistory,
+  npStringOverrides,
+  npUserOAuthIdentities,
+  npUserRoleEnum,
+  npUsers,
+  npUsersRelations,
+  npWorkerHeartbeats,
+  pluginConfigCacheTag,
+  principalCan,
+  processImage,
+  processMediaImage,
+  promoteMemberDocument,
+  pruneJobLogsOlderThan,
+  publishScheduledDocuments,
+  purgeMemberContent,
+  purgeStaleWorkers,
+  recordAuditEvent,
+  recordDigestSent,
+  recordHeartbeat,
+  recordJobLog,
+  registerBuiltinHandlers,
+  registerCollection,
+  registerCommunityRole,
+  registerCustomRoute,
+  registerJobHandler,
+  registerNotificationKind,
+  registerOAuthProvider,
+  registerPluginTemplates,
+  registerThemes,
+  reindexCollection,
+  removeReaction,
+  renderAtomFeed,
+  renderCommentMarkdown,
+  renderSitemapIndexXml,
+  renderSitemapXml,
+  reportError,
+  requestMemberPasswordReset,
+  requestPasswordReset,
+  resetCommunityRoles,
+  resetCurrentSiteResolver,
+  resetEmailAdapter,
+  resetErrorReporter,
+  resetI18nConfig,
+  resetIntlFormatterCache,
+  resetLogger,
+  resetOAuthProviders,
+  resetPluginTemplates,
+  resetPlugins,
+  resetProfanityAdapter,
+  resetReputationAdapter,
+  resetSearchAdapter,
+  resetSpamAdapter,
+  resetStringOverrideCache,
+  resetStrings,
+  resetThemes,
+  resetTranslationCache,
+  resolveLocale,
+  resolveMemberOAuthLogin,
+  resolveMentionedMembers,
+  resolveOAuthLogin,
+  resolveReport,
+  resolveSiteForHostname,
+  resolveTemplateComponent,
+  resolveUserRoleOnSite,
+  restoreComment,
+  restoreRevision,
+  revokeBan,
+  revokeMemberIdentity,
+  revokeMemberRole,
+  revokeSiteMembership,
+  revokeUserIdentity,
+  runDigestSweep,
+  runHook,
+  runHookAndCollect,
+  runInJobContext,
+  runPluginScheduledTask,
+  sanitizeTokenValue,
+  saveDocument,
+  schedulePluginTask,
+  searchCollections,
+  setActiveThemeId,
+  setCurrentSiteResolver,
+  setDb,
+  setEmailAdapter,
+  setErrorReporter,
+  setI18nConfig,
+  setJobQueue,
+  setJobsPauseState,
+  setLogger,
+  setMemberNotificationPrefs,
+  setPluginConfig,
+  setProfanityAdapter,
+  setRateLimiter,
+  setReputationAdapter,
+  setSearchAdapter,
+  setSpamAdapter,
+  setStorageAdapter,
+  setStringOverride,
+  setStrings,
+  setSuperAdmin,
+  setThemeSettings,
+  sha256,
+  signMemberToken,
+  signToken,
+  staffDeleteComment,
+  staffHideComment,
+  staffRestoreComment,
+  startProducer,
+  startWorker,
+  stopProducer,
+  stopWorker,
+  syncPluginRegistrations,
+  t,
+  tSync,
+  unfollow,
+  unmuteMember,
+  unreadNotificationCount,
+  unresolvedReportCount,
+  updateComment,
+  updateCommunitySettings,
+  updateMemberDocument,
+  updatePluginState,
+  updateSite,
+  uploadMedia,
+  validateCommunitySettingsPatch,
+  validateSeoSettingsPatch,
+  verifyCsrf,
+  verifyMemberToken,
+  verifyOAuthState,
+  verifyPassword,
+  verifyStartupSafety,
+  verifyToken,
+  verifyTokenFull,
+  withCurrentSite,
+  withMemberWrite
+};
+//# sourceMappingURL=index.js.map