dineway 0.1.48 → 0.2.0

package/dist/{runtime-DEWQpZ-4.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-eu5UDgHN.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-CwRuZ-u8.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";
 
@@ -227,6 +229,139 @@ interface DatabaseConfig {
   authToken?: string;
 }
 //#endregion
+//#region src/loader.d.ts
+/**
+ * Entry data type - generic object
+ */
+type EntryData = Record<string, unknown>;
+/**
+ * Sort direction
+ */
+type SortDirection$1 = "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
+ */
+type OrderBySpec$1 = Record<string, SortDirection$1>;
+/**
+ * Range filter for comparison operators on field values.
+ * ISO 8601 timestamps sort lexicographically in the same order as time.
+ */
+interface WhereRange {
+  gt?: string;
+  gte?: string;
+  lt?: string;
+  lte?: string;
+}
+type WhereValue = string | string[] | WhereRange;
+/**
+ * Fields shared by every collection filter, independent of pagination mode.
+ */
+interface CollectionFilterBase$1 {
+  type: string;
+  status?: "draft" | "published" | "archived";
+  limit?: number;
+  /**
+   * Filter by field values, taxonomy terms, byline credits, or ranges.
+   *
+   * 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. Other keys are treated as content table
+   * column filters.
+   */
+  where?: Record<string, WhereValue>;
+  /** Case-insensitive substring search across the provided columns. */
+  q?: string;
+  searchColumns?: string[];
+  /**
+   * Order results by field(s)
+   * @default { created_at: "desc" }
+   */
+  orderBy?: OrderBySpec$1;
+  /**
+   * Filter by locale (e.g. 'en', 'fr').
+   * When set, only returns content in this locale.
+   */
+  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
+ */
+interface EntryFilter {
+  type: string;
+  id: string;
+  /**
+   * When set, fetch content data from this revision instead of the content table.
+   * Used by preview mode to serve draft revision data.
+   */
+  revisionId?: string;
+  /**
+   * Locale to scope slug lookup. Only affects slug resolution;
+   * IDs are globally unique and always resolve regardless of locale.
+   */
+  locale?: string;
+}
+/**
+ * Get the database instance. Used by query wrapper functions and middleware.
+ *
+ * Checks the ALS request context first — if a per-request DB override is set
+ * (e.g. by preview or playground middleware), it takes precedence over the
+ * module-level cached instance. This allows preview flows to route queries
+ * to an isolated session database without modifying any calling code.
+ *
+ * Initializes the default database on first call using config from virtual module.
+ */
+declare function getDb(): Promise<Kysely<Database>>;
+/**
+ * Create a Dineway Live Collections loader
+ *
+ * This loader handles ALL content types in a single Astro collection.
+ * Use `getDinewayCollection()` and `getDinewayEntry()` to query
+ * specific content types.
+ *
+ * Database is configured in astro.config.mjs via the dineway() integration.
+ *
+ * @example
+ * ```ts
+ * // src/live.config.ts
+ * import { defineLiveCollection } from "astro:content";
+ * import { dinewayLoader } from "dineway";
+ *
+ * export const collections = {
+ *   dineway: defineLiveCollection({
+ *     loader: dinewayLoader(),
+ *   }),
+ * };
+ * ```
+ */
+declare function dinewayLoader(): LiveLoader<EntryData, EntryFilter, CollectionFilter$1>;
+//#endregion
 //#region src/database/repositories/content.d.ts
 /**
  * Repository for content CRUD operations
@@ -301,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.
    */
@@ -490,6 +625,8 @@ declare class MediaRepository {
     width?: number;
     height?: number;
     size?: number;
+    blurhash?: string;
+    dominantColor?: string;
   }): Promise<MediaItem | null>;
   /**
    * Mark upload as failed
@@ -561,6 +698,7 @@ interface PublicComment {
   isRegisteredUser: boolean;
   body: string;
   createdAt: string;
+  reactions?: Record<string, number>;
   replies?: PublicComment[];
 }
 //#endregion
@@ -806,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).
@@ -819,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
@@ -895,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>;
+//#region src/plugins/email.d.ts
 /**
- * Generate admin manifest from collections
+ * EmailPipeline orchestrates email delivery through the plugin hook system.
+ *
+ * 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 function generateManifest(collections: CollectionMap, plugins?: Record<string, {
-  adminPages?: Array<{
-    path: string;
-    component: string;
-  }>;
-  widgets?: string[];
-}>): Promise<ManifestResponse>;
+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;
+}
 //#endregion
-//#region src/api/handlers/revision.d.ts
-interface RevisionListResponse {
-  items: Revision[];
-  total: number;
+//#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 RevisionResponse {
-  item: Revision;
+interface PluginContextFactoryOptions {
+  db: Kysely<Database>;
+  /**
+   * 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.
+   */
+  getDb?: () => 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[];
 }
+//#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";
 /**
- * List revisions for a content entry
+ * Hook execution result
  */
-declare function handleRevisionList(db: Kysely<Database>, collection: string, entryId: string, params?: {
-  limit?: number;
-}): Promise<ApiResult<RevisionListResponse>>;
+interface HookResult<T> {
+  success: boolean;
+  value?: T;
+  error?: Error;
+  pluginId: string;
+  duration: number;
+}
 /**
- * Get a specific revision
+ * Hook pipeline for executing hooks in order
  */
-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);
-}
-/**
- * Schema Registry
- *
- * Manages collection and field definitions stored in the database.
- * Handles runtime DDL operations (CREATE TABLE, ALTER TABLE).
- */
-declare class SchemaRegistry {
-  private db;
-  constructor(db: Kysely<Database>);
+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;
   /**
-   * List all collections
+   * Selected provider plugin ID for each exclusive hook.
+   * Set by the PluginManager after resolution.
    */
-  listCollections(): Promise<Collection[]>;
+  private exclusiveSelections;
+  constructor(plugins: ResolvedPlugin[], factoryOptions?: PluginContextFactoryOptions);
   /**
-   * List all collections with their fields using bounded query shapes.
+   * 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`).
    */
-  listCollectionsWithFields(): Promise<CollectionWithFields[]>;
+  setContextFactory(options: Partial<PluginContextFactoryOptions>): void;
   /**
-   * Get a collection by slug
+   * Get context for a plugin
    */
-  getCollection(slug: string): Promise<Collection | null>;
+  private getContext;
   /**
-   * Get a collection with all its fields
+   * 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.
    */
-  getCollectionWithFields(slug: string): Promise<CollectionWithFields | null>;
+  private getTypedHooks;
   /**
-   * Create a new collection
+   * 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.
    */
-  createCollection(input: CreateCollectionInput): Promise<Collection>;
+  private registerPlugins;
   /**
-   * Update a collection
+   * 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.
    */
-  updateCollection(slug: string, input: UpdateCollectionInput): Promise<Collection>;
-  private validateUrlPattern;
-  private checkLabelUniqueness;
-  private checkUrlPatternUniqueness;
+  private static readonly HOOK_REQUIRED_CAPABILITY;
   /**
-   * Delete a collection
+   * Register a single plugin's hook by name
    */
-  deleteCollection(slug: string, options?: {
-    force?: boolean;
-  }): Promise<void>;
+  private registerPluginHook;
   /**
-   * List fields for a collection
+   * Register a single hook
    */
-  listFields(collectionId: string): Promise<Field[]>;
+  private registerHook;
   /**
-   * Get a field by slug within a collection
+   * Sort hooks by priority and dependencies
    */
-  getField(collectionSlug: string, fieldSlug: string): Promise<Field | null>;
+  private sortHooks;
   /**
-   * Create a new field
+   * Execute a hook with timeout
    */
-  createField(collectionSlug: string, input: CreateFieldInput): Promise<Field>;
+  private executeWithTimeout;
   /**
-   * 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.
+   * Run plugin:install hooks
    */
-  ensureCollectionContentTable(collectionSlug: string): Promise<boolean>;
+  runPluginInstall(pluginId: string): Promise<HookResult<void>[]>;
   /**
-   * 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.
+   * Run plugin:activate hooks
    */
-  ensureFieldColumn(collectionSlug: string, fieldSlug: string): Promise<boolean>;
+  runPluginActivate(pluginId: string): Promise<HookResult<void>[]>;
   /**
-   * Update a field
+   * Run plugin:deactivate hooks
    */
-  updateField(collectionSlug: string, fieldSlug: string, input: UpdateFieldInput): Promise<Field>;
+  runPluginDeactivate(pluginId: string): Promise<HookResult<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.
+   * Run plugin:uninstall hooks
    */
-  private syncSearchState;
+  runPluginUninstall(pluginId: string, deleteData: boolean): Promise<HookResult<void>[]>;
+  private runLifecycleHook;
   /**
-   * Delete a field
+   * Run content:beforeSave hooks
+   * Returns modified content from the pipeline
    */
-  deleteField(collectionSlug: string, fieldSlug: string): Promise<void>;
+  runContentBeforeSave(content: Record<string, unknown>, collection: string, isNew: boolean): Promise<{
+    content: Record<string, unknown>;
+    results: HookResult<Record<string, unknown>>[];
+  }>;
   /**
-   * Reorder fields
+   * Run content:afterSave hooks
    */
-  reorderFields(collectionSlug: string, fieldSlugs: string[]): Promise<void>;
+  runContentAfterSave(content: Record<string, unknown>, collection: string, isNew: boolean): Promise<HookResult<void>[]>;
   /**
-   * Create a content table for a collection
+   * Run content:beforeDelete hooks
+   * Returns whether deletion is allowed
    */
-  private createContentTable;
+  runContentBeforeDelete(id: string, collection: string): Promise<{
+    allowed: boolean;
+    results: HookResult<boolean>[];
+  }>;
   /**
-   * Drop a content table
+   * Run content:afterDelete hooks
    */
-  private dropContentTable;
+  runContentAfterDelete(id: string, collection: string, permanent: boolean): Promise<HookResult<void>[]>;
   /**
-   * Add a column to a content table
+   * Run content:afterPublish hooks (fire-and-forget).
    */
-  private addColumn;
+  runContentAfterPublish(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
   /**
-   * Drop a column from a content table
+   * Run content:afterUnpublish hooks (fire-and-forget).
    */
-  private dropColumn;
+  runContentAfterUnpublish(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
   /**
-   * Check if a collection has any content
+   * Run content:afterRestore hooks (fire-and-forget).
    */
-  private collectionHasContent;
+  runContentAfterRestore(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
   /**
-   * Get table name for a collection
+   * Run content:afterSchedule hooks (fire-and-forget).
    */
-  private getTableName;
+  runContentAfterSchedule(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
   /**
-   * Get column name for a field
+   * Run content:afterUnschedule hooks (fire-and-forget).
    */
-  private getColumnName;
+  runContentAfterUnschedule(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
+  private runContentStateChangeHook;
   /**
-   * Validate a slug
+   * Run media:beforeUpload hooks
    */
-  private validateSlug;
+  runMediaBeforeUpload(file: {
+    name: string;
+    type: string;
+    size: number;
+  }): Promise<{
+    file: {
+      name: string;
+      type: string;
+      size: number;
+    };
+    results: HookResult<{
+      name: string;
+      type: string;
+      size: number;
+    }>[];
+  }>;
   /**
-   * 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 (`''`).
+   * Run media:afterUpload hooks
    */
-  private formatDefaultValue;
+  runMediaAfterUpload(media: {
+    id: string;
+    filename: string;
+    mimeType: string;
+    size: number | null;
+    url: string;
+    createdAt: string;
+  }): Promise<HookResult<void>[]>;
   /**
-   * Get empty default for a field type
+   * 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.
    */
-  private getEmptyDefault;
+  invokeCronHook(pluginId: string, event: CronEvent): Promise<HookResult<void>>;
   /**
-   * Map a collection row to a Collection object
+   * 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.
    */
-  private mapCollectionRow;
+  runEmailBeforeSend(message: EmailMessage, source: string): Promise<{
+    message: EmailMessage | false;
+    results: HookResult<EmailMessage | false>[];
+  }>;
   /**
-   * Map a field row to a Field object
+   * Run email:afterSend hooks (fire-and-forget).
+   *
+   * Errors are logged but don't propagate — they don't affect the caller.
    */
-  private mapFieldRow;
+  runEmailAfterSend(message: EmailMessage, source: string): Promise<HookResult<void>[]>;
   /**
-   * Discover orphaned content tables
+   * Run comment:beforeCreate hooks (middleware pipeline).
    *
-   * Finds ec_* tables that exist in the database but don't have a
-   * corresponding entry in _dineway_collections.
+   * 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.
    */
-  discoverOrphanedTables(): Promise<Array<{
-    slug: string;
-    tableName: string;
-    rowCount: number;
-  }>>;
+  runCommentBeforeCreate(event: CommentBeforeCreateEvent): Promise<CommentBeforeCreateEvent | false>;
   /**
-   * Register an orphaned table as a collection
+   * Run comment:afterCreate hooks (fire-and-forget).
    *
-   * Creates a _dineway_collections entry for an existing ec_* table.
+   * Errors are logged but don't propagate — they don't affect the caller.
    */
-  registerOrphanedTable(slug: string, options?: {
-    label?: string;
-    labelSingular?: string;
-    description?: string;
-  }): Promise<Collection>;
+  runCommentAfterCreate(event: CommentAfterCreateEvent): Promise<void>;
   /**
-   * Convert slug to human-readable label
+   * Run comment:afterModerate hooks (fire-and-forget).
+   *
+   * Errors are logged but don't propagate — they don't affect the caller.
    */
-  private slugToLabel;
+  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
+   */
+  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>;
 }
-//#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
- * }
- * ```
+ * Create a hook pipeline from plugins
  */
-declare function getCollectionInfo(slug: string): Promise<Collection | null>;
+declare function createHookPipeline(plugins: ResolvedPlugin[], factoryOptions?: PluginContextFactoryOptions): HookPipeline;
 //#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;
-}
-/**
- * Options for querying sections
- */
-interface GetSectionsOptions {
-  /** Filter by source */
-  source?: SectionSource;
-  /** Search title, description, keywords */
-  search?: string;
-  /** Limit results */
-  limit?: number;
-  /** Cursor for pagination */
-  cursor?: string;
+//#region src/plugins/mcp.d.ts
+interface RegisteredPluginMcpTool {
+  pluginId: string;
+  pluginVersion: string;
+  tool: PluginMcpTool;
+  authorizeTarget?: PluginMcpTargetAuthorizer$1;
 }
-//#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>>;
+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
 /**
@@ -1384,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.
@@ -1430,1429 +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;
+interface SandboxedPluginEntry {
+  id: string;
+  version: string;
+  options: Record<string, unknown>;
+  code: 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[];
+}
+//#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[];
   };
-  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;
 }
+type CollectionMap = Record<string, CollectionDefinition>;
 /**
- * Code block
+ * Generate admin manifest from collections
  */
-interface PortableTextCodeBlock {
-  _type: "code";
-  _key: string;
-  code: string;
-  language?: string;
-  filename?: string;
+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;
 }
-/**
- * HTML block (raw HTML content)
- */
-interface PortableTextHtmlBlock {
-  _type: "htmlBlock";
-  _key: string;
-  html: string;
+interface RevisionResponse {
+  item: Revision;
 }
 /**
- * Unknown/custom block (preserved for plugin compatibility)
+ * List revisions for a content entry
  */
-interface PortableTextUnknownBlock {
-  _type: string;
-  _key: string;
-  [key: string]: unknown;
-}
+declare function handleRevisionList(db: Kysely<Database>, collection: string, entryId: string, params?: {
+  limit?: number;
+}): Promise<ApiResult<RevisionListResponse>>;
 /**
- * Any Portable Text block
+ * Get a specific revision
  */
-type PortableTextBlock = PortableTextTextBlock | PortableTextImageBlock | PortableTextCodeBlock | PortableTextHtmlBlock | PortableTextUnknownBlock;
+declare function handleRevisionGet(db: Kysely<Database>, revisionId: string): Promise<ApiResult<RevisionResponse>>;
 /**
- * ProseMirror JSON types (simplified for TipTap)
+ * Restore a revision (updates content to this revision's data and creates new revision)
  */
-interface ProseMirrorMark {
-  type: string;
-  attrs?: Record<string, unknown>;
-}
-interface ProseMirrorNode {
-  type: string;
-  attrs?: Record<string, unknown>;
-  content?: ProseMirrorNode[];
-  marks?: ProseMirrorMark[];
-  text?: string;
+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 ProseMirrorDocument {
-  type: "doc";
-  content: ProseMirrorNode[];
+interface MediaResponse {
+  item: MediaItem;
 }
-//#endregion
-//#region src/content/converters/prosemirror-to-portable-text.d.ts
 /**
- * Convert ProseMirror document to Portable Text
+ * List media items
  */
-declare function prosemirrorToPortableText(doc: ProseMirrorDocument): PortableTextBlock[];
-//#endregion
-//#region src/content/converters/portable-text-to-prosemirror.d.ts
+declare function handleMediaList(db: Kysely<Database>, params: {
+  cursor?: string;
+  limit?: number;
+  mimeType?: string | readonly string[];
+  q?: string;
+}): Promise<ApiResult<MediaListResponse>>;
 /**
- * Convert Portable Text to ProseMirror document
+ * Get single media item
  */
-declare function portableTextToProsemirror(blocks: PortableTextBlock[]): ProseMirrorDocument;
-//#endregion
-//#region src/utils/hash.d.ts
+declare function handleMediaGet(db: Kysely<Database>, id: string): Promise<ApiResult<MediaResponse>>;
 /**
- * SHA-256 hash of a string, truncated to 16 hex chars (64 bits).
- * For cache invalidation / ETags — not for security.
+ * Create media item (after file upload)
  */
-declare function hashString(content: string): Promise<string>;
+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>>;
 /**
- * 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
+ * Update media metadata
  */
-declare function computeContentHash(content: Uint8Array | ArrayBuffer): Promise<string>;
+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/utils/url.d.ts
+//#region src/schema/registry.d.ts
 /**
- * URL scheme validation utilities
- *
- * Prevents XSS via dangerous URL schemes (javascript:, data:, vbscript:, etc.)
- * by allowlisting known-safe schemes before rendering into href attributes.
+ * 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);
+}
 /**
- * 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:`.
+ * Schema Registry
  *
- * @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("")                            // "#"
- * ```
- */
-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/loader.d.ts
-/**
- * Entry data type - generic object
- */
-type EntryData = Record<string, unknown>;
-/**
- * Sort direction
- */
-type SortDirection$1 = "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
- */
-type OrderBySpec$1 = Record<string, SortDirection$1>;
-/**
- * Range filter for comparison operators on field values.
- * ISO 8601 timestamps sort lexicographically in the same order as time.
- */
-interface WhereRange {
-  gt?: string;
-  gte?: string;
-  lt?: string;
-  lte?: string;
-}
-type WhereValue = string | string[] | WhereRange;
-/**
- * Filter for loadCollection - type is required
+ * Manages collection and field definitions stored in the database.
+ * Handles runtime DDL operations (CREATE TABLE, ALTER TABLE).
  */
-interface CollectionFilter$1 {
-  type: string;
-  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.
+   * 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. 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.
    */
-  where?: Record<string, WhereValue>;
-  /** Case-insensitive substring search across the provided columns. */
-  q?: string;
-  searchColumns?: string[];
+  ensureCollectionContentTable(collectionSlug: string): Promise<boolean>;
   /**
-   * Order results by field(s)
-   * @default { created_at: "desc" }
+   * 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.
    */
-  orderBy?: OrderBySpec$1;
+  ensureFieldColumn(collectionSlug: string, fieldSlug: string): Promise<boolean>;
   /**
-   * Filter by locale (e.g. 'en', 'fr').
-   * When set, only returns content in this locale.
+   * Update a field
    */
-  locale?: string;
-}
-/**
- * Filter for loadEntry - type and id are required
- */
-interface EntryFilter {
-  type: string;
-  id: string;
+  updateField(collectionSlug: string, fieldSlug: string, input: UpdateFieldInput): Promise<Field>;
   /**
-   * When set, fetch content data from this revision instead of the content table.
-   * Used by preview mode to serve draft revision data.
+   * 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.
    */
-  revisionId?: string;
+  private syncSearchState;
   /**
-   * Locale to scope slug lookup. Only affects slug resolution;
-   * IDs are globally unique and always resolve regardless of locale.
+   * Delete a field
    */
-  locale?: string;
+  deleteField(collectionSlug: string, fieldSlug: string): Promise<void>;
+  /**
+   * Reorder fields
+   */
+  reorderFields(collectionSlug: string, fieldSlugs: string[]): Promise<void>;
+  /**
+   * Create a content table for a collection
+   */
+  private createContentTable;
+  /**
+   * Drop a content table
+   */
+  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
 /**
- * Get the database instance. Used by query wrapper functions and middleware.
- *
- * Checks the ALS request context first — if a per-request DB override is set
- * (e.g. by preview or playground middleware), it takes precedence over the
- * module-level cached instance. This allows preview flows to route queries
- * to an isolated session database without modifying any calling code.
- *
- * Initializes the default database on first call using config from virtual module.
- */
-declare function getDb(): Promise<Kysely<Database>>;
-/**
- * Create a Dineway Live Collections loader
- *
- * This loader handles ALL content types in a single Astro collection.
- * Use `getDinewayCollection()` and `getDinewayEntry()` to query
- * specific content types.
- *
- * Database is configured in astro.config.mjs via the dineway() integration.
+ * Get collection metadata by slug.
  *
  * @example
  * ```ts
- * // src/live.config.ts
- * import { defineLiveCollection } from "astro:content";
- * import { dinewayLoader } from "dineway";
+ * import { getCollectionInfo } from "dineway";
  *
- * export const collections = {
- *   dineway: defineLiveCollection({
- *     loader: dinewayLoader(),
- *   }),
- * };
- * ```
- */
-declare function dinewayLoader(): LiveLoader<EntryData, EntryFilter, CollectionFilter$1>;
+ * const info = await getCollectionInfo("posts");
+ * if (info?.commentsEnabled) {
+ *   // render comment UI
+ * }
+ * ```
+ */
+declare function getCollectionInfo(slug: string): Promise<Collection | null>;
 //#endregion
-//#region src/visual-editing/editable.d.ts
+//#region src/sections/types.d.ts
 /**
- * Visual editing annotation system
- *
- * Creates Proxy objects that emit data-dineway-ref attributes when spread onto elements.
+ * Section source types
  */
-interface CMSAnnotation {
-  collection: string;
+type SectionSource = "theme" | "user" | "import";
+/**
+ * Section as returned to templates/admin
+ */
+interface Section {
   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;
+  slug: string;
+  title: string;
+  description?: string;
+  keywords: string[];
+  content: PortableTextBlock$1[];
+  previewUrl?: string;
+  source: SectionSource;
+  themeId?: string;
+  createdAt: string;
+  updatedAt: string;
 }
-interface EditableOptions {
-  /** Entry status: "draft", "published", "scheduled" */
-  status?: string;
-  /** true when draftRevisionId exists and differs from liveRevisionId */
-  hasDraft?: boolean;
+/**
+ * Input for creating a section
+ */
+interface CreateSectionInput {
+  slug: string;
+  title: string;
+  description?: string;
+  keywords?: string[];
+  content: PortableTextBlock$1[];
+  previewMediaId?: string;
+  source?: SectionSource;
+  themeId?: string;
 }
 /**
- * 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)
+ * Input for updating a section
  */
-declare function createEditable(collection: string, id: string, options?: EditableOptions): EditProxy;
+interface UpdateSectionInput {
+  slug?: string;
+  title?: string;
+  description?: string;
+  keywords?: string[];
+  content?: PortableTextBlock$1[];
+  previewMediaId?: string | null;
+}
 /**
- * Create a noop proxy for production mode.
- * Spreading this produces no attributes.
+ * Options for querying sections
  */
-declare function createNoop(): EditProxy;
+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
 /**
- * Visual editing proxy type.
+ * Get a section by slug
  *
- * Spread directly onto elements for entry-level annotations: `{...entry.edit}`
- * Access a field for field-level annotations: `{...entry.edit.title}`
+ * @example
+ * ```ts
+ * import { getSection } from "dineway";
  *
- * In production, spreading produces no attributes (noop).
+ * const section = await getSection("hero-centered");
+ * if (section) {
+ *   console.log(section.content); // Portable Text array
+ * }
+ * ```
  */
-type EditProxy = {
-  readonly [field: string]: Partial<FieldAnnotation>;
-};
-//#endregion
-//#region src/query.d.ts
+declare function getSection(slug: string): Promise<Section | null>;
 /**
- * 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.
+ * Get all sections with optional filtering
  *
  * @example
  * ```ts
- * // In dineway-env.d.ts (generated):
- * declare module "dineway" {
- *   interface DinewayCollections {
- *     posts: { title: string; content: PortableTextBlock[]; };
- *     pages: { title: string; body: PortableTextBlock[]; };
- *   }
- * }
+ * import { getSections } from "dineway";
  *
- * // Then in your code:
- * const { entries } = await getDinewayCollection("posts");
- * // entries[0].data.title is typed as string
+ * // Get all theme-provided sections
+ * const themeSections = await getSections({ source: "theme" });
+ *
+ * // Search sections
+ * const results = await getSections({ search: "pricing" });
  * ```
  */
-interface DinewayCollections {}
+declare function getSections(options?: GetSectionsOptions): Promise<FindManyResult<Section>>;
+//#endregion
+//#region src/content/converters/types.d.ts
 /**
- * Helper type to infer the data type for a collection.
- * Returns the registered type if known, otherwise falls back to Record<string, unknown>.
+ * Portable Text Types
+ *
+ * Defines the structure of Portable Text blocks used in Dineway.
  */
-type InferCollectionData<T extends string> = T extends keyof DinewayCollections ? DinewayCollections[T] : Record<string, unknown>;
 /**
- * Sort direction
+ * Base span (inline text)
  */
-type SortDirection = "asc" | "desc";
+interface PortableTextSpan {
+  _type: "span";
+  _key: string;
+  text: string;
+  marks?: string[];
+}
 /**
- * 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
+ * Mark definition (bold, italic, link, etc.)
  */
-type OrderBySpec = Record<string, SortDirection>;
-interface CollectionFilter {
-  status?: "draft" | "published" | "archived";
-  limit?: number;
-  /**
-   * 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,
-   * });
-   * ```
-   */
-  cursor?: string;
-  /**
-   * Filter by field values, taxonomy terms, byline credits, or ranges.
-   *
-   * 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.
-   *
-   * @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
-   */
-  where?: Record<string, WhereValue>;
-  /**
-   * Case-insensitive substring search across selected content fields.
-   *
-   * `searchColumns` must contain concrete field slugs or system column names.
-   * When `q` is present without `searchColumns`, no search condition is applied.
-   */
-  q?: string;
-  searchColumns?: string[];
-  /**
-   * 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
-   */
-  orderBy?: OrderBySpec;
-  /**
-   * 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
-   */
-  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;
+interface PortableTextMarkDef {
+  _type: string;
+  _key: string;
+  [key: string]: unknown;
 }
 /**
- * Result from getDinewayCollection
+ * Link mark definition
  */
-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;
-  /**
-   * 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.
-   */
-  nextCursor?: string;
-  /**
-   * Total number of entries matching the current filter, excluding cursor and limit.
-   */
-  total?: number;
+interface PortableTextLinkMark extends PortableTextMarkDef {
+  _type: "link";
+  href: string;
+  blank?: boolean;
 }
 /**
- * Result from getDinewayEntry
+ * Text block (paragraph, heading, etc.)
  */
-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;
+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";
 }
 /**
- * Read edit metadata from a value (returns undefined if not tagged).
- * Uses Object.getOwnPropertyDescriptor to access Symbol-keyed property
- * without an unsafe type assertion.
+ * Image block
  */
-declare function getEditMeta(value: unknown): EditFieldMeta | undefined;
+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;
+}
 /**
- * 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" });
- * ```
+ * Code block
  */
-declare function getDinewayCollection<T extends string, D = InferCollectionData<T>>(type: T, filter?: CollectionFilter): Promise<CollectionResult<D>>;
+interface PortableTextCodeBlock {
+  _type: "code";
+  _key: string;
+  code: string;
+  language?: string;
+  filename?: 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");
- * ```
+ * HTML block (raw HTML content)
  */
-declare function getDinewayEntry<T extends string, D = InferCollectionData<T>>(type: T, id: string, options?: {
-  locale?: string;
-}): Promise<EntryResult<D>>;
+interface PortableTextHtmlBlock {
+  _type: "htmlBlock";
+  _key: string;
+  html: string;
+}
 /**
- * Translation summary for a single locale variant
+ * Unknown/custom block (preserved for plugin compatibility)
  */
-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 PortableTextUnknownBlock {
+  _type: string;
+  _key: string;
+  [key: string]: unknown;
 }
 /**
- * Result from getTranslations
+ * Any Portable Text block
  */
-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;
+type PortableTextBlock = PortableTextTextBlock | PortableTextImageBlock | PortableTextCodeBlock | PortableTextHtmlBlock | PortableTextUnknownBlock;
+/**
+ * ProseMirror JSON types (simplified for TipTap)
+ */
+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
 /**
- * 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" }, ...]
- * ```
+ * Convert ProseMirror document to Portable Text
  */
-declare function getTranslations(type: string, id: string): Promise<TranslationsResult>;
+declare function prosemirrorToPortableText(doc: ProseMirrorDocument): PortableTextBlock[];
+//#endregion
+//#region src/content/converters/portable-text-to-prosemirror.d.ts
 /**
- * Result from resolveDinewayPath
+ * Convert Portable Text to ProseMirror document
  */
-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 portableTextToProsemirror(blocks: PortableTextBlock[]): ProseMirrorDocument;
+//#endregion
+//#region src/utils/hash.d.ts
 /**
- * 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.
+ * 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
  *
- * @example
- * ```ts
- * import { resolveDinewayPath } from "dineway";
+ * 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.
  *
- * // 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
- * }
- * ```
+ * Returns hex string prefixed with "sha1:" for future-proofing
  */
-declare function resolveDinewayPath<T = Record<string, unknown>>(path: string): Promise<ResolvePathResult<T> | null>;
+declare function computeContentHash(content: Uint8Array | ArrayBuffer): Promise<string>;
 //#endregion
-//#region src/after.d.ts
+//#region src/utils/url.d.ts
 /**
- * Defer work past the current synchronous path.
+ * URL scheme validation utilities
  *
- * 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.
+ * Prevents XSS via dangerous URL schemes (javascript:, data:, vbscript:, etc.)
+ * by allowlisting known-safe schemes before rendering into href attributes.
  */
-type AfterCallback = () => void | Promise<void>;
-declare function after(fn: AfterCallback): void;
-//#endregion
-//#region src/i18n/config.d.ts
 /**
- * Dineway i18n Configuration
+ * Returns the URL unchanged if it uses a safe scheme, otherwise returns "#".
  *
- * Reads locale configuration from the virtual module (sourced from Astro config).
- * Initialized during runtime startup, then available via getI18nConfig().
+ * 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("")                            // "#"
+ * ```
  */
-interface I18nConfig {
-  defaultLocale: string;
-  locales: string[];
-  fallback?: Record<string, string>;
-  prefixDefaultLocale?: boolean;
-}
+declare function sanitizeHref(url: string | undefined | null): string;
 /**
- * Get the current i18n config.
- * Returns null if i18n is not configured.
+ * Returns true if the URL uses a safe scheme for rendering in href attributes.
  */
-declare function getI18nConfig(): I18nConfig | null;
+declare function isSafeHref(url: string): boolean;
+//#endregion
+//#region src/auth/rate-limit.d.ts
 /**
- * Check if i18n is enabled.
- * Returns true when multiple locales are configured.
+ * Result of a rate limit check.
  */
-declare function isI18nEnabled(): boolean;
+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;
+}
 /**
- * Resolve fallback locale chain for a given locale.
- * Returns array of locales to try, from most preferred to least.
- * Always ends with defaultLocale.
+ * Check (and increment) the rate limit for a given IP + endpoint.
+ *
+ * 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 function getFallbackChain(locale: string): string[];
+declare function checkRateLimit(db: Kysely<Database>, ip: string | null, endpoint: string, maxRequests: number, windowSeconds: number): Promise<RateLimitResult>;
 //#endregion
-//#region src/preview/sidecar-client.d.ts
-/**
- * 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.
- */
-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;
+//#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;
-  lastTouchedAt: number;
-}
-interface SessionDatabaseHandle {
-  created: boolean;
-  session: SessionDatabaseInfo;
-  db: Kysely<Database>;
-  close(): Promise<void>;
-}
-interface SessionCleanupResult {
-  removedSessionIds: string[];
-  removedPaths: string[];
 }
-interface SessionOpenOptions {
-  id: string;
+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 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 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;
 }
-interface FileSessionDatabaseFactoryOptions {
-  rootDir: string;
-  maxDiskBytes?: number;
-  registryFileName?: string;
-  sessionsDirName?: string;
+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");
 }
-declare class SessionDatabaseLimitError extends Error {
-  constructor(message?: string);
+/**
+ * Issues an expiring capability for one guest purpose and one restaurant target.
+ * Persist only tokenHash/tokenId and revocation metadata; never persist or log token.
+ */
+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;
 }
-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;
+/** The shape returned when spreading an edit annotation onto an element */
+interface FieldAnnotation {
+  "data-dineway-ref": string;
 }
-//#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;
+interface EditableOptions {
+  /** Entry status: "draft", "published", "scheduled" */
+  status?: string;
+  /** true when draftRevisionId exists and differs from liveRevisionId */
+  hasDraft?: boolean;
 }
-declare function createFilePreviewMiddleware(config: FilePreviewMiddlewareConfig): MiddlewareHandler;
-//#endregion
-//#region src/plugins/define-plugin.d.ts
 /**
- * Define a Dineway plugin.
+ * Create an editable proxy for an entry.
  *
- * **Standard format** -- the canonical format for plugins that work in both
- * trusted and sandboxed modes. No id/version -- those come from the descriptor.
+ * 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.
  *
- * @example
- * ```typescript
- * import { definePlugin } from "dineway";
+ * Spread directly onto elements for entry-level annotations: `{...entry.edit}`
+ * Access a field for field-level annotations: `{...entry.edit.title}`
  *
- * 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 }),
- *     },
- *   },
- * });
- * ```
+ * 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.
  *
- * **Native format** -- for plugins that need React admin, direct DB access,
- * or other capabilities not available in the sandbox.
+ * This interface is extended by the generated dineway-env.d.ts file
+ * to provide type inference for collection names and their data shapes.
  *
  * @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
+ * // 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
  * ```
  */
-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
+interface DinewayCollections {}
 /**
- * Zod schema matching the PluginManifest interface from types.ts.
- *
- * Every JSON.parse of a manifest.json should validate through this.
+ * Helper type to infer the data type for a collection.
+ * Returns the registered type if known, otherwise falls back to Record<string, unknown>.
  */
-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";
-        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/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";
+type InferCollectionData<T extends string> = T extends keyof DinewayCollections ? DinewayCollections[T] : Record<string, unknown>;
 /**
- * Hook execution result
+ * Sort direction
  */
-interface HookResult<T> {
-  success: boolean;
-  value?: T;
-  error?: Error;
-  pluginId: string;
-  duration: number;
-}
+type SortDirection = "asc" | "desc";
 /**
- * Hook pipeline for executing hooks in order
+ * 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
  */
-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;
+type OrderBySpec = Record<string, SortDirection>;
+/**
+ * Fields shared by every collection query, independent of pagination mode.
+ */
+interface CollectionFilterBase {
+  status?: "draft" | "published" | "archived";
+  limit?: number;
   /**
-   * 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.
+   * Filter by field values, taxonomy terms, byline credits, or ranges.
    *
-   * 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.
+   * 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.
    *
-   * 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.
+   * @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
    */
-  private registerPlugins;
+  where?: Record<string, WhereValue>;
   /**
-   * Maps hook names to the capability required to register them.
+   * Case-insensitive substring search across selected content fields.
    *
-   * 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
+   * `searchColumns` must contain concrete field slugs or system column names.
+   * When `q` is present without `searchColumns`, no search condition is applied.
    */
-  private sortHooks;
+  q?: string;
+  searchColumns?: string[];
   /**
-   * Execute a hook with timeout
+   * 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
    */
-  private executeWithTimeout;
+  orderBy?: OrderBySpec;
   /**
-   * Run plugin:install hooks
+   * 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
    */
-  runPluginInstall(pluginId: string): Promise<HookResult<void>[]>;
+  locale?: string;
+}
+/** Keyset-paginated query filter. Cannot also carry an offset. */
+interface CursorCollectionFilter extends CollectionFilterBase {
   /**
-   * Run plugin:activate hooks
+   * 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,
+   * });
+   * ```
    */
-  runPluginActivate(pluginId: string): Promise<HookResult<void>[]>;
+  cursor?: string;
+  offset?: never;
+}
+/** Offset-paginated query filter. Cannot also carry a cursor. */
+interface OffsetCollectionFilter extends CollectionFilterBase {
   /**
-   * Run plugin:deactivate hooks
+   * Skip this many entries before returning results. Use with `limit` for
+   * numbered archive routes, for example `offset = (page - 1) * perPage`.
    */
-  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>[]>;
-  /**
-   * 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.
-   */
-  runCommentBeforeCreate(event: CommentBeforeCreateEvent): Promise<CommentBeforeCreateEvent | false>;
-  /**
-   * Run comment:afterCreate hooks (fire-and-forget).
-   *
-   * Errors are logged but don't propagate — they don't affect the caller.
-   */
-  runCommentAfterCreate(event: CommentAfterCreateEvent): Promise<void>;
-  /**
-   * Run comment:afterModerate hooks (fire-and-forget).
-   *
-   * 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
-   */
-  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;
+  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;
 }
 /**
- * Create a hook pipeline from plugins
+ * Result from getDinewayEntry
  */
-declare function createHookPipeline(plugins: ResolvedPlugin[], factoryOptions?: PluginContextFactoryOptions): HookPipeline;
-//#endregion
-//#region src/plugins/email.d.ts
+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;
+}
 /**
- * EmailPipeline orchestrates email delivery through the plugin hook system.
- *
- * 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
+ * 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 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;
+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;
+}
+/**
+ * Get the current i18n config.
+ * Returns null if i18n is not configured.
+ */
+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/preview/sidecar-client.d.ts
+/**
+ * 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.
+ */
+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)
    *
@@ -4497,8 +4960,9 @@ interface DinewayConfig {
    * while the browser uses `https://`, which breaks WebAuthn, CSRF, OAuth, and redirect URLs.
    *
    * Set to the full origin users type in the address bar (no path), e.g.
-   * `https://mysite.example.com`. When not set, falls back to environment variables
-   * `DINEWAY_SITE_URL` > `SITE_URL`, then to the request URL's origin.
+   * `https://mysite.example.com`. `DINEWAY_SITE_URL` is an explicit runtime
+   * override for container deployments; otherwise this falls back to `SITE_URL`,
+   * then to the request URL's origin.
    *
    * Replaces `passkeyPublicOrigin` (which only fixed passkeys).
    */
@@ -4614,4 +5078,4 @@ declare global {
   var __dinewayConfig: DinewayConfig | undefined;
 }
 //#endregion
-export { CreateMenuItemInput as $, hashString as $n, handleContentList as $r, createFilePreviewMiddleware as $t, UpdateWidgetInput as A, ParseResult as Ai, ResolvePathResult as An, MediaListResponse as Ar, GeneratePreviewTokenOptions as At, getTerm as B, FieldDescriptor as Bi, FieldAnnotation as Bn, handleRevisionList as Br, SandboxNotAvailableError as Bt, getWidgetArea as C, CreateMediaInput as Ci, CollectionFilter as Cn, GetSectionsOptions as Cr, renderPreviewLoadingPage as Ct, CreateWidgetInput as D, DatabaseConfig as Di, EditFieldMeta as Dn, getCollectionInfo as Dr, GetPreviewUrlOptions as Dt, CreateWidgetAreaInput as E, ContentRepository as Ei, DinewayCollections as En, UpdateSectionInput as Er, isPreviewRequest as Et, getEntriesByTerm as F, apiSuccess as Fi, getEditMeta as Fn, handleMediaList as Fr, parseContentId as Ft, TaxonomyTermRow as G, EntryFilter as Gn, handleContentCountScheduled as Gr, EmailPipeline as Gt, CreateTermInput as H, ManifestResponse as Hi, createNoop as Hn, generateManifest as Hr, PluginManager as Ht, getEntryTerms as I, handleError as Ii, getTranslations as In, handleMediaUpdate as Ir, verifyPreviewToken as It, getBylineBySlug as J, dinewayLoader as Jn, handleContentDelete as Jr, createHookPipeline as Jt, UpdateTermInput as K, WhereRange as Kn, handleContentCountTrashed as Kr, HookPipeline as Kt, getTaxonomyDef as L, ApiContext as Li, resolveDinewayPath as Ln, RevisionListResponse as Lr, NodeSandboxRunner as Lt, WidgetArea as M, parseBody as Mi, TranslationsResult as Mn, handleMediaCreate as Mr, VerifyPreviewTokenOptions as Mt, WidgetComponentDef as N, parseQuery as Ni, getDinewayCollection as Nn, handleMediaDelete as Nr, VerifyPreviewTokenResult as Nt, PropDef as O, DinewayDatabaseError as Oi, EntryResult as On, SchemaError as Or, buildPreviewUrl as Ot, WidgetType as P, apiError as Pi, getDinewayEntry as Pn, handleMediaGet as Pr, generatePreviewToken as Pt, CreateMenuInput as Q, computeContentHash as Qn, handleContentGetIncludingTrashed as Qr, FilePreviewMiddlewareConfig as Qt, getTaxonomyDefs as R, ContentListResponse as Ri, CMSAnnotation as Rn, RevisionResponse as Rr, createNodeSandboxRunner as Rt, Suggestion as S, PublicComment as Si, CacheHint as Sn, CreateSectionInput as Sr, Snapshot as St, getWidgetComponents as T, MediaRepository as Ti, ContentEntry as Tn, SectionSource as Tr, getPreviewToken as Tt, TaxonomyDef as U, CollectionFilter$1 as Un, handleContentAuthors as Ur, createPluginManager as Ut, getTermsForEntries as V, ListResponse as Vi, createEditable as Vn, handleRevisionRestore as Vr, createNoopSandboxRunner as Vt, TaxonomyTerm as W, EntryData as Wn, handleContentCompare as Wr, PluginRouteError as Wt, getMenu as X, isSafeHref as Xn, handleContentDuplicate as Xr, pluginManifestSchema as Xt, getEntriesByByline as Y, getDb as Yn, handleContentDiscardDraft as Yr, ValidatedPluginManifest as Yt, getMenus as Z, sanitizeHref as Zn, handleContentGet as Zr, definePlugin as Zt, SearchOptions as _, ContentReference as _i, getFallbackChain as _n, SandboxRunnerFactory as _r, AppliedSnapshotMeta as _t, S3StorageConfig as a, handleContentTranslations as ai, SessionDatabaseInfo as an, PortableTextLinkMark as ar, UpdateMenuItemInput as at, SearchStats as b, RelationRepository as bi, AfterCallback as bn, getSection as br, dropSessionDatabaseTables as bt, extractSearchableFields as c, handleContentUpdate as ci, SessionOpenOrCreateOptions as cn, PortableTextTextBlock as cr, getCommentCount as ct, search as d, image as di, buildPreviewSignatureHeader as dn, ProseMirrorMark as dr, getPluginSettings as dt, handleContentListTrashed as ei, FileSessionDatabaseFactory as en, portableTextToProsemirror as er, Menu as et, searchCollection as f, FieldDefinition as fi, defaultPreviewSidecarClient as fn, ProseMirrorNode as fr, getSiteSetting as ft, SearchConfig as g, PortableTextBlock$1 as gi, I18nConfig as gn, SandboxRunner as gr, renderPreviewToolbar as gt, CollectionSearchOptions as h, ImageValue as hi, verifyPreviewSignature as hn, SandboxOptions as hr, PreviewToolbarConfig as ht, LocalStorageConfig as i, handleContentSchedule as ii, SessionDatabaseHandle as in, PortableTextImageBlock as ir, UpdateMenuInput as it, Widget as j, isParseError as ji, TranslationSummary as jn, MediaResponse as jr, PreviewTokenPayload as jt, ReorderWidgetsInput as k, OptionsRepository as ki, InferCollectionData as kn, SchemaRegistry as kr, getPreviewUrl as kt, getSearchStats as l, portableText as li, PreviewSidecarClient as ln, PortableTextUnknownBlock as lr, getComments as lt, FTSManager as m, FileValue as mi, signPreviewUrl as mn, SandboxEmailSendCallback as mr, setSiteSettings as mt, PluginDescriptor as n, handleContentPublish as ni, SessionCleanupResult as nn, PortableTextCodeBlock as nr, MenuItemType as nt, StorageDescriptor as o, handleContentUnpublish as oi, SessionDatabaseLimitError as on, PortableTextMarkDef as or, GetCommentsOptions as ot, searchWithDb as p, FieldUIHints as pi, parsePreviewSignatureHeader as pn, SandboxEmailMessage as pr, getSiteSettings as pt, getByline as q, WhereValue as qn, handleContentCreate as qr, HookResult as qt, getStoredConfig as r, handleContentRestore as ri, SessionDatabaseFactory as rn, PortableTextHtmlBlock as rr, ReorderMenuItemsInput as rt, extractPlainText as s, handleContentUnschedule as si, SessionOpenOptions as sn, PortableTextSpan as sr, GetCommentsResult as st, DinewayConfig as t, handleContentPermanentDelete as ti, FileSessionDatabaseFactoryOptions as tn, prosemirrorToPortableText as tr, MenuItem as tt, getSuggestions as u, reference as ui, PreviewSidecarSignature as un, ProseMirrorDocument as ur, getPluginSetting as ut, SearchResponse as v, CreateRelationInput as vi, getI18nConfig as vn, SandboxedPlugin as vr, ApplySnapshotToDatabaseOptions as vt, getWidgetAreas as w, MediaItem as wi, CollectionResult as wn, Section as wr, isBlockedInPreview as wt, SuggestOptions as x, UpdateRelationInput as xi, after as xn, getSections as xr, getAppliedSnapshotMeta as xt, SearchResult as y, Relation as yi, isI18nEnabled as yn, SerializedRequest as yr, applySnapshotToDatabase as yt, getTaxonomyTerms as z, ContentResponse as zi, EditProxy as zn, handleRevisionGet 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 };