dineway 0.1.49 → 0.2.0

package/dist/{runtime-C4-2lSFg.d.mts → runtime-BOeiQsCv.d.mts}

@@ -1,16 +1,18 @@
-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-CwawBUTa.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-DRIKLmJI.mjs";
-import { t as Database } from "./types-CuJOqHfM.mjs";
-import { A as PageMetadataContribution, B as PluginDefinition, D as PageFragmentContribution, H as PluginManifest, J as RequestMeta, O as PageFragmentEvent, W as PluginStorageConfig, X as ResolvedPlugin, a as CommentAfterModerateEvent, g as EmailMessage, h as CronEvent, j as PageMetadataEvent, r as CommentAfterCreateEvent, s as CommentBeforeCreateEvent, tt as StandardPluginDefinition, w as MediaItem$1 } from "./types-DSPGWjxO.mjs";
-import { r as AuthProviderDescriptor, t as AuthDescriptor } from "./types-Dryvv7LH.mjs";
-import { t as DatabaseDescriptor } from "./adapters-OQCImOL7.mjs";
-import { _ as MediaValue, m as MediaProviderDescriptor } from "./placeholder-CXfoCtCd.mjs";
-import { S as ContentBylineInput } from "./index-CZiWCQDp.mjs";
-import { d as Storage } from "./types-DZpT-PnG.mjs";
-import { i as SiteSettings, r as SiteSettingKey } from "./types-nP9vGUFq.mjs";
-import { 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-DW_-sFyz.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-C_ly5eTp.mjs";
+import { t as Database } from "./types-DU0bU2Wu.mjs";
+import { A as PageMetadataContribution, D as PageFragmentContribution, Dt as StandardPluginDefinition, F as PluginActor, G as PluginManifest, J as PluginMcpCommandTool, O as PageFragmentEvent, U as PluginDefinition, V as PluginCapability, X as PluginMcpExecutionContext, _ as FieldWidgetConfig, a as CommentAfterModerateEvent, at as PluginMcpTargetAuthorizer$1, et as PluginMcpResource, g as EmailMessage, gt as PortableTextBlockConfig, h as CronEvent, ht as PluginTargetScope, j as PageMetadataEvent, mt as PluginStorageConfig, ot as PluginMcpTool, r as CommentAfterCreateEvent, s as CommentBeforeCreateEvent, w as MediaItem$1, xt as ResolvedPlugin, yt as RequestMeta } from "./types-C8XW6L19.mjs";
+import { d as Storage } from "./types-POH8PQZh.mjs";
+import { r as AuthProviderDescriptor, t as AuthDescriptor } from "./types-Rc3gQqqw.mjs";
+import { t as DatabaseDescriptor } from "./adapters-NVSs4UH7.mjs";
+import { _ as MediaValue, m as MediaProviderDescriptor } from "./placeholder-uvNRZBX9.mjs";
+import { r as ObjectCacheDescriptor } from "./types-DF7ZuGGk.mjs";
+import { E as ContentBylineInput } from "./index-D4y6NGiy.mjs";
+import { i as SiteSettings, r as SiteSettingKey } from "./types-C46EvNdc.mjs";
+import { Dialect, Kysely, Transaction } from "kysely";
 import { z } from "astro/zod";
 import { z as z$1 } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { LiveLoader } from "astro/loaders";
 import { MiddlewareHandler } from "astro";
 
@@ -254,17 +256,12 @@ interface WhereRange {
 }
 type WhereValue = string | string[] | WhereRange;
 /**
- * Filter for loadCollection - type is required
+ * Fields shared by every collection filter, independent of pagination mode.
  */
-interface CollectionFilter$1 {
+interface CollectionFilterBase$1 {
   type: string;
   status?: "draft" | "published" | "archived";
   limit?: number;
-  /**
-   * Opaque cursor for keyset pagination.
-   * Pass the `nextCursor` value from a previous result to fetch the next page.
-   */
-  cursor?: string;
   /**
    * Filter by field values, taxonomy terms, byline credits, or ranges.
    *
@@ -288,6 +285,31 @@ interface CollectionFilter$1 {
    */
   locale?: string;
 }
+/** Keyset-paginated collection filter. Cannot also carry an offset. */
+interface CursorCollectionFilter$1 extends CollectionFilterBase$1 {
+  /**
+   * Opaque cursor for keyset pagination.
+   * Pass the `nextCursor` value from a previous result to fetch the next page.
+   */
+  cursor?: string;
+  offset?: never;
+}
+/** Offset-paginated collection filter. Cannot also carry a cursor. */
+interface OffsetCollectionFilter$1 extends CollectionFilterBase$1 {
+  /**
+   * Skip this many rows before returning results. Use with `limit` for numbered
+   * archives, for example `offset = (page - 1) * perPage`.
+   */
+  offset?: number;
+  cursor?: never;
+}
+/**
+ * Filter for loadCollection - type is required.
+ *
+ * Cursor and offset are mutually exclusive pagination modes. Runtime callers
+ * that supply both are treated as cursor-paginated so the two skips do not stack.
+ */
+type CollectionFilter$1 = CursorCollectionFilter$1 | OffsetCollectionFilter$1;
 /**
  * Filter for loadEntry - type and id are required
  */
@@ -414,7 +436,7 @@ declare class ContentRepository {
   /**
    * Restore content from trash
    */
-  restore(type: string, id: string): Promise<boolean>;
+  restore(type: string, id: string): Promise<ContentItem | null>;
   /**
    * Permanently delete a soft-deleted content row.
    */
@@ -603,6 +625,8 @@ declare class MediaRepository {
     width?: number;
     height?: number;
     size?: number;
+    blurhash?: string;
+    dominantColor?: string;
   }): Promise<MediaItem | null>;
   /**
    * Mark upload as failed
@@ -674,6 +698,7 @@ interface PublicComment {
   isRegisteredUser: boolean;
   body: string;
   createdAt: string;
+  reactions?: Record<string, number>;
   replies?: PublicComment[];
 }
 //#endregion
@@ -919,12 +944,14 @@ declare function handleContentDuplicate(db: Kysely<Database>, collection: string
  */
 declare function handleContentDelete(db: Kysely<Database>, collection: string, id: string): Promise<ApiResult<{
   deleted: true;
+  id: string;
 }>>;
 /**
  * Restore content item from trash
  */
 declare function handleContentRestore(db: Kysely<Database>, collection: string, id: string): Promise<ApiResult<{
   restored: true;
+  item: ContentItem;
 }>>;
 /**
  * Permanently delete content item (cannot be undone).
@@ -932,6 +959,7 @@ declare function handleContentRestore(db: Kysely<Database>, collection: string,
  */
 declare function handleContentPermanentDelete(db: Kysely<Database>, collection: string, id: string): Promise<ApiResult<{
   deleted: true;
+  id: string;
 }>>;
 /**
  * List trashed content items
@@ -1008,392 +1036,443 @@ declare function handleContentTranslations(db: Kysely<Database>, collection: str
   }>;
 }>>;
 //#endregion
-//#region src/api/handlers/manifest.d.ts
-interface CollectionDefinition {
-  schema: {
-    _def?: {
-      shape?: () => Record<string, unknown>;
-    };
-    shape?: Record<string, unknown>;
-  };
-  admin: {
-    label: string;
-    labelSingular?: string;
-    supports?: string[];
-  };
-}
-type CollectionMap = Record<string, CollectionDefinition>;
-/**
- * Generate admin manifest from collections
- */
-declare function generateManifest(collections: CollectionMap, plugins?: Record<string, {
-  adminPages?: Array<{
-    path: string;
-    component: string;
-  }>;
-  widgets?: string[];
-}>): Promise<ManifestResponse>;
-//#endregion
-//#region src/api/handlers/revision.d.ts
-interface RevisionListResponse {
-  items: Revision[];
-  total: number;
-}
-interface RevisionResponse {
-  item: Revision;
-}
-/**
- * List revisions for a content entry
- */
-declare function handleRevisionList(db: Kysely<Database>, collection: string, entryId: string, params?: {
-  limit?: number;
-}): Promise<ApiResult<RevisionListResponse>>;
-/**
- * Get a specific revision
- */
-declare function handleRevisionGet(db: Kysely<Database>, revisionId: string): Promise<ApiResult<RevisionResponse>>;
-/**
- * Restore a revision (updates content to this revision's data and creates new revision)
- */
-declare function handleRevisionRestore(db: Kysely<Database>, revisionId: string, callerUserId: string): Promise<ApiResult<ContentResponse>>;
-//#endregion
-//#region src/api/handlers/media.d.ts
-interface MediaListResponse {
-  items: MediaItem[];
-  nextCursor?: string;
-}
-interface MediaResponse {
-  item: MediaItem;
-}
-/**
- * List media items
- */
-declare function handleMediaList(db: Kysely<Database>, params: {
-  cursor?: string;
-  limit?: number;
-  mimeType?: string | readonly string[];
-  q?: string;
-}): Promise<ApiResult<MediaListResponse>>;
-/**
- * Get single media item
- */
-declare function handleMediaGet(db: Kysely<Database>, id: string): Promise<ApiResult<MediaResponse>>;
-/**
- * Create media item (after file upload)
- */
-declare function handleMediaCreate(db: Kysely<Database>, input: {
-  filename: string;
-  mimeType: string;
-  size?: number;
-  width?: number;
-  height?: number;
-  alt?: string;
-  storageKey: string;
-  contentHash?: string;
-  blurhash?: string;
-  dominantColor?: string;
-  authorId?: string;
-}): Promise<ApiResult<MediaResponse>>;
-/**
- * Update media metadata
- */
-declare function handleMediaUpdate(db: Kysely<Database>, id: string, input: {
-  alt?: string;
-  caption?: string;
-  width?: number;
-  height?: number;
-}): Promise<ApiResult<MediaResponse>>;
-/**
- * Delete media item
- */
-declare function handleMediaDelete(db: Kysely<Database>, id: string): Promise<ApiResult<{
-  deleted: true;
-}>>;
-//#endregion
-//#region src/schema/registry.d.ts
-/**
- * Error thrown when a schema operation fails
- */
-declare class SchemaError extends Error {
-  code: string;
-  details?: Record<string, unknown> | undefined;
-  constructor(message: string, code: string, details?: Record<string, unknown> | undefined);
-}
+//#region src/plugins/email.d.ts
 /**
- * Schema Registry
+ * EmailPipeline orchestrates email delivery through the plugin hook system.
  *
- * Manages collection and field definitions stored in the database.
- * Handles runtime DDL operations (CREATE TABLE, ALTER TABLE).
+ * The pipeline runs in three stages:
+ * 1. email:beforeSend — middleware hooks that can transform or cancel messages
+ * 2. email:deliver — exclusive hook dispatching to the selected provider
+ * 3. email:afterSend — fire-and-forget hooks for logging/analytics
  */
-declare class SchemaRegistry {
-  private db;
-  constructor(db: Kysely<Database>);
-  /**
-   * List all collections
-   */
-  listCollections(): Promise<Collection[]>;
-  /**
-   * List all collections with their fields using bounded query shapes.
-   */
-  listCollectionsWithFields(): Promise<CollectionWithFields[]>;
-  /**
-   * Get a collection by slug
-   */
-  getCollection(slug: string): Promise<Collection | null>;
-  /**
-   * Get a collection with all its fields
-   */
-  getCollectionWithFields(slug: string): Promise<CollectionWithFields | null>;
+declare class EmailPipeline {
+  private pipeline;
+  constructor(pipeline: HookPipeline);
   /**
-   * Create a new collection
+   * Replace the underlying hook pipeline.
+   *
+   * Called by the runtime when rebuilding the hook pipeline after a
+   * plugin is enabled or disabled, so the email pipeline dispatches
+   * to the current set of active hooks.
    */
-  createCollection(input: CreateCollectionInput): Promise<Collection>;
+  setPipeline(pipeline: HookPipeline): void;
   /**
-   * Update a collection
+   * Send an email through the full pipeline.
+   *
+   * @param message - The email to send
+   * @param source - Where the email originated ("system" for auth, plugin ID for plugins)
+   * @throws EmailNotConfiguredError if no provider is selected
+   * @throws EmailRecursionError if called re-entrantly from within a hook
+   * @throws Error if the provider handler throws
    */
-  updateCollection(slug: string, input: UpdateCollectionInput): Promise<Collection>;
-  private validateUrlPattern;
-  private checkLabelUniqueness;
-  private checkUrlPatternUniqueness;
+  send(message: EmailMessage, source: string): Promise<void>;
   /**
-   * Delete a collection
+   * Inner send implementation, separated from the recursion guard.
    */
-  deleteCollection(slug: string, options?: {
-    force?: boolean;
-  }): Promise<void>;
+  private sendInner;
   /**
-   * List fields for a collection
+   * Check if an email provider is configured and available.
+   *
+   * Returns true if an email:deliver provider is selected in the exclusive
+   * hook system. Plugins and auth code use this to decide whether to show
+   * "send invite" vs "copy invite link" UI.
    */
-  listFields(collectionId: string): Promise<Field[]>;
+  isAvailable(): boolean;
+}
+//#endregion
+//#region src/plugins/context.d.ts
+/**
+ * Options for creating site info
+ */
+interface SiteInfoOptions {
+  /** Site name from options table */
+  siteName?: string;
+  /** Site URL from options table or Astro config */
+  siteUrl?: string;
+  /** Site locale from options table */
+  locale?: string;
+}
+interface PluginContextFactoryOptions {
+  db: Kysely<Database>;
   /**
-   * Get a field by slug within a collection
+   * Resolver for the current database connection. When omitted, `db` is used.
+   * Runtime code provides this so plugin hooks and routes honor request-scoped
+   * database overrides from preview/playground sidecars.
    */
-  getField(collectionSlug: string, fieldSlug: string): Promise<Field | null>;
+  getDb?: () => Kysely<Database>;
   /**
-   * Create a new field
+   * Storage backend for direct media uploads.
+   * If not provided, upload() will throw.
    */
-  createField(collectionSlug: string, input: CreateFieldInput): Promise<Field>;
+  storage?: Storage;
   /**
-   * Ensure the content table for an existing collection exists.
-   *
-   * This repairs interrupted schema creation where the metadata row exists but
-   * the physical `ec_*` table was not created.
+   * Function to generate upload URLs for media.
+   * If not provided, media write operations will throw.
    */
-  ensureCollectionContentTable(collectionSlug: string): Promise<boolean>;
+  getUploadUrl?: (filename: string, contentType: string) => Promise<{
+    uploadUrl: string;
+    mediaId: string;
+  }>;
   /**
-   * Ensure the physical column for an existing field exists on its content table.
-   *
-   * This repairs interrupted field creation where `_dineway_fields` was written
-   * but `ALTER TABLE ec_* ADD COLUMN` did not complete.
+   * Site information for ctx.site and ctx.url().
+   * If not provided, site info will have empty defaults.
    */
-  ensureFieldColumn(collectionSlug: string, fieldSlug: string): Promise<boolean>;
+  siteInfo?: SiteInfoOptions;
   /**
-   * Update a field
+   * Callback to notify the cron scheduler that the next due time may have changed.
+   * If not provided, ctx.cron will not be available.
    */
-  updateField(collectionSlug: string, fieldSlug: string, input: UpdateFieldInput): Promise<Field>;
+  cronReschedule?: () => void;
   /**
-   * Synchronize an existing FTS index with the collection's current state.
-   *
-   * Schema writes must not first-time enable FTS. Initial enablement stays in
-   * explicit seed/import/admin flows where FTS failures can be handled deliberately.
+   * Email pipeline instance for ctx.email.
+   * If not provided (or no provider configured), ctx.email will be undefined.
    */
-  private syncSearchState;
+  emailPipeline?: EmailPipeline;
   /**
-   * Delete a field
+   * Trusted reverse-proxy headers for request metadata IP extraction.
    */
-  deleteField(collectionSlug: string, fieldSlug: string): Promise<void>;
-  /**
-   * Reorder fields
+  trustedProxyHeaders?: string[];
+}
+//#endregion
+//#region src/plugins/hooks.d.ts
+type HookNameV2 = "plugin:install" | "plugin:activate" | "plugin:deactivate" | "plugin:uninstall" | "content:beforeSave" | "content:afterSave" | "content:beforeDelete" | "content:afterDelete" | "content:afterPublish" | "content:afterUnpublish" | "content:afterRestore" | "content:afterSchedule" | "content:afterUnschedule" | "media:beforeUpload" | "media:afterUpload" | "cron" | "email:beforeSend" | "email:deliver" | "email:afterSend" | "comment:beforeCreate" | "comment:moderate" | "comment:afterCreate" | "comment:afterModerate" | "page:metadata" | "page:fragments";
+/**
+ * Hook execution result
+ */
+interface HookResult<T> {
+  success: boolean;
+  value?: T;
+  error?: Error;
+  pluginId: string;
+  duration: number;
+}
+/**
+ * Hook pipeline for executing hooks in order
+ */
+declare class HookPipeline {
+  private hooks;
+  private pluginMap;
+  private contextFactory;
+  /** Stored so setContextFactory can merge incrementally. */
+  private contextFactoryOptions;
+  /** Hook names where at least one handler declared exclusive: true */
+  private exclusiveHookNames;
+  /**
+   * Selected provider plugin ID for each exclusive hook.
+   * Set by the PluginManager after resolution.
    */
-  reorderFields(collectionSlug: string, fieldSlugs: string[]): Promise<void>;
+  private exclusiveSelections;
+  constructor(plugins: ResolvedPlugin[], factoryOptions?: PluginContextFactoryOptions);
   /**
-   * Create a content table for a collection
+   * Set or update the context factory options.
+   *
+   * When called on a pipeline that already has a factory, the new options
+   * are merged on top of the existing ones so that callers don't need to
+   * repeat every field (e.g. adding `cronReschedule` without losing
+   * `storage` / `getUploadUrl`).
    */
-  private createContentTable;
+  setContextFactory(options: Partial<PluginContextFactoryOptions>): void;
   /**
-   * Drop a content table
+   * Get context for a plugin
    */
-  private dropContentTable;
+  private getContext;
   /**
-   * Add a column to a content table
+   * Get typed hooks for a specific hook name.
+   * The internal map stores ResolvedHook<unknown>, but we know each name
+   * maps to a specific handler type via HookHandlerMap.
+   *
+   * Exclusive hooks that have a selected provider are filtered out — they
+   * should only run via invokeExclusiveHook(), not in the regular pipeline.
    */
-  private addColumn;
+  private getTypedHooks;
   /**
-   * Drop a column from a content table
+   * Register all hooks from plugins.
+   *
+   * Registers each hook name individually to preserve type safety. The
+   * internal map stores ResolvedHook<unknown> since it's keyed by string,
+   * but getTypedHooks() restores the correct handler type on retrieval.
    */
-  private dropColumn;
+  private registerPlugins;
   /**
-   * Check if a collection has any content
+   * Maps hook names to the capability required to register them.
+   *
+   * Hooks not listed here have no capability requirement (e.g. lifecycle
+   * hooks, cron). Any plugin declaring a listed hook without the required
+   * capability will have that hook silently skipped at registration time.
    */
-  private collectionHasContent;
+  private static readonly HOOK_REQUIRED_CAPABILITY;
   /**
-   * Get table name for a collection
+   * Register a single plugin's hook by name
    */
-  private getTableName;
+  private registerPluginHook;
   /**
-   * Get column name for a field
+   * Register a single hook
    */
-  private getColumnName;
+  private registerHook;
   /**
-   * Validate a slug
+   * Sort hooks by priority and dependencies
    */
-  private validateSlug;
+  private sortHooks;
   /**
-   * Format a default value for SQL.
+   * Execute a hook with timeout
+   */
+  private executeWithTimeout;
+  /**
+   * Run plugin:install hooks
+   */
+  runPluginInstall(pluginId: string): Promise<HookResult<void>[]>;
+  /**
+   * Run plugin:activate hooks
+   */
+  runPluginActivate(pluginId: string): Promise<HookResult<void>[]>;
+  /**
+   * Run plugin:deactivate hooks
+   */
+  runPluginDeactivate(pluginId: string): Promise<HookResult<void>[]>;
+  /**
+   * Run plugin:uninstall hooks
+   */
+  runPluginUninstall(pluginId: string, deleteData: boolean): Promise<HookResult<void>[]>;
+  private runLifecycleHook;
+  /**
+   * Run content:beforeSave hooks
+   * Returns modified content from the pipeline
+   */
+  runContentBeforeSave(content: Record<string, unknown>, collection: string, isNew: boolean): Promise<{
+    content: Record<string, unknown>;
+    results: HookResult<Record<string, unknown>>[];
+  }>;
+  /**
+   * Run content:afterSave hooks
+   */
+  runContentAfterSave(content: Record<string, unknown>, collection: string, isNew: boolean): Promise<HookResult<void>[]>;
+  /**
+   * Run content:beforeDelete hooks
+   * Returns whether deletion is allowed
+   */
+  runContentBeforeDelete(id: string, collection: string): Promise<{
+    allowed: boolean;
+    results: HookResult<boolean>[];
+  }>;
+  /**
+   * Run content:afterDelete hooks
+   */
+  runContentAfterDelete(id: string, collection: string, permanent: boolean): Promise<HookResult<void>[]>;
+  /**
+   * Run content:afterPublish hooks (fire-and-forget).
+   */
+  runContentAfterPublish(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
+  /**
+   * Run content:afterUnpublish hooks (fire-and-forget).
+   */
+  runContentAfterUnpublish(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
+  /**
+   * Run content:afterRestore hooks (fire-and-forget).
+   */
+  runContentAfterRestore(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
+  /**
+   * Run content:afterSchedule hooks (fire-and-forget).
+   */
+  runContentAfterSchedule(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
+  /**
+   * Run content:afterUnschedule hooks (fire-and-forget).
+   */
+  runContentAfterUnschedule(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
+  private runContentStateChangeHook;
+  /**
+   * Run media:beforeUpload hooks
+   */
+  runMediaBeforeUpload(file: {
+    name: string;
+    type: string;
+    size: number;
+  }): Promise<{
+    file: {
+      name: string;
+      type: string;
+      size: number;
+    };
+    results: HookResult<{
+      name: string;
+      type: string;
+      size: number;
+    }>[];
+  }>;
+  /**
+   * Run media:afterUpload hooks
+   */
+  runMediaAfterUpload(media: {
+    id: string;
+    filename: string;
+    mimeType: string;
+    size: number | null;
+    url: string;
+    createdAt: string;
+  }): Promise<HookResult<void>[]>;
+  /**
+   * Invoke the cron hook for a specific plugin.
    *
-   * SQLite `ALTER TABLE ADD COLUMN ... DEFAULT` requires a literal constant
-   * expression — parameterized values cannot be used here. We manually escape
-   * single quotes and coerce types to ensure the output is safe.
+   * Unlike other hooks which broadcast to all plugins, the cron hook is
+   * dispatched only to the target plugin — the one that owns the task.
+   */
+  invokeCronHook(pluginId: string, event: CronEvent): Promise<HookResult<void>>;
+  /**
+   * Run email:beforeSend hooks (middleware pipeline).
    *
-   * INTEGER/REAL values are coerced through `Number()` which can only produce
-   * digits, `.`, `-`, `e`, `Infinity`, or `NaN` — all safe in SQL.
-   * TEXT/JSON values have single quotes escaped via SQL standard doubling (`''`).
+   * Each handler receives the message and returns a modified message or
+   * `false` to cancel delivery. The pipeline chains message transformations —
+   * each handler receives the output of the previous one.
    */
-  private formatDefaultValue;
+  runEmailBeforeSend(message: EmailMessage, source: string): Promise<{
+    message: EmailMessage | false;
+    results: HookResult<EmailMessage | false>[];
+  }>;
   /**
-   * Get empty default for a field type
+   * Run email:afterSend hooks (fire-and-forget).
+   *
+   * Errors are logged but don't propagate — they don't affect the caller.
    */
-  private getEmptyDefault;
+  runEmailAfterSend(message: EmailMessage, source: string): Promise<HookResult<void>[]>;
   /**
-   * Map a collection row to a Collection object
+   * Run comment:beforeCreate hooks (middleware pipeline).
+   *
+   * Each handler receives the event and returns a modified event or
+   * `false` to reject the comment. The pipeline chains transformations —
+   * each handler receives the output of the previous one.
    */
-  private mapCollectionRow;
+  runCommentBeforeCreate(event: CommentBeforeCreateEvent): Promise<CommentBeforeCreateEvent | false>;
   /**
-   * Map a field row to a Field object
+   * Run comment:afterCreate hooks (fire-and-forget).
+   *
+   * Errors are logged but don't propagate — they don't affect the caller.
    */
-  private mapFieldRow;
+  runCommentAfterCreate(event: CommentAfterCreateEvent): Promise<void>;
   /**
-   * Discover orphaned content tables
+   * Run comment:afterModerate hooks (fire-and-forget).
    *
-   * Finds ec_* tables that exist in the database but don't have a
-   * corresponding entry in _dineway_collections.
+   * Errors are logged but don't propagate — they don't affect the caller.
    */
-  discoverOrphanedTables(): Promise<Array<{
-    slug: string;
-    tableName: string;
-    rowCount: number;
+  runCommentAfterModerate(event: CommentAfterModerateEvent): Promise<void>;
+  /**
+   * Run page:metadata hooks. Each handler returns contributions that are
+   * merged by the metadata collector. Errors are logged but don't propagate.
+   */
+  runPageMetadata(event: PageMetadataEvent): Promise<Array<{
+    pluginId: string;
+    contributions: PageMetadataContribution[];
   }>>;
   /**
-   * Register an orphaned table as a collection
-   *
-   * Creates a _dineway_collections entry for an existing ec_* table.
+   * Run page:fragments hooks. Only trusted plugins should be registered
+   * for this hook. Errors are logged but don't propagate.
    */
-  registerOrphanedTable(slug: string, options?: {
-    label?: string;
-    labelSingular?: string;
-    description?: string;
-  }): Promise<Collection>;
+  runPageFragments(event: PageFragmentEvent): Promise<Array<{
+    pluginId: string;
+    contributions: PageFragmentContribution[];
+  }>>;
   /**
-   * Convert slug to human-readable label
+   * Check if any hooks are registered for a given name
    */
-  private slugToLabel;
-}
-//#endregion
-//#region src/schema/query.d.ts
-/**
- * Get collection metadata by slug.
- *
- * @example
- * ```ts
- * import { getCollectionInfo } from "dineway";
- *
- * const info = await getCollectionInfo("posts");
- * if (info?.commentsEnabled) {
- *   // render comment UI
- * }
- * ```
- */
-declare function getCollectionInfo(slug: string): Promise<Collection | null>;
-//#endregion
-//#region src/sections/types.d.ts
-/**
- * Section source types
- */
-type SectionSource = "theme" | "user" | "import";
-/**
- * Section as returned to templates/admin
- */
-interface Section {
-  id: string;
-  slug: string;
-  title: string;
-  description?: string;
-  keywords: string[];
-  content: PortableTextBlock$1[];
-  previewUrl?: string;
-  source: SectionSource;
-  themeId?: string;
-  createdAt: string;
-  updatedAt: string;
-}
-/**
- * Input for creating a section
- */
-interface CreateSectionInput {
-  slug: string;
-  title: string;
-  description?: string;
-  keywords?: string[];
-  content: PortableTextBlock$1[];
-  previewMediaId?: string;
-  source?: SectionSource;
-  themeId?: string;
-}
-/**
- * Input for updating a section
- */
-interface UpdateSectionInput {
-  slug?: string;
-  title?: string;
-  description?: string;
-  keywords?: string[];
-  content?: PortableTextBlock$1[];
-  previewMediaId?: string | null;
+  hasHooks(name: HookNameV2): boolean;
+  /**
+   * Get hook count for debugging
+   */
+  getHookCount(name: HookNameV2): number;
+  /**
+   * Get all registered hook names
+   */
+  getRegisteredHooks(): HookNameV2[];
+  /**
+   * Returns hook names where at least one handler declared exclusive: true
+   */
+  getRegisteredExclusiveHooks(): string[];
+  /**
+   * Check if a hook is exclusive
+   */
+  isExclusiveHook(name: string): boolean;
+  /**
+   * Set the selected provider for an exclusive hook.
+   * Called by PluginManager after resolution.
+   */
+  setExclusiveSelection(hookName: string, pluginId: string): void;
+  /**
+   * Clear the selected provider for an exclusive hook.
+   */
+  clearExclusiveSelection(hookName: string): void;
+  /**
+   * Get the selected provider for an exclusive hook (if any).
+   */
+  getExclusiveSelection(hookName: string): string | undefined;
+  /**
+   * Get all plugins that registered a handler for a given exclusive hook.
+   */
+  getExclusiveHookProviders(hookName: string): Array<{
+    pluginId: string;
+  }>;
+  /**
+   * Get all plugins that registered a non-exclusive handler for a given hook,
+   * preserving priority order. This partitions with getExclusiveHookProviders().
+   */
+  getHookProviders(hookName: string): Array<{
+    pluginId: string;
+  }>;
+  /**
+   * Invoke an exclusive hook — dispatch only to the selected provider.
+   * Returns null if no provider is selected or if the selected hook
+   * is not found in the pipeline.
+   *
+   * This is a generic dispatch used by the email pipeline and other
+   * exclusive hook consumers. The handler type is unknown — callers
+   * must know the expected signature.
+   *
+   * Errors are isolated: a failing handler returns an error result
+   * instead of propagating the exception to the caller.
+   */
+  invokeExclusiveHook(hookName: string, event: unknown): Promise<{
+    result: unknown;
+    pluginId: string;
+    error?: Error;
+    duration: number;
+  } | null>;
 }
 /**
- * Options for querying sections
+ * Create a hook pipeline from plugins
  */
-interface GetSectionsOptions {
-  /** Filter by source */
-  source?: SectionSource;
-  /** Search title, description, keywords */
-  search?: string;
-  /** Limit results */
-  limit?: number;
-  /** Cursor for pagination */
-  cursor?: string;
-}
+declare function createHookPipeline(plugins: ResolvedPlugin[], factoryOptions?: PluginContextFactoryOptions): HookPipeline;
 //#endregion
-//#region src/sections/index.d.ts
-/**
- * Get a section by slug
- *
- * @example
- * ```ts
- * import { getSection } from "dineway";
- *
- * const section = await getSection("hero-centered");
- * if (section) {
- *   console.log(section.content); // Portable Text array
- * }
- * ```
- */
-declare function getSection(slug: string): Promise<Section | null>;
-/**
- * Get all sections with optional filtering
- *
- * @example
- * ```ts
- * import { getSections } from "dineway";
- *
- * // Get all theme-provided sections
- * const themeSections = await getSections({ source: "theme" });
- *
- * // Search sections
- * const results = await getSections({ search: "pricing" });
- * ```
- */
-declare function getSections(options?: GetSectionsOptions): Promise<FindManyResult<Section>>;
+//#region src/plugins/mcp.d.ts
+interface RegisteredPluginMcpTool {
+  pluginId: string;
+  pluginVersion: string;
+  tool: PluginMcpTool;
+  authorizeTarget?: PluginMcpTargetAuthorizer$1;
+}
+interface RegisteredPluginMcpResource {
+  pluginId: string;
+  pluginVersion: string;
+  resource: PluginMcpResource;
+  authorizeTarget?: PluginMcpTargetAuthorizer$1;
+}
+interface PluginMcpRegistry {
+  tools: RegisteredPluginMcpTool[];
+  resources: RegisteredPluginMcpResource[];
+}
+interface PluginMcpTargetAuthorizationRequest {
+  restaurantPermission: string;
+  target: PluginTargetScope;
+  context: PluginMcpExecutionContext;
+}
+type PluginMcpTargetAuthorizer = (request: PluginMcpTargetAuthorizationRequest) => Promise<void>;
+interface PluginMcpReviewMetadata {
+  hitlRequestId?: string;
+  quickActionHash?: string;
+}
+interface PluginMcpCommandExecutionRequest {
+  target?: PluginTargetScope;
+  review: PluginMcpReviewMetadata;
+}
+type PluginMcpCommandExecutor = (command: RegisteredPluginMcpTool & {
+  tool: PluginMcpCommandTool;
+}, input: Record<string, unknown>, context: PluginMcpExecutionContext, request: PluginMcpCommandExecutionRequest) => Promise<Record<string, unknown>>;
 //#endregion
 //#region src/plugins/sandbox/types.d.ts
 /**
@@ -1497,6 +1576,8 @@ interface SerializedRequest {
   headers: Record<string, string>;
   /** Normalized request metadata extracted before RPC serialization */
   meta: RequestMeta;
+  /** Safe authenticated actor metadata; null for unauthenticated public routes. */
+  actor?: PluginActor | null;
 }
 /**
  * Sandbox runner interface.
@@ -1543,1316 +1624,1654 @@ interface SandboxRunner {
  */
 type SandboxRunnerFactory = (options: SandboxOptions) => SandboxRunner;
 //#endregion
-//#region src/content/converters/types.d.ts
-/**
- * Portable Text Types
- *
- * Defines the structure of Portable Text blocks used in Dineway.
- */
+//#region src/plugins/routes.d.ts
 /**
- * Base span (inline text)
+ * Result from a route invocation
  */
-interface PortableTextSpan {
-  _type: "span";
-  _key: string;
-  text: string;
-  marks?: string[];
+interface RouteResult<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: {
+    code: string;
+    message: string;
+    details?: unknown;
+  };
+  status: number;
 }
 /**
- * Mark definition (bold, italic, link, etc.)
+ * Route invocation options
  */
-interface PortableTextMarkDef {
-  _type: string;
-  _key: string;
-  [key: string]: unknown;
+interface InvokeRouteOptions {
+  /** The original request */
+  request: Request;
+  /** Request body (already parsed) */
+  body?: unknown;
+  /** Exact request bytes for routes that declare body: "raw". */
+  rawBody?: Uint8Array;
+  /** Normalized authenticated actor supplied by the core route boundary. */
+  actor?: PluginActor | null;
 }
 /**
- * Link mark definition
+ * Error class for plugin routes
+ * Allows plugins to return structured errors with specific HTTP status codes
  */
-interface PortableTextLinkMark extends PortableTextMarkDef {
-  _type: "link";
-  href: string;
-  blank?: boolean;
+declare class PluginRouteError extends Error {
+  code: string;
+  status: number;
+  details?: unknown | undefined;
+  constructor(code: string, message: string, status?: number, details?: unknown | undefined);
+  /**
+   * Create a bad request error (400)
+   */
+  static badRequest(message: string, details?: unknown): PluginRouteError;
+  /**
+   * Create an unauthorized error (401)
+   */
+  static unauthorized(message?: string): PluginRouteError;
+  /**
+   * Create a forbidden error (403)
+   */
+  static forbidden(message?: string): PluginRouteError;
+  /**
+   * Create a not found error (404)
+   */
+  static notFound(message?: string): PluginRouteError;
+  /**
+   * Create a conflict error (409)
+   */
+  static conflict(message: string, details?: unknown): PluginRouteError;
+  /**
+   * Create an internal error (500)
+   */
+  static internal(message?: string): PluginRouteError;
 }
-/**
- * Text block (paragraph, heading, etc.)
- */
-interface PortableTextTextBlock {
-  _type: "block";
-  _key: string;
-  style?: "normal" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "blockquote";
-  listItem?: "bullet" | "number";
-  level?: number;
-  children: PortableTextSpan[];
-  markDefs?: PortableTextMarkDef[];
+//#endregion
+//#region src/plugins/sandbox/runtime-options.d.ts
+interface SandboxRunnerRuntimeOptions extends SandboxOptions {
+  mediaStorage?: Storage;
+  cronReschedule?: () => void;
 }
+//#endregion
+//#region src/dineway-runtime.d.ts
 /**
- * Image block
+ * Sandboxed plugin entry from virtual module
  */
-interface PortableTextImageBlock {
-  _type: "image";
-  _key: string;
-  asset: {
-    _ref: string;
-    url?: string; /** Provider ID for external media (e.g., "image-cdn") */
-    provider?: string;
-  };
-  alt?: string;
-  caption?: string;
-  /** Original image width */
-  width?: number;
-  /** Original image height */
-  height?: number;
-  /** Display width for this instance (overrides original) */
-  displayWidth?: number;
-  /** Display height for this instance (overrides original) */
-  displayHeight?: number;
-}
-/**
- * Code block
- */
-interface PortableTextCodeBlock {
-  _type: "code";
-  _key: string;
+interface SandboxedPluginEntry {
+  id: string;
+  version: string;
+  options: Record<string, unknown>;
   code: string;
-  language?: string;
-  filename?: string;
+  /** Capabilities the plugin requests */
+  capabilities: PluginCapability[];
+  /** Allowed hosts for network:request */
+  allowedHosts: string[];
+  /** Declared storage collections */
+  storage: PluginStorageConfig;
+  /** Admin pages */
+  adminPages?: Array<{
+    path: string;
+    label?: string;
+    icon?: string;
+  }>;
+  /** Dashboard widgets */
+  adminWidgets?: Array<{
+    id: string;
+    title?: string;
+    size?: string;
+  }>;
+  /** Portable Text block types contributed to the editor through declarative Block Kit. */
+  portableTextBlocks?: PortableTextBlockConfig[];
+  /** Field widget types contributed for schema-field editing UIs. */
+  fieldWidgets?: FieldWidgetConfig[];
+  /** Admin entry module */
+  adminEntry?: string;
+  /**
+   * Exclusive hooks this plugin should be auto-selected for.
+   * Weaker than an existing admin DB selection — config order wins when no selection exists.
+   */
+  preferred?: string[];
 }
-/**
- * HTML block (raw HTML content)
- */
-interface PortableTextHtmlBlock {
-  _type: "htmlBlock";
-  _key: string;
-  html: string;
+//#endregion
+//#region src/api/handlers/manifest.d.ts
+interface CollectionDefinition {
+  schema: {
+    _def?: {
+      shape?: () => Record<string, unknown>;
+    };
+    shape?: Record<string, unknown>;
+  };
+  admin: {
+    label: string;
+    labelSingular?: string;
+    supports?: string[];
+  };
 }
+type CollectionMap = Record<string, CollectionDefinition>;
 /**
- * Unknown/custom block (preserved for plugin compatibility)
+ * Generate admin manifest from collections
  */
-interface PortableTextUnknownBlock {
-  _type: string;
-  _key: string;
-  [key: string]: unknown;
+declare function generateManifest(collections: CollectionMap, plugins?: Record<string, {
+  adminPages?: Array<{
+    path: string;
+    component: string;
+  }>;
+  widgets?: string[];
+}>): Promise<ManifestResponse>;
+//#endregion
+//#region src/api/handlers/revision.d.ts
+interface RevisionListResponse {
+  items: Revision[];
+  total: number;
+}
+interface RevisionResponse {
+  item: Revision;
 }
 /**
- * Any Portable Text block
- */
-type PortableTextBlock = PortableTextTextBlock | PortableTextImageBlock | PortableTextCodeBlock | PortableTextHtmlBlock | PortableTextUnknownBlock;
-/**
- * ProseMirror JSON types (simplified for TipTap)
+ * List revisions for a content entry
  */
-interface ProseMirrorMark {
-  type: string;
-  attrs?: Record<string, unknown>;
-}
-interface ProseMirrorNode {
-  type: string;
-  attrs?: Record<string, unknown>;
-  content?: ProseMirrorNode[];
-  marks?: ProseMirrorMark[];
-  text?: string;
-}
-interface ProseMirrorDocument {
-  type: "doc";
-  content: ProseMirrorNode[];
-}
-//#endregion
-//#region src/content/converters/prosemirror-to-portable-text.d.ts
+declare function handleRevisionList(db: Kysely<Database>, collection: string, entryId: string, params?: {
+  limit?: number;
+}): Promise<ApiResult<RevisionListResponse>>;
 /**
- * Convert ProseMirror document to Portable Text
+ * Get a specific revision
  */
-declare function prosemirrorToPortableText(doc: ProseMirrorDocument): PortableTextBlock[];
-//#endregion
-//#region src/content/converters/portable-text-to-prosemirror.d.ts
+declare function handleRevisionGet(db: Kysely<Database>, revisionId: string): Promise<ApiResult<RevisionResponse>>;
 /**
- * Convert Portable Text to ProseMirror document
+ * Restore a revision (updates content to this revision's data and creates new revision)
  */
-declare function portableTextToProsemirror(blocks: PortableTextBlock[]): ProseMirrorDocument;
+declare function handleRevisionRestore(db: Kysely<Database>, revisionId: string, callerUserId: string): Promise<ApiResult<ContentResponse>>;
 //#endregion
-//#region src/utils/hash.d.ts
+//#region src/api/handlers/media.d.ts
+interface MediaListResponse {
+  items: MediaItem[];
+  nextCursor?: string;
+}
+interface MediaResponse {
+  item: MediaItem;
+}
 /**
- * SHA-256 hash of a string, truncated to 16 hex chars (64 bits).
- * For cache invalidation / ETags — not for security.
+ * List media items
  */
-declare function hashString(content: string): Promise<string>;
+declare function handleMediaList(db: Kysely<Database>, params: {
+  cursor?: string;
+  limit?: number;
+  mimeType?: string | readonly string[];
+  q?: string;
+}): Promise<ApiResult<MediaListResponse>>;
 /**
- * Compute content hash using Web Crypto API
- *
- * Uses SHA-1 which is the fastest option in SubtleCrypto.
- * SHA-1 is cryptographically weak but fine for content deduplication
- * where we only need to detect identical files, not resist attacks.
- *
- * Returns hex string prefixed with "sha1:" for future-proofing
+ * Get single media item
  */
-declare function computeContentHash(content: Uint8Array | ArrayBuffer): Promise<string>;
-//#endregion
-//#region src/utils/url.d.ts
+declare function handleMediaGet(db: Kysely<Database>, id: string): Promise<ApiResult<MediaResponse>>;
 /**
- * URL scheme validation utilities
- *
- * Prevents XSS via dangerous URL schemes (javascript:, data:, vbscript:, etc.)
- * by allowlisting known-safe schemes before rendering into href attributes.
+ * Create media item (after file upload)
  */
+declare function handleMediaCreate(db: Kysely<Database>, input: {
+  filename: string;
+  mimeType: string;
+  size?: number;
+  width?: number;
+  height?: number;
+  alt?: string;
+  storageKey: string;
+  contentHash?: string;
+  blurhash?: string;
+  dominantColor?: string;
+  authorId?: string;
+}): Promise<ApiResult<MediaResponse>>;
 /**
- * Returns the URL unchanged if it uses a safe scheme, otherwise returns "#".
- *
- * Use this at the render layer as the primary defense against XSS via
- * dangerous URL schemes like `javascript:`, `data:`, or `vbscript:`.
- *
- * @example
- * ```ts
- * sanitizeHref("https://example.com")        // "https://example.com"
- * sanitizeHref("/about")                      // "/about"
- * sanitizeHref("#section")                    // "#section"
- * sanitizeHref("mailto:a@b.com")              // "mailto:a@b.com"
- * sanitizeHref("javascript:alert(1)")         // "#"
- * sanitizeHref("data:text/html,<script>")     // "#"
- * sanitizeHref("")                            // "#"
- * ```
+ * Update media metadata
  */
-declare function sanitizeHref(url: string | undefined | null): string;
+declare function handleMediaUpdate(db: Kysely<Database>, id: string, input: {
+  alt?: string;
+  caption?: string;
+  width?: number;
+  height?: number;
+}): Promise<ApiResult<MediaResponse>>;
 /**
- * Returns true if the URL uses a safe scheme for rendering in href attributes.
+ * Delete media item
  */
-declare function isSafeHref(url: string): boolean;
+declare function handleMediaDelete(db: Kysely<Database>, id: string): Promise<ApiResult<{
+  deleted: true;
+}>>;
 //#endregion
-//#region src/visual-editing/editable.d.ts
+//#region src/schema/registry.d.ts
 /**
- * Visual editing annotation system
- *
- * Creates Proxy objects that emit data-dineway-ref attributes when spread onto elements.
+ * Error thrown when a schema operation fails
  */
-interface CMSAnnotation {
-  collection: string;
-  id: string;
-  field?: string;
-  /** Entry status — only present on entry-level annotations (not field-level) */
-  status?: string;
-  /** Whether the entry has unpublished draft changes */
-  hasDraft?: boolean;
-}
-/** The shape returned when spreading an edit annotation onto an element */
-interface FieldAnnotation {
-  "data-dineway-ref": string;
-}
-interface EditableOptions {
-  /** Entry status: "draft", "published", "scheduled" */
-  status?: string;
-  /** true when draftRevisionId exists and differs from liveRevisionId */
-  hasDraft?: boolean;
+declare class SchemaError extends Error {
+  code: string;
+  details?: Record<string, unknown> | undefined;
+  constructor(message: string, code: string, details?: Record<string, unknown> | undefined);
 }
 /**
- * Create an editable proxy for an entry.
- *
- * Usage:
- * - `{...entry.edit}` - entry-level annotation (includes status/hasDraft)
- * - `{...entry.edit.title}` - field-level annotation
- * - `{...entry.edit['nested.field']}` - nested field (bracket notation)
- */
-declare function createEditable(collection: string, id: string, options?: EditableOptions): EditProxy;
-/**
- * Create a noop proxy for production mode.
- * Spreading this produces no attributes.
- */
-declare function createNoop(): EditProxy;
-/**
- * Visual editing proxy type.
- *
- * Spread directly onto elements for entry-level annotations: `{...entry.edit}`
- * Access a field for field-level annotations: `{...entry.edit.title}`
+ * Schema Registry
  *
- * In production, spreading produces no attributes (noop).
+ * Manages collection and field definitions stored in the database.
+ * Handles runtime DDL operations (CREATE TABLE, ALTER TABLE).
  */
-type EditProxy = {
-  readonly [field: string]: Partial<FieldAnnotation>;
-};
-//#endregion
-//#region src/query.d.ts
-/**
- * Collection type registry for type-safe queries.
- *
- * This interface is extended by the generated dineway-env.d.ts file
- * to provide type inference for collection names and their data shapes.
- *
- * @example
- * ```ts
- * // In dineway-env.d.ts (generated):
- * declare module "dineway" {
- *   interface DinewayCollections {
- *     posts: { title: string; content: PortableTextBlock[]; };
- *     pages: { title: string; body: PortableTextBlock[]; };
- *   }
- * }
- *
- * // Then in your code:
- * const { entries } = await getDinewayCollection("posts");
- * // entries[0].data.title is typed as string
- * ```
- */
-interface DinewayCollections {}
-/**
- * Helper type to infer the data type for a collection.
- * Returns the registered type if known, otherwise falls back to Record<string, unknown>.
- */
-type InferCollectionData<T extends string> = T extends keyof DinewayCollections ? DinewayCollections[T] : Record<string, unknown>;
-/**
- * Sort direction
- */
-type SortDirection = "asc" | "desc";
-/**
- * Order by specification - field name to direction
- * @example { created_at: "desc" } - Sort by created_at descending
- * @example { title: "asc" } - Sort by title ascending
- * @example { published_at: "desc", title: "asc" } - Multi-field sort
- */
-type OrderBySpec = Record<string, SortDirection>;
-interface CollectionFilter {
-  status?: "draft" | "published" | "archived";
-  limit?: number;
+declare class SchemaRegistry {
+  private db;
+  constructor(db: Kysely<Database>);
   /**
-   * Opaque cursor for keyset pagination.
-   * Pass the `nextCursor` value from a previous result to fetch the next page.
-   * @example
-   * ```ts
-   * const cursor = Astro.url.searchParams.get("cursor") ?? undefined;
-   * const { entries, nextCursor } = await getDinewayCollection("posts", {
-   *   limit: 10,
-   *   cursor,
-   * });
-   * ```
+   * List all collections
    */
-  cursor?: string;
+  listCollections(): Promise<Collection[]>;
   /**
-   * Filter by field values, taxonomy terms, byline credits, or ranges.
+   * List all collections with their fields using bounded query shapes.
+   */
+  listCollectionsWithFields(): Promise<CollectionWithFields[]>;
+  /**
+   * Get a collection by slug
+   */
+  getCollection(slug: string): Promise<Collection | null>;
+  /**
+   * Get a collection with all its fields
+   */
+  getCollectionWithFields(slug: string): Promise<CollectionWithFields | null>;
+  /**
+   * Create a new collection
+   */
+  createCollection(input: CreateCollectionInput): Promise<Collection>;
+  /**
+   * Update a collection
+   */
+  updateCollection(slug: string, input: UpdateCollectionInput): Promise<Collection>;
+  private validateUrlPattern;
+  private checkLabelUniqueness;
+  private checkUrlPatternUniqueness;
+  /**
+   * Delete a collection
+   */
+  deleteCollection(slug: string, options?: {
+    force?: boolean;
+  }): Promise<void>;
+  /**
+   * List fields for a collection
+   */
+  listFields(collectionId: string): Promise<Field[]>;
+  /**
+   * Get a field by slug within a collection
+   */
+  getField(collectionSlug: string, fieldSlug: string): Promise<Field | null>;
+  /**
+   * Create a new field
+   */
+  createField(collectionSlug: string, input: CreateFieldInput): Promise<Field>;
+  /**
+   * Ensure the content table for an existing collection exists.
    *
-   * Taxonomy names are detected automatically and filtered by term.
-   * The reserved `byline` key filters by byline credit in any position,
-   * not just the primary credit. It accepts one or more byline translation
-   * groups, or concrete byline row IDs.
-   * Other keys are treated as content table column filters.
+   * This repairs interrupted schema creation where the metadata row exists but
+   * the physical `ec_*` table was not created.
+   */
+  ensureCollectionContentTable(collectionSlug: string): Promise<boolean>;
+  /**
+   * Ensure the physical column for an existing field exists on its content table.
    *
-   * @example { category: 'news' } - Filter by taxonomy term
-   * @example { category: ['news', 'featured'] } - Filter by multiple terms (OR)
-   * @example { byline: '01HXYZ...' } - Entries credited to a byline (any position)
-   * @example { byline: ['01HXYZ...', '01HABC...'] } - Credited to any of these bylines (OR)
-   * @example { series: 'main' } - Exact match on a content field
-   * @example { published_at: { gte: '2024-01-01', lt: '2025-01-01' } } - Date range
+   * This repairs interrupted field creation where `_dineway_fields` was written
+   * but `ALTER TABLE ec_* ADD COLUMN` did not complete.
    */
-  where?: Record<string, WhereValue>;
+  ensureFieldColumn(collectionSlug: string, fieldSlug: string): Promise<boolean>;
   /**
-   * Case-insensitive substring search across selected content fields.
+   * Update a field
+   */
+  updateField(collectionSlug: string, fieldSlug: string, input: UpdateFieldInput): Promise<Field>;
+  /**
+   * Synchronize an existing FTS index with the collection's current state.
    *
-   * `searchColumns` must contain concrete field slugs or system column names.
-   * When `q` is present without `searchColumns`, no search condition is applied.
+   * Schema writes must not first-time enable FTS. Initial enablement stays in
+   * explicit seed/import/admin flows where FTS failures can be handled deliberately.
    */
-  q?: string;
-  searchColumns?: string[];
+  private syncSearchState;
   /**
-   * Order results by field(s)
-   * @default { created_at: "desc" }
-   * @example { created_at: "desc" } - Sort by created_at descending (default)
-   * @example { title: "asc" } - Sort by title ascending
-   * @example { published_at: "desc", title: "asc" } - Multi-field sort
+   * Delete a field
    */
-  orderBy?: OrderBySpec;
+  deleteField(collectionSlug: string, fieldSlug: string): Promise<void>;
   /**
-   * Filter by locale. When set, only returns entries in this locale.
-   * Only relevant when i18n is configured.
-   * @example "en" — English entries only
-   * @example "fr" — French entries only
+   * Reorder fields
    */
-  locale?: string;
-}
-interface ContentEntry<T = Record<string, unknown>> {
-  id: string;
-  data: T;
-  /** Visual editing annotations. Spread onto elements: {...entry.edit.title} */
-  edit: EditProxy;
-}
-/** Cache hint returned by the content loader for route caching */
-interface CacheHint {
-  tags?: string[];
-  lastModified?: Date;
-}
-/**
- * Result from getDinewayCollection
- */
-interface CollectionResult<T> {
-  /** The entries (empty array if error or none found) */
-  entries: ContentEntry<T>[];
-  /** Error if the query failed */
-  error?: Error;
-  /** Cache hint for route caching (pass to Astro.cache.set()) */
-  cacheHint: CacheHint;
+  reorderFields(collectionSlug: string, fieldSlugs: string[]): Promise<void>;
   /**
-   * Opaque cursor for the next page.
-   * Undefined when there are no more results.
-   * Pass this as `cursor` in the next query to get the next page.
+   * Create a content table for a collection
    */
-  nextCursor?: string;
+  private createContentTable;
   /**
-   * Total number of entries matching the current filter, excluding cursor and limit.
+   * Drop a content table
    */
-  total?: number;
+  private dropContentTable;
+  /**
+   * Add a column to a content table
+   */
+  private addColumn;
+  /**
+   * Drop a column from a content table
+   */
+  private dropColumn;
+  /**
+   * Check if a collection has any content
+   */
+  private collectionHasContent;
+  /**
+   * Get table name for a collection
+   */
+  private getTableName;
+  /**
+   * Get column name for a field
+   */
+  private getColumnName;
+  /**
+   * Validate a slug
+   */
+  private validateSlug;
+  /**
+   * Format a default value for SQL.
+   *
+   * SQLite `ALTER TABLE ADD COLUMN ... DEFAULT` requires a literal constant
+   * expression — parameterized values cannot be used here. We manually escape
+   * single quotes and coerce types to ensure the output is safe.
+   *
+   * INTEGER/REAL values are coerced through `Number()` which can only produce
+   * digits, `.`, `-`, `e`, `Infinity`, or `NaN` — all safe in SQL.
+   * TEXT/JSON values have single quotes escaped via SQL standard doubling (`''`).
+   */
+  private formatDefaultValue;
+  /**
+   * Get empty default for a field type
+   */
+  private getEmptyDefault;
+  /**
+   * Map a collection row to a Collection object
+   */
+  private mapCollectionRow;
+  /**
+   * Map a field row to a Field object
+   */
+  private mapFieldRow;
+  /**
+   * Discover orphaned content tables
+   *
+   * Finds ec_* tables that exist in the database but don't have a
+   * corresponding entry in _dineway_collections.
+   */
+  discoverOrphanedTables(): Promise<Array<{
+    slug: string;
+    tableName: string;
+    rowCount: number;
+  }>>;
+  /**
+   * Register an orphaned table as a collection
+   *
+   * Creates a _dineway_collections entry for an existing ec_* table.
+   */
+  registerOrphanedTable(slug: string, options?: {
+    label?: string;
+    labelSingular?: string;
+    description?: string;
+  }): Promise<Collection>;
+  /**
+   * Convert slug to human-readable label
+   */
+  private slugToLabel;
 }
+//#endregion
+//#region src/schema/query.d.ts
 /**
- * Result from getDinewayEntry
+ * Get collection metadata by slug.
+ *
+ * @example
+ * ```ts
+ * import { getCollectionInfo } from "dineway";
+ *
+ * const info = await getCollectionInfo("posts");
+ * if (info?.commentsEnabled) {
+ *   // render comment UI
+ * }
+ * ```
  */
-interface EntryResult<T> {
-  /** The entry, or null if not found */
-  entry: ContentEntry<T> | null;
-  /** Error if the query failed (not set for "not found", only for actual errors) */
-  error?: Error;
-  /** Whether we're in preview mode (valid token was provided) */
-  isPreview: boolean;
-  /** Set when a fallback locale was used instead of the requested locale */
-  fallbackLocale?: string;
-  /** Cache hint for route caching (pass to Astro.cache.set()) */
-  cacheHint: CacheHint;
-}
-/** Edit metadata attached to PT arrays in edit mode */
-interface EditFieldMeta {
-  collection: string;
-  id: string;
-  field: string;
-}
+declare function getCollectionInfo(slug: string): Promise<Collection | null>;
+//#endregion
+//#region src/sections/types.d.ts
 /**
- * Read edit metadata from a value (returns undefined if not tagged).
- * Uses Object.getOwnPropertyDescriptor to access Symbol-keyed property
- * without an unsafe type assertion.
+ * Section source types
  */
-declare function getEditMeta(value: unknown): EditFieldMeta | undefined;
+type SectionSource = "theme" | "user" | "import";
 /**
- * Get all entries of a content type
- *
- * Returns { entries, error } for graceful error handling.
- *
- * When dineway-env.d.ts is generated, the collection name will be
- * type-checked and the return type will be inferred automatically.
- *
- * @example
- * ```ts
- * import { getDinewayCollection } from "dineway";
- *
- * const { entries: posts, error } = await getDinewayCollection("posts");
- * if (error) {
- *   console.error("Failed to load posts:", error);
- *   return;
- * }
- * // posts[0].data.title is typed (if dineway-env.d.ts exists)
- *
- * // With filters
- * const { entries: drafts } = await getDinewayCollection("posts", { status: "draft" });
- * ```
+ * Section as returned to templates/admin
  */
-declare function getDinewayCollection<T extends string, D = InferCollectionData<T>>(type: T, filter?: CollectionFilter): Promise<CollectionResult<D>>;
+interface Section {
+  id: string;
+  slug: string;
+  title: string;
+  description?: string;
+  keywords: string[];
+  content: PortableTextBlock$1[];
+  previewUrl?: string;
+  source: SectionSource;
+  themeId?: string;
+  createdAt: string;
+  updatedAt: string;
+}
 /**
- * Get a single entry by type and ID/slug
- *
- * Returns { entry, error, isPreview } for graceful error handling.
- * - entry is null if not found (not an error)
- * - error is set only for actual errors (db issues, etc.)
- *
- * Preview mode is detected automatically from request context (ALS).
- * When the URL has a valid `_preview` token, the middleware sets preview
- * context and this function serves draft revision data if available.
- *
- * @example
- * ```ts
- * import { getDinewayEntry } from "dineway";
- *
- * // Simple usage — preview just works via middleware
- * const { entry: post, isPreview, error } = await getDinewayEntry("posts", "my-slug");
- * if (!post) return Astro.redirect("/404");
- * ```
+ * Input for creating a section
  */
-declare function getDinewayEntry<T extends string, D = InferCollectionData<T>>(type: T, id: string, options?: {
-  locale?: string;
-}): Promise<EntryResult<D>>;
+interface CreateSectionInput {
+  slug: string;
+  title: string;
+  description?: string;
+  keywords?: string[];
+  content: PortableTextBlock$1[];
+  previewMediaId?: string;
+  source?: SectionSource;
+  themeId?: string;
+}
 /**
- * Translation summary for a single locale variant
+ * Input for updating a section
  */
-interface TranslationSummary {
-  /** Content item ID */
-  id: string;
-  /** Locale code (e.g. "en", "fr") */
-  locale: string;
-  /** URL slug */
-  slug: string | null;
-  /** Current status */
-  status: string;
+interface UpdateSectionInput {
+  slug?: string;
+  title?: string;
+  description?: string;
+  keywords?: string[];
+  content?: PortableTextBlock$1[];
+  previewMediaId?: string | null;
 }
 /**
- * Result from getTranslations
+ * Options for querying sections
  */
-interface TranslationsResult {
-  /** The translation group ID (shared across locales) */
-  translationGroup: string;
-  /** All locale variants in this group */
-  translations: TranslationSummary[];
-  /** Error if the query failed */
-  error?: Error;
+interface GetSectionsOptions {
+  /** Filter by source */
+  source?: SectionSource;
+  /** Search title, description, keywords */
+  search?: string;
+  /** Limit results */
+  limit?: number;
+  /** Cursor for pagination */
+  cursor?: string;
 }
+//#endregion
+//#region src/sections/index.d.ts
 /**
- * Get all translations of a content item.
- *
- * Given a content entry, returns all locale variants that share the same
- * translation group. This is useful for building language switcher UI.
+ * Get a section by slug
  *
  * @example
  * ```ts
- * import { getDinewayEntry, getTranslations } from "dineway";
+ * import { getSection } from "dineway";
  *
- * const { entry: post } = await getDinewayEntry("posts", "hello-world", { locale: "en" });
- * const { translations } = await getTranslations("posts", post.data.id);
- * // translations = [{ id: "...", locale: "en", slug: "hello-world", status: "published" }, ...]
+ * const section = await getSection("hero-centered");
+ * if (section) {
+ *   console.log(section.content); // Portable Text array
+ * }
  * ```
  */
-declare function getTranslations(type: string, id: string): Promise<TranslationsResult>;
-/**
- * Result from resolveDinewayPath
- */
-interface ResolvePathResult<T = Record<string, unknown>> {
-  /** The matched entry */
-  entry: ContentEntry<T>;
-  /** The collection slug that matched */
-  collection: string;
-  /** Extracted parameters from the URL pattern (e.g. { slug: "my-post" }) */
-  params: Record<string, string>;
-}
+declare function getSection(slug: string): Promise<Section | null>;
 /**
- * Resolve a URL path to a content entry by matching against collection URL patterns.
- *
- * Loads all collections with a `urlPattern` set, converts each pattern to a regex,
- * and tests the given path. On match, extracts the slug and fetches the entry.
+ * Get all sections with optional filtering
  *
  * @example
  * ```ts
- * import { resolveDinewayPath } from "dineway";
+ * import { getSections } from "dineway";
  *
- * // Given pages with urlPattern "/{slug}" and posts with "/blog/{slug}":
- * const result = await resolveDinewayPath("/blog/hello-world");
- * if (result) {
- *   console.log(result.collection); // "posts"
- *   console.log(result.params.slug); // "hello-world"
- *   console.log(result.entry.data); // post data
- * }
+ * // Get all theme-provided sections
+ * const themeSections = await getSections({ source: "theme" });
+ *
+ * // Search sections
+ * const results = await getSections({ search: "pricing" });
  * ```
  */
-declare function resolveDinewayPath<T = Record<string, unknown>>(path: string): Promise<ResolvePathResult<T> | null>;
+declare function getSections(options?: GetSectionsOptions): Promise<FindManyResult<Section>>;
 //#endregion
-//#region src/after.d.ts
+//#region src/content/converters/types.d.ts
 /**
- * Defer work past the current synchronous path.
+ * Portable Text Types
  *
- * Use this for best-effort bookkeeping that should not block runtime
- * initialization or response handling. Node keeps the process alive for
- * pending work; callers that need stronger durability should await their own
- * operation instead of using this helper.
+ * Defines the structure of Portable Text blocks used in Dineway.
  */
-type AfterCallback = () => void | Promise<void>;
-declare function after(fn: AfterCallback): void;
-//#endregion
-//#region src/i18n/config.d.ts
 /**
- * Dineway i18n Configuration
- *
- * Reads locale configuration from the virtual module (sourced from Astro config).
- * Initialized during runtime startup, then available via getI18nConfig().
+ * Base span (inline text)
  */
-interface I18nConfig {
-  defaultLocale: string;
-  locales: string[];
-  fallback?: Record<string, string>;
-  prefixDefaultLocale?: boolean;
+interface PortableTextSpan {
+  _type: "span";
+  _key: string;
+  text: string;
+  marks?: string[];
 }
 /**
- * Get the current i18n config.
- * Returns null if i18n is not configured.
+ * Mark definition (bold, italic, link, etc.)
  */
-declare function getI18nConfig(): I18nConfig | null;
+interface PortableTextMarkDef {
+  _type: string;
+  _key: string;
+  [key: string]: unknown;
+}
 /**
- * Check if i18n is enabled.
- * Returns true when multiple locales are configured.
+ * Link mark definition
  */
-declare function isI18nEnabled(): boolean;
+interface PortableTextLinkMark extends PortableTextMarkDef {
+  _type: "link";
+  href: string;
+  blank?: boolean;
+}
 /**
- * Resolve fallback locale chain for a given locale.
- * Returns array of locales to try, from most preferred to least.
- * Always ends with defaultLocale.
+ * Text block (paragraph, heading, etc.)
  */
-declare function getFallbackChain(locale: string): string[];
-//#endregion
-//#region src/preview/sidecar-client.d.ts
+interface PortableTextTextBlock {
+  _type: "block";
+  _key: string;
+  style?: "normal" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "blockquote";
+  listItem?: "bullet" | "number";
+  level?: number;
+  children: PortableTextSpan[];
+  markDefs?: PortableTextMarkDef[];
+  textAlign?: "left" | "center" | "right" | "justify";
+}
 /**
- * Preview sidecar protocol helpers.
- *
- * These utilities define the signed URL and snapshot-auth contract shared
- * by preview sidecars and the source site serving snapshot exports.
+ * Image block
  */
-interface PreviewSidecarSignature {
-  source: string;
-  exp: number;
-  sig: string;
-}
-interface PreviewSidecarClient {
-  signPreviewUrl(previewBase: string, source: string, secret: string, ttl?: number): Promise<string>;
-  buildSnapshotSignatureHeader(signature: PreviewSidecarSignature): string;
-}
-declare function signPreviewUrl(previewBase: string, source: string, secret: string, ttl?: number): Promise<string>;
-declare function buildPreviewSignatureHeader(signature: PreviewSidecarSignature): string;
-declare function parsePreviewSignatureHeader(header: string): PreviewSidecarSignature | null;
-declare function verifyPreviewSignature(source: string, exp: number, sig: string, secret: string): Promise<boolean>;
-declare const defaultPreviewSidecarClient: PreviewSidecarClient;
-//#endregion
-//#region src/preview/session-database-factory.d.ts
-interface SessionDatabaseInfo {
-  id: string;
-  dbPath: string;
-  createdAt: number;
-  expiresAt: number;
-  lastTouchedAt: number;
-}
-interface SessionDatabaseHandle {
-  created: boolean;
-  session: SessionDatabaseInfo;
-  db: Kysely<Database>;
-  close(): Promise<void>;
-}
-interface SessionCleanupResult {
-  removedSessionIds: string[];
-  removedPaths: string[];
+interface PortableTextImageBlock {
+  _type: "image";
+  _key: string;
+  asset: {
+    _ref: string;
+    url?: string; /** Provider ID for external media (e.g., "image-cdn") */
+    provider?: string;
+  };
+  alt?: string;
+  caption?: string;
+  /** Original image width */
+  width?: number;
+  /** Original image height */
+  height?: number;
+  /** Display width for this instance (overrides original) */
+  displayWidth?: number;
+  /** Display height for this instance (overrides original) */
+  displayHeight?: number;
 }
-interface SessionOpenOptions {
-  id: string;
-  now?: number;
+/**
+ * Code block
+ */
+interface PortableTextCodeBlock {
+  _type: "code";
+  _key: string;
+  code: string;
+  language?: string;
+  filename?: string;
 }
-interface SessionOpenOrCreateOptions extends SessionOpenOptions {
-  ttlMs: number;
+/**
+ * HTML block (raw HTML content)
+ */
+interface PortableTextHtmlBlock {
+  _type: "htmlBlock";
+  _key: string;
+  html: string;
 }
-interface SessionDatabaseFactory {
-  open(input: SessionOpenOptions): Promise<SessionDatabaseHandle | null>;
-  openOrCreate(input: SessionOpenOrCreateOptions): Promise<SessionDatabaseHandle>;
-  destroy(id: string): Promise<boolean>;
-  cleanup(now?: number): Promise<SessionCleanupResult>;
-  close(): Promise<void>;
+/**
+ * Unknown/custom block (preserved for plugin compatibility)
+ */
+interface PortableTextUnknownBlock {
+  _type: string;
+  _key: string;
+  [key: string]: unknown;
 }
-interface FileSessionDatabaseFactoryOptions {
-  rootDir: string;
-  maxDiskBytes?: number;
-  registryFileName?: string;
-  sessionsDirName?: string;
+/**
+ * Any Portable Text block
+ */
+type PortableTextBlock = PortableTextTextBlock | PortableTextImageBlock | PortableTextCodeBlock | PortableTextHtmlBlock | PortableTextUnknownBlock;
+/**
+ * ProseMirror JSON types (simplified for TipTap)
+ */
+interface ProseMirrorMark {
+  type: string;
+  attrs?: Record<string, unknown>;
 }
-declare class SessionDatabaseLimitError extends Error {
-  constructor(message?: string);
+interface ProseMirrorNode {
+  type: string;
+  attrs?: Record<string, unknown>;
+  content?: ProseMirrorNode[];
+  marks?: ProseMirrorMark[];
+  text?: string;
 }
-declare class FileSessionDatabaseFactory implements SessionDatabaseFactory {
-  private readonly options;
-  private readonly registry;
-  private readonly sessionsDir;
-  private readonly maxDiskBytes;
-  constructor(options: FileSessionDatabaseFactoryOptions);
-  open(input: SessionOpenOptions): Promise<SessionDatabaseHandle | null>;
-  openOrCreate(input: SessionOpenOrCreateOptions): Promise<SessionDatabaseHandle>;
-  destroy(id: string): Promise<boolean>;
-  cleanup(now?: number): Promise<SessionCleanupResult>;
-  close(): Promise<void>;
-  private createHandle;
-  private getSessionRow;
-  private toSessionInfo;
-  private deleteSession;
-  private getActiveDiskBytes;
-  private getDbPath;
-  private getManagedPaths;
-  private listSessionRows;
-  private listDbPathRows;
+interface ProseMirrorDocument {
+  type: "doc";
+  content: ProseMirrorNode[];
 }
 //#endregion
-//#region src/preview/middleware.d.ts
-interface FilePreviewMiddlewareConfig {
-  rootDir?: string;
-  secret: string;
-  ttlSeconds?: number;
-  cookieName?: string;
-  snapshotPath?: string;
-  maxSessionDiskBytes?: number;
-  sessionFactory?: SessionDatabaseFactory;
-  fetch?: typeof globalThis.fetch;
-}
-declare function createFilePreviewMiddleware(config: FilePreviewMiddlewareConfig): MiddlewareHandler;
+//#region src/content/converters/prosemirror-to-portable-text.d.ts
+/**
+ * Convert ProseMirror document to Portable Text
+ */
+declare function prosemirrorToPortableText(doc: ProseMirrorDocument): PortableTextBlock[];
 //#endregion
-//#region src/plugins/define-plugin.d.ts
+//#region src/content/converters/portable-text-to-prosemirror.d.ts
 /**
- * Define a Dineway plugin.
+ * Convert Portable Text to ProseMirror document
+ */
+declare function portableTextToProsemirror(blocks: PortableTextBlock[]): ProseMirrorDocument;
+//#endregion
+//#region src/utils/hash.d.ts
+/**
+ * SHA-256 hash of a string, truncated to 16 hex chars (64 bits).
+ * For cache invalidation / ETags — not for security.
+ */
+declare function hashString(content: string): Promise<string>;
+/**
+ * Compute content hash using Web Crypto API
  *
- * **Standard format** -- the canonical format for plugins that work in both
- * trusted and sandboxed modes. No id/version -- those come from the descriptor.
+ * Uses SHA-1 which is the fastest option in SubtleCrypto.
+ * SHA-1 is cryptographically weak but fine for content deduplication
+ * where we only need to detect identical files, not resist attacks.
  *
- * @example
- * ```typescript
- * import { definePlugin } from "dineway";
+ * Returns hex string prefixed with "sha1:" for future-proofing
+ */
+declare function computeContentHash(content: Uint8Array | ArrayBuffer): Promise<string>;
+//#endregion
+//#region src/utils/url.d.ts
+/**
+ * URL scheme validation utilities
  *
- * export default definePlugin({
- *   hooks: {
- *     "content:afterSave": {
- *       handler: async (event, ctx) => {
- *         await ctx.kv.set("lastSave", Date.now());
- *       },
- *     },
- *   },
- *   routes: {
- *     status: {
- *       handler: async (routeCtx, ctx) => ({ ok: true }),
- *     },
- *   },
- * });
- * ```
+ * Prevents XSS via dangerous URL schemes (javascript:, data:, vbscript:, etc.)
+ * by allowlisting known-safe schemes before rendering into href attributes.
+ */
+/**
+ * Returns the URL unchanged if it uses a safe scheme, otherwise returns "#".
  *
- * **Native format** -- for plugins that need React admin, direct DB access,
- * or other capabilities not available in the sandbox.
+ * Use this at the render layer as the primary defense against XSS via
+ * dangerous URL schemes like `javascript:`, `data:`, or `vbscript:`.
  *
  * @example
- * ```typescript
- * import { definePlugin } from "dineway";
- *
- * export default definePlugin({
- *   id: "my-plugin",
- *   version: "1.0.0",
- *   capabilities: ["content:read"],
- *   hooks: {
- *     "content:beforeSave": async (event, ctx) => {
- *       ctx.log.info("Saving content", { collection: event.collection });
- *       return event.content;
- *     }
- *   },
- *   routes: {
- *     "sync": {
- *       handler: async (ctx) => {
- *         return { status: "ok" };
- *       }
- *     }
- *   }
- * });
+ * ```ts
+ * sanitizeHref("https://example.com")        // "https://example.com"
+ * sanitizeHref("/about")                      // "/about"
+ * sanitizeHref("#section")                    // "#section"
+ * sanitizeHref("mailto:a@b.com")              // "mailto:a@b.com"
+ * sanitizeHref("javascript:alert(1)")         // "#"
+ * sanitizeHref("data:text/html,<script>")     // "#"
+ * sanitizeHref("")                            // "#"
  * ```
  */
-declare function definePlugin<TStorage extends PluginStorageConfig>(definition: PluginDefinition<TStorage>): ResolvedPlugin<TStorage>;
-declare function definePlugin(definition: StandardPluginDefinition): StandardPluginDefinition;
+declare function sanitizeHref(url: string | undefined | null): string;
+/**
+ * Returns true if the URL uses a safe scheme for rendering in href attributes.
+ */
+declare function isSafeHref(url: string): boolean;
 //#endregion
-//#region src/plugins/manifest-schema.d.ts
+//#region src/auth/rate-limit.d.ts
 /**
- * Zod schema matching the PluginManifest interface from types.ts.
+ * Result of a rate limit check.
+ */
+interface RateLimitResult {
+  /** Whether the request is allowed (within limit). */
+  allowed: boolean;
+  /** Current request count in this window. */
+  count: number;
+  /** Maximum requests allowed in this window. */
+  limit: number;
+}
+/**
+ * Check (and increment) the rate limit for a given IP + endpoint.
  *
- * Every JSON.parse of a manifest.json should validate through this.
+ * If `ip` is null (no trusted IP available), rate limiting is skipped
+ * and the request is allowed. There's no meaningful key to rate limit
+ * on when the IP is unknown.
+ *
+ * Returns whether the request is allowed. The counter is always
+ * incremented — even when the limit is exceeded — so that repeated
+ * abuse doesn't reset the window.
+ *
+ * Piggybacks cleanup of expired entries with a 1% probability
+ * to prevent unbounded table growth.
  */
-declare const pluginManifestSchema: z$1.ZodObject<{
-  id: z$1.ZodString;
-  version: z$1.ZodString;
-  capabilities: z$1.ZodArray<z$1.ZodEnum<{
-    "network:request": "network:request";
-    "network:request:unrestricted": "network:request:unrestricted";
-    "content:read": "content:read";
-    "content:write": "content:write";
-    "media:read": "media:read";
-    "media:write": "media:write";
-    "users:read": "users:read";
-    "email:send": "email:send";
-    "hooks.email-transport:register": "hooks.email-transport:register";
-    "hooks.email-events:register": "hooks.email-events:register";
-    "hooks.page-fragments:register": "hooks.page-fragments:register";
-  }>>;
-  allowedHosts: z$1.ZodArray<z$1.ZodString>;
-  storage: z$1.ZodRecord<z$1.ZodString, z$1.ZodObject<{
-    indexes: z$1.ZodArray<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodArray<z$1.ZodString>]>>;
-    uniqueIndexes: z$1.ZodOptional<z$1.ZodArray<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodArray<z$1.ZodString>]>>>;
-  }, z$1.core.$strip>>;
-  hooks: z$1.ZodArray<z$1.ZodUnion<readonly [z$1.ZodEnum<{
-    "plugin:install": "plugin:install";
-    "plugin:activate": "plugin:activate";
-    "plugin:deactivate": "plugin:deactivate";
-    "plugin:uninstall": "plugin:uninstall";
-    "content:beforeSave": "content:beforeSave";
-    "content:afterSave": "content:afterSave";
-    "content:beforeDelete": "content:beforeDelete";
-    "content:afterDelete": "content:afterDelete";
-    "content:afterPublish": "content:afterPublish";
-    "content:afterUnpublish": "content:afterUnpublish";
-    "media:beforeUpload": "media:beforeUpload";
-    "media:afterUpload": "media:afterUpload";
-    cron: "cron";
-    "email:beforeSend": "email:beforeSend";
-    "email:deliver": "email:deliver";
-    "email:afterSend": "email:afterSend";
-    "comment:beforeCreate": "comment:beforeCreate";
-    "comment:moderate": "comment:moderate";
-    "comment:afterCreate": "comment:afterCreate";
-    "comment:afterModerate": "comment:afterModerate";
-    "page:metadata": "page:metadata";
-    "page:fragments": "page:fragments";
-  }>, z$1.ZodObject<{
-    name: z$1.ZodEnum<{
-      "plugin:install": "plugin:install";
-      "plugin:activate": "plugin:activate";
-      "plugin:deactivate": "plugin:deactivate";
-      "plugin:uninstall": "plugin:uninstall";
-      "content:beforeSave": "content:beforeSave";
-      "content:afterSave": "content:afterSave";
-      "content:beforeDelete": "content:beforeDelete";
-      "content:afterDelete": "content:afterDelete";
-      "content:afterPublish": "content:afterPublish";
-      "content:afterUnpublish": "content:afterUnpublish";
-      "media:beforeUpload": "media:beforeUpload";
-      "media:afterUpload": "media:afterUpload";
-      cron: "cron";
-      "email:beforeSend": "email:beforeSend";
-      "email:deliver": "email:deliver";
-      "email:afterSend": "email:afterSend";
-      "comment:beforeCreate": "comment:beforeCreate";
-      "comment:moderate": "comment:moderate";
-      "comment:afterCreate": "comment:afterCreate";
-      "comment:afterModerate": "comment:afterModerate";
-      "page:metadata": "page:metadata";
-      "page:fragments": "page:fragments";
-    }>;
-    exclusive: z$1.ZodOptional<z$1.ZodBoolean>;
-    priority: z$1.ZodOptional<z$1.ZodNumber>;
-    timeout: z$1.ZodOptional<z$1.ZodNumber>;
-  }, z$1.core.$strip>]>>;
-  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>;
-  }, 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<{
-      type: z$1.ZodLiteral<"string">;
-      default: z$1.ZodOptional<z$1.ZodString>;
-      multiline: z$1.ZodOptional<z$1.ZodBoolean>;
-      label: z$1.ZodString;
-      description: z$1.ZodOptional<z$1.ZodString>;
-    }, z$1.core.$strip>, z$1.ZodObject<{
-      type: z$1.ZodLiteral<"number">;
-      default: z$1.ZodOptional<z$1.ZodNumber>;
-      min: z$1.ZodOptional<z$1.ZodNumber>;
-      max: z$1.ZodOptional<z$1.ZodNumber>;
-      label: z$1.ZodString;
-      description: z$1.ZodOptional<z$1.ZodString>;
-    }, z$1.core.$strip>, z$1.ZodObject<{
-      type: z$1.ZodLiteral<"boolean">;
-      default: z$1.ZodOptional<z$1.ZodBoolean>;
-      label: z$1.ZodString;
-      description: z$1.ZodOptional<z$1.ZodString>;
-    }, z$1.core.$strip>, z$1.ZodObject<{
-      type: z$1.ZodLiteral<"select">;
-      options: z$1.ZodArray<z$1.ZodObject<{
-        value: z$1.ZodString;
-        label: z$1.ZodString;
-      }, z$1.core.$strip>>;
-      default: z$1.ZodOptional<z$1.ZodString>;
-      label: z$1.ZodString;
-      description: z$1.ZodOptional<z$1.ZodString>;
-    }, z$1.core.$strip>, z$1.ZodObject<{
-      type: z$1.ZodLiteral<"secret">;
-      label: z$1.ZodString;
-      description: z$1.ZodOptional<z$1.ZodString>;
-    }, z$1.core.$strip>, z$1.ZodObject<{
-      type: z$1.ZodLiteral<"url">;
-      default: z$1.ZodOptional<z$1.ZodString>;
-      placeholder: z$1.ZodOptional<z$1.ZodString>;
-      label: z$1.ZodString;
-      description: z$1.ZodOptional<z$1.ZodString>;
-    }, z$1.core.$strip>, z$1.ZodObject<{
-      type: z$1.ZodLiteral<"email">;
-      default: z$1.ZodOptional<z$1.ZodString>;
-      placeholder: z$1.ZodOptional<z$1.ZodString>;
-      label: z$1.ZodString;
-      description: z$1.ZodOptional<z$1.ZodString>;
-    }, z$1.core.$strip>], "type">>>;
-    pages: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
-      path: z$1.ZodString;
-      label: z$1.ZodString;
-      icon: z$1.ZodOptional<z$1.ZodString>;
-    }, z$1.core.$strip>>>;
-    widgets: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
-      id: z$1.ZodString;
-      size: z$1.ZodOptional<z$1.ZodEnum<{
-        full: "full";
-        half: "half";
-        third: "third";
-      }>>;
-      title: z$1.ZodOptional<z$1.ZodString>;
-    }, z$1.core.$strip>>>;
-    fieldWidgets: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
-      name: z$1.ZodString;
-      label: z$1.ZodString;
-      fieldTypes: z$1.ZodArray<z$1.ZodEnum<{
-        string: "string";
-        number: "number";
-        boolean: "boolean";
-        file: "file";
-        image: "image";
-        datetime: "datetime";
-        slug: "slug";
-        text: "text";
-        integer: "integer";
-        select: "select";
-        multiSelect: "multiSelect";
-        portableText: "portableText";
-        reference: "reference";
-        json: "json";
-        repeater: "repeater";
-      }>>;
-      elements: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
-        type: z$1.ZodString;
-        action_id: z$1.ZodString;
-        label: z$1.ZodOptional<z$1.ZodString>;
-      }, z$1.core.$loose>>>;
-    }, z$1.core.$strip>>>;
-  }, z$1.core.$strip>;
-}, z$1.core.$strip>;
-type ValidatedPluginManifest = z$1.infer<typeof pluginManifestSchema>;
+declare function checkRateLimit(db: Kysely<Database>, ip: string | null, endpoint: string, maxRequests: number, windowSeconds: number): Promise<RateLimitResult>;
 //#endregion
-//#region src/plugins/hooks.d.ts
-type HookNameV2 = "plugin:install" | "plugin:activate" | "plugin:deactivate" | "plugin:uninstall" | "content:beforeSave" | "content:afterSave" | "content:beforeDelete" | "content:afterDelete" | "content:afterPublish" | "content:afterUnpublish" | "media:beforeUpload" | "media:afterUpload" | "cron" | "email:beforeSend" | "email:deliver" | "email:afterSend" | "comment:beforeCreate" | "comment:moderate" | "comment:afterCreate" | "comment:afterModerate" | "page:metadata" | "page:fragments";
+//#region src/security/guest-access-tokens.d.ts
+interface GuestAccessTokenClaims {
+  version: 1;
+  tokenId: string;
+  purpose: string;
+  subjectType: string;
+  subjectId: string;
+  locationId: string;
+  issuedAt: number;
+  expiresAt: number;
+}
+interface IssueGuestAccessTokenOptions {
+  secret: string;
+  purpose: string;
+  subjectType: string;
+  subjectId: string;
+  locationId: string;
+  /** Reuses an already persisted identifier to reconstruct the exact same capability. */
+  tokenId?: string;
+  expiresIn?: string | number;
+  now?: number;
+}
+interface IssuedGuestAccessToken {
+  token: string;
+  tokenHash: string;
+  claims: GuestAccessTokenClaims;
+}
+interface GuestAccessExpectedScope {
+  purpose: string;
+  subjectType: string;
+  subjectId?: string;
+  locationId?: string;
+}
+interface VerifyGuestAccessTokenOptions {
+  token: string | null | undefined;
+  /** Primary secret first, followed by retained rotation secrets. */
+  secrets: string | readonly string[];
+  expected: GuestAccessExpectedScope;
+  now?: number;
+}
+type VerifyGuestAccessTokenResult = {
+  valid: true;
+  claims: GuestAccessTokenClaims;
+  tokenHash: string;
+} | {
+  valid: false;
+  error: "none" | "malformed" | "invalid" | "expired" | "scope_mismatch";
+};
+declare class GuestAccessTokenConfigurationError extends Error {
+  readonly code: "INVALID_GUEST_TOKEN_SECRET" | "INVALID_GUEST_TOKEN_INPUT";
+  readonly name = "GuestAccessTokenConfigurationError";
+  constructor(message: string, code: "INVALID_GUEST_TOKEN_SECRET" | "INVALID_GUEST_TOKEN_INPUT");
+}
 /**
- * Hook execution result
+ * Issues an expiring capability for one guest purpose and one restaurant target.
+ * Persist only tokenHash/tokenId and revocation metadata; never persist or log token.
  */
-interface HookResult<T> {
-  success: boolean;
-  value?: T;
-  error?: Error;
-  pluginId: string;
-  duration: number;
+declare function issueGuestAccessToken(options: IssueGuestAccessTokenOptions): Promise<IssuedGuestAccessToken>;
+/**
+ * Verifies signature, expiry, and the caller-declared purpose/target scope.
+ * A valid result still requires the plugin to check its revocation record by tokenHash.
+ */
+declare function verifyGuestAccessToken(options: VerifyGuestAccessTokenOptions): Promise<VerifyGuestAccessTokenResult>;
+/** Returns the non-reversible identifier stored for revocation and lookup. */
+declare function hashGuestAccessToken(token: string): Promise<string>;
+//#endregion
+//#region src/visual-editing/editable.d.ts
+/**
+ * Visual editing annotation system
+ *
+ * Creates Proxy objects that emit data-dineway-ref attributes when spread onto elements.
+ */
+interface CMSAnnotation {
+  collection: string;
+  id: string;
+  field?: string;
+  /** Entry status — only present on entry-level annotations (not field-level) */
+  status?: string;
+  /** Whether the entry has unpublished draft changes */
+  hasDraft?: boolean;
+}
+/** The shape returned when spreading an edit annotation onto an element */
+interface FieldAnnotation {
+  "data-dineway-ref": string;
+}
+interface EditableOptions {
+  /** Entry status: "draft", "published", "scheduled" */
+  status?: string;
+  /** true when draftRevisionId exists and differs from liveRevisionId */
+  hasDraft?: boolean;
 }
 /**
- * Hook pipeline for executing hooks in order
+ * Create an editable proxy for an entry.
+ *
+ * Usage:
+ * - `{...entry.edit}` - entry-level annotation (includes status/hasDraft)
+ * - `{...entry.edit.title}` - field-level annotation
+ * - `{...entry.edit['nested.field']}` - nested field (bracket notation)
  */
-declare class HookPipeline {
-  private hooks;
-  private pluginMap;
-  private contextFactory;
-  /** Stored so setContextFactory can merge incrementally. */
-  private contextFactoryOptions;
-  /** Hook names where at least one handler declared exclusive: true */
-  private exclusiveHookNames;
-  /**
-   * Selected provider plugin ID for each exclusive hook.
-   * Set by the PluginManager after resolution.
-   */
-  private exclusiveSelections;
-  constructor(plugins: ResolvedPlugin[], factoryOptions?: PluginContextFactoryOptions);
-  /**
-   * Set or update the context factory options.
-   *
-   * When called on a pipeline that already has a factory, the new options
-   * are merged on top of the existing ones so that callers don't need to
-   * repeat every field (e.g. adding `cronReschedule` without losing
-   * `storage` / `getUploadUrl`).
-   */
-  setContextFactory(options: Partial<PluginContextFactoryOptions>): void;
-  /**
-   * Get context for a plugin
-   */
-  private getContext;
-  /**
-   * Get typed hooks for a specific hook name.
-   * The internal map stores ResolvedHook<unknown>, but we know each name
-   * maps to a specific handler type via HookHandlerMap.
-   *
-   * Exclusive hooks that have a selected provider are filtered out — they
-   * should only run via invokeExclusiveHook(), not in the regular pipeline.
-   */
-  private getTypedHooks;
-  /**
-   * Register all hooks from plugins.
-   *
-   * Registers each hook name individually to preserve type safety. The
-   * internal map stores ResolvedHook<unknown> since it's keyed by string,
-   * but getTypedHooks() restores the correct handler type on retrieval.
-   */
-  private registerPlugins;
-  /**
-   * Maps hook names to the capability required to register them.
-   *
-   * Hooks not listed here have no capability requirement (e.g. lifecycle
-   * hooks, cron). Any plugin declaring a listed hook without the required
-   * capability will have that hook silently skipped at registration time.
-   */
-  private static readonly HOOK_REQUIRED_CAPABILITY;
-  /**
-   * Register a single plugin's hook by name
-   */
-  private registerPluginHook;
-  /**
-   * Register a single hook
-   */
-  private registerHook;
-  /**
-   * Sort hooks by priority and dependencies
-   */
-  private sortHooks;
-  /**
-   * Execute a hook with timeout
-   */
-  private executeWithTimeout;
-  /**
-   * Run plugin:install hooks
-   */
-  runPluginInstall(pluginId: string): Promise<HookResult<void>[]>;
-  /**
-   * Run plugin:activate hooks
-   */
-  runPluginActivate(pluginId: string): Promise<HookResult<void>[]>;
-  /**
-   * Run plugin:deactivate hooks
-   */
-  runPluginDeactivate(pluginId: string): Promise<HookResult<void>[]>;
-  /**
-   * Run plugin:uninstall hooks
-   */
-  runPluginUninstall(pluginId: string, deleteData: boolean): Promise<HookResult<void>[]>;
-  private runLifecycleHook;
-  /**
-   * Run content:beforeSave hooks
-   * Returns modified content from the pipeline
-   */
-  runContentBeforeSave(content: Record<string, unknown>, collection: string, isNew: boolean): Promise<{
-    content: Record<string, unknown>;
-    results: HookResult<Record<string, unknown>>[];
-  }>;
-  /**
-   * Run content:afterSave hooks
-   */
-  runContentAfterSave(content: Record<string, unknown>, collection: string, isNew: boolean): Promise<HookResult<void>[]>;
-  /**
-   * Run content:beforeDelete hooks
-   * Returns whether deletion is allowed
-   */
-  runContentBeforeDelete(id: string, collection: string): Promise<{
-    allowed: boolean;
-    results: HookResult<boolean>[];
-  }>;
-  /**
-   * Run content:afterDelete hooks
-   */
-  runContentAfterDelete(id: string, collection: string, permanent: boolean): Promise<HookResult<void>[]>;
-  /**
-   * Run content:afterPublish hooks (fire-and-forget).
-   */
-  runContentAfterPublish(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
-  /**
-   * Run content:afterUnpublish hooks (fire-and-forget).
-   */
-  runContentAfterUnpublish(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
-  /**
-   * Run media:beforeUpload hooks
-   */
-  runMediaBeforeUpload(file: {
-    name: string;
-    type: string;
-    size: number;
-  }): Promise<{
-    file: {
-      name: string;
-      type: string;
-      size: number;
-    };
-    results: HookResult<{
-      name: string;
-      type: string;
-      size: number;
-    }>[];
-  }>;
-  /**
-   * Run media:afterUpload hooks
-   */
-  runMediaAfterUpload(media: {
-    id: string;
-    filename: string;
-    mimeType: string;
-    size: number | null;
-    url: string;
-    createdAt: string;
-  }): Promise<HookResult<void>[]>;
-  /**
-   * Invoke the cron hook for a specific plugin.
-   *
-   * Unlike other hooks which broadcast to all plugins, the cron hook is
-   * dispatched only to the target plugin — the one that owns the task.
-   */
-  invokeCronHook(pluginId: string, event: CronEvent): Promise<HookResult<void>>;
-  /**
-   * Run email:beforeSend hooks (middleware pipeline).
-   *
-   * Each handler receives the message and returns a modified message or
-   * `false` to cancel delivery. The pipeline chains message transformations —
-   * each handler receives the output of the previous one.
-   */
-  runEmailBeforeSend(message: EmailMessage, source: string): Promise<{
-    message: EmailMessage | false;
-    results: HookResult<EmailMessage | false>[];
-  }>;
-  /**
-   * Run email:afterSend hooks (fire-and-forget).
-   *
-   * Errors are logged but don't propagate — they don't affect the caller.
-   */
-  runEmailAfterSend(message: EmailMessage, source: string): Promise<HookResult<void>[]>;
+declare function createEditable(collection: string, id: string, options?: EditableOptions): EditProxy;
+/**
+ * Create a noop proxy for production mode.
+ * Spreading this produces no attributes.
+ */
+declare function createNoop(): EditProxy;
+/**
+ * Visual editing proxy type.
+ *
+ * Spread directly onto elements for entry-level annotations: `{...entry.edit}`
+ * Access a field for field-level annotations: `{...entry.edit.title}`
+ *
+ * In production, spreading produces no attributes (noop).
+ */
+type EditProxy = {
+  readonly [field: string]: Partial<FieldAnnotation>;
+};
+//#endregion
+//#region src/query.d.ts
+/**
+ * Collection type registry for type-safe queries.
+ *
+ * This interface is extended by the generated dineway-env.d.ts file
+ * to provide type inference for collection names and their data shapes.
+ *
+ * @example
+ * ```ts
+ * // In dineway-env.d.ts (generated):
+ * declare module "dineway" {
+ *   interface DinewayCollections {
+ *     posts: { title: string; content: PortableTextBlock[]; };
+ *     pages: { title: string; body: PortableTextBlock[]; };
+ *   }
+ * }
+ *
+ * // Then in your code:
+ * const { entries } = await getDinewayCollection("posts");
+ * // entries[0].data.title is typed as string
+ * ```
+ */
+interface DinewayCollections {}
+/**
+ * Helper type to infer the data type for a collection.
+ * Returns the registered type if known, otherwise falls back to Record<string, unknown>.
+ */
+type InferCollectionData<T extends string> = T extends keyof DinewayCollections ? DinewayCollections[T] : Record<string, unknown>;
+/**
+ * Sort direction
+ */
+type SortDirection = "asc" | "desc";
+/**
+ * Order by specification - field name to direction
+ * @example { created_at: "desc" } - Sort by created_at descending
+ * @example { title: "asc" } - Sort by title ascending
+ * @example { published_at: "desc", title: "asc" } - Multi-field sort
+ */
+type OrderBySpec = Record<string, SortDirection>;
+/**
+ * Fields shared by every collection query, independent of pagination mode.
+ */
+interface CollectionFilterBase {
+  status?: "draft" | "published" | "archived";
+  limit?: number;
   /**
-   * Run comment:beforeCreate hooks (middleware pipeline).
+   * Filter by field values, taxonomy terms, byline credits, or ranges.
    *
-   * Each handler receives the event and returns a modified event or
-   * `false` to reject the comment. The pipeline chains transformations —
-   * each handler receives the output of the previous one.
-   */
-  runCommentBeforeCreate(event: CommentBeforeCreateEvent): Promise<CommentBeforeCreateEvent | false>;
-  /**
-   * Run comment:afterCreate hooks (fire-and-forget).
+   * Taxonomy names are detected automatically and filtered by term.
+   * The reserved `byline` key filters by byline credit in any position,
+   * not just the primary credit. It accepts one or more byline translation
+   * groups, or concrete byline row IDs.
+   * Other keys are treated as content table column filters.
    *
-   * Errors are logged but don't propagate — they don't affect the caller.
+   * @example { category: 'news' } - Filter by taxonomy term
+   * @example { category: ['news', 'featured'] } - Filter by multiple terms (OR)
+   * @example { byline: '01HXYZ...' } - Entries credited to a byline (any position)
+   * @example { byline: ['01HXYZ...', '01HABC...'] } - Credited to any of these bylines (OR)
+   * @example { series: 'main' } - Exact match on a content field
+   * @example { published_at: { gte: '2024-01-01', lt: '2025-01-01' } } - Date range
    */
-  runCommentAfterCreate(event: CommentAfterCreateEvent): Promise<void>;
+  where?: Record<string, WhereValue>;
   /**
-   * Run comment:afterModerate hooks (fire-and-forget).
+   * Case-insensitive substring search across selected content fields.
    *
-   * Errors are logged but don't propagate — they don't affect the caller.
-   */
-  runCommentAfterModerate(event: CommentAfterModerateEvent): Promise<void>;
-  /**
-   * Run page:metadata hooks. Each handler returns contributions that are
-   * merged by the metadata collector. Errors are logged but don't propagate.
-   */
-  runPageMetadata(event: PageMetadataEvent): Promise<Array<{
-    pluginId: string;
-    contributions: PageMetadataContribution[];
-  }>>;
-  /**
-   * Run page:fragments hooks. Only trusted plugins should be registered
-   * for this hook. Errors are logged but don't propagate.
-   */
-  runPageFragments(event: PageFragmentEvent): Promise<Array<{
-    pluginId: string;
-    contributions: PageFragmentContribution[];
-  }>>;
-  /**
-   * Check if any hooks are registered for a given name
-   */
-  hasHooks(name: HookNameV2): boolean;
-  /**
-   * Get hook count for debugging
-   */
-  getHookCount(name: HookNameV2): number;
-  /**
-   * Get all registered hook names
-   */
-  getRegisteredHooks(): HookNameV2[];
-  /**
-   * Returns hook names where at least one handler declared exclusive: true
+   * `searchColumns` must contain concrete field slugs or system column names.
+   * When `q` is present without `searchColumns`, no search condition is applied.
    */
-  getRegisteredExclusiveHooks(): string[];
+  q?: string;
+  searchColumns?: string[];
   /**
-   * Check if a hook is exclusive
+   * Order results by field(s)
+   * @default { created_at: "desc" }
+   * @example { created_at: "desc" } - Sort by created_at descending (default)
+   * @example { title: "asc" } - Sort by title ascending
+   * @example { published_at: "desc", title: "asc" } - Multi-field sort
    */
-  isExclusiveHook(name: string): boolean;
+  orderBy?: OrderBySpec;
   /**
-   * Set the selected provider for an exclusive hook.
-   * Called by PluginManager after resolution.
+   * Filter by locale. When set, only returns entries in this locale.
+   * Only relevant when i18n is configured.
+   * @example "en" — English entries only
+   * @example "fr" — French entries only
    */
-  setExclusiveSelection(hookName: string, pluginId: string): void;
+  locale?: string;
+}
+/** Keyset-paginated query filter. Cannot also carry an offset. */
+interface CursorCollectionFilter extends CollectionFilterBase {
   /**
-   * Clear the selected provider for an exclusive hook.
+   * Opaque cursor for keyset pagination.
+   * Pass the `nextCursor` value from a previous result to fetch the next page.
+   * @example
+   * ```ts
+   * const cursor = Astro.url.searchParams.get("cursor") ?? undefined;
+   * const { entries, nextCursor } = await getDinewayCollection("posts", {
+   *   limit: 10,
+   *   cursor,
+   * });
+   * ```
    */
-  clearExclusiveSelection(hookName: string): void;
+  cursor?: string;
+  offset?: never;
+}
+/** Offset-paginated query filter. Cannot also carry a cursor. */
+interface OffsetCollectionFilter extends CollectionFilterBase {
   /**
-   * Get the selected provider for an exclusive hook (if any).
+   * Skip this many entries before returning results. Use with `limit` for
+   * numbered archive routes, for example `offset = (page - 1) * perPage`.
    */
-  getExclusiveSelection(hookName: string): string | undefined;
+  offset?: number;
+  cursor?: never;
+}
+type CollectionFilter = CursorCollectionFilter | OffsetCollectionFilter;
+interface ContentEntry<T = Record<string, unknown>> {
+  id: string;
+  data: T;
+  /** Visual editing annotations. Spread onto elements: {...entry.edit.title} */
+  edit: EditProxy;
+}
+/** Cache hint returned by the content loader for route caching */
+interface CacheHint {
+  tags?: string[];
+  lastModified?: Date;
+}
+/**
+ * Result from getDinewayCollection
+ */
+interface CollectionResult<T> {
+  /** The entries (empty array if error or none found) */
+  entries: ContentEntry<T>[];
+  /** Error if the query failed */
+  error?: Error;
+  /** Cache hint for route caching (pass to Astro.cache.set()) */
+  cacheHint: CacheHint;
   /**
-   * Get all plugins that registered a handler for a given exclusive hook.
+   * Opaque cursor for the next page.
+   * Undefined when there are no more results.
+   * Pass this as `cursor` in the next query to get the next page.
    */
-  getExclusiveHookProviders(hookName: string): Array<{
-    pluginId: string;
-  }>;
+  nextCursor?: string;
   /**
-   * Get all plugins that registered a non-exclusive handler for a given hook,
-   * preserving priority order. This partitions with getExclusiveHookProviders().
+   * Whether more entries exist beyond this page. Set whenever `limit` is
+   * provided, including offset-paginated numbered archives.
    */
-  getHookProviders(hookName: string): Array<{
-    pluginId: string;
-  }>;
+  hasMore?: boolean;
   /**
-   * Invoke an exclusive hook — dispatch only to the selected provider.
-   * Returns null if no provider is selected or if the selected hook
-   * is not found in the pipeline.
-   *
-   * This is a generic dispatch used by the email pipeline and other
-   * exclusive hook consumers. The handler type is unknown — callers
-   * must know the expected signature.
-   *
-   * Errors are isolated: a failing handler returns an error result
-   * instead of propagating the exception to the caller.
+   * Total number of entries matching the current filter, excluding cursor and limit.
    */
-  invokeExclusiveHook(hookName: string, event: unknown): Promise<{
-    result: unknown;
-    pluginId: string;
-    error?: Error;
-    duration: number;
-  } | null>;
+  total?: number;
+}
+/**
+ * Result from getDinewayEntry
+ */
+interface EntryResult<T> {
+  /** The entry, or null if not found */
+  entry: ContentEntry<T> | null;
+  /** Error if the query failed (not set for "not found", only for actual errors) */
+  error?: Error;
+  /** Whether we're in preview mode (valid token was provided) */
+  isPreview: boolean;
+  /** Set when a fallback locale was used instead of the requested locale */
+  fallbackLocale?: string;
+  /** Cache hint for route caching (pass to Astro.cache.set()) */
+  cacheHint: CacheHint;
+}
+/** Edit metadata attached to PT arrays in edit mode */
+interface EditFieldMeta {
+  collection: string;
+  id: string;
+  field: string;
+}
+/**
+ * Read edit metadata from a value (returns undefined if not tagged).
+ * Uses Object.getOwnPropertyDescriptor to access Symbol-keyed property
+ * without an unsafe type assertion.
+ */
+declare function getEditMeta(value: unknown): EditFieldMeta | undefined;
+/**
+ * Get all entries of a content type
+ *
+ * Returns { entries, error } for graceful error handling.
+ *
+ * When dineway-env.d.ts is generated, the collection name will be
+ * type-checked and the return type will be inferred automatically.
+ *
+ * @example
+ * ```ts
+ * import { getDinewayCollection } from "dineway";
+ *
+ * const { entries: posts, error } = await getDinewayCollection("posts");
+ * if (error) {
+ *   console.error("Failed to load posts:", error);
+ *   return;
+ * }
+ * // posts[0].data.title is typed (if dineway-env.d.ts exists)
+ *
+ * // With filters
+ * const { entries: drafts } = await getDinewayCollection("posts", { status: "draft" });
+ * ```
+ */
+declare function getDinewayCollection<T extends string, D = InferCollectionData<T>>(type: T, filter?: CollectionFilter): Promise<CollectionResult<D>>;
+/**
+ * Get a single entry by type and ID/slug
+ *
+ * Returns { entry, error, isPreview } for graceful error handling.
+ * - entry is null if not found (not an error)
+ * - error is set only for actual errors (db issues, etc.)
+ *
+ * Preview mode is detected automatically from request context (ALS).
+ * When the URL has a valid `_preview` token, the middleware sets preview
+ * context and this function serves draft revision data if available.
+ *
+ * @example
+ * ```ts
+ * import { getDinewayEntry } from "dineway";
+ *
+ * // Simple usage — preview just works via middleware
+ * const { entry: post, isPreview, error } = await getDinewayEntry("posts", "my-slug");
+ * if (!post) return Astro.redirect("/404");
+ * ```
+ */
+declare function getDinewayEntry<T extends string, D = InferCollectionData<T>>(type: T, id: string, options?: {
+  locale?: string;
+}): Promise<EntryResult<D>>;
+/**
+ * Translation summary for a single locale variant
+ */
+interface TranslationSummary {
+  /** Content item ID */
+  id: string;
+  /** Locale code (e.g. "en", "fr") */
+  locale: string;
+  /** URL slug */
+  slug: string | null;
+  /** Current status */
+  status: string;
+}
+/**
+ * Result from getTranslations
+ */
+interface TranslationsResult {
+  /** The translation group ID (shared across locales) */
+  translationGroup: string;
+  /** All locale variants in this group */
+  translations: TranslationSummary[];
+  /** Error if the query failed */
+  error?: Error;
+}
+/**
+ * Get all translations of a content item.
+ *
+ * Given a content entry, returns all locale variants that share the same
+ * translation group. This is useful for building language switcher UI.
+ *
+ * @example
+ * ```ts
+ * import { getDinewayEntry, getTranslations } from "dineway";
+ *
+ * const { entry: post } = await getDinewayEntry("posts", "hello-world", { locale: "en" });
+ * const { translations } = await getTranslations("posts", post.data.id);
+ * // translations = [{ id: "...", locale: "en", slug: "hello-world", status: "published" }, ...]
+ * ```
+ */
+declare function getTranslations(type: string, id: string): Promise<TranslationsResult>;
+/**
+ * Result from resolveDinewayPath
+ */
+interface ResolvePathResult<T = Record<string, unknown>> {
+  /** The matched entry */
+  entry: ContentEntry<T>;
+  /** The collection slug that matched */
+  collection: string;
+  /** Extracted parameters from the URL pattern (e.g. { slug: "my-post" }) */
+  params: Record<string, string>;
+}
+/**
+ * Resolve a URL path to a content entry by matching against collection URL patterns.
+ *
+ * Loads all collections with a `urlPattern` set, converts each pattern to a regex,
+ * and tests the given path. On match, extracts the slug and fetches the entry.
+ *
+ * @example
+ * ```ts
+ * import { resolveDinewayPath } from "dineway";
+ *
+ * // Given pages with urlPattern "/{slug}" and posts with "/blog/{slug}":
+ * const result = await resolveDinewayPath("/blog/hello-world");
+ * if (result) {
+ *   console.log(result.collection); // "posts"
+ *   console.log(result.params.slug); // "hello-world"
+ *   console.log(result.entry.data); // post data
+ * }
+ * ```
+ */
+declare function resolveDinewayPath<T = Record<string, unknown>>(path: string): Promise<ResolvePathResult<T> | null>;
+//#endregion
+//#region src/after.d.ts
+/**
+ * Defer work past the current synchronous path.
+ *
+ * Use this for best-effort bookkeeping that should not block runtime
+ * initialization or response handling. Node keeps the process alive for
+ * pending work; callers that need stronger durability should await their own
+ * operation instead of using this helper.
+ */
+type AfterCallback = () => void | Promise<void>;
+declare function after(fn: AfterCallback): void;
+//#endregion
+//#region src/object-cache/index.d.ts
+/** Options for {@link cachedQuery}. */
+interface CachedQueryOptions<T> {
+  /**
+   * Invalidation namespace(s). A single string for self-contained data
+   * (`settings`, `menus`), or several when the cached value depends on data
+   * owned by other namespaces — e.g. a content entry hydrates bylines and
+   * taxonomy terms, so it caches under
+   * `[content:posts, "bylines", "taxonomies"]` and is invalidated when *any*
+   * of them is bumped. Every namespace's epoch is folded into the key.
+   */
+  namespace: string | readonly string[];
+  /** Stable, fully-qualifying cache key *within* the namespace. */
+  key: string;
+  /** Loader run on a miss (or when caching is disabled/bypassed). */
+  load: () => Promise<T>;
+  /** TTL override in seconds. Falls back to the configured `defaultTtl`. */
+  ttl?: number;
+  /**
+   * Predicate gating whether a freshly-loaded value is stored. Defaults to
+   * always-cache. Use it to skip caching error/empty sentinels.
+   */
+  cacheable?: (value: T) => boolean;
+}
+/**
+ * Distributed read-through cache around `load`.
+ *
+ * `T` must be the value as it should be *stored* — i.e. JSON-serializable with
+ * the codec's `Date` support, carrying no functions or symbol-keyed props.
+ * Callers caching richer objects (content entries) reduce to a serializable
+ * snapshot here and rebuild on the way out; see `query.ts`.
+ *
+ * On a miss or when the cache is disabled/bypassed, this is equivalent to
+ * `await load()`. Backend errors never propagate: a failing `get` is a miss, a
+ * failing `set` is dropped.
+ */
+declare function cachedQuery<T>(options: CachedQueryOptions<T>): Promise<T>;
+/** Whether object-cache reads are active for the current request. */
+declare function isObjectCacheActive(): Promise<boolean>;
+/**
+ * Invalidate every cached value in `namespace` by bumping its epoch.
+ *
+ * Sync and non-blocking: the local epoch is stamped immediately (so the
+ * writing isolate is instantly consistent) and the backend write is deferred
+ * via `after`. Other isolates pick up the new epoch within their `revalidate`
+ * window. No-ops when the cache is disabled.
+ */
+declare function invalidateObjectCache(namespace: string): void;
+/**
+ * Fixed namespaces for data shared across collections. Content reads fold the
+ * `BYLINES` and `TAXONOMIES` epochs into their keys (via {@link cachedQuery})
+ * because entries hydrate byline and taxonomy-term data — so renaming an
+ * author or a category correctly invalidates every cached entry that displays
+ * it, without tracking which collections reference it.
+ */
+declare const CacheNamespace: {
+  readonly SETTINGS: "settings";
+  readonly MENUS: "menus";
+  readonly TAXONOMIES: "taxonomies";
+  readonly BYLINES: "bylines"; /** Collection schema/metadata (label, supports, commentsEnabled, fields). */
+  readonly SCHEMA: "schema"; /** Public (approved) comments. */
+  readonly COMMENTS: "comments";
+};
+/** Namespace for a content collection's cached queries. */
+declare function contentNamespace(collection: string): string;
+/**
+ * Namespaces a content read depends on: the collection itself plus the shared
+ * byline/taxonomy data folded into each entry.
+ */
+declare function contentNamespaces(collection: string): readonly string[];
+/**
+ * Invalidate all cached reads (list + entry) for a content collection.
+ * Call from every write path that mutates rows in `ec_<collection>`.
+ */
+declare function invalidateCollectionCache(collection: string): void;
+/** Invalidate cached taxonomy definitions/terms and all content that hydrates them. */
+declare function invalidateTaxonomyObjectCache(): void;
+/** Invalidate cached bylines and all content that hydrates them. */
+declare function invalidateBylineObjectCache(): void;
+/** Invalidate cached navigation menus. */
+declare function invalidateMenuObjectCache(): void;
+/** Invalidate cached collection schema/metadata reads (e.g. getCollectionInfo). */
+declare function invalidateSchemaObjectCache(): void;
+/** Invalidate cached public comment reads. */
+declare function invalidateCommentObjectCache(): void;
+//#endregion
+//#region src/i18n/config.d.ts
+/**
+ * Dineway i18n Configuration
+ *
+ * Reads locale configuration from the virtual module (sourced from Astro config).
+ * Initialized during runtime startup, then available via getI18nConfig().
+ */
+interface I18nConfig {
+  defaultLocale: string;
+  locales: string[];
+  fallback?: Record<string, string>;
+  prefixDefaultLocale?: boolean;
 }
 /**
- * Create a hook pipeline from plugins
+ * Get the current i18n config.
+ * Returns null if i18n is not configured.
  */
-declare function createHookPipeline(plugins: ResolvedPlugin[], factoryOptions?: PluginContextFactoryOptions): HookPipeline;
+declare function getI18nConfig(): I18nConfig | null;
+/**
+ * Check if i18n is enabled.
+ * Returns true when multiple locales are configured.
+ */
+declare function isI18nEnabled(): boolean;
+/**
+ * Resolve fallback locale chain for a given locale.
+ * Returns array of locales to try, from most preferred to least.
+ * Always ends with defaultLocale.
+ */
+declare function getFallbackChain(locale: string): string[];
 //#endregion
-//#region src/plugins/email.d.ts
+//#region src/preview/sidecar-client.d.ts
 /**
- * EmailPipeline orchestrates email delivery through the plugin hook system.
+ * Preview sidecar protocol helpers.
  *
- * The pipeline runs in three stages:
- * 1. email:beforeSend — middleware hooks that can transform or cancel messages
- * 2. email:deliver — exclusive hook dispatching to the selected provider
- * 3. email:afterSend — fire-and-forget hooks for logging/analytics
+ * These utilities define the signed URL and snapshot-auth contract shared
+ * by preview sidecars and the source site serving snapshot exports.
  */
-declare class EmailPipeline {
-  private pipeline;
-  constructor(pipeline: HookPipeline);
-  /**
-   * Replace the underlying hook pipeline.
-   *
-   * Called by the runtime when rebuilding the hook pipeline after a
-   * plugin is enabled or disabled, so the email pipeline dispatches
-   * to the current set of active hooks.
-   */
-  setPipeline(pipeline: HookPipeline): void;
-  /**
-   * Send an email through the full pipeline.
-   *
-   * @param message - The email to send
-   * @param source - Where the email originated ("system" for auth, plugin ID for plugins)
-   * @throws EmailNotConfiguredError if no provider is selected
-   * @throws EmailRecursionError if called re-entrantly from within a hook
-   * @throws Error if the provider handler throws
-   */
-  send(message: EmailMessage, source: string): Promise<void>;
-  /**
-   * Inner send implementation, separated from the recursion guard.
-   */
-  private sendInner;
-  /**
-   * Check if an email provider is configured and available.
-   *
-   * Returns true if an email:deliver provider is selected in the exclusive
-   * hook system. Plugins and auth code use this to decide whether to show
-   * "send invite" vs "copy invite link" UI.
-   */
-  isAvailable(): boolean;
+interface PreviewSidecarSignature {
+  source: string;
+  exp: number;
+  sig: string;
+}
+interface PreviewSidecarClient {
+  signPreviewUrl(previewBase: string, source: string, secret: string, ttl?: number): Promise<string>;
+  buildSnapshotSignatureHeader(signature: PreviewSidecarSignature): string;
+}
+declare function signPreviewUrl(previewBase: string, source: string, secret: string, ttl?: number): Promise<string>;
+declare function buildPreviewSignatureHeader(signature: PreviewSidecarSignature): string;
+declare function parsePreviewSignatureHeader(header: string): PreviewSidecarSignature | null;
+declare function verifyPreviewSignature(source: string, exp: number, sig: string, secret: string): Promise<boolean>;
+declare const defaultPreviewSidecarClient: PreviewSidecarClient;
+//#endregion
+//#region src/preview/session-database-factory.d.ts
+interface SessionDatabaseInfo {
+  id: string;
+  dbPath: string;
+  createdAt: number;
+  expiresAt: number;
+  lastTouchedAt: number;
+}
+interface SessionDatabaseHandle {
+  created: boolean;
+  session: SessionDatabaseInfo;
+  db: Kysely<Database>;
+  close(): Promise<void>;
+}
+interface SessionCleanupResult {
+  removedSessionIds: string[];
+  removedPaths: string[];
+}
+interface SessionOpenOptions {
+  id: string;
+  now?: number;
+}
+interface SessionOpenOrCreateOptions extends SessionOpenOptions {
+  ttlMs: number;
+}
+interface SessionDatabaseFactory {
+  open(input: SessionOpenOptions): Promise<SessionDatabaseHandle | null>;
+  openOrCreate(input: SessionOpenOrCreateOptions): Promise<SessionDatabaseHandle>;
+  destroy(id: string): Promise<boolean>;
+  cleanup(now?: number): Promise<SessionCleanupResult>;
+  close(): Promise<void>;
+}
+interface FileSessionDatabaseFactoryOptions {
+  rootDir: string;
+  maxDiskBytes?: number;
+  registryFileName?: string;
+  sessionsDirName?: string;
+}
+declare class SessionDatabaseLimitError extends Error {
+  constructor(message?: string);
+}
+declare class FileSessionDatabaseFactory implements SessionDatabaseFactory {
+  private readonly options;
+  private readonly registry;
+  private readonly sessionsDir;
+  private readonly maxDiskBytes;
+  constructor(options: FileSessionDatabaseFactoryOptions);
+  open(input: SessionOpenOptions): Promise<SessionDatabaseHandle | null>;
+  openOrCreate(input: SessionOpenOrCreateOptions): Promise<SessionDatabaseHandle>;
+  destroy(id: string): Promise<boolean>;
+  cleanup(now?: number): Promise<SessionCleanupResult>;
+  close(): Promise<void>;
+  private createHandle;
+  private getSessionRow;
+  private toSessionInfo;
+  private deleteSession;
+  private getActiveDiskBytes;
+  private getDbPath;
+  private getManagedPaths;
+  private listSessionRows;
+  private listDbPathRows;
+}
+//#endregion
+//#region src/preview/middleware.d.ts
+interface FilePreviewMiddlewareConfig {
+  rootDir?: string;
+  secret: string;
+  ttlSeconds?: number;
+  cookieName?: string;
+  snapshotPath?: string;
+  maxSessionDiskBytes?: number;
+  sessionFactory?: SessionDatabaseFactory;
+  fetch?: typeof globalThis.fetch;
 }
+declare function createFilePreviewMiddleware(config: FilePreviewMiddlewareConfig): MiddlewareHandler;
+//#endregion
+//#region src/plugins/define-plugin.d.ts
+/**
+ * Define a Dineway plugin.
+ *
+ * **Standard format** -- the canonical format for plugins that work in both
+ * trusted and sandboxed modes. No id/version -- those come from the descriptor.
+ *
+ * @example
+ * ```typescript
+ * import { definePlugin } from "dineway";
+ *
+ * export default definePlugin({
+ *   hooks: {
+ *     "content:afterSave": {
+ *       handler: async (event, ctx) => {
+ *         await ctx.kv.set("lastSave", Date.now());
+ *       },
+ *     },
+ *   },
+ *   routes: {
+ *     status: {
+ *       handler: async (routeCtx, ctx) => ({ ok: true }),
+ *     },
+ *   },
+ * });
+ * ```
+ *
+ * **Native format** -- for plugins that need React admin, direct DB access,
+ * or other capabilities not available in the sandbox.
+ *
+ * @example
+ * ```typescript
+ * import { definePlugin } from "dineway";
+ *
+ * export default definePlugin({
+ *   id: "my-plugin",
+ *   version: "1.0.0",
+ *   capabilities: ["content:read"],
+ *   hooks: {
+ *     "content:beforeSave": async (event, ctx) => {
+ *       ctx.log.info("Saving content", { collection: event.collection });
+ *       return event.content;
+ *     }
+ *   },
+ *   routes: {
+ *     "sync": {
+ *       handler: async (ctx) => {
+ *         return { status: "ok" };
+ *       }
+ *     }
+ *   }
+ * });
+ * ```
+ */
+declare function definePlugin<TStorage extends PluginStorageConfig>(definition: PluginDefinition<TStorage>): ResolvedPlugin<TStorage>;
+declare function definePlugin(definition: StandardPluginDefinition): StandardPluginDefinition;
+//#endregion
+//#region src/plugins/manifest-schema.d.ts
+/**
+ * Zod schema matching the PluginManifest interface from types.ts.
+ *
+ * Every JSON.parse of a manifest.json should validate through this.
+ */
+declare const pluginManifestSchema: z$1.ZodObject<{
+  id: z$1.ZodString;
+  version: z$1.ZodString;
+  declaredAccess: z$1.ZodOptional<z$1.ZodObject<{
+    content: 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>>;
+    }, 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>>;
+    }, z$1.core.$strip>>;
+    network: z$1.ZodOptional<z$1.ZodObject<{
+      request: z$1.ZodOptional<z$1.ZodObject<{
+        allowedHosts: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
+      }, z$1.core.$strip>>;
+    }, z$1.core.$strip>>;
+    email: z$1.ZodOptional<z$1.ZodObject<{
+      send: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+      events: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+      transport: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+    }, z$1.core.$strip>>;
+    page: z$1.ZodOptional<z$1.ZodObject<{
+      fragments: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+    }, z$1.core.$strip>>;
+    users: z$1.ZodOptional<z$1.ZodObject<{
+      read: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+    }, z$1.core.$strip>>;
+  }, z$1.core.$strip>>;
+  capabilities: z$1.ZodArray<z$1.ZodEnum<{
+    "network:request": "network:request";
+    "network:request:unrestricted": "network:request:unrestricted";
+    "content:read": "content:read";
+    "content:write": "content:write";
+    "media:read": "media:read";
+    "media:write": "media:write";
+    "users:read": "users:read";
+    "email:send": "email:send";
+    "hooks.email-transport:register": "hooks.email-transport:register";
+    "hooks.email-events:register": "hooks.email-events:register";
+    "hooks.page-fragments:register": "hooks.page-fragments:register";
+  }>>;
+  allowedHosts: z$1.ZodArray<z$1.ZodString>;
+  storage: z$1.ZodRecord<z$1.ZodString, z$1.ZodObject<{
+    indexes: z$1.ZodArray<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodArray<z$1.ZodString>]>>;
+    uniqueIndexes: z$1.ZodOptional<z$1.ZodArray<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodArray<z$1.ZodString>]>>>;
+  }, z$1.core.$strip>>;
+  hooks: z$1.ZodArray<z$1.ZodUnion<readonly [z$1.ZodEnum<{
+    "plugin:install": "plugin:install";
+    "plugin:activate": "plugin:activate";
+    "plugin:deactivate": "plugin:deactivate";
+    "plugin:uninstall": "plugin:uninstall";
+    "content:beforeSave": "content:beforeSave";
+    "content:afterSave": "content:afterSave";
+    "content:beforeDelete": "content:beforeDelete";
+    "content:afterDelete": "content:afterDelete";
+    "content:afterPublish": "content:afterPublish";
+    "content:afterUnpublish": "content:afterUnpublish";
+    "content:afterRestore": "content:afterRestore";
+    "content:afterSchedule": "content:afterSchedule";
+    "content:afterUnschedule": "content:afterUnschedule";
+    "media:beforeUpload": "media:beforeUpload";
+    "media:afterUpload": "media:afterUpload";
+    cron: "cron";
+    "email:beforeSend": "email:beforeSend";
+    "email:deliver": "email:deliver";
+    "email:afterSend": "email:afterSend";
+    "comment:beforeCreate": "comment:beforeCreate";
+    "comment:moderate": "comment:moderate";
+    "comment:afterCreate": "comment:afterCreate";
+    "comment:afterModerate": "comment:afterModerate";
+    "page:metadata": "page:metadata";
+    "page:fragments": "page:fragments";
+  }>, z$1.ZodObject<{
+    name: z$1.ZodEnum<{
+      "plugin:install": "plugin:install";
+      "plugin:activate": "plugin:activate";
+      "plugin:deactivate": "plugin:deactivate";
+      "plugin:uninstall": "plugin:uninstall";
+      "content:beforeSave": "content:beforeSave";
+      "content:afterSave": "content:afterSave";
+      "content:beforeDelete": "content:beforeDelete";
+      "content:afterDelete": "content:afterDelete";
+      "content:afterPublish": "content:afterPublish";
+      "content:afterUnpublish": "content:afterUnpublish";
+      "content:afterRestore": "content:afterRestore";
+      "content:afterSchedule": "content:afterSchedule";
+      "content:afterUnschedule": "content:afterUnschedule";
+      "media:beforeUpload": "media:beforeUpload";
+      "media:afterUpload": "media:afterUpload";
+      cron: "cron";
+      "email:beforeSend": "email:beforeSend";
+      "email:deliver": "email:deliver";
+      "email:afterSend": "email:afterSend";
+      "comment:beforeCreate": "comment:beforeCreate";
+      "comment:moderate": "comment:moderate";
+      "comment:afterCreate": "comment:afterCreate";
+      "comment:afterModerate": "comment:afterModerate";
+      "page:metadata": "page:metadata";
+      "page:fragments": "page:fragments";
+    }>;
+    exclusive: z$1.ZodOptional<z$1.ZodBoolean>;
+    priority: z$1.ZodOptional<z$1.ZodNumber>;
+    timeout: z$1.ZodOptional<z$1.ZodNumber>;
+  }, z$1.core.$strip>]>>;
+  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>;
+  }, 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<{
+      type: z$1.ZodLiteral<"string">;
+      default: z$1.ZodOptional<z$1.ZodString>;
+      multiline: z$1.ZodOptional<z$1.ZodBoolean>;
+      label: z$1.ZodString;
+      description: z$1.ZodOptional<z$1.ZodString>;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+      type: z$1.ZodLiteral<"number">;
+      default: z$1.ZodOptional<z$1.ZodNumber>;
+      min: z$1.ZodOptional<z$1.ZodNumber>;
+      max: z$1.ZodOptional<z$1.ZodNumber>;
+      label: z$1.ZodString;
+      description: z$1.ZodOptional<z$1.ZodString>;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+      type: z$1.ZodLiteral<"boolean">;
+      default: z$1.ZodOptional<z$1.ZodBoolean>;
+      label: z$1.ZodString;
+      description: z$1.ZodOptional<z$1.ZodString>;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+      type: z$1.ZodLiteral<"select">;
+      options: z$1.ZodArray<z$1.ZodObject<{
+        value: z$1.ZodString;
+        label: z$1.ZodString;
+      }, z$1.core.$strip>>;
+      default: z$1.ZodOptional<z$1.ZodString>;
+      label: z$1.ZodString;
+      description: z$1.ZodOptional<z$1.ZodString>;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+      type: z$1.ZodLiteral<"secret">;
+      label: z$1.ZodString;
+      description: z$1.ZodOptional<z$1.ZodString>;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+      type: z$1.ZodLiteral<"url">;
+      default: z$1.ZodOptional<z$1.ZodString>;
+      placeholder: z$1.ZodOptional<z$1.ZodString>;
+      label: z$1.ZodString;
+      description: z$1.ZodOptional<z$1.ZodString>;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+      type: z$1.ZodLiteral<"email">;
+      default: z$1.ZodOptional<z$1.ZodString>;
+      placeholder: z$1.ZodOptional<z$1.ZodString>;
+      label: z$1.ZodString;
+      description: z$1.ZodOptional<z$1.ZodString>;
+    }, z$1.core.$strip>], "type">>>;
+    pages: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
+      path: z$1.ZodString;
+      label: z$1.ZodString;
+      icon: z$1.ZodOptional<z$1.ZodString>;
+    }, z$1.core.$strip>>>;
+    widgets: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
+      id: z$1.ZodString;
+      size: z$1.ZodOptional<z$1.ZodEnum<{
+        full: "full";
+        half: "half";
+        third: "third";
+      }>>;
+      title: z$1.ZodOptional<z$1.ZodString>;
+    }, z$1.core.$strip>>>;
+    fieldWidgets: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
+      name: z$1.ZodString;
+      label: z$1.ZodString;
+      fieldTypes: z$1.ZodArray<z$1.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        file: "file";
+        slug: "slug";
+        text: "text";
+        integer: "integer";
+        datetime: "datetime";
+        select: "select";
+        multiSelect: "multiSelect";
+        portableText: "portableText";
+        image: "image";
+        reference: "reference";
+        json: "json";
+        repeater: "repeater";
+      }>>;
+      elements: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
+        type: z$1.ZodString;
+        action_id: z$1.ZodString;
+        label: z$1.ZodOptional<z$1.ZodString>;
+      }, z$1.core.$loose>>>;
+    }, z$1.core.$strip>>>;
+  }, z$1.core.$strip>;
+}, z$1.core.$strip>;
+type ValidatedPluginManifest = z$1.infer<typeof pluginManifestSchema>;
 //#endregion
-//#region src/plugins/context.d.ts
-/**
- * Options for creating site info
- */
-interface SiteInfoOptions {
-  /** Site name from options table */
-  siteName?: string;
-  /** Site URL from options table or Astro config */
-  siteUrl?: string;
-  /** Site locale from options table */
-  locale?: string;
-}
-interface PluginContextFactoryOptions {
-  db: Kysely<Database>;
-  /**
-   * Storage backend for direct media uploads.
-   * If not provided, upload() will throw.
-   */
-  storage?: Storage;
-  /**
-   * Function to generate upload URLs for media.
-   * If not provided, media write operations will throw.
-   */
-  getUploadUrl?: (filename: string, contentType: string) => Promise<{
-    uploadUrl: string;
-    mediaId: string;
-  }>;
-  /**
-   * Site information for ctx.site and ctx.url().
-   * If not provided, site info will have empty defaults.
-   */
-  siteInfo?: SiteInfoOptions;
-  /**
-   * Callback to notify the cron scheduler that the next due time may have changed.
-   * If not provided, ctx.cron will not be available.
-   */
-  cronReschedule?: () => void;
-  /**
-   * Email pipeline instance for ctx.email.
-   * If not provided (or no provider configured), ctx.email will be undefined.
-   */
-  emailPipeline?: EmailPipeline;
-  /**
-   * Trusted reverse-proxy headers for request metadata IP extraction.
-   */
-  trustedProxyHeaders?: string[];
+//#region src/config/secrets.d.ts
+interface ParsedEncryptionKey {
+  kid: string;
+  key: Uint8Array;
+  raw: string;
+}
+interface SecretsEnv {
+  DINEWAY_ENCRYPTION_KEY?: string;
+  DINEWAY_PREVIEW_SECRET?: string;
+  PREVIEW_SECRET?: string;
+  DINEWAY_IP_SALT?: string;
+  IP_SALT?: string;
 }
 //#endregion
-//#region src/plugins/routes.d.ts
-/**
- * Result from a route invocation
- */
-interface RouteResult<T = unknown> {
-  success: boolean;
-  data?: T;
-  error?: {
-    code: string;
-    message: string;
-    details?: unknown;
-  };
-  status: number;
+//#region src/plugins/secrets.d.ts
+interface PluginSecretStatus {
+  pluginId: string;
+  name: string;
+  present: true;
+  fingerprint: string;
+  keyId: string;
+  createdAt: string;
+  updatedAt: string;
 }
-/**
- * Route invocation options
- */
-interface InvokeRouteOptions {
-  /** The original request */
-  request: Request;
-  /** Request body (already parsed) */
-  body?: unknown;
+interface PluginSecretStoreOptions {
+  env?: Pick<SecretsEnv, "DINEWAY_ENCRYPTION_KEY">;
+  keys?: readonly ParsedEncryptionKey[];
 }
 /**
- * Error class for plugin routes
- * Allows plugins to return structured errors with specific HTTP status codes
+ * Encrypted storage for trusted plugin credentials.
+ *
+ * Management surfaces must use set/status/list/delete and never echo the value
+ * passed to set. resolveForRuntime is reserved for trusted server-side provider
+ * calls and must not be exposed through plugin routes, MCP, logs, or audit data.
  */
-declare class PluginRouteError extends Error {
-  code: string;
-  status: number;
-  details?: unknown | undefined;
-  constructor(code: string, message: string, status?: number, details?: unknown | undefined);
-  /**
-   * Create a bad request error (400)
-   */
-  static badRequest(message: string, details?: unknown): PluginRouteError;
-  /**
-   * Create an unauthorized error (401)
-   */
-  static unauthorized(message?: string): PluginRouteError;
-  /**
-   * Create a forbidden error (403)
-   */
-  static forbidden(message?: string): PluginRouteError;
-  /**
-   * Create a not found error (404)
-   */
-  static notFound(message?: string): PluginRouteError;
-  /**
-   * Create a conflict error (409)
-   */
-  static conflict(message: string, details?: unknown): PluginRouteError;
-  /**
-   * Create an internal error (500)
-   */
-  static internal(message?: string): PluginRouteError;
+declare class PluginSecretStore {
+  private readonly repository;
+  private readonly keysPromise;
+  constructor(db: Kysely<Database> | Transaction<Database>, options?: PluginSecretStoreOptions);
+  set(pluginId: string, name: string, value: string): Promise<PluginSecretStatus>;
+  status(pluginId: string, name: string): Promise<PluginSecretStatus | null>;
+  list(pluginId: string): Promise<PluginSecretStatus[]>;
+  delete(pluginId: string, name: string): Promise<boolean>;
+  resolveForRuntime(pluginId: string, name: string): Promise<string | null>;
+  private requireKeys;
 }
 //#endregion
+//#region src/plugins/mcp-reviewed-executor.d.ts
+declare function createReviewedPluginMcpCommandExecutor(): PluginMcpCommandExecutor;
+//#endregion
 //#region src/plugins/manager.d.ts
 /**
  * Plugin state in the manager
@@ -2952,6 +3371,18 @@ declare class PluginManager {
    * Run content:afterUnpublish hooks across all active plugins
    */
   runContentAfterUnpublish(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
+  /**
+   * Run content:afterRestore hooks across all active plugins
+   */
+  runContentAfterRestore(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
+  /**
+   * Run content:afterSchedule hooks across all active plugins
+   */
+  runContentAfterSchedule(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
+  /**
+   * Run content:afterUnschedule hooks across all active plugins
+   */
+  runContentAfterUnschedule(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
   /**
    * Run media:beforeUpload hooks across all active plugins
    */
@@ -3108,12 +3539,6 @@ declare class NoopSandboxRunner implements SandboxRunner {
  */
 declare function createNoopSandboxRunner(_options?: SandboxOptions): SandboxRunner;
 //#endregion
-//#region src/plugins/sandbox/runtime-options.d.ts
-interface SandboxRunnerRuntimeOptions extends SandboxOptions {
-  mediaStorage?: Storage;
-  cronReschedule?: () => void;
-}
-//#endregion
 //#region src/plugins/sandbox/node.d.ts
 declare class NodeSandboxRunner implements SandboxRunner {
   private readonly options;
@@ -3457,6 +3882,8 @@ interface GetCommentsOptions {
   collection: string;
   contentId: string;
   threaded?: boolean;
+  reactions?: boolean;
+  sort?: "oldest" | "best";
 }
 interface GetCommentsResult {
   items: PublicComment[];
@@ -3915,6 +4342,8 @@ interface Suggestion {
   collection: string;
   /** Entry ID */
   id: string;
+  /** Entry slug, when available */
+  slug?: string | null;
   /** Entry title */
   title: string;
 }
@@ -4262,6 +4691,13 @@ interface PluginDescriptor<TOptions = Record<string, unknown>> {
   adminPages?: PluginAdminPage[];
   /** Dashboard widgets */
   adminWidgets?: PluginDashboardWidget[];
+  /**
+   * Portable Text block types this plugin contributes to the editor.
+   * Declarative Block Kit config consumed from the admin manifest.
+   */
+  portableTextBlocks?: PortableTextBlockConfig[];
+  /** Field widget types this plugin contributes for schema-field editing UIs. */
+  fieldWidgets?: FieldWidgetConfig[];
   /**
    * Capabilities the plugin requests.
    * For standard-format plugins, capabilities are enforced in both trusted and
@@ -4317,6 +4753,33 @@ interface DinewayConfig {
    * Storage configuration (for media)
    */
   storage?: StorageDescriptor;
+  /**
+   * Optional object cache for public query results.
+   *
+   * This cache is disabled by default. When configured, it sits beneath
+   * request-scoped caching and above the database for anonymous, non-preview,
+   * non-edit reads. Preview, visual editing, and isolated playground databases
+   * bypass it so editors always see live data.
+   *
+   * @example
+   * ```ts
+   * import { memoryCache } from "dineway/astro";
+   *
+   * dineway({
+   *   objectCache: memoryCache({ defaultTtl: 600 }),
+   * })
+   * ```
+   */
+  objectCache?: ObjectCacheDescriptor;
+  /**
+   * Image optimization.
+   *
+   * By default Dineway wraps Astro's image endpoint so storage-backed media can
+   * be optimized through the normal `<Image>` / `getImage` pipeline while
+   * loading source bytes directly from the storage adapter. Set to `false` to
+   * leave Astro's image endpoint untouched.
+   */
+  images?: boolean;
   /**
    * Trusted plugins to load (run in main isolate)
    *
@@ -4615,4 +5078,4 @@ declare global {
   var __dinewayConfig: DinewayConfig | undefined;
 }
 //#endregion
-export { CreateMenuItemInput as $, PortableTextMarkDef as $n, handleContentUnpublish as $r, createFilePreviewMiddleware as $t, UpdateWidgetInput as A, ParseResult as Ai, ResolvePathResult as An, RevisionListResponse as Ar, GeneratePreviewTokenOptions as At, getTerm as B, FieldDescriptor as Bi, FieldAnnotation as Bn, handleContentCreate as Br, SandboxNotAvailableError as Bt, getWidgetArea as C, WhereRange as Ci, CollectionFilter as Cn, MediaListResponse as Cr, renderPreviewLoadingPage as Ct, CreateWidgetInput as D, DatabaseConfig as Di, EditFieldMeta as Dn, handleMediaGet as Dr, GetPreviewUrlOptions as Dt, CreateWidgetAreaInput as E, getDb as Ei, DinewayCollections as En, handleMediaDelete as Er, isPreviewRequest as Et, getEntriesByTerm as F, apiSuccess as Fi, getEditMeta as Fn, generateManifest as Fr, parseContentId as Ft, TaxonomyTermRow as G, computeContentHash as Gn, handleContentGetIncludingTrashed as Gr, EmailPipeline as Gt, CreateTermInput as H, ManifestResponse as Hi, createNoop as Hn, handleContentDiscardDraft as Hr, PluginManager as Ht, getEntryTerms as I, handleError as Ii, getTranslations as In, handleContentAuthors as Ir, verifyPreviewToken as It, getBylineBySlug as J, prosemirrorToPortableText as Jn, handleContentPermanentDelete as Jr, createHookPipeline as Jt, UpdateTermInput as K, hashString as Kn, handleContentList as Kr, HookPipeline as Kt, getTaxonomyDef as L, ApiContext as Li, resolveDinewayPath as Ln, handleContentCompare as Lr, NodeSandboxRunner as Lt, WidgetArea as M, parseBody as Mi, TranslationsResult as Mn, handleRevisionGet as Mr, VerifyPreviewTokenOptions as Mt, WidgetComponentDef as N, parseQuery as Ni, getDinewayCollection as Nn, handleRevisionList as Nr, VerifyPreviewTokenResult as Nt, PropDef as O, DinewayDatabaseError as Oi, EntryResult as On, handleMediaList as Or, buildPreviewUrl as Ot, WidgetType as P, apiError as Pi, getDinewayEntry as Pn, handleRevisionRestore as Pr, generatePreviewToken as Pt, CreateMenuInput as Q, PortableTextLinkMark as Qn, handleContentTranslations as Qr, FilePreviewMiddlewareConfig as Qt, getTaxonomyDefs as R, ContentListResponse as Ri, CMSAnnotation as Rn, handleContentCountScheduled as Rr, createNodeSandboxRunner as Rt, Suggestion as S, EntryFilter as Si, CacheHint as Sn, SchemaRegistry as Sr, Snapshot as St, getWidgetComponents as T, dinewayLoader as Ti, ContentEntry as Tn, handleMediaCreate as Tr, getPreviewToken as Tt, TaxonomyDef as U, isSafeHref as Un, handleContentDuplicate as Ur, createPluginManager as Ut, getTermsForEntries as V, ListResponse as Vi, createEditable as Vn, handleContentDelete as Vr, createNoopSandboxRunner as Vt, TaxonomyTerm as W, sanitizeHref as Wn, handleContentGet as Wr, PluginRouteError as Wt, getMenu as X, PortableTextHtmlBlock as Xn, handleContentRestore as Xr, pluginManifestSchema as Xt, getEntriesByByline as Y, PortableTextCodeBlock as Yn, handleContentPublish as Yr, ValidatedPluginManifest as Yt, getMenus as Z, PortableTextImageBlock as Zn, handleContentSchedule as Zr, definePlugin as Zt, SearchOptions as _, MediaItem as _i, getFallbackChain as _n, Section as _r, AppliedSnapshotMeta as _t, S3StorageConfig as a, FieldDefinition as ai, SessionDatabaseInfo as an, ProseMirrorNode as ar, UpdateMenuItemInput as at, SearchStats as b, CollectionFilter$1 as bi, AfterCallback as bn, getCollectionInfo as br, dropSessionDatabaseTables as bt, extractSearchableFields as c, ImageValue as ci, SessionOpenOrCreateOptions as cn, SandboxOptions as cr, getCommentCount as ct, search as d, CreateRelationInput as di, buildPreviewSignatureHeader as dn, SandboxedPlugin as dr, getPluginSettings as dt, handleContentUnschedule as ei, FileSessionDatabaseFactory as en, PortableTextSpan as er, Menu as et, searchCollection as f, Relation as fi, defaultPreviewSidecarClient as fn, SerializedRequest as fr, getSiteSetting as ft, SearchConfig as g, CreateMediaInput as gi, I18nConfig as gn, GetSectionsOptions as gr, renderPreviewToolbar as gt, CollectionSearchOptions as h, PublicComment as hi, verifyPreviewSignature as hn, CreateSectionInput as hr, PreviewToolbarConfig as ht, LocalStorageConfig as i, image as ii, SessionDatabaseHandle as in, ProseMirrorMark as ir, UpdateMenuInput as it, Widget as j, isParseError as ji, TranslationSummary as jn, RevisionResponse as jr, PreviewTokenPayload as jt, ReorderWidgetsInput as k, OptionsRepository as ki, InferCollectionData as kn, handleMediaUpdate as kr, getPreviewUrl as kt, getSearchStats as l, PortableTextBlock$1 as li, PreviewSidecarClient as ln, SandboxRunner as lr, getComments as lt, FTSManager as m, UpdateRelationInput as mi, signPreviewUrl as mn, getSections as mr, setSiteSettings as mt, PluginDescriptor as n, portableText as ni, SessionCleanupResult as nn, PortableTextUnknownBlock as nr, MenuItemType as nt, StorageDescriptor as o, FieldUIHints as oi, SessionDatabaseLimitError as on, SandboxEmailMessage as or, GetCommentsOptions as ot, searchWithDb as p, RelationRepository as pi, parsePreviewSignatureHeader as pn, getSection as pr, getSiteSettings as pt, getByline as q, portableTextToProsemirror as qn, handleContentListTrashed as qr, HookResult as qt, getStoredConfig as r, reference as ri, SessionDatabaseFactory as rn, ProseMirrorDocument as rr, ReorderMenuItemsInput as rt, extractPlainText as s, FileValue as si, SessionOpenOptions as sn, SandboxEmailSendCallback as sr, GetCommentsResult as st, DinewayConfig as t, handleContentUpdate as ti, FileSessionDatabaseFactoryOptions as tn, PortableTextTextBlock as tr, MenuItem as tt, getSuggestions as u, ContentReference as ui, PreviewSidecarSignature as un, SandboxRunnerFactory as ur, getPluginSetting as ut, SearchResponse as v, MediaRepository as vi, getI18nConfig as vn, SectionSource as vr, ApplySnapshotToDatabaseOptions as vt, getWidgetAreas as w, WhereValue as wi, CollectionResult as wn, MediaResponse as wr, isBlockedInPreview as wt, SuggestOptions as x, EntryData as xi, after as xn, SchemaError as xr, getAppliedSnapshotMeta as xt, SearchResult as y, ContentRepository as yi, isI18nEnabled as yn, UpdateSectionInput as yr, applySnapshotToDatabase as yt, getTaxonomyTerms as z, ContentResponse as zi, EditProxy as zn, handleContentCountTrashed as zr, NoopSandboxRunner as zt };
+export { CreateMenuItemInput as $, EntryData as $i, createEditable as $n, SandboxedPluginEntry as $r, FileSessionDatabaseFactory as $t, UpdateWidgetInput as A, handleContentTranslations as Ai, invalidateTaxonomyObjectCache as An, getSection as Ar, GeneratePreviewTokenOptions as At, getTerm as B, ImageValue as Bi, EntryResult as Bn, MediaListResponse as Br, SandboxNotAvailableError as Bt, getWidgetArea as C, handleContentGetIncludingTrashed as Ci, contentNamespaces as Cn, PortableTextMarkDef as Cr, renderPreviewLoadingPage as Ct, CreateWidgetInput as D, handleContentPublish as Di, invalidateMenuObjectCache as Dn, ProseMirrorDocument as Dr, GetPreviewUrlOptions as Dt, CreateWidgetAreaInput as E, handleContentPermanentDelete as Ei, invalidateCommentObjectCache as En, PortableTextUnknownBlock as Er, isPreviewRequest as Et, getEntriesByTerm as F, reference as Fi, CollectionFilter as Fn, SectionSource as Fr, parseContentId as Ft, TaxonomyTermRow as G, RelationRepository as Gi, getDinewayCollection as Gn, handleMediaList as Gr, PluginSecretStatus as Gt, CreateTermInput as H, ContentReference as Hi, ResolvePathResult as Hn, handleMediaCreate as Hr, PluginManager as Ht, getEntryTerms as I, image as Ii, CollectionResult as In, UpdateSectionInput as Ir, verifyPreviewToken as It, getBylineBySlug as J, CreateMediaInput as Ji, getTranslations as Jn, RevisionResponse as Jr, ValidatedPluginManifest as Jt, UpdateTermInput as K, UpdateRelationInput as Ki, getDinewayEntry as Kn, handleMediaUpdate as Kr, PluginSecretStore as Kt, getTaxonomyDef as L, FieldDefinition as Li, ContentEntry as Ln, getCollectionInfo as Lr, NodeSandboxRunner as Lt, WidgetArea as M, handleContentUnschedule as Mi, AfterCallback as Mn, CreateSectionInput as Mr, VerifyPreviewTokenOptions as Mt, WidgetComponentDef as N, handleContentUpdate as Ni, after as Nn, GetSectionsOptions as Nr, VerifyPreviewTokenResult as Nt, PropDef as O, handleContentRestore as Oi, invalidateObjectCache as On, ProseMirrorMark as Or, buildPreviewUrl as Ot, WidgetType as P, portableText as Pi, CacheHint as Pn, Section as Pr, generatePreviewToken as Pt, CreateMenuInput as Q, CollectionFilter$1 as Qi, FieldAnnotation as Qn, generateManifest as Qr, createFilePreviewMiddleware as Qt, getTaxonomyDefs as R, FieldUIHints as Ri, DinewayCollections as Rn, SchemaError as Rr, createNodeSandboxRunner as Rt, Suggestion as S, handleContentGet as Si, contentNamespace as Sn, PortableTextLinkMark as Sr, Snapshot as St, getWidgetComponents as T, handleContentListTrashed as Ti, invalidateCollectionCache as Tn, PortableTextTextBlock as Tr, getPreviewToken as Tt, TaxonomyDef as U, CreateRelationInput as Ui, TranslationSummary as Un, handleMediaDelete as Ur, createPluginManager as Ut, getTermsForEntries as V, PortableTextBlock$1 as Vi, InferCollectionData as Vn, MediaResponse as Vr, createNoopSandboxRunner as Vt, TaxonomyTerm as W, Relation as Wi, TranslationsResult as Wn, handleMediaGet as Wr, createReviewedPluginMcpCommandExecutor as Wt, getMenu as X, MediaRepository as Xi, CMSAnnotation as Xn, handleRevisionList as Xr, definePlugin as Xt, getEntriesByByline as Y, MediaItem as Yi, resolveDinewayPath as Yn, handleRevisionGet as Yr, pluginManifestSchema as Yt, getMenus as Z, ContentRepository as Zi, EditProxy as Zn, handleRevisionRestore as Zr, FilePreviewMiddlewareConfig as Zt, SearchOptions as _, ContentResponse as _a, handleContentCountTrashed as _i, getI18nConfig as _n, portableTextToProsemirror as _r, AppliedSnapshotMeta as _t, S3StorageConfig as a, DatabaseConfig as aa, SandboxRunnerFactory as ai, SessionDatabaseLimitError as an, IssuedGuestAccessToken as ar, UpdateMenuItemInput as at, SearchStats as b, ManifestResponse as ba, handleContentDiscardDraft as bi, CachedQueryOptions as bn, PortableTextHtmlBlock as br, dropSessionDatabaseTables as bt, extractSearchableFields as c, ParseResult as ca, PluginMcpRegistry as ci, PreviewSidecarClient as cn, hashGuestAccessToken as cr, getCommentCount as ct, search as d, parseQuery as da, HookResult as di, defaultPreviewSidecarClient as dn, RateLimitResult as dr, getPluginSettings as dt, EntryFilter as ea, PluginRouteError as ei, FileSessionDatabaseFactoryOptions as en, createNoop as er, Menu as et, searchCollection as f, apiError as fa, createHookPipeline as fi, parsePreviewSignatureHeader as fn, checkRateLimit as fr, getSiteSetting as ft, SearchConfig as g, ContentListResponse as ga, handleContentCountScheduled as gi, getFallbackChain as gn, hashString as gr, renderPreviewToolbar as gt, CollectionSearchOptions as h, ApiContext as ha, handleContentCompare as hi, I18nConfig as hn, computeContentHash as hr, PreviewToolbarConfig as ht, LocalStorageConfig as i, getDb as ia, SandboxRunner as ii, SessionDatabaseInfo as in, IssueGuestAccessTokenOptions as ir, UpdateMenuInput as it, Widget as j, handleContentUnpublish as ji, isObjectCacheActive as jn, getSections as jr, PreviewTokenPayload as jt, ReorderWidgetsInput as k, handleContentSchedule as ki, invalidateSchemaObjectCache as kn, ProseMirrorNode as kr, getPreviewUrl as kt, getSearchStats as l, isParseError as la, PluginMcpTargetAuthorizer as li, PreviewSidecarSignature as ln, issueGuestAccessToken as lr, getComments as lt, FTSManager as m, handleError as ma, handleContentAuthors as mi, verifyPreviewSignature as mn, sanitizeHref as mr, setSiteSettings as mt, PluginDescriptor as n, WhereValue as na, SandboxEmailSendCallback as ni, SessionDatabaseFactory as nn, GuestAccessTokenClaims as nr, MenuItemType as nt, StorageDescriptor as o, DinewayDatabaseError as oa, SandboxedPlugin as oi, SessionOpenOptions as on, VerifyGuestAccessTokenOptions as or, GetCommentsOptions as ot, searchWithDb as p, apiSuccess as pa, EmailPipeline as pi, signPreviewUrl as pn, isSafeHref as pr, getSiteSettings as pt, getByline as q, PublicComment as qi, getEditMeta as qn, RevisionListResponse as qr, PluginSecretStoreOptions as qt, getStoredConfig as r, dinewayLoader as ra, SandboxOptions as ri, SessionDatabaseHandle as rn, GuestAccessTokenConfigurationError as rr, ReorderMenuItemsInput as rt, extractPlainText as s, OptionsRepository as sa, SerializedRequest as si, SessionOpenOrCreateOptions as sn, VerifyGuestAccessTokenResult as sr, GetCommentsResult as st, DinewayConfig as t, WhereRange as ta, SandboxEmailMessage as ti, SessionCleanupResult as tn, GuestAccessExpectedScope as tr, MenuItem as tt, getSuggestions as u, parseBody as ua, HookPipeline as ui, buildPreviewSignatureHeader as un, verifyGuestAccessToken as ur, getPluginSetting as ut, SearchResponse as v, FieldDescriptor as va, handleContentCreate as vi, isI18nEnabled as vn, prosemirrorToPortableText as vr, ApplySnapshotToDatabaseOptions as vt, getWidgetAreas as w, handleContentList as wi, invalidateBylineObjectCache as wn, PortableTextSpan as wr, isBlockedInPreview as wt, SuggestOptions as x, handleContentDuplicate as xi, cachedQuery as xn, PortableTextImageBlock as xr, getAppliedSnapshotMeta as xt, SearchResult as y, ListResponse as ya, handleContentDelete as yi, CacheNamespace as yn, PortableTextCodeBlock as yr, applySnapshotToDatabase as yt, getTaxonomyTerms as z, FileValue as zi, EditFieldMeta as zn, SchemaRegistry as zr, NoopSandboxRunner as zt };