emdash 0.28.1 → 0.30.0

package/dist/{index-B9sIxwe4.d.mts → index-wYnC6u4o.d.mts}

@@ -1,16 +1,17 @@
-import { _ as UpdateFieldInput, f as FieldValidation, g as UpdateCollectionInput, i as CollectionWithFields, o as CreateCollectionInput, s as CreateFieldInput, t as Collection, u as Field } from "./types-g_aFIdW0.mjs";
-import { f as UpdateContentInput, i as ContentItem, l as FindManyOptions, o as ContentSeoInput, r as ContentDateField, s as CreateContentInput, t as BylineSummary, u as FindManyResult } from "./types-BcLUUbbR.mjs";
-import { d as ContentListResponse, f as ContentResponse, h as ManifestResponse, u as ApiResult } from "./options-iMpRRxIe.mjs";
-import { t as Database } from "./types-_HFLRzTn.mjs";
-import { Ct as RequestMeta, H as HttpAccess, Nt as WhereClause, O as CronEvent, Ot as StorageCollection, R as EmailMessage, St as QueryOptions, Tt as ResolvedPlugin, Z as MediaItem$1, c as CommentBeforeCreateEvent, ct as PaginatedResult, et as PageFragmentContribution, ft as PluginCapability, gt as PluginManifest, i as CommentAfterCreateEvent, it as PageMetadataEvent, mt as PluginDefinition, o as CommentAfterModerateEvent, rt as PageMetadataContribution, tt as PageFragmentEvent, vt as PluginStorageConfig, yt as PortableTextBlockConfig, z as FieldWidgetConfig } from "./types-CGbYowGQ.mjs";
-import { _ as MediaValue, m as MediaProviderDescriptor } from "./placeholder-BSKwzRe4.mjs";
-import { w as ContentBylineInput } from "./index-Bm-Gy8Mh.mjs";
-import { r as AuthProviderDescriptor, t as AuthDescriptor } from "./types-CgvhU-hF.mjs";
-import { t as DatabaseDescriptor } from "./adapters-hUy8vOB-.mjs";
-import { r as ObjectCacheDescriptor } from "./types-ClUkdbWb.mjs";
-import { d as Storage } from "./types-ea9sAPck.mjs";
-import { i as SiteSettings, r as SiteSettingKey } from "./types-DmHk7vAt.mjs";
-import { Dialect, Kysely } from "kysely";
+import { _ as UpdateFieldInput, f as FieldValidation, g as UpdateCollectionInput, i as CollectionWithFields, o as CreateCollectionInput, s as CreateFieldInput, t as Collection, u as Field } from "./types-Kmaxdarz.mjs";
+import { f as UpdateContentInput, i as ContentItem, l as FindManyOptions, o as ContentSeoInput, r as ContentDateField, s as CreateContentInput, t as BylineSummary, u as FindManyResult } from "./types-BfYUPJdP.mjs";
+import { d as ContentListResponse, f as ContentResponse, h as ManifestResponse, u as ApiResult } from "./options-BqMkWfYa.mjs";
+import { t as Database } from "./types-DPKhI5ib.mjs";
+import { At as StorageCollection, Ct as QueryOptions, Et as ResolvedPlugin, H as HttpAccess, O as CronEvent, R as EmailMessage, St as PublicPageContext, Z as MediaItem$1, _t as PluginMcpManifestConfig, bt as PortableTextBlockConfig, c as CommentBeforeCreateEvent, ct as PaginatedResult, et as PageFragmentContribution, ft as PluginCapability, gt as PluginManifest, i as CommentAfterCreateEvent, it as PageMetadataEvent, kt as SettingField, mt as PluginDefinition, o as CommentAfterModerateEvent, rt as PageMetadataContribution, tt as PageFragmentEvent, wt as RequestMeta, yt as PluginStorageConfig, z as FieldWidgetConfig, zt as WhereClause } from "./types-BvB7gDOD.mjs";
+import { _ as MediaValue, f as MediaProvider, m as MediaProviderDescriptor, p as MediaProviderCapabilities } from "./placeholder-Dop47JMM.mjs";
+import { w as ContentBylineInput } from "./index-BEui-cRd.mjs";
+import { r as AuthProviderDescriptor, t as AuthDescriptor } from "./types-B4vm81VH.mjs";
+import { t as DatabaseDescriptor } from "./adapters-C0ONzkUP.mjs";
+import { r as ObjectCacheDescriptor } from "./types-iVeZ5g6N.mjs";
+import { d as Storage } from "./types-B97jg3aW.mjs";
+import { i as SiteSettings, r as SiteSettingKey } from "./types-BNfPHfay.mjs";
+import { EmDashManifest } from "./astro/types.mjs";
+import { Dialect, Kysely, sql } from "kysely";
 import { z } from "astro/zod";
 import { z as z$1 } from "zod";
 import "@emdash-cms/registry-client/env";
@@ -108,6 +109,19 @@ declare class ContentRepository {
    * Restore content from trash
    */
   restore(type: string, id: string): Promise<ContentItem | null>;
+  /**
+   * Re-stamp the denormalized filter + sort columns on every
+   * `content_taxonomies` pivot row for an entry from its authoritative `ec_*`
+   * row (migration 051). Called after any mutation that moves one of those
+   * columns so a taxonomy-filtered listing can seek the entry directly.
+   *
+   * A single correlated `UPDATE` reads the post-mutation values from `ec_*`, so
+   * the pivot converges to the authoritative row. This is NOT atomic with the
+   * `ec_*` mutation on D1 (no transactions), which is why the read path
+   * re-checks the real predicates on the joined `ec_*` row. Untagged entries
+   * have no pivot rows, so the statement is a cheap no-op for them.
+   */
+  private restampEntryPivot;
   /**
    * Permanently delete content (cannot be undone)
    */
@@ -133,10 +147,20 @@ declare class ContentRepository {
    */
   countTrashed(type: string): Promise<number>;
   /**
-   * Apply the optional case-insensitive `q` substring filter across the
-   * handler-resolved `searchColumns` (OR'd). User input is treated literally
-   * (LIKE wildcards escaped) and `lower()` is applied on both sides for
-   * SQLite/Postgres case-insensitive parity.
+   * Apply the optional `q` filter.
+   *
+   * When the handler sets `useFts` (collection has a healthy FTS5 index
+   * covering the display columns; SQLite only), the filter is served from
+   * the index: a token-prefix MATCH against `_emdash_fts_<slug>` OR'd with
+   * an index-served `slug GLOB 'term*'` prefix (the slug is not in the FTS
+   * index). Both sides are index-backed, so SQLite's OR optimization avoids
+   * the full-table scan the LIKE fallback needs (#1517). The trade-off is
+   * search semantics: token-prefix matching instead of arbitrary substring.
+   *
+   * Fallback (Postgres, search disabled, or no usable terms): case-
+   * insensitive substring LIKE across the handler-resolved `searchColumns`
+   * (OR'd). User input is treated literally (LIKE wildcards escaped) and
+   * `lower()` is applied on both sides for SQLite/Postgres parity.
    */
   private applySearchFilter;
   /**
@@ -161,6 +185,7 @@ declare class ContentRepository {
     total: number;
     published: number;
     draft: number;
+    scheduled: number;
   }>;
   /**
    * Schedule content for future publishing
@@ -193,6 +218,39 @@ declare class ContentRepository {
    * Find all translations in a translation group
    */
   findTranslations(type: string, translationGroup: string): Promise<ContentItem[]>;
+  /**
+   * Batch variant of {@link findTranslations}: every (non-deleted) locale
+   * variant for any of `translationGroups`, in one `WHERE translation_group IN
+   * (...)` query chunked at `SQL_BATCH_SIZE` for D1's bind-parameter limit.
+   * Lets callers resolve many edge groups without an N+1 per group. The caller
+   * groups the flat result by `translationGroup` itself.
+   *
+   * `publishedOnly` restricts the result to `status = 'published'` — reference
+   * reads pass this for callers without `content:read_drafts` so draft/scheduled
+   * entries never leak through an edge traversal.
+   *
+   * A reference edge stores only a collection slug (no SQL FK), so the table may
+   * have been dropped since the edge was written. That is a tolerated dangling
+   * state, not an error: a missing table resolves to no rows, mirroring how the
+   * content read handlers treat `isMissingTableError`.
+   */
+  findTranslationsForGroups(type: string, translationGroups: string[], options?: {
+    publishedOnly?: boolean;
+  }): Promise<ContentItem[]>;
+  /**
+   * Batch variant of {@link findByIdOrSlug}: resolve many identifiers (each an
+   * id OR a slug) within `type` in a constant number of queries — one `WHERE id
+   * IN (...)` and one `WHERE slug IN (...)`, each chunked at `SQL_BATCH_SIZE`.
+   * Returns a map from the input identifier to its resolved item; identifiers
+   * that match nothing are absent. Used on write paths that accept a list of
+   * references, so a single request doesn't fan out to an N+1 of point lookups.
+   *
+   * Resolution mirrors {@link findByIdOrSlug}: a ULID-shaped identifier prefers
+   * the id match and falls back to slug; anything else prefers the slug match
+   * and falls back to id. Slug matches collapse to the lowest-locale variant
+   * (`ORDER BY locale ASC`), matching the slug-without-locale lookup.
+   */
+  findManyByIdOrSlug(type: string, identifiers: string[]): Promise<Map<string, ContentItem>>;
   /**
    * Publish the current draft
    *
@@ -737,6 +795,7 @@ declare function handleContentCreate(db: Kysely<Database>, collection: string, b
   locale?: string;
   translationOf?: string;
   seo?: ContentSeoInput;
+  taxonomies?: Record<string, string[]>;
   createdAt?: string | null;
   publishedAt?: string | null;
 }): Promise<ApiResult<ContentResponse>>;
@@ -756,6 +815,7 @@ declare function handleContentUpdate(db: Kysely<Database>, collection: string, i
   locale?: string;
   _rev?: string;
   seo?: ContentSeoInput;
+  taxonomies?: Record<string, string[]>;
   publishedAt?: string | null;
 }): Promise<ApiResult<ContentResponse>>;
 /**
@@ -966,6 +1026,10 @@ declare function handleMediaDelete(db: Kysely<Database>, id: string): Promise<Ap
   deleted: true;
 }>>;
 //#endregion
+//#region src/media/usage/content-refresh.d.ts
+type ContentMediaUsageRefreshErrorCode = "CONTENT_NOT_FOUND" | "DRAFT_REVISION_NOT_FOUND" | "DRAFT_REVISION_MISMATCH" | "DRAFT_REVISION_INVALID" | "CONTENT_USAGE_REFRESH_ERROR" | "CONTENT_USAGE_DELETE_ERROR" | "CONTENT_USAGE_GENERATION_CONFLICT" | "CONTENT_USAGE_STALE";
+declare function markContentMediaUsageCollectionStaleSafely(db: Kysely<Database>, collectionSlug: string, lastErrorCode: ContentMediaUsageRefreshErrorCode): Promise<boolean>;
+//#endregion
 //#region src/schema/registry.d.ts
 /**
  * Error thrown when a schema operation fails
@@ -1017,6 +1081,17 @@ declare class SchemaRegistry {
    * Create a new collection
    */
   createCollection(input: CreateCollectionInput): Promise<Collection>;
+  /**
+   * Create a seed-owned collection and all of its fields in bulk.
+   *
+   * Fresh seeds can define dozens of fields. Creating them through
+   * `createField` performs multiple reads, one ALTER TABLE, and one media
+   * usage invalidation per field, which can exhaust D1's per-request query
+   * budget. This path validates the full schema before mutating it, creates
+   * the complete content table in one statement, and inserts field metadata
+   * in parameter-safe batches.
+   */
+  createSeedCollection(input: Omit<CreateCollectionInput, "source">, fields: readonly CreateFieldInput[]): Promise<void>;
   /**
    * Update a collection
    */
@@ -1485,6 +1560,8 @@ interface PluginDescriptor<TOptions = Record<string, unknown>> {
   adminPages?: PluginAdminPage[];
   /** Dashboard widgets */
   adminWidgets?: PluginDashboardWidget[];
+  /** Settings schema for the auto-generated admin settings form */
+  settingsSchema?: Record<string, SettingField>;
   /**
    * Portable Text block types this plugin contributes to the editor.
    * Declarative (Block Kit) — surfaced in the admin slash menu and consumed
@@ -1510,6 +1587,8 @@ interface PluginDescriptor<TOptions = Record<string, unknown>> {
    * Sandboxed plugins can only access declared collections.
    */
   storage?: Record<string, StorageCollectionDeclaration>;
+  /** Serialized MCP declarations emitted by the plugin build. */
+  mcp?: PluginMcpManifestConfig;
 }
 /**
  * Sandboxed plugin descriptor - same format as PluginDescriptor
@@ -1920,6 +1999,29 @@ interface EmDashConfig {
     siteName?: string; /** URL or path to a custom favicon for the admin panel. */
     favicon?: string;
   };
+  /**
+   * Editor toolbar delivery on public pages.
+   *
+   * - `"server"` (default): the toolbar is injected server-side into every
+   *   HTML response rendered for an authenticated editor. Simple and
+   *   zero-config, but behind a shared cache (Cloudflare Cache Everything /
+   *   Workers Cache, Fastly, Varnish, …) editors often receive the cached
+   *   anonymous variant — without the toolbar — whenever an anonymous visitor
+   *   primed the cache first, so the toolbar appears and disappears with
+   *   cache state.
+   * - `"client"`: public HTML is identical for everyone (nothing
+   *   session-specific is injected server-side, so shared caches stay fully
+   *   effective). A tiny bootstrap script shows an "Edit" pill for browsers
+   *   that have logged into the admin (non-secret localStorage flag). Clicking
+   *   it verifies the session and reloads the page with an `_edit` query
+   *   param, which is always rendered fresh (never cached) with the full
+   *   toolbar. Logged-out visitors opening an `_edit` URL are redirected to
+   *   the canonical URL.
+   * - `false`: never render the toolbar or bootstrap script.
+   *
+   * See the visual-editing docs for the cache-behavior details.
+   */
+  toolbar?: "server" | "client" | false;
   /**
    * Version of Astro the host project is building with. Populated by the
    * integration's `astro:config:setup` hook (not authored by the user) and
@@ -1992,6 +2094,7 @@ interface SandboxOptions {
     name: string;
     url: string;
     locale: string;
+    trailingSlash?: "always" | "never" | "ignore";
   };
   /** Email send callback, wired from the EmailPipeline by the runtime */
   emailSend?: SandboxEmailSendCallback;
@@ -2183,6 +2286,8 @@ interface SiteInfoOptions {
   siteUrl?: string;
   /** Site locale from options table */
   locale?: string;
+  /** Astro's `trailingSlash` config (from `virtual:emdash/config`). */
+  trailingSlash?: "always" | "never" | "ignore";
 }
 interface PluginContextFactoryOptions {
   db: Kysely<Database>;
@@ -2590,6 +2695,19 @@ declare class EmailPipeline {
 }
 //#endregion
 //#region src/plugins/routes.d.ts
+/**
+ * Route metadata (public flag) without the handler.
+ * Used by the catch-all route to decide auth before dispatch.
+ */
+interface RouteMeta {
+  public: boolean;
+  permission?: string;
+  /**
+   * Cache-Control value for successful GET responses. Only ever set for
+   * public routes — authenticated responses must stay `private, no-store`.
+   */
+  cacheControl?: string;
+}
 /**
  * Result from a route invocation
  */
@@ -2674,7 +2792,19 @@ interface CronScheduler {
  */
 type SystemCleanupFn = () => Promise<void>;
 //#endregion
+//#region src/scheduled-publish.d.ts
+/** A content item that was promoted to published by a sweep. */
+interface PublishedRef {
+  collection: string;
+  id: string;
+}
+//#endregion
 //#region src/emdash-runtime.d.ts
+/** Combined result from a single-pass page contribution collection */
+interface PageContributions {
+  metadata: PageMetadataContribution[];
+  fragments: PageFragmentContribution[];
+}
 /**
  * Sandboxed plugin entry from virtual module
  */
@@ -2689,6 +2819,8 @@ interface SandboxedPluginEntry {
   allowedHosts: string[];
   /** Declared storage collections */
   storage: PluginStorageConfig;
+  /** Serialized MCP declarations emitted at plugin build time. */
+  mcp?: PluginMcpManifestConfig;
   /** Admin pages */
   adminPages?: Array<{
     path: string;
@@ -2701,6 +2833,8 @@ interface SandboxedPluginEntry {
     title?: string;
     size?: string;
   }>;
+  /** Settings schema for the auto-generated admin settings form */
+  settingsSchema?: Record<string, SettingField>;
   /** Portable Text block types contributed to the editor (declarative Block Kit) */
   portableTextBlocks?: PortableTextBlockConfig[];
   /** Field widget types contributed for schema-field editing UIs */
@@ -2713,6 +2847,697 @@ interface SandboxedPluginEntry {
    */
   preferred?: string[];
 }
+/**
+ * Media provider entry from virtual module
+ */
+interface MediaProviderEntry {
+  id: string;
+  name: string;
+  icon?: string;
+  capabilities: MediaProviderCapabilities;
+  /** Factory function to create the provider instance */
+  createProvider: (ctx: MediaProviderContext) => MediaProvider;
+}
+/**
+ * Context passed to media provider factory functions
+ */
+interface MediaProviderContext {
+  db: Kysely<Database>;
+  /**
+   * Resolver for the live connection, preferred over `db` by providers that
+   * query EmDash's database. Resolves the current request/event-scoped
+   * connection from ALS so connection-backed adapters (Postgres over
+   * Hyperdrive) don't reuse the per-isolate singleton's socket across events.
+   * Providers should resolve per operation rather than capturing `db` once.
+   * Omitted-safe: falls back to `db` for stateless adapters (D1, Node SQLite).
+   */
+  getDb?: () => Kysely<Database>;
+  storage: Storage | null;
+}
+/**
+ * Builds the timer-based scheduler that drives cron ticks and maintenance.
+ * Injected via `virtual:emdash/scheduler` so the platform — not core — decides
+ * whether a long-lived heartbeat exists.
+ */
+type CreateSchedulerFn = (executor: CronExecutor) => CronScheduler;
+/**
+ * Dependencies injected from virtual modules (middleware reads these)
+ */
+interface RuntimeDependencies {
+  config: EmDashConfig;
+  plugins: ResolvedPlugin[];
+  createDialect: (config: any) => Dialect;
+  /**
+   * Factory for a dialect that batches same-turn reads into one round trip
+   * ({@link EmDashRuntime.create} uses it for the cold-start read phase).
+   * Present only on batching backends (D1, DO); absent backends fall back to
+   * the singleton. Returns a fresh connection each call — it must never be the
+   * long-lived singleton, whose coalescing buffer would be shared across
+   * requests.
+   */
+  createCoalescingDialect?: (config: any) => Dialect | null;
+  createStorage: ((config: any) => Storage) | null;
+  sandboxEnabled: boolean;
+  /** sandbox: false escape hatch - load sandboxed plugins in-process */
+  sandboxBypassed?: boolean;
+  /**
+   * Factory for the timer-based cron/maintenance heartbeat. Supplied by the
+   * generated `virtual:emdash/scheduler` module: a `NodeCronScheduler` factory
+   * on long-lived runtimes (Node/Bun), or `null` on serverless adapters where
+   * an external driver (e.g. the Cloudflare Worker's `scheduled()` Cron
+   * Trigger) calls `runScheduledTasks()` instead. When absent or null, the
+   * runtime starts no scheduler. Keeping the platform decision in the
+   * integration means core has no adapter-specific runtime checks.
+   */
+  createScheduler?: CreateSchedulerFn | null;
+  /** Media provider entries from virtual module */
+  mediaProviderEntries?: MediaProviderEntry[];
+  sandboxedPluginEntries: SandboxedPluginEntry[];
+  /** Factory function supplied by the active platform adapter. */
+  createSandboxRunner: SandboxRunnerFactory | null;
+}
+/**
+ * Constructor parameters for `EmDashRuntime`.
+ *
+ * Production code should use `EmDashRuntime.create()` which discovers and
+ * loads all parts (database, plugins, hooks, cron, etc.) and then calls the
+ * constructor. Direct construction is supported for callers that already
+ * have all the dependencies in hand — for example, integration tests that
+ * supply a pre-migrated database and an empty plugin set.
+ *
+ * Every field corresponds 1:1 to internal state set on the runtime — none of
+ * these are derived. If you don't have a value for one, see what `create()`
+ * passes for that field as the canonical default.
+ */
+interface EmDashRuntimeParts {
+  db: Kysely<Database>;
+  storage: Storage | null;
+  configuredPlugins: ResolvedPlugin[];
+  sandboxedPlugins: Map<string, SandboxedPluginInstance>;
+  sandboxedPluginEntries: SandboxedPluginEntry[];
+  hooks: HookPipeline;
+  enabledPlugins: Set<string>;
+  pluginStates: Map<string, string>;
+  config: EmDashConfig;
+  mediaProviders: Map<string, MediaProvider>;
+  mediaProviderEntries: MediaProviderEntry[];
+  cronExecutor: CronExecutor | null;
+  cronScheduler: CronScheduler | null;
+  emailPipeline: EmailPipeline | null;
+  allPipelinePlugins: ResolvedPlugin[];
+  pipelineFactoryOptions: {
+    db: Kysely<Database>;
+    getDb?: () => Kysely<Database>;
+    storage?: Storage;
+    siteInfo?: {
+      siteName?: string;
+      siteUrl?: string;
+      locale?: string;
+      trailingSlash?: "always" | "never" | "ignore";
+    };
+  };
+  runtimeDeps: RuntimeDependencies;
+  pipelineRef: {
+    current: HookPipeline;
+  };
+}
+/**
+ * EmDashRuntime - singleton per worker
+ */
+declare class EmDashRuntime {
+  /**
+   * The singleton database instance (worker-lifetime cached).
+   * Use the `db` getter instead — it checks the request context first
+   * for per-request overrides (D1 read replica sessions, DO multi-site).
+   */
+  private readonly _db;
+  readonly storage: Storage | null;
+  readonly configuredPlugins: ResolvedPlugin[];
+  readonly sandboxedPlugins: Map<string, SandboxedPluginInstance>;
+  readonly sandboxedPluginEntries: SandboxedPluginEntry[];
+  /**
+   * Schema registry bound to the current request/event-scoped connection.
+   * Built per access (SchemaRegistry just wraps a db) against `this.db`, the
+   * ALS-aware getter — never a captured snapshot of the singleton. On a
+   * connection-backed adapter (Postgres over Hyperdrive) a captured singleton
+   * would query a socket opened by an earlier event and trip workerd's
+   * cross-request I/O guard; the catch in handlers like handleContentUpdate
+   * would then silently treat a revision-enabled collection as non-revisioned
+   * and write draft edits to live columns. Same reasoning as the per-call
+   * registry in _buildManifest().
+   */
+  get schemaRegistry(): SchemaRegistry;
+  private _hooks;
+  readonly config: EmDashConfig;
+  readonly mediaProviders: Map<string, MediaProvider>;
+  readonly mediaProviderEntries: MediaProviderEntry[];
+  readonly cronExecutor: CronExecutor | null;
+  readonly email: EmailPipeline | null;
+  private cronScheduler;
+  private enabledPlugins;
+  private pluginStates;
+  /**
+   * Isolate-lifetime guard so FTS indexes are verified at most once per
+   * worker rather than on every admin request. See ensureSearchHealthy().
+   * Uses the poison-immune single-flight cache (never a shared awaitable
+   * promise) so a cancelled first caller can't wedge later ones.
+   */
+  private readonly _searchHealthCache;
+  /** Current hook pipeline. Use the `hooks` getter for external access. */
+  get hooks(): HookPipeline;
+  /** All plugins eligible for the hook pipeline (includes built-in plugins).
+   *  Stored so we can rebuild the pipeline when plugins are enabled/disabled. */
+  private allPipelinePlugins;
+  /** Factory options for the hook pipeline context factory */
+  private pipelineFactoryOptions;
+  /** Dependencies needed for exclusive hook resolution */
+  private runtimeDeps;
+  /** Mutable ref for the cron invokeCronHook closure to read the current pipeline */
+  private pipelineRef;
+  /**
+   * Get the database instance for the current request.
+   *
+   * Checks the ALS-based request context first — middleware sets a
+   * per-request Kysely instance there for D1 read replica sessions
+   * or DO preview databases. Falls back to the singleton instance.
+   */
+  get db(): Kysely<Database>;
+  constructor(parts: EmDashRuntimeParts);
+  /**
+   * Get the sandbox runner instance (for marketplace install/update)
+   */
+  getSandboxRunner(): SandboxRunner | null;
+  /**
+   * Whether the sandbox bypass mode (sandbox: false) is active.
+   * Marketplace install/update handlers use this to skip the
+   * SANDBOX_NOT_AVAILABLE gate, since the bypass path loads
+   * marketplace plugins in-process via syncMarketplacePlugins().
+   */
+  isSandboxBypassed(): boolean;
+  /**
+   * Publish any content whose scheduled time has passed.
+   * Returns the items promoted so callers can invalidate their cache tags.
+   */
+  publishScheduled(): Promise<PublishedRef[]>;
+  /**
+   * Run the full scheduled-maintenance batch: cron tasks, scheduled
+   * publishing, and system cleanup. For request-less drivers — the
+   * Cloudflare `scheduled()` handler invokes this from a Cron Trigger.
+   * (On Node the timer-based scheduler drives the same work itself.)
+   *
+   * Each step is independent and non-fatal. Returns the content promoted
+   * by the publishing sweep so the caller can purge edge-cache tags.
+   *
+   * `onPublished` (optional) is awaited after each collection's batch so a
+   * request-less driver can invalidate edge-cache tags incrementally rather
+   * than only after the whole sweep — bounding stale-cache exposure if the
+   * runtime is killed mid-sweep.
+   */
+  runScheduledTasks(options?: {
+    onPublished?: (refs: PublishedRef[]) => Promise<void>;
+  }): Promise<{
+    published: PublishedRef[];
+  }>;
+  /**
+   * Stop the cron scheduler gracefully.
+   * Call during worker shutdown or hot-reload.
+   */
+  stopCron(): Promise<void>;
+  /**
+   * Update in-memory plugin status and rebuild the hook pipeline.
+   *
+   * Rebuilding the pipeline ensures disabled plugins' hooks stop firing
+   * and re-enabled plugins' hooks start firing again without a restart.
+   * Exclusive hook selections are re-resolved after each rebuild.
+   */
+  setPluginStatus(pluginId: string, status: "active" | "inactive"): Promise<void>;
+  /**
+   * Rebuild the hook pipeline from the current set of enabled plugins.
+   *
+   * Filters `allPipelinePlugins` to only those in `enabledPlugins`,
+   * creates a fresh HookPipeline, re-resolves exclusive hook selections,
+   * and re-wires the context factory so existing references (cron
+   * callbacks, email pipeline) use the new pipeline.
+   */
+  private rebuildHookPipeline;
+  /**
+   * Synchronize marketplace plugin runtime state with DB + storage.
+   *
+   * Ensures install/update/uninstall changes take effect immediately in the
+   * current worker: loads newly active plugins and removes uninstalled ones.
+   */
+  syncMarketplacePlugins(): Promise<void>;
+  /**
+   * Synchronize registry plugin runtime state with DB + storage.
+   *
+   * Mirrors {@link syncMarketplacePlugins} for plugins installed via the
+   * experimental decentralized plugin registry. Called after install,
+   * update, and uninstall handlers complete.
+   */
+  syncRegistryPlugins(): Promise<void>;
+  /**
+   * Internal: reconcile in-memory sandboxed-plugin state with the
+   * `_plugin_state` table for the given source tier. Shared
+   * implementation behind {@link syncMarketplacePlugins} and
+   * {@link syncRegistryPlugins}.
+   *
+   * Each source tier has its own key set in `${source}PluginKeys` so a
+   * sync for one tier doesn't invalidate the other.
+   */
+  private syncSandboxedSourcePlugins;
+  /**
+   * Remove a plugin from the in-memory pipeline lists by ID.
+   * Mutates allPipelinePlugins and configuredPlugins in place.
+   */
+  private removePluginFromLists;
+  /**
+   * Sync marketplace plugin metadata in sandbox: false bypass mode.
+   *
+   * In bypass mode the noop runner can't load plugins, but admin pages,
+   * widgets, and route metadata still need to refresh in-process when an
+   * admin installs/updates/uninstalls a marketplace plugin. Otherwise the
+   * admin UI shows stale data until the server restarts.
+   *
+   * Hooks and routes still won't execute under bypass (matches the
+   * cold-start bypass behavior in loadMarketplacePluginsBypassed).
+   *
+   * Known limitation: bypass plugins are loaded via `import(dataUrl)`,
+   * which Node's ESM cache keys on the full URL. Updates create fresh
+   * module objects, but old ones remain cached for the worker's lifetime.
+   * In practice this is a few KB per update — only matters for sites with
+   * very frequent marketplace updates running long-lived processes. The
+   * fix would be vm.SourceTextModule for explicit lifecycle management.
+   */
+  private syncMarketplacePluginsBypassed;
+  /**
+   * Create and initialize the runtime
+   */
+  static create(deps: RuntimeDependencies, timings?: Array<{
+    name: string;
+    dur: number;
+    desc?: string;
+  }>): Promise<EmDashRuntime>;
+  /**
+   * Get a media provider by ID
+   */
+  getMediaProvider(providerId: string): MediaProvider | undefined;
+  /**
+   * Get all media provider entries (for admin UI)
+   */
+  getMediaProviderList(): Array<{
+    id: string;
+    name: string;
+    icon?: string;
+    capabilities: MediaProviderCapabilities;
+  }>;
+  /**
+   * Get or create database instance
+   */
+  private static getDatabase;
+  /**
+   * Get or create storage instance
+   */
+  private static getStorage;
+  /**
+   * Load sandboxed plugin entries as trusted in-process plugins.
+   * Used by the sandbox: false debugging escape hatch.
+   *
+   * Imports each plugin's bundled ESM code via a data URL, adapts it
+   * with adaptSandboxEntry, and returns ResolvedPlugin objects ready
+   * to be merged into the pipeline plugin list.
+   */
+  private static loadBypassedPlugins;
+  /**
+   * Load sandboxed plugins using SandboxRunner
+   */
+  private static loadSandboxedPlugins;
+  /**
+   * Cold-start: load marketplace-installed plugins from site-local R2 storage
+   *
+   * Queries _plugin_state for source='marketplace' rows, fetches each bundle
+   * from R2, and loads via SandboxRunner.
+   */
+  /**
+   * Cold-start load of all active sandboxed plugins for one install
+   * tier (marketplace or registry) from site-local R2.
+   *
+   * Mirrors {@link syncSandboxedSourcePlugins} but runs once at runtime
+   * creation, before request traffic arrives; the sync method runs on
+   * demand after install / update / uninstall handlers.
+   */
+  private static loadInstalledSandboxedPlugins;
+  /**
+   * Cold-start: load marketplace plugins in bypass mode (sandbox: false).
+   *
+   * Each active marketplace bundle is read, evaluated via data URL, adapted
+   * with adaptSandboxEntry, and returned as a ResolvedPlugin. The caller is
+   * responsible for merging these into allPipelinePlugins / configuredPlugins
+   * BEFORE the hook pipeline is created, so hooks and routes register in
+   * the trusted pipeline.
+   *
+   * Also caches manifest and route metadata so admin UI / getManifest() work.
+   *
+   * Returns ResolvedPlugins to be merged into the pipeline.
+   */
+  private static loadMarketplacePluginsBypassed;
+  /**
+   * Resolve exclusive hook selections on startup.
+   *
+   * Delegates to the shared resolveExclusiveHooks() in hooks.ts.
+   * The runtime version considers all pipeline providers as "active" since
+   * the pipeline was already built from only active/enabled plugins.
+   */
+  private static resolveExclusiveHooks;
+  /**
+   * Build the admin manifest from the live database.
+   *
+   * Used by the admin UI (sidebar collections, content editor field
+   * dispatch, manifest endpoint) and by WordPress import — it's never
+   * read on a public request, so this isn't on any anonymous hot path.
+   *
+   * No cross-request cache. The previous worker-isolate cache produced
+   * a class of cross-isolate staleness bugs (#776, #873, #876, #877)
+   * because Cloudflare Workers keeps multiple warm isolates per region
+   * and there's no fan-out primitive to invalidate them in step. The
+   * cache existed to amortize an N+1 schema query pattern; now that
+   * `listCollectionsWithFields()` does the same work in two queries,
+   * the rebuild is fast enough to pay on every admin request.
+   *
+   * Within a single request, `requestCached` deduplicates concurrent
+   * callers (the manifest endpoint and an admin SSR template, say).
+   */
+  getManifest(): Promise<EmDashManifest>;
+  /**
+   * Build the manifest from the database.
+   *
+   * Constant query shapes via `listCollectionsWithFields()` — one query
+   * for collections, one batched query for fields (chunked at
+   * `SQL_BATCH_SIZE` collection IDs to stay under D1's bound-parameter
+   * limit). Typical sites stay well under the chunk threshold, so this
+   * is two queries in practice; never N+1.
+   */
+  private _buildManifest;
+  /**
+   * Verify and repair FTS indexes on demand. Runs at most once per worker
+   * lifetime.
+   *
+   * Originally called from `EmDashRuntime.create()`, but on a busy D1 link
+   * (e.g. SIN replica ~80-150ms per query) it added ~1.5s to every cold
+   * start for a modest-sized site — more than every other init phase
+   * combined. Anonymous public reads never touch the search write path,
+   * so the cost isn't paid back for the vast majority of requests.
+   *
+   * Instead, search endpoints call this lazily: the first request that
+   * actually needs the index pays the verify cost (usually fast — no
+   * rebuild needed), everyone else runs cold-free.
+   *
+   * Uses the runtime's singleton database (`this._db`) rather than the
+   * request-scoped DB. Verify reads only, but `rebuildIndex` writes, and
+   * a GET search request on D1 carries a `first-unconstrained` session
+   * that's free to route at a read replica — unsafe for writes. The
+   * singleton always goes through the default binding, which the D1
+   * adapter will promote to `first-primary` for write statements.
+   *
+   * Safe to call concurrently: repeated callers share the same in-flight
+   * promise. Errors are swallowed internally so callers don't need to
+   * defend against FTS not existing yet (pre-setup).
+   */
+  ensureSearchHealthy(): Promise<void>;
+  handleContentList(collection: string, params: {
+    cursor?: string;
+    limit?: number;
+    status?: string;
+    orderBy?: string;
+    order?: "asc" | "desc";
+    locale?: string;
+    q?: string;
+    authorId?: string;
+    dateField?: ContentDateField;
+    dateFrom?: string;
+    dateTo?: string;
+  }): Promise<ApiResult<ContentListResponse>>;
+  handleContentAuthors(collection: string): Promise<ApiResult<{
+    items: ContentAuthor[];
+  }>>;
+  handleContentGet(collection: string, id: string, locale?: string): Promise<ApiResult<ContentResponse>>;
+  handleContentGetIncludingTrashed(collection: string, id: string, locale?: string): Promise<ApiResult<ContentResponse>>;
+  /**
+   * If the response item has a `draftRevisionId`, replace `item.data` with
+   * the draft revision's data and expose the original published values as
+   * `liveData`. This makes the content_get / content_update round-trip
+   * intuitive — read returns the latest content the caller has saved
+   * (their pending draft), with the previously-published values still
+   * accessible for compare-style flows.
+   *
+   * No-op when no draft exists or the response is an error.
+   */
+  private hydrateDraftData;
+  handleContentCreate(collection: string, body: {
+    data: Record<string, unknown>;
+    slug?: string;
+    status?: string;
+    authorId?: string;
+    bylines?: Array<{
+      bylineId: string;
+      roleLabel?: string | null;
+    }>;
+    locale?: string;
+    translationOf?: string;
+    taxonomies?: Record<string, string[]>;
+  }): Promise<{
+    success: false;
+    error: {
+      code: string;
+      message: string;
+      details?: Record<string, unknown>;
+    };
+  } | {
+    success: true;
+    data: ContentResponse;
+  } | {
+    success: false;
+    error: {
+      code: "VALIDATION_ERROR" | "COLLECTION_NOT_FOUND";
+      message: string;
+    };
+  }>;
+  handleContentUpdate(collection: string, id: string, body: {
+    data?: Record<string, unknown>;
+    slug?: string;
+    status?: string;
+    authorId?: string | null;
+    bylines?: Array<{
+      bylineId: string;
+      roleLabel?: string | null;
+    }>;
+    seo?: {
+      title?: string | null;
+      description?: string | null;
+      image?: string | null;
+      canonical?: string | null;
+      noIndex?: boolean;
+    };
+    taxonomies?: Record<string, string[]>;
+    publishedAt?: string | null;
+    locale?: string; /** Skip revision creation (used by autosave) */
+    skipRevision?: boolean;
+    _rev?: string;
+  }): Promise<ApiResult<ContentResponse>>;
+  handleContentDelete(collection: string, id: string): Promise<{
+    success: false;
+    error: {
+      code: string;
+      message: string;
+      details?: Record<string, unknown>;
+    };
+  } | {
+    success: true;
+    data: {
+      deleted: true;
+      id: string;
+    };
+  } | {
+    success: boolean;
+    error: {
+      code: string;
+      message: string;
+    };
+  }>;
+  handleContentListTrashed(collection: string, params?: {
+    cursor?: string;
+    limit?: number;
+  }): Promise<ApiResult<{
+    items: TrashedContentItem[];
+    nextCursor?: string;
+  }>>;
+  handleContentRestore(collection: string, id: string): Promise<ApiResult<{
+    restored: true;
+    item: ContentItem;
+  }>>;
+  handleContentPermanentDelete(collection: string, id: string): Promise<ApiResult<{
+    deleted: true;
+    id: string;
+  }>>;
+  handleContentCountTrashed(collection: string): Promise<ApiResult<{
+    count: number;
+  }>>;
+  handleContentDuplicate(collection: string, id: string, authorId?: string): Promise<ApiResult<{
+    item: ContentItem;
+  }>>;
+  handleContentPublish(collection: string, id: string, options?: {
+    publishedAt?: string;
+    requireScheduledDue?: boolean;
+  }): Promise<ApiResult<ContentResponse>>;
+  handleContentUnpublish(collection: string, id: string): Promise<ApiResult<ContentResponse>>;
+  handleContentSchedule(collection: string, id: string, scheduledAt: string): Promise<ApiResult<ContentResponse>>;
+  handleContentUnschedule(collection: string, id: string): Promise<ApiResult<ContentResponse>>;
+  handleContentCountScheduled(collection: string): Promise<ApiResult<{
+    count: number;
+  }>>;
+  handleContentDiscardDraft(collection: string, id: string): Promise<ApiResult<ContentResponse>>;
+  handleContentCompare(collection: string, id: string): Promise<ApiResult<{
+    hasChanges: boolean;
+    live: Record<string, unknown> | null;
+    draft: Record<string, unknown> | null;
+  }>>;
+  handleContentTranslations(collection: string, id: string): Promise<ApiResult<{
+    translationGroup: string;
+    translations: Array<{
+      id: string;
+      locale: string | null;
+      slug: string | null;
+      status: string;
+      updatedAt: string;
+    }>;
+  }>>;
+  handleMediaList(params: {
+    cursor?: string;
+    limit?: number;
+    mimeType?: string | readonly string[];
+    q?: string;
+  }): Promise<ApiResult<MediaListResponse>>;
+  handleMediaGet(id: string): Promise<ApiResult<MediaResponse>>;
+  handleMediaCreate(input: {
+    filename: string;
+    mimeType: string;
+    size?: number;
+    width?: number;
+    height?: number;
+    storageKey: string;
+    contentHash?: string;
+    blurhash?: string;
+    dominantColor?: string;
+    authorId?: string;
+  }): Promise<ApiResult<MediaResponse>>;
+  handleMediaUpdate(id: string, input: {
+    alt?: string;
+    caption?: string;
+    width?: number;
+    height?: number;
+  }): Promise<ApiResult<MediaResponse>>;
+  handleMediaDelete(id: string): Promise<ApiResult<{
+    deleted: true;
+  }>>;
+  handleRevisionList(collection: string, entryId: string, params?: {
+    limit?: number;
+  }): Promise<ApiResult<RevisionListResponse>>;
+  handleRevisionGet(revisionId: string): Promise<ApiResult<RevisionResponse>>;
+  handleRevisionRestore(revisionId: string, callerUserId: string): Promise<ApiResult<ContentResponse>>;
+  private refreshContentUsageAfterSuccessfulWrite;
+  private deleteContentUsageAfterSuccessfulPermanentDelete;
+  /**
+   * Get route metadata for a plugin route without invoking the handler.
+   * Used by the catch-all route to decide auth before dispatch.
+   * Returns null if the plugin or route doesn't exist.
+   */
+  getPluginRouteMeta(pluginId: string, path: string): RouteMeta | null;
+  /**
+   * Resolve the settings schema for a runtime-installed (marketplace or
+   * registry) plugin from its cached manifest. Returns `{}` for a known
+   * plugin without a schema and `null` for unknown plugins, matching the
+   * contract of `getPluginSettingsSchema` for build-time plugins.
+   */
+  getRuntimePluginSettingsSchema(pluginId: string): Record<string, SettingField> | null;
+  handlePluginApiRoute(pluginId: string, _method: string, path: string, request: Request): Promise<{
+    success: boolean;
+    data?: unknown;
+    error?: {
+      code: string;
+      message: string;
+    };
+  }>;
+  getPluginMcpTools(pluginId?: string): Promise<{
+    pluginId: string;
+    name: string;
+    description: string;
+    route: string;
+    permission: string;
+    destructive: boolean;
+    inputSchema: z$1.ZodType;
+    outputSchema?: z$1.ZodType;
+  }[]>;
+  getEnabledPluginMcpTools(): Promise<{
+    pluginId: string;
+    name: string;
+    description: string;
+    route: string;
+    permission: string;
+    destructive: boolean;
+    inputSchema: z$1.ZodType;
+    outputSchema?: z$1.ZodType;
+  }[]>;
+  serializePluginMcpConsent(tools: Awaited<ReturnType<EmDashRuntime["getPluginMcpTools"]>>, pluginId: string): string;
+  handlePluginMcpTool(pluginId: string, toolName: string, route: string, input: unknown, actorId: string, request: Request): Promise<{
+    success: boolean;
+    data?: unknown;
+    error?: {
+      code: string;
+      message: string;
+    };
+  }>;
+  handlePluginMcpDenied(pluginId: string, toolName: string, route: string, actorId: string, request: Request, reason: string): Promise<void>;
+  private findSandboxedPlugin;
+  /**
+   * Normalize image/file fields in content data.
+   * Fills missing dimensions, storageKey, mimeType, and filename from providers.
+   */
+  private normalizeMediaFields;
+  private runSandboxedBeforeSave;
+  private runSandboxedBeforeDelete;
+  private runAfterSaveHooks;
+  private runAfterDeleteHooks;
+  private runDeferredContentHook;
+  private runAfterPublishHooks;
+  private runAfterUnpublishHooks;
+  private runAfterRestoreHooks;
+  private runAfterScheduleHooks;
+  private runAfterUnscheduleHooks;
+  private handleSandboxedRoute;
+  /**
+   * Cache for page contributions. Uses a WeakMap keyed on the PublicPageContext
+   * object so results are collected once per page context per request, even when
+   * multiple render components (EmDashHead, EmDashBodyStart, EmDashBodyEnd)
+   * request contributions from the same page.
+   */
+  private pageContributionCache;
+  /**
+   * Collect all page contributions (metadata + fragments) in a single pass.
+   * Results are cached by page context object identity.
+   */
+  collectPageContributions(page: PublicPageContext): Promise<PageContributions>;
+  private doCollectPageContributions;
+  /**
+   * Collect page metadata contributions from trusted and sandboxed plugins.
+   * Delegates to the single-pass collector and returns the metadata portion.
+   */
+  collectPageMetadata(page: PublicPageContext): Promise<PageMetadataContribution[]>;
+  /**
+   * Collect page fragment contributions from trusted plugins only.
+   * Delegates to the single-pass collector and returns the fragments portion.
+   */
+  collectPageFragments(page: PublicPageContext): Promise<PageFragmentContribution[]>;
+  private isPluginEnabled;
+}
 //#endregion
 //#region src/sections/types.d.ts
 /**
@@ -3693,6 +4518,9 @@ declare const pluginManifestSchema: z$1.ZodObject<{
       read: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
       write: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
     }, z$1.core.$strip>>;
+    taxonomies: z$1.ZodOptional<z$1.ZodObject<{
+      read: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+    }, z$1.core.$strip>>;
     media: z$1.ZodOptional<z$1.ZodObject<{
       read: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
       write: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
@@ -3719,6 +4547,7 @@ declare const pluginManifestSchema: z$1.ZodObject<{
     "network:request:unrestricted": "network:request:unrestricted";
     "content:read": "content:read";
     "content:write": "content:write";
+    "taxonomies:read": "taxonomies:read";
     "media:read": "media:read";
     "media:write": "media:write";
     "users:read": "users:read";
@@ -3803,7 +4632,20 @@ declare const pluginManifestSchema: z$1.ZodObject<{
   routes: z$1.ZodArray<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodObject<{
     name: z$1.ZodString;
     public: z$1.ZodOptional<z$1.ZodBoolean>;
+    permission: z$1.ZodOptional<z$1.ZodString>;
+    cacheControl: z$1.ZodOptional<z$1.ZodString>;
   }, z$1.core.$strip>]>>;
+  mcp: z$1.ZodOptional<z$1.ZodObject<{
+    tools: z$1.ZodArray<z$1.ZodObject<{
+      name: z$1.ZodString;
+      description: z$1.ZodString;
+      route: z$1.ZodString;
+      permission: z$1.ZodString;
+      destructive: z$1.ZodBoolean;
+      inputSchema: z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>;
+      outputSchema: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+    }, z$1.core.$strip>>;
+  }, z$1.core.$strip>>;
   admin: z$1.ZodObject<{
     entry: z$1.ZodOptional<z$1.ZodString>;
     settingsSchema: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
@@ -3871,13 +4713,13 @@ declare const pluginManifestSchema: z$1.ZodObject<{
         string: "string";
         number: "number";
         boolean: "boolean";
-        slug: "slug";
-        text: "text";
-        select: "select";
         file: "file";
+        slug: "slug";
         image: "image";
         datetime: "datetime";
+        text: "text";
         integer: "integer";
+        select: "select";
         multiSelect: "multiSelect";
         portableText: "portableText";
         reference: "reference";
@@ -5116,6 +5958,23 @@ declare class FTSManager {
    * Get searchable fields for a collection
    */
   getSearchableFields(collectionSlug: string): Promise<string[]>;
+  /**
+   * Whether a collection has a user-defined `title` field.
+   *
+   * `title` is not a system column on `ec_*` tables -- it exists only when a
+   * collection defines a field with slug `title`. Search and suggestion SQL
+   * that selects `c.title` must check this first; otherwise collections
+   * without a title field raise "no such column: c.title" (#1178).
+   */
+  hasTitleColumn(collectionSlug: string): Promise<boolean>;
+  /**
+   * Bulk variant of `hasTitleColumn()`: which of the given collections have
+   * a user-defined `title` field. One query instead of one `hasTitleColumn`
+   * round-trip pair per collection -- callers that check this once per
+   * collection in a loop (multi-collection search, suggestions) should use
+   * this instead (AGENTS.md: "one query beats two").
+   */
+  getCollectionsWithTitleColumn(collectionSlugs: string[]): Promise<Set<string>>;
   /**
    * Enable search for a collection.
    *
@@ -5261,5 +6120,5 @@ declare function extractPlainText(blocks: PortableTextBlock[] | string | null |
  */
 declare function extractSearchableFields(entry: Record<string, unknown>, fields: string[]): Record<string, string>;
 //#endregion
-export { ReorderMenuItemsInput as $, HookPipeline as $n, handleContentUpdate as $r, ContentEntry as $t, getEntriesByTerm as A, PortableTextCodeBlock as An, handleRevisionGet as Ar, pluginManifestSchema as At, TaxonomyTerm as B, ProseMirrorNode as Bn, handleContentDiscardDraft as Br, invalidateMenuObjectCache as Bt, ReorderWidgetsInput as C, getDb as Cn, handleMediaCreate as Cr, NoopSandboxRunner as Ct, WidgetComponentDef as D, hashString as Dn, handleMediaUpdate as Dr, PluginManager as Dt, WidgetArea as E, computeContentHash as En, handleMediaList as Er, NodeCronScheduler as Et, getTerm as F, PortableTextSpan as Fn, handleContentCompare as Fr, contentNamespace as Ft, getEntriesByByline as G, Section as Gn, handleContentListTrashed as Gr, getFallbackChain as Gt, UpdateTermInput as H, getSections as Hn, handleContentGet as Hr, invalidateSchemaObjectCache as Ht, getTermsForEntries as I, PortableTextTextBlock as In, handleContentCountScheduled as Ir, contentNamespaces as It, CreateMenuInput as J, SandboxedPluginEntry as Jn, handleContentRestore as Jr, WaitUntilFn as Jt, getMenu as K, SectionSource as Kn, handleContentPermanentDelete as Kr, getI18nConfig as Kt, invalidateTermCache as L, PortableTextUnknownBlock as Ln, handleContentCountTrashed as Lr, invalidateBylineObjectCache as Lt, getTaxonomyDef as M, PortableTextImageBlock as Mn, handleRevisionRestore as Mr, CacheNamespace as Mt, getTaxonomyDefs as N, PortableTextLinkMark as Nn, generateManifest as Nr, CachedQueryOptions as Nt, WidgetType as O, portableTextToProsemirror as On, RevisionListResponse as Or, createPluginManager as Ot, getTaxonomyTerms as P, PortableTextMarkDef as Pn, handleContentAuthors as Pr, cachedQuery as Pt, MenuItemType as Q, EmailPipeline as Qn, handleContentUnschedule as Qr, CollectionResult as Qt, CreateTermInput as R, ProseMirrorDocument as Rn, handleContentCreate as Rr, invalidateCollectionCache as Rt, PropDef as S, emdashLoader as Sn, MediaResponse as Sr, verifyPreviewToken as St, Widget as T, sanitizeHref as Tn, handleMediaGet as Tr, createNoopSandboxRunner as Tt, getByline as U, CreateSectionInput as Un, handleContentGetIncludingTrashed as Ur, invalidateTaxonomyObjectCache as Ut, TaxonomyTermRow as V, getSection as Vn, handleContentDuplicate as Vr, invalidateObjectCache as Vt, getBylineBySlug as W, GetSectionsOptions as Wn, handleContentList as Wr, I18nConfig as Wt, Menu as X, SystemCleanupFn as Xn, handleContentTranslations as Xr, CacheHint as Xt, CreateMenuItemInput as Y, CronScheduler as Yn, handleContentSchedule as Yr, after as Yt, MenuItem as Z, PluginRouteError as Zn, handleContentUnpublish as Zr, CollectionFilter as Zt, getWidgetArea as _, CollectionFilter$1 as _n, StorageDescriptor as _r, PreviewTokenPayload as _t, search as a, FieldUIHints as ai, TranslationSummary as an, SandboxEmailSendCallback as ar, getComments as at, CreateWidgetAreaInput as b, WhereRange as bn, SchemaRegistry as br, generatePreviewToken as bt, FTSManager as c, PortableTextBlock$1 as ci, getEmDashCollection as cn, SandboxRunnerFactory as cr, getSiteSetting as ct, SearchOptions as d, CreateMediaInput as di, resolveEmDashPath as dn, SerializedRequest as dr, getPreviewToken as dt, portableText as ei, EditFieldMeta as en, HookResult as er, UpdateMenuInput as et, SearchResponse as f, MediaItem as fi, CMSAnnotation as fn, EmDashConfig as fr, isPreviewRequest as ft, Suggestion as g, EmDashDatabaseError as gi, createNoop as gn, S3StorageConfig as gr, GeneratePreviewTokenOptions as gt, SuggestOptions as h, DatabaseConfig as hi, createEditable as hn, LocalStorageConfig as hr, getPreviewUrl as ht, getSuggestions as i, FieldDefinition as ii, ResolvePathResult as in, SandboxEmailMessage as ir, getCommentCount as it, getEntryTerms as j, PortableTextHtmlBlock as jn, handleRevisionList as jr, definePlugin as jt, getAllTermsForEntries as k, prosemirrorToPortableText as kn, RevisionResponse as kr, ValidatedPluginManifest as kt, CollectionSearchOptions as l, PluginStorageRepository as li, getEmDashEntry as ln, SandboxUnavailableError as lr, getSiteSettings as lt, SearchStats as m, ContentRepository as mi, FieldAnnotation as mn, getStoredConfig as mr, buildPreviewUrl as mt, extractSearchableFields as n, file as ni, EntryResult as nn, createHttpAccess as nr, GetCommentsOptions as nt, searchCollection as o, FileValue as oi, TranslationsResult as on, SandboxOptions as or, getPluginSetting as ot, SearchResult as p, MediaRepository as pi, EditProxy as pn, PluginDescriptor as pr, GetPreviewUrlOptions as pt, getMenus as q, UpdateSectionInput as qn, handleContentPublish as qr, isI18nEnabled as qt, getSearchStats as r, image as ri, InferCollectionData as rn, createUnrestrictedHttpAccess as rr, GetCommentsResult as rt, searchWithDb as s, ImageValue as si, getEditMeta as sn, SandboxRunner as sr, getPluginSettings as st, extractPlainText as t, reference as ti, EmDashCollections as tn, createHookPipeline as tr, UpdateMenuItemInput as tt, SearchConfig as u, UserRepository as ui, getTranslations as un, SandboxedPluginInstance as ur, setSiteSettings as ut, getWidgetAreas as v, EntryData as vn, getCollectionInfo as vr, VerifyPreviewTokenOptions as vt, UpdateWidgetInput as w, isSafeHref as wn, handleMediaDelete as wr, SandboxNotAvailableError as wt, CreateWidgetInput as x, WhereValue as xn, MediaListResponse as xr, parseContentId as xt, getWidgetComponents as y, EntryFilter as yn, SchemaError as yr, VerifyPreviewTokenResult as yt, TaxonomyDef as z, ProseMirrorMark as zn, handleContentDelete as zr, invalidateCommentObjectCache as zt };
-//# sourceMappingURL=index-B9sIxwe4.d.mts.map
+export { ReorderMenuItemsInput as $, PluginRouteError as $n, handleContentSchedule as $r, ContentEntry as $t, getEntriesByTerm as A, PortableTextCodeBlock as An, handleMediaList as Ar, pluginManifestSchema as At, TaxonomyTerm as B, ProseMirrorNode as Bn, handleContentCountScheduled as Br, invalidateMenuObjectCache as Bt, ReorderWidgetsInput as C, getDb as Cn, SchemaRegistry as Cr, NoopSandboxRunner as Ct, WidgetComponentDef as D, hashString as Dn, handleMediaCreate as Dr, PluginManager as Dt, WidgetArea as E, computeContentHash as En, MediaResponse as Er, NodeCronScheduler as Et, getTerm as F, PortableTextSpan as Fn, handleRevisionList as Fr, contentNamespace as Ft, getEntriesByByline as G, Section as Gn, handleContentDuplicate as Gr, getFallbackChain as Gt, UpdateTermInput as H, getSections as Hn, handleContentCreate as Hr, invalidateSchemaObjectCache as Ht, getTermsForEntries as I, PortableTextTextBlock as In, handleRevisionRestore as Ir, contentNamespaces as It, CreateMenuInput as J, EmDashRuntime as Jn, handleContentList as Jr, WaitUntilFn as Jt, getMenu as K, SectionSource as Kn, handleContentGet as Kr, getI18nConfig as Kt, invalidateTermCache as L, PortableTextUnknownBlock as Ln, generateManifest as Lr, invalidateBylineObjectCache as Lt, getTaxonomyDef as M, PortableTextImageBlock as Mn, RevisionListResponse as Mr, CacheNamespace as Mt, getTaxonomyDefs as N, PortableTextLinkMark as Nn, RevisionResponse as Nr, CachedQueryOptions as Nt, WidgetType as O, portableTextToProsemirror as On, handleMediaDelete as Or, createPluginManager as Ot, getTaxonomyTerms as P, PortableTextMarkDef as Pn, handleRevisionGet as Pr, cachedQuery as Pt, MenuItemType as Q, SystemCleanupFn as Qn, handleContentRestore as Qr, CollectionResult as Qt, CreateTermInput as R, ProseMirrorDocument as Rn, handleContentAuthors as Rr, invalidateCollectionCache as Rt, PropDef as S, emdashLoader as Sn, SchemaError as Sr, verifyPreviewToken as St, Widget as T, sanitizeHref as Tn, MediaListResponse as Tr, createNoopSandboxRunner as Tt, getByline as U, CreateSectionInput as Un, handleContentDelete as Ur, invalidateTaxonomyObjectCache as Ut, TaxonomyTermRow as V, getSection as Vn, handleContentCountTrashed as Vr, invalidateObjectCache as Vt, getBylineBySlug as W, GetSectionsOptions as Wn, handleContentDiscardDraft as Wr, I18nConfig as Wt, Menu as X, PublishedRef as Xn, handleContentPermanentDelete as Xr, CacheHint as Xt, CreateMenuItemInput as Y, SandboxedPluginEntry as Yn, handleContentListTrashed as Yr, after as Yt, MenuItem as Z, CronScheduler as Zn, handleContentPublish as Zr, CollectionFilter as Zt, getWidgetArea as _, MediaRepository as _i, CollectionFilter$1 as _n, getStoredConfig as _r, PreviewTokenPayload as _t, search as a, reference as ai, TranslationSummary as an, createHttpAccess as ar, getComments as at, CreateWidgetAreaInput as b, EmDashDatabaseError as bi, WhereRange as bn, StorageDescriptor as br, generatePreviewToken as bt, FTSManager as c, FieldDefinition as ci, getEmDashCollection as cn, SandboxEmailSendCallback as cr, getSiteSetting as ct, SearchOptions as d, ImageValue as di, resolveEmDashPath as dn, SandboxRunnerFactory as dr, getPreviewToken as dt, handleContentTranslations as ei, EditFieldMeta as en, RouteMeta as er, UpdateMenuInput as et, SearchResponse as f, PortableTextBlock$1 as fi, CMSAnnotation as fn, SandboxUnavailableError as fr, isPreviewRequest as ft, Suggestion as g, MediaItem as gi, createNoop as gn, PluginDescriptor as gr, GeneratePreviewTokenOptions as gt, SuggestOptions as h, CreateMediaInput as hi, createEditable as hn, EmDashConfig as hr, getPreviewUrl as ht, getSuggestions as i, portableText as ii, ResolvePathResult as in, createHookPipeline as ir, getCommentCount as it, getEntryTerms as j, PortableTextHtmlBlock as jn, handleMediaUpdate as jr, definePlugin as jt, getAllTermsForEntries as k, prosemirrorToPortableText as kn, handleMediaGet as kr, ValidatedPluginManifest as kt, CollectionSearchOptions as l, FieldUIHints as li, getEmDashEntry as ln, SandboxOptions as lr, getSiteSettings as lt, SearchStats as m, UserRepository as mi, FieldAnnotation as mn, SerializedRequest as mr, buildPreviewUrl as mt, extractSearchableFields as n, handleContentUnschedule as ni, EntryResult as nn, HookPipeline as nr, GetCommentsOptions as nt, searchCollection as o, file as oi, TranslationsResult as on, createUnrestrictedHttpAccess as or, getPluginSetting as ot, SearchResult as p, PluginStorageRepository as pi, EditProxy as pn, SandboxedPluginInstance as pr, GetPreviewUrlOptions as pt, getMenus as q, UpdateSectionInput as qn, handleContentGetIncludingTrashed as qr, isI18nEnabled as qt, getSearchStats as r, handleContentUpdate as ri, InferCollectionData as rn, HookResult as rr, GetCommentsResult as rt, searchWithDb as s, image as si, getEditMeta as sn, SandboxEmailMessage as sr, getPluginSettings as st, extractPlainText as t, handleContentUnpublish as ti, EmDashCollections as tn, EmailPipeline as tr, UpdateMenuItemInput as tt, SearchConfig as u, FileValue as ui, getTranslations as un, SandboxRunner as ur, setSiteSettings as ut, getWidgetAreas as v, ContentRepository as vi, EntryData as vn, LocalStorageConfig as vr, VerifyPreviewTokenOptions as vt, UpdateWidgetInput as w, isSafeHref as wn, markContentMediaUsageCollectionStaleSafely as wr, SandboxNotAvailableError as wt, CreateWidgetInput as x, WhereValue as xn, getCollectionInfo as xr, parseContentId as xt, getWidgetComponents as y, DatabaseConfig as yi, EntryFilter as yn, S3StorageConfig as yr, VerifyPreviewTokenResult as yt, TaxonomyDef as z, ProseMirrorMark as zn, handleContentCompare as zr, invalidateCommentObjectCache as zt };
+//# sourceMappingURL=index-wYnC6u4o.d.mts.map