emdash 1.3.0 → 1.3.1

package/dist/storage-query-Cy0SZ8iG.d.mts

@@ -0,0 +1,1619 @@
+import { f as UpdateContentInput, i as ContentItem, l as FindManyOptions, s as CreateContentInput, t as BylineSummary, u as FindManyResult } from "./types-BqJgTL_y.mjs";
+import { t as Database } from "./types-CCEHAhOv.mjs";
+import { $ as ContentSchedulePolicyEvent, An as StorageCollection, Bt as PageMetadataContribution, Cn as ResolvedPlugin, D as ContentAccess, Dn as SettingField, Dt as MediaAccess, E as ConditionalWriteResult, En as SchemaAccess, G as ContentItem$1, Gt as PaginatedResult, H as ContentCreateOptions, Hn as UpdateIfResult, J as ContentPolicyEvent, Kn as VersionedValue, Lt as PageFragmentContribution, Mt as MediaItem$1, Nt as MediaMetadataPatch, O as ContentAccessWithWrite, On as SettingsAccess, Pn as TaxonomyAccessWithWrite, Q as ContentSaveHookDetails, Qt as PluginContentCreateCallback, Rt as PageFragmentEvent, St as HttpAccess, T as ConditionalDeleteResult, Un as UserInfo, Vt as PageMetadataEvent, Wn as VersionedContentItem, Xt as PluginComment, Zt as PluginCommentStatus, _ as CommentAfterModerateEvent, an as PluginManifest, at as CronEvent, gt as EmailMessage, h as CommentAfterCreateEvent, hn as RedirectAccessWithWrite, it as CronAccess, jt as MediaBytes, kn as SiteInfo, m as CommentAccess, mn as RedirectAccess, pn as QueryOptions, qn as WhereClause, r as BylineAccess, rt as ContentWriteInput, st as CronTaskInfo, t as ActorInfo, xn as RequestMeta, y as CommentBeforeCreateEvent } from "./types-mQGTpP-4.mjs";
+import { t as OptionsRepository } from "./options-CmUpkyKW.mjs";
+import { p as Storage } from "./types-CLVwYRBr.mjs";
+import { Kysely } from "kysely";
+import { PluginUiContext } from "@emdash-cms/blocks/server";
+
+//#region src/config/secrets.d.ts
+/**
+ * A parsed encryption key with its kid (key id) fingerprint.
+ *
+ * `kid` is the first 8 chars of the SHA-256 hash of the decoded key bytes
+ * (lowercase hex), used to tag envelopes so the decryptor can pick the right
+ * key during rotation.
+ */
+interface ParsedEncryptionKey {
+  /** 8-char lowercase hex fingerprint derived from the decoded key bytes. */
+  kid: string;
+  /** The 32 raw key bytes, ready for `crypto.subtle.importKey`. */
+  key: Uint8Array;
+  /** The original env-var-formatted string (kept for re-emit; never log). */
+  raw: string;
+}
+/** Environment-variable shape consulted by the resolver. */
+interface SecretsEnv {
+  /**
+   * Read by `validateEncryptionKeyAtStartup` and the plugin-secret encryption
+   * layer. **Not** consulted by `resolveSecrets`,
+   * so a malformed value can't 500 the preview/comment hot paths.
+   */
+  EMDASH_ENCRYPTION_KEY?: string;
+  EMDASH_PREVIEW_SECRET?: string;
+  /** Legacy alias; new docs point at EMDASH_PREVIEW_SECRET. */
+  PREVIEW_SECRET?: string;
+  EMDASH_IP_SALT?: string;
+  /**
+   * Legacy fallback. Prior code derived the IP salt from
+   * `EMDASH_AUTH_SECRET || AUTH_SECRET || "emdash-ip-salt"`. We preserve
+   * the env-var fallback (so existing installs keep their stable salt)
+   * but no longer read it from `import.meta.env` in route handlers.
+   */
+  EMDASH_AUTH_SECRET?: string;
+  /** Legacy alias. */
+  AUTH_SECRET?: string;
+}
+/**
+ * Resolve the encryption keys used for plugin secret settings.
+ *
+ * This is deliberately separate from `resolveSecrets`: plugin settings are
+ * not on the anonymous request path, and a missing or malformed key must only
+ * fail operations that need encrypted plugin settings.
+ */
+declare function resolvePluginEncryptionKeys(env?: SecretsEnv): Promise<ParsedEncryptionKey[] | null>;
+//#endregion
+//#region src/datetime-normalization.d.ts
+interface DatetimeFieldDescriptor {
+  slug: string;
+  type: "datetime" | "repeater";
+  datetimeSubFields?: readonly string[];
+}
+//#endregion
+//#region src/database/content-datetime.d.ts
+interface UrlFieldDescriptor {
+  slug: string;
+  urlSubFields?: readonly string[];
+}
+interface DatetimeContext {
+  timezone: string;
+  fields: DatetimeFieldDescriptor[];
+  urlFields: UrlFieldDescriptor[];
+  writableFieldSlugs: ReadonlySet<string>;
+}
+/**
+ * Datetime contexts by collection slug, shared so that a bulk write reads each
+ * collection's context once. A cached context doesn't see later writes to the
+ * `site:timezone` setting or to field definitions, so share one only across
+ * work that makes neither.
+ */
+type DatetimeContextCache = Map<string, Promise<DatetimeContext>>;
+//#endregion
+//#region src/database/repositories/content.d.ts
+type ContentRevisionPrecondition = Pick<ContentItem, "version" | "updatedAt">;
+/**
+ * Repository for content CRUD operations
+ *
+ * Content is stored in per-collection tables (ec_posts, ec_pages, etc.)
+ * Each field becomes a real column in the table.
+ */
+declare class ContentRepository {
+  private db;
+  private readonly datetimeContexts?;
+  private readonly datetimes;
+  constructor(db: Kysely<Database>, datetimeContexts?: DatetimeContextCache | undefined);
+  private assertAliasAwareSlugAvailable;
+  /**
+   * Create a new content item
+   */
+  create(input: CreateContentInput): Promise<ContentItem>;
+  /**
+   * Generate a unique slug for a content item within a collection.
+   *
+   * Checks the collection table for existing slugs that match `baseSlug`
+   * (optionally scoped to a locale) and appends a numeric suffix (`-1`,
+   * `-2`, etc.) on collision to guarantee uniqueness.
+   *
+   * Returns null when slug normalization cannot produce a value.
+   */
+  generateUniqueSlug(type: string, text: string, locale?: string): Promise<string | null>;
+  /**
+   * Duplicate a content item
+   * Creates a new draft copy with "(Copy)" appended to the title.
+   * A slug is auto-generated from the new title by the handler layer.
+   */
+  duplicate(type: string, id: string, authorId?: string): Promise<ContentItem>;
+  /**
+   * Find content by ID
+   */
+  findById(type: string, id: string): Promise<ContentItem | null>;
+  findManyByIds(type: string, ids: string[], options?: {
+    includeTrashed?: boolean;
+  }): Promise<Map<string, ContentItem>>;
+  findManyBySlugsInLocale(type: string, slugs: string[], locale: string, options?: {
+    includeTrashed?: boolean;
+    publishedOnly?: boolean;
+  }): Promise<Map<string, ContentItem>>;
+  /**
+   * Find content by id, including trashed (soft-deleted) items.
+   * Used by restore endpoint for ownership checks.
+   *
+   * `deletedAt` rides along because the row is already in hand: a caller that
+   * has to know whether the row is trashed before touching anything else would
+   * otherwise pay a second read for a column this row already carries.
+   */
+  findByIdIncludingTrashed(type: string, id: string): Promise<(ContentItem & {
+    deletedAt: string | null;
+  }) | null>;
+  /**
+   * Find content by ID or slug. Tries ID first if it looks like a ULID,
+   * otherwise tries slug. Falls back to the other if the first lookup misses.
+   */
+  findByIdOrSlug(type: string, identifier: string, locale?: string): Promise<ContentItem | null>;
+  /**
+   * Find content by ID or slug, including trashed (soft-deleted) items.
+   * Used by restore/permanent-delete endpoints.
+   */
+  findByIdOrSlugIncludingTrashed(type: string, identifier: string, locale?: string): Promise<ContentItem | null>;
+  isTrashed(type: string, id: string): Promise<boolean>;
+  private _findByIdOrSlug;
+  /**
+   * Find content by slug
+   */
+  findBySlug(type: string, slug: string, locale?: string): Promise<ContentItem | null>;
+  /**
+   * Find content by slug, including trashed (soft-deleted) items.
+   * Used by restore/permanent-delete endpoints.
+   */
+  findBySlugIncludingTrashed(type: string, slug: string, locale?: string): Promise<ContentItem | null>;
+  /**
+   * Find many content items with filtering and pagination
+   */
+  findMany(type: string, options?: FindManyOptions): Promise<FindManyResult<ContentItem>>;
+  /**
+   * Update content
+   */
+  update(type: string, id: string, input: UpdateContentInput): Promise<ContentItem>;
+  restoreRevision(type: string, id: string, revisionData: Record<string, unknown>, authorId: string): Promise<{
+    item: ContentItem;
+    revisionId: string;
+  }>;
+  restoreDraftRevision(type: string, id: string, revisionData: Record<string, unknown>, authorId: string): Promise<string | null>;
+  /**
+   * Update plugin-authored fields without letting content columns diverge
+   * from the revision pointers that publication promotes.
+   */
+  updateDraftAware(type: string, id: string, input: UpdateContentInput): Promise<ContentItem>;
+  private deleteUnstagedRevision;
+  private replaceDraftRevisionForUpdate;
+  /**
+   * Copy non-translatable field values to every other entry in the
+   * translation group, trashed entries included.
+   *
+   * Only the fields present in `data` are copied. With `previous`, `data` is
+   * the entry's complete new state and only the fields whose value differs
+   * from `previous` are copied, an absent field as null. An entry that already
+   * holds every copied value is left untouched, so its `updated_at` does not
+   * move.
+   *
+   * On collections with revisions a changed entry also gets a new live
+   * revision, because republishing and unpublishing read that revision rather
+   * than the columns. A pending draft takes a value only where it still holds
+   * the entry's previous value, so an unpublished edit to the field survives.
+   */
+  syncNonTranslatableFields(type: string, sourceId: string, translationGroup: string, data: Record<string, unknown>, options?: {
+    previous?: Record<string, unknown>;
+  }): Promise<void>;
+  private syncSiblingValues;
+  /**
+   * Delete content (soft delete - moves to trash)
+   */
+  delete(type: string, id: string): Promise<boolean>;
+  /**
+   * Restore content from trash
+   *
+   * The entry comes back as a draft with no schedule. The live version is not
+   * copied into a draft revision: collections without revisions save to the
+   * columns, and a draft revision would hide those saves.
+   */
+  restore(type: string, id: string, expectedRevision?: ContentRevisionPrecondition): Promise<ContentItem | null>;
+  /**
+   * Permanently delete content (cannot be undone)
+   */
+  /**
+   * Permanently delete a soft-deleted content row.
+   *
+   * Returns `true` only when a soft-deleted (trashed) row was removed.
+   * Returns `false` when no row exists OR when the row exists but is live —
+   * the caller is responsible for distinguishing these cases (typically via
+   * a follow-up `findByIdOrSlugIncludingTrashed` to surface NOT_FOUND vs
+   * NOT_TRASHED). The `AND deleted_at IS NOT NULL` clause is the safety net
+   * that prevents permanent delete from bypassing the trash workflow.
+   */
+  permanentDelete(type: string, id: string): Promise<boolean>;
+  /**
+   * Find trashed content items
+   */
+  findTrashed(type: string, options?: Omit<FindManyOptions, "where"> & {
+    where?: {
+      locale?: string;
+    };
+  }): Promise<FindManyResult<ContentItem & {
+    deletedAt: string;
+  }>>;
+  /**
+   * Count trashed content items
+   */
+  countTrashed(type: string, options?: {
+    locale?: string;
+  }): Promise<number>;
+  /**
+   * Apply the optional `q` filter.
+   *
+   * When the handler sets `useFts` (collection has a healthy FTS5 index
+   * covering the display columns; SQLite only), the filter is served from
+   * the index: a token-prefix MATCH against `_emdash_fts_<slug>` OR'd with
+   * an index-served `slug GLOB 'term*'` prefix (the slug is not in the FTS
+   * index). Both sides are index-backed, so SQLite's OR optimization avoids
+   * the full-table scan the LIKE fallback needs (#1517). The trade-off is
+   * search semantics: token-prefix matching instead of arbitrary substring.
+   *
+   * Fallback (Postgres, search disabled, or no usable terms): case-
+   * insensitive substring LIKE across the handler-resolved `searchColumns`
+   * (OR'd). User input is treated literally (LIKE wildcards escaped) and
+   * `lower()` is applied on both sides for SQLite/Postgres parity.
+   */
+  private applySearchFilter;
+  /**
+   * Apply the optional inclusive date-range filter. The field is mapped
+   * through `DATE_FILTER_COLUMNS` (a closed whitelist), and bounds compare
+   * lexicographically against the stored ISO 8601 timestamps. A `publishedAt`
+   * range naturally excludes never-published rows (their column is NULL).
+   */
+  private applyDateFilter;
+  /**
+   * Apply the optional byline filter as a correlated (NOT) EXISTS against
+   * `_emdash_content_bylines`.
+   *
+   * Correlating from the content table preserves the outer sort index so
+   * `LIMIT` can short-circuit. `mode: "none"` tests the junction rather than
+   * `primary_byline_id` because the two are written in the same call but
+   * are not atomically consistent, so the junction is authoritative.
+   *
+   * Whether a credit *renders* is locale-scoped; whether one *exists* is
+   * not. Both are needed: the first decides what the filter matches, the
+   * second decides whether the author fallback applies at all.
+   */
+  private applyBylineFilter;
+  /**
+   * Count content items
+   */
+  count(type: string, where?: FindManyOptions["where"]): Promise<number>;
+  private countWithResolvedFilters;
+  /**
+   * Distinct, non-null `author_id` values across the collection's live
+   * (non-trashed) content. Used to populate the admin author filter with
+   * only the users who have actually authored entries, rather than the
+   * full user directory (which requires admin privileges to read).
+   */
+  findDistinctAuthorIds(type: string): Promise<string[]>;
+  getStats(type: string, now?: Date): Promise<{
+    total: number;
+    published: number;
+    draft: number;
+    scheduled: number;
+    overdueScheduled: number;
+  }>;
+  /**
+   * Schedule content for future publishing
+   *
+   * Sets status to 'scheduled' and stores the scheduled publish time.
+   * The content will be auto-published when the scheduled time is reached.
+   */
+  schedule(type: string, id: string, scheduledAt: string, currentTime?: Date, expectedRevision?: ContentRevisionPrecondition): Promise<ContentItem>;
+  /**
+   * Unschedule content
+   *
+   * Clears the scheduled time. Published posts stay published;
+   * draft/scheduled posts revert to 'draft'.
+   */
+  unschedule(type: string, id: string, expectedRevision?: ContentRevisionPrecondition): Promise<ContentItem>;
+  /**
+   * Find content that is ready to be published
+   *
+   * Returns all content where scheduled_at <= now, regardless of status.
+   * This covers both draft-scheduled posts (status='scheduled') and
+   * published posts with scheduled draft changes (status='published').
+   *
+   * `limit` (optional) caps how many due rows are returned, oldest-due first.
+   * The scheduled-publishing sweep passes a limit so a large backlog can't
+   * fan out unbounded publish/webhook work in a single tick (and blow a Worker
+   * invocation's CPU/subrequest budget); the remainder drains on later ticks.
+   */
+  findReadyToPublish(type: string, limit?: number, currentTime?: Date, after?: {
+    scheduledAt: string;
+    id: string;
+  }): Promise<ContentItem[]>;
+  findTranslationIds(type: string, translationGroup: string): Promise<string[]>;
+  findTranslationIdsForGroups(type: string, translationGroups: string[]): Promise<Map<string, string[]>>;
+  /**
+   * Find all translations in a translation group
+   */
+  findTranslations(type: string, translationGroup: string): Promise<ContentItem[]>;
+  /**
+   * Whether any row still shares `translationGroup`, trashed rows included.
+   * Group-keyed satellite data (term assignments, reference edges) is owned by
+   * the group, not by a single locale row, so a purge may only cascade to it
+   * once nothing is left to own it — and a trashed sibling is still restorable.
+   */
+  hasTranslationsIncludingTrashed(type: string, translationGroup: string, options?: {
+    excludeId?: string;
+  }): Promise<boolean>;
+  /**
+   * Batch variant of {@link findTranslations}: every (non-deleted) locale
+   * variant for any of `translationGroups`, in one `WHERE translation_group IN
+   * (...)` query chunked at `SQL_BATCH_SIZE` for D1's bind-parameter limit.
+   * Lets callers resolve many edge groups without an N+1 per group. The caller
+   * groups the flat result by `translationGroup` itself.
+   *
+   * `translation_group` leads the sort so the ordering follows
+   * `idx_{table}_del_tg_locale` past its `deleted_at` equality; callers group by
+   * `translationGroup`, so the per-group locale order they rely on is preserved.
+   *
+   * `publishedOnly` restricts the result to `status = 'published'` — reference
+   * reads pass this for callers without `content:read_drafts` so draft/scheduled
+   * entries never leak through an edge traversal.
+   *
+   * A reference edge stores only a collection slug (no SQL FK), so the table may
+   * have been dropped since the edge was written. That is a tolerated dangling
+   * state, not an error: a missing table resolves to no rows, mirroring how the
+   * content read handlers treat `isMissingTableError`.
+   */
+  findTranslationsForGroups(type: string, translationGroups: string[], options?: {
+    publishedOnly?: boolean;
+  }): Promise<ContentItem[]>;
+  /**
+   * Batch variant of {@link findByIdOrSlug}: resolve many identifiers (each an
+   * id OR a slug) within `type` in a constant number of queries — one `WHERE id
+   * IN (...)` and one `WHERE slug IN (...)`, each chunked at `SQL_BATCH_SIZE`.
+   * Returns a map from the input identifier to its resolved item; identifiers
+   * that match nothing are absent. Used on write paths that accept a list of
+   * references, so a single request doesn't fan out to an N+1 of point lookups.
+   *
+   * Resolution mirrors {@link findByIdOrSlug}: a ULID-shaped identifier prefers
+   * the id match and falls back to slug; anything else prefers the slug match
+   * and falls back to id. Slug matches collapse to the lowest-locale variant
+   * (`ORDER BY locale ASC`), matching the slug-without-locale lookup.
+   */
+  findManyByIdOrSlug(type: string, identifiers: string[]): Promise<Map<string, ContentItem>>;
+  /**
+   * Publish the current draft
+   *
+   * Promotes draft_revision_id to live_revision_id and clears draft pointer.
+   * Syncs the draft revision's data into the content table columns so the
+   * content table always reflects the published version.
+   * If no draft revision exists, creates one from current data and publishes it.
+   * When `promoteRevision` is false, publishes the current content-table data
+   * by changing lifecycle metadata only.
+   *
+   * `publishedAt` (optional) overrides the publication timestamp. If omitted,
+   * the existing `published_at` is preserved (idempotent re-publish keeps the
+   * original date) and falls back to the current time on first publish. Pass
+   * an explicit value to backdate a publish (e.g. when migrating content from
+   * another CMS).
+   *
+   * `requireDue` gates the final update on the row still being due.
+   * `expectedScheduledAt` additionally fences changes made after a sweep
+   * selected the row but before publication preparation began.
+   */
+  publish(type: string, id: string, publishedAt?: string, requireDue?: boolean, expectedScheduledAt?: string, promoteRevision?: boolean, requireSlug?: boolean, expectedRevision?: ContentRevisionPrecondition, currentTime?: Date): Promise<ContentItem>;
+  /**
+   * Unpublish content
+   *
+   * Removes live pointer and cancels any pending schedule, but preserves the
+   * draft and publication date. If no draft exists and `draftFromLive` is set,
+   * creates one from the live version so the content isn't lost. Collections
+   * without revisions save to the columns, and a draft revision would hide
+   * those saves.
+   */
+  unpublish(type: string, id: string, expectedRevision?: ContentRevisionPrecondition, draftFromLive?: boolean): Promise<ContentItem>;
+  /**
+   * Set the draft revision pointer for a content item.
+   *
+   * Used by seed/import paths that stage a new revision's data before
+   * promoting it to live via `publish()`.
+   *
+   * Validates that the content item exists and is not soft-deleted, that
+   * the revision exists, and that the revision belongs to the same
+   * collection and entry. Without these checks, a caller could leave the
+   * content row pointing at a missing or unrelated revision.
+   */
+  setDraftRevision(type: string, id: string, revisionId: string): Promise<void>;
+  replaceDraftRevision(type: string, id: string, revisionId: string, expected: Pick<ContentItem, "version" | "liveRevisionId" | "draftRevisionId">): Promise<boolean>;
+  /**
+   * Discard pending draft changes
+   *
+   * Clears draft_revision_id. The content table columns already hold the
+   * published version, so no data sync is needed.
+   */
+  discardDraft(type: string, id: string, expectedRevision?: ContentRevisionPrecondition): Promise<ContentItem>;
+  /**
+   * Count content items with a pending schedule.
+   * Includes both draft-scheduled (status='scheduled') and published
+   * posts with scheduled draft changes (status='published', scheduled_at set).
+   */
+  countScheduled(type: string): Promise<number>;
+  /**
+   * Map database row to ContentItem
+   * Extracts system columns and puts content fields in data
+   * Excludes null values from data to match input semantics
+   */
+  private mapRow;
+  private normalizeFilterScalar;
+  private normalizeFieldFilter;
+  private collectionExists;
+  private resolveFieldFilters;
+  private applyFieldFilters;
+  /**
+   * Map order field names to database columns.
+   * Only allows known fields to prevent column enumeration via crafted orderBy values.
+   */
+  private mapOrderField;
+  private resolveOrderField;
+}
+//#endregion
+//#region src/media/focal-point.d.ts
+interface FocalPointUpdate {
+  focalX?: number | null;
+  focalY?: number | null;
+}
+//#endregion
+//#region src/database/repositories/media.d.ts
+type MediaStatus = "pending" | "ready" | "failed";
+interface MediaItem {
+  id: string;
+  filename: string;
+  mimeType: string;
+  size: number | null;
+  width: number | null;
+  height: number | null;
+  focalX: number | null;
+  focalY: number | null;
+  alt: string | null;
+  caption: string | null;
+  storageKey: string;
+  status: MediaStatus;
+  contentHash: string | null;
+  blurhash: string | null;
+  dominantColor: string | null;
+  createdAt: string;
+  authorId: string | null;
+  folderId?: string | null;
+}
+interface CreateMediaInput {
+  filename: string;
+  mimeType: string;
+  size?: number;
+  width?: number;
+  height?: number;
+  alt?: string;
+  caption?: string;
+  storageKey: string;
+  contentHash?: string;
+  blurhash?: string;
+  dominantColor?: string;
+  status?: MediaStatus;
+  authorId?: string;
+  folderId?: string | null;
+}
+interface FindManyMediaOptions {
+  limit?: number;
+  cursor?: string;
+  /** Filter by MIME type. Pass a string for a single prefix/exact, or an array to match any. Strings ending with "/" are treated as LIKE prefix matches; others are exact equality. */
+  mimeType?: string | readonly string[];
+  status?: MediaStatus | "all";
+  /** Case-insensitive substring matched against the filename (covers filename and extension). */
+  q?: string;
+  /** Omit for all media, pass null for the Main library, or pass a folder ID. */
+  folderId?: string | null;
+}
+interface UpdateMediaInput extends FocalPointUpdate {
+  alt?: string | null;
+  caption?: string | null;
+  width?: number;
+  height?: number;
+  folderId?: string | null;
+}
+interface ReplaceReadyMediaInput {
+  size: number;
+  width: number;
+  height: number;
+  contentHash: string;
+}
+interface FindMediaPageOptions extends Omit<FindManyMediaOptions, "cursor"> {
+  page: number;
+}
+interface MediaPageResult {
+  items: MediaItem[];
+  totalCount: number;
+}
+/**
+ * Media repository for database operations
+ */
+declare class MediaRepository {
+  private db;
+  constructor(db: Kysely<Database>);
+  /**
+   * Create a new media item
+   */
+  create(input: CreateMediaInput): Promise<MediaItem>;
+  /**
+   * Create a pending media item (for signed URL upload flow)
+   */
+  createPending(input: {
+    filename: string;
+    mimeType: string;
+    size?: number;
+    storageKey: string;
+    contentHash?: string;
+    authorId?: string;
+    folderId?: string | null;
+  }): Promise<MediaItem>;
+  createUploadAttempt(mediaId: string, storageKey: string): Promise<void>;
+  /**
+   * Register a stored object for cleanup before its media row is removed,
+   * so a failed storage delete is retried by the cleanup sweep instead of
+   * leaving the object unreferenced and unreachable.
+   */
+  trackStorageKeyForCleanup(mediaId: string, storageKey: string): Promise<void>;
+  hasUploadAttempt(storageKey: string): Promise<boolean>;
+  claimUploadAttemptForCleanup(storageKey: string): Promise<boolean>;
+  deleteUploadAttempt(storageKey: string): Promise<void>;
+  deferUploadAttemptCleanup(storageKey: string): Promise<void>;
+  deleteCompletedUploadAttempts(): Promise<number>;
+  findUploadAttemptsForCleanup(maxAgeMs?: number, limit?: number): Promise<string[]>;
+  publishPendingStorageKey(id: string, expectedStorageKey: string, storageKey: string, contentHash?: string): Promise<boolean>;
+  /**
+   * Confirm upload (mark as ready)
+   */
+  confirmUpload(id: string, metadata?: {
+    width?: number;
+    height?: number;
+    size?: number;
+    blurhash?: string;
+    dominantColor?: string;
+    contentHash?: string | null;
+  }, expectedStorageKey?: string): Promise<MediaItem | null>;
+  /**
+   * Mark upload as failed
+   */
+  markFailed(id: string, expectedStorageKey?: string): Promise<MediaItem | null>;
+  /**
+   * Find the pending media row minted for a signed upload URL.
+   */
+  findPendingByStorageKey(storageKey: string): Promise<MediaItem | null>;
+  /**
+   * Find media by ID
+   */
+  findById(id: string): Promise<MediaItem | null>;
+  /**
+   * Find media by filename
+   * Useful for idempotent imports
+   */
+  findByFilename(filename: string): Promise<MediaItem | null>;
+  findAvailableFilename(filename: string): Promise<string>;
+  /**
+   * Find media by content hash
+   * Used for deduplication - same content = same hash
+   */
+  findByContentHash(contentHash: string): Promise<MediaItem | null>;
+  /**
+   * Find many media items with cursor pagination
+   *
+   * Uses keyset pagination (cursor-based) for consistent results.
+   * The cursor encodes the created_at and id of the last item.
+   */
+  findMany(options?: FindManyMediaOptions): Promise<FindManyResult<MediaItem>>;
+  findPage(options: FindMediaPageOptions): Promise<MediaPageResult>;
+  /**
+   * Update media metadata
+   */
+  update(id: string, input: UpdateMediaInput): Promise<MediaItem | null>;
+  updateReadyMetadata(id: string, input: Pick<UpdateMediaInput, "alt" | "caption" | "focalX" | "focalY">): Promise<MediaItem | null>;
+  replaceReadyFile(id: string, expectedStorageKey: string, input: ReplaceReadyMediaInput): Promise<MediaItem | null>;
+  /**
+   * Delete media item
+   */
+  deleteWithStorageKey(id: string): Promise<string | null>;
+  isStorageKeyReferenced(storageKey: string): Promise<boolean>;
+  delete(id: string): Promise<boolean>;
+  /**
+   * Count media items
+   */
+  count(mimeType?: string | readonly string[]): Promise<number>;
+  private applyListFilters;
+  /**
+   * Delete pending uploads older than the given age.
+   * Pending uploads that were never confirmed indicate abandoned upload flows.
+   *
+   * Returns the storage keys of deleted rows so callers can remove the
+   * corresponding files from object storage.
+   */
+  cleanupPendingUploads(maxAgeMs?: number): Promise<string[]>;
+  /**
+   * Convert database row to MediaItem
+   */
+  private rowToItem;
+}
+//#endregion
+//#region src/database/repositories/plugin-storage.d.ts
+declare class PluginStorageRepository<T = unknown> implements StorageCollection<T> {
+  private db;
+  private pluginId;
+  private collection;
+  private indexedFields;
+  constructor(db: Kysely<Database>, pluginId: string, collection: string, indexes: Array<string | string[]>);
+  /**
+   * Get a document by ID
+   */
+  get(id: string): Promise<T | null>;
+  /**
+   * Store a document
+   */
+  put(id: string, data: T): Promise<void>;
+  getVersioned(id: string): Promise<VersionedValue<T> | null>;
+  compareAndSet(id: string, expectedRevision: string | null, data: T): Promise<ConditionalWriteResult>;
+  compareAndDelete(id: string, expectedRevision: string): Promise<ConditionalDeleteResult>;
+  /**
+   * Delete a document
+   */
+  delete(id: string): Promise<boolean>;
+  /**
+   * Check if a document exists
+   */
+  exists(id: string): Promise<boolean>;
+  /**
+   * Get multiple documents by ID
+   */
+  getMany(ids: string[]): Promise<Map<string, T>>;
+  /**
+   * Store multiple documents
+   */
+  putMany(items: Array<{
+    id: string;
+    data: T;
+  }>): Promise<void>;
+  /**
+   * Delete multiple documents
+   */
+  deleteMany(ids: string[]): Promise<number>;
+  /**
+   * Query documents with filters
+   */
+  query(options?: QueryOptions): Promise<PaginatedResult<{
+    id: string;
+    data: T;
+  }>>;
+  /**
+   * Count documents matching a filter
+   */
+  count(where?: WhereClause): Promise<number>;
+  updateIf(id: string, args: unknown): Promise<UpdateIfResult<T>>;
+}
+//#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:beforePublish" | "content:beforeSchedule" | "content:beforeUnpublish" | "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" | "byline:afterSave" | "byline:afterDelete" | "page:metadata" | "page:fragments";
+type ContentPolicyHookName = "content:beforePublish" | "content:beforeSchedule" | "content:beforeUnpublish";
+type ContentPolicyRunResult = {
+  cancellation?: {
+    pluginId: string;
+    reason: string;
+  };
+  results: HookResult<void>[];
+};
+/**
+ * Hook execution result
+ */
+interface HookResult<T> {
+  success: boolean;
+  value?: T;
+  error?: Error;
+  pluginId: string;
+  duration: number;
+}
+/**
+ * Hook pipeline for executing hooks in order
+ */
+declare class HookPipeline {
+  private hooks;
+  private pluginMap;
+  private contextFactory;
+  /** Stored so setContextFactory can merge incrementally. */
+  private contextFactoryOptions;
+  /** Hook names where at least one handler declared exclusive: true */
+  private exclusiveHookNames;
+  /**
+   * Selected provider plugin ID for each exclusive hook.
+   * Set by the PluginManager after resolution.
+   */
+  private exclusiveSelections;
+  constructor(plugins: ResolvedPlugin[], factoryOptions?: PluginContextFactoryOptions);
+  /**
+   * Set or update the context factory options.
+   *
+   * When called on a pipeline that already has a factory, the new options
+   * are merged on top of the existing ones so that callers don't need to
+   * repeat every field (e.g. adding `cronReschedule` without losing
+   * `storage` / `getUploadUrl`).
+   */
+  setContextFactory(options: Partial<PluginContextFactoryOptions>): void;
+  /**
+   * Get context for a plugin
+   */
+  private getContext;
+  /**
+   * Get typed hooks for a specific hook name.
+   * The internal map stores ResolvedHook<unknown>, but we know each name
+   * maps to a specific handler type via HookHandlerMap.
+   *
+   * Exclusive hooks that have a selected provider are filtered out — they
+   * should only run via invokeExclusiveHook(), not in the regular pipeline.
+   */
+  private getTypedHooks;
+  /**
+   * Register all hooks from plugins.
+   *
+   * Registers each hook name individually to preserve type safety. The
+   * internal map stores ResolvedHook<unknown> since it's keyed by string,
+   * but getTypedHooks() restores the correct handler type on retrieval.
+   */
+  private registerPlugins;
+  /**
+   * Maps hook names to the capability required to register them.
+   *
+   * Hooks not listed here have no capability requirement (e.g. lifecycle
+   * hooks, cron). Any plugin declaring a listed hook without the required
+   * capability will have that hook silently skipped at registration time.
+   */
+  private static readonly HOOK_REQUIRED_CAPABILITY;
+  /**
+   * Register a single plugin's hook by name
+   */
+  private registerPluginHook;
+  /**
+   * Register a single hook
+   */
+  private registerHook;
+  /**
+   * Sort hooks by priority and dependencies
+   */
+  private sortHooks;
+  /**
+   * Execute a hook with timeout
+   */
+  private executeWithTimeout;
+  /**
+   * Run plugin:install hooks
+   */
+  runPluginInstall(pluginId: string): Promise<HookResult<void>[]>;
+  /**
+   * Run plugin:activate hooks
+   */
+  runPluginActivate(pluginId: string): Promise<HookResult<void>[]>;
+  /**
+   * Run plugin:deactivate hooks
+   */
+  runPluginDeactivate(pluginId: string): Promise<HookResult<void>[]>;
+  /**
+   * Run plugin:uninstall hooks
+   */
+  runPluginUninstall(pluginId: string, deleteData: boolean): Promise<HookResult<void>[]>;
+  private runLifecycleHook;
+  /**
+   * Run content:beforeSave hooks
+   * Returns modified content from the pipeline. `id` is the existing item's
+   * ID when updating. `actor` is the authenticated user that triggered the
+   * save, when one is available.
+   */
+  runContentBeforeSave(content: Record<string, unknown>, collection: string, isNew: boolean, id?: string, actor?: ActorInfo, details?: ContentSaveHookDetails): Promise<{
+    content: Record<string, unknown>;
+    results: HookResult<Record<string, unknown>>[];
+  }>;
+  /**
+   * Run content:afterSave hooks
+   */
+  runContentAfterSave(content: Record<string, unknown>, collection: string, isNew: boolean, actor?: ActorInfo, excludePluginId?: string, details?: ContentSaveHookDetails): 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>[]>;
+  runContentPolicy(name: "content:beforePublish", event: ContentPolicyEvent): Promise<ContentPolicyRunResult>;
+  runContentPolicy(name: "content:beforeSchedule", event: ContentSchedulePolicyEvent): Promise<ContentPolicyRunResult>;
+  runContentPolicy(name: "content:beforeUnpublish", event: ContentPolicyEvent): Promise<ContentPolicyRunResult>;
+  runContentPolicy(name: ContentPolicyHookName, event: ContentPolicyEvent | ContentSchedulePolicyEvent): Promise<ContentPolicyRunResult>;
+  private runContentPolicyHooks;
+  /**
+   * Run content state-change hooks that all share the same event shape.
+   */
+  private runContentStateChangeHook;
+  /**
+   * Run content:afterPublish hooks (fire-and-forget).
+   */
+  runContentAfterPublish(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
+  /**
+   * Run content:afterUnpublish hooks (fire-and-forget).
+   */
+  runContentAfterUnpublish(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
+  /**
+   * Run content:afterRestore hooks (fire-and-forget).
+   */
+  runContentAfterRestore(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
+  /**
+   * Run content:afterSchedule hooks (fire-and-forget).
+   */
+  runContentAfterSchedule(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
+  /**
+   * Run content:afterUnschedule hooks (fire-and-forget).
+   */
+  runContentAfterUnschedule(content: Record<string, unknown>, collection: string): Promise<HookResult<void>[]>;
+  /**
+   * 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 byline:afterSave hooks. Errors are logged and never propagate. */
+  runBylineAfterSave(byline: BylineSummary, isNew: boolean): Promise<void>;
+  /** Run byline:afterDelete hooks. Errors are logged and never propagate. */
+  runBylineAfterDelete(byline: BylineSummary): Promise<void>;
+  private runLoggedHook;
+  /**
+   * 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 (e.g. `email:beforeSend`, `email:afterSend`), preserving priority
+   * order. Partitions with `getExclusiveHookProviders()`, which returns
+   * plugins whose registration is marked `exclusive: true`.
+   */
+  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>;
+}
+/**
+ * Create a hook pipeline from plugins
+ */
+declare function createHookPipeline(plugins: ResolvedPlugin[], factoryOptions?: PluginContextFactoryOptions): HookPipeline;
+//#endregion
+//#region src/plugins/email.d.ts
+/**
+ * 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 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/plugins/settings.d.ts
+interface EncryptedPluginSetting {
+  $emdash: "plugin-setting";
+  v: 1;
+  kid: string;
+  iv: string;
+  ciphertext: string;
+}
+declare class PluginSettingEncryptionError extends Error {
+  readonly name = "PluginSettingEncryptionError";
+  readonly code: "PLUGIN_SETTING_ENCRYPTION_KEY_MISSING" | "PLUGIN_SETTING_ENCRYPTION_KEY_UNKNOWN" | "PLUGIN_SETTING_ENCRYPTION_FAILED" | "PLUGIN_SETTING_DECRYPTION_FAILED";
+  constructor(code: PluginSettingEncryptionError["code"], message: string);
+}
+declare function isEncryptedPluginSetting(value: unknown): value is EncryptedPluginSetting;
+declare function encryptPluginSetting(pluginId: string, key: string, value: string, keys?: ParsedEncryptionKey[] | null): Promise<EncryptedPluginSetting>;
+declare function decodePluginSettingValue<T = unknown>(pluginId: string, key: string, value: unknown, schema: Record<string, SettingField>, keys?: ParsedEncryptionKey[] | null, onSecret?: (key: string, value: string) => void): Promise<T>;
+declare function createSettingsAccess(optionsRepo: OptionsRepository, pluginId: string, schema?: Record<string, SettingField>, keys?: ParsedEncryptionKey[] | null, onSecret?: (key: string, value: string) => void): SettingsAccess;
+//#endregion
+//#region src/plugins/content-access.d.ts
+declare function createContentAccess(db: Kysely<Database>, accessOptions?: {
+  site?: SiteInfo;
+  revisions?: boolean;
+}): ContentAccess;
+//#endregion
+//#region src/plugins/context.d.ts
+declare function createSchemaAccess(db: Kysely<Database>): SchemaAccess;
+declare function createCommentAccess(db: Kysely<Database>, moderate?: (id: string, status: PluginCommentStatus, expectedStatus: PluginCommentStatus) => Promise<PluginComment>): CommentAccess;
+declare class RedirectAccessError extends Error {
+  readonly code: string;
+  readonly name = "RedirectAccessError";
+  constructor(code: string, message: string);
+}
+declare function createRedirectAccess(db: Kysely<Database>): RedirectAccess;
+declare function createRedirectAccess(db: Kysely<Database>, writable: true): RedirectAccessWithWrite;
+/**
+ * Called immediately before a plugin content write; it throws to refuse the
+ * write. When it returns a function, that function is called once the write
+ * has succeeded.
+ */
+type ContentWriteGuard = () => Promise<void | (() => Promise<void>)>;
+/**
+ * Create full content access with write operations.
+ *
+ * `create` and `update` accept a reserved `seo` key in their `data`
+ * argument. When present, it is routed to the core SEO panel
+ * (`_emdash_seo`) via `SeoRepository.upsert`, in the same transaction as
+ * the content write. The returned `ContentItem.seo` reflects the resulting
+ * SEO state for SEO-enabled collections.
+ */
+declare function createContentAccessWithWrite(db: Kysely<Database>, beforeContentWrite?: ContentWriteGuard, accessOptions?: {
+  site?: SiteInfo;
+  revisions?: boolean;
+}, contentCreate?: (data: {
+  collection: string;
+  input: ContentWriteInput;
+  options?: ContentCreateOptions;
+}) => Promise<ContentItem$1>): ContentAccessWithWrite;
+/**
+ * Create read-only media access
+ */
+declare function createMediaAccess(db: Kysely<Database>): MediaAccess;
+/**
+ * Create HTTP access with host validation and SSRF protection.
+ *
+ * Uses redirect: "manual" to re-validate each redirect target before dispatch.
+ */
+declare function createHttpAccess(pluginId: string, allowedHosts: string[], fetchImpl?: typeof fetch): HttpAccess;
+/**
+ * Create unrestricted HTTP access (for plugins with network:request:unrestricted capability).
+ * No host validation, but applies SSRF protection on redirect targets to
+ * prevent plugins from being tricked into reaching internal services.
+ */
+declare function createUnrestrictedHttpAccess(pluginId: string, fetchImpl?: typeof fetch): HttpAccess;
+/**
+ * Options for creating site info
+ */
+interface SiteInfoOptions {
+  /** Site name from options table */
+  siteName?: string;
+  /** Site URL, resolved by the runtime in the same order as links in emails */
+  siteUrl?: string;
+  /** Site locale from options table */
+  locale?: string;
+  /** Astro's `trailingSlash` config (from `virtual:emdash/config`). */
+  trailingSlash?: "always" | "never" | "ignore";
+}
+interface PluginContextFactoryOptions {
+  db: Kysely<Database>;
+  beforeContentWrite?: ContentWriteGuard;
+  contentCreate?: PluginContentCreateCallback;
+  contentActions?: ContentActionCallbacks;
+  /**
+   * Resolver for the database connection, preferred over `db` when present.
+   * Called per `createContext()` so connection-backed adapters (e.g. Postgres
+   * over Hyperdrive) get the current request/event-scoped connection from ALS
+   * rather than a snapshot of the per-isolate singleton — reusing the
+   * singleton's socket from a later event trips workerd's cross-request I/O
+   * guard. When omitted, `db` is used directly (correct for stateless
+   * adapters like D1 and Node SQLite). `db` remains required as the fallback.
+   */
+  getDb?: () => Kysely<Database>;
+  /**
+   * Storage backend for direct media uploads.
+   * If not provided, upload() will throw.
+   */
+  storage?: Storage;
+  /**
+   * Explicit provider for `ctx.media.getUploadUrl()`. Optional: when omitted
+   * but `storage` is configured, the factory derives a working `getUploadUrl()`
+   * (and `upload()`) from storage. Only when neither `getUploadUrl` nor
+   * `storage` is present do media write operations become unavailable.
+   */
+  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;
+  /** Clock used to calculate the first run of recurring plugin tasks. */
+  now?: () => Date;
+  /**
+   * Email pipeline instance for ctx.email.
+   * If not provided (or no provider configured), ctx.email will be undefined.
+   */
+  emailPipeline?: EmailPipeline;
+  /**
+   * Pre-resolved list of trusted proxy header names (from the runtime
+   * `EmDashConfig.trustedProxyHeaders` or the env var). Plugin route
+   * handlers pass this to `extractRequestMeta` so plugins see the same
+   * client IP the core auth path does.
+   */
+  trustedProxyHeaders?: string[];
+  commentModerate?: (pluginId: string, id: string, status: PluginCommentStatus, expectedStatus: PluginCommentStatus) => Promise<PluginComment>;
+}
+interface ContentActionCallbacks {
+  /** Register a sandbox invocation before it can call a content action. */
+  begin?(pluginId: string, invocationId: string, invalidateContentCache?: (tags: string[]) => Promise<void>): void;
+  /** Release queued after-hooks; `final: false` keeps late actions self-scheduling after timeout. */
+  flush(pluginId: string, invocationId?: string, final?: boolean): Promise<void>;
+  getVersioned(pluginId: string, collection: string, id: string): Promise<VersionedContentItem | null>;
+  publish(pluginId: string, collection: string, id: string, options: {
+    _rev: string;
+  }, invocationId?: string, invalidateContentCache?: (tags: string[]) => Promise<void>): Promise<VersionedContentItem>;
+  unpublish(pluginId: string, collection: string, id: string, options: {
+    _rev: string;
+  }, invocationId?: string, invalidateContentCache?: (tags: string[]) => Promise<void>): Promise<VersionedContentItem>;
+  schedule(pluginId: string, collection: string, id: string, options: {
+    scheduledAt: string;
+    _rev: string;
+  }, invocationId?: string, invalidateContentCache?: (tags: string[]) => Promise<void>): Promise<VersionedContentItem>;
+  unschedule(pluginId: string, collection: string, id: string, options: {
+    _rev: string;
+  }, invocationId?: string, invalidateContentCache?: (tags: string[]) => Promise<void>): Promise<VersionedContentItem>;
+  getTrashedVersioned(pluginId: string, collection: string, id: string): Promise<VersionedContentItem | null>;
+  restore(pluginId: string, collection: string, id: string, options: {
+    _rev: string;
+  }, invocationId?: string, invalidateContentCache?: (tags: string[]) => Promise<void>): Promise<VersionedContentItem>;
+}
+//#endregion
+//#region src/plugins/sandbox/types.d.ts
+/**
+ * Resource limits for sandboxed plugins.
+ * Enforced by the sandbox runtime (e.g., Worker Loader).
+ */
+interface ResourceLimits {
+  /** CPU time per invocation in milliseconds (default: 50ms) */
+  cpuMs?: number;
+  /** Memory limit in MB (default: 128MB) */
+  memoryMb?: number;
+  /** Maximum subrequests per invocation (default: 10) */
+  subrequests?: number;
+  /** Wall-clock time limit in milliseconds (default: 30000ms) */
+  wallTimeMs?: number;
+}
+/**
+ * Storage interface for loading plugin code.
+ * Could be R2, local filesystem, or any other storage backend.
+ */
+interface PluginCodeStorage {
+  /** Get plugin bundle code by path */
+  get(path: string): Promise<string | null>;
+  /** Check if a bundle exists */
+  exists(path: string): Promise<boolean>;
+}
+/**
+ * Serialized email message for sandbox RPC transport.
+ * Matches the core EmailMessage type but uses only serializable fields.
+ */
+interface SandboxEmailMessage {
+  to: string;
+  cc?: string[];
+  replyTo?: string;
+  subject: string;
+  text: string;
+  html?: string;
+}
+/**
+ * Callback for sending email from a sandboxed plugin.
+ * The sandbox runner wires this up from the EmailPipeline.
+ *
+ * @param message - The email message to send
+ * @param pluginId - The sending plugin's ID (used as source)
+ */
+type SandboxEmailSendCallback = (message: SandboxEmailMessage, pluginId: string) => Promise<void>;
+type SandboxCommentModerateCallback = (pluginId: string, id: string, status: PluginCommentStatus, expectedStatus: PluginCommentStatus) => Promise<PluginComment>;
+type SandboxContentCreateCallback = (pluginId: string, collection: string, data: ContentWriteInput, options?: ContentCreateOptions & {
+  originHook?: "content:beforeSave" | "content:afterSave";
+  sandboxOrigin?: true;
+}) => Promise<ContentItem$1>;
+type SandboxHttpFetchCallback = typeof fetch;
+/**
+ * Options for creating a sandbox runner
+ */
+interface SandboxOptions {
+  /** Storage interface for loading plugin code */
+  storage?: PluginCodeStorage;
+  /** Database for bridge operations */
+  db: Kysely<Database>;
+  /**
+   * Called immediately before a sandboxed plugin content mutation; it throws
+   * to refuse the write. When it returns a function, the bridge calls that
+   * function once the write has succeeded.
+   */
+  beforeContentWrite?: () => Promise<void | (() => Promise<void>)>;
+  /** Runtime-owned taxonomy mutation surface used by sandbox bridges. */
+  taxonomyWrite?: TaxonomyAccessWithWrite;
+  contentActions?: ContentActionCallbacks;
+  /** Clock used to calculate recurring plugin task schedules. */
+  now?: () => Date;
+  /** Default resource limits */
+  limits?: ResourceLimits;
+  /** Site info for plugin context (injected into wrapper at generation time) */
+  siteInfo?: {
+    name: string;
+    url: string;
+    locale: string;
+    trailingSlash?: "always" | "never" | "ignore";
+  };
+  /** Email send callback, wired from the EmailPipeline by the runtime */
+  emailSend?: SandboxEmailSendCallback;
+  commentModerate?: SandboxCommentModerateCallback;
+  /** Optional host HTTP transport used by test hosts and custom runtimes. */
+  httpFetch?: SandboxHttpFetchCallback;
+  /**
+   * Media storage adapter for sandboxed plugin byte reads, uploads, and deletes.
+   * Each operation remains gated by its own media capability.
+   */
+  mediaStorage?: {
+    upload(options: {
+      key: string;
+      body: Uint8Array;
+      contentType: string;
+    }): Promise<unknown>;
+    download(key: string): Promise<{
+      body: ReadableStream<Uint8Array>;
+      contentType: string;
+      size: number;
+    }>;
+    delete(key: string): Promise<unknown>;
+  };
+  /** Worker Loader name suffix. The plugin's logical ID remains unchanged. */
+  isolateKey?: string;
+}
+/**
+ * Handle to a sandboxed plugin running inside an isolate. Returned
+ * by `SandboxRunner.load` and held by the runtime's cache so hooks /
+ * routes can be invoked across the isolate boundary. Distinct from
+ * the author-facing `SandboxedPlugin` type in `emdash/plugin`, which
+ * describes the source-level shape of a plugin's default export.
+ */
+interface SandboxedPluginInstance {
+  /** Unique identifier: `${manifest.id}:${manifest.version}` */
+  readonly id: string;
+  /**
+   * Invoke a hook in the sandboxed plugin.
+   *
+   * @param hookName - Name of the hook (e.g., "content:beforeSave")
+   * @param event - Event data to pass to the hook
+   * @returns Hook result (transformed content, void, etc.)
+   */
+  invokeHook(hookName: string, event: unknown): Promise<unknown>;
+  /**
+   * Invoke an API route in the sandboxed plugin.
+   *
+   * @param routeName - Name of the route
+   * @param input - Validated input data
+   * @param request - Serialized request info for context
+   * @returns Route response data
+   */
+  invokeRoute(routeName: string, input: unknown, request: SerializedRequest, options?: SandboxInvocationOptions): Promise<unknown>;
+  /**
+   * Change whether the plugin may access host services.
+   * Deactivation revokes credentials synchronously; reactivation issues fresh credentials.
+   */
+  setActive?(active: boolean): void;
+  /**
+   * Terminate the sandboxed plugin.
+   * Releases resources and prevents further invocations.
+   */
+  terminate(): Promise<void>;
+}
+interface SandboxInvocationOptions {
+  invalidateContentCache?: (tags: string[]) => Promise<void>;
+}
+/**
+ * Serialized request for RPC transport.
+ * Worker Loader can't pass Request objects directly.
+ */
+interface SerializedRequest {
+  url: string;
+  method: string;
+  headers: Record<string, string>;
+  /** Normalized request metadata extracted before RPC serialization */
+  meta: RequestMeta;
+  /** Host-attested context for a validated Block Kit request. */
+  ui?: PluginUiContext;
+  /**
+   * Authenticated caller for private routes, resolved by the host before
+   * dispatch. Undefined for public routes and unbound machine tokens.
+   */
+  user?: UserInfo;
+}
+declare const SANDBOX_ROUTE_ERROR_DEFINITIONS: {
+  readonly MEDIA_USAGE_ACTIVATION_IN_PROGRESS: {
+    readonly message: "Media usage activation is in progress";
+    readonly status: 503;
+  };
+  readonly MEDIA_USAGE_ACTIVATION_CHECK_FAILED: {
+    readonly message: "Unable to verify media usage activation state";
+    readonly status: 503;
+  };
+  readonly TRANSFER_IMPORT_IN_PROGRESS: {
+    readonly message: "A site import is in progress or incomplete; writes are disabled";
+    readonly status: 503;
+  };
+  readonly TRANSFER_FENCE_CHECK_FAILED: {
+    readonly message: "Unable to verify whether site writes are allowed";
+    readonly status: 503;
+  };
+};
+type SandboxRouteErrorCode = keyof typeof SANDBOX_ROUTE_ERROR_DEFINITIONS;
+interface SandboxRouteErrorDetails {
+  code: SandboxRouteErrorCode;
+  message: string;
+  status: 503;
+}
+interface SandboxRouteErrorEnvelope {
+  __emdashSandboxRouteError: true;
+  error: SandboxRouteErrorDetails;
+}
+declare function getSandboxRouteErrorDetails(error: unknown): SandboxRouteErrorDetails | null;
+declare function createSandboxRouteError(code: SandboxRouteErrorCode): Error & SandboxRouteErrorDetails;
+declare function createSandboxRouteErrorEnvelope(error: unknown): SandboxRouteErrorEnvelope | null;
+declare function getSandboxRouteErrorEnvelope(value: unknown): SandboxRouteErrorEnvelope | null;
+/**
+ * Sandbox runner interface.
+ * Platform adapters implement this to provide plugin isolation.
+ */
+interface SandboxRunner {
+  /**
+   * Check if sandboxing is available on this platform.
+   * Returns false for platforms that don't support isolation.
+   */
+  isAvailable(): boolean;
+  /**
+   * Check if the sandbox runtime is currently healthy.
+   * For in-process runners this always returns true.
+   * For sidecar-based runners (workerd), returns false if the
+   * child process has crashed and hasn't been restarted yet.
+   */
+  isHealthy(): boolean;
+  /**
+   * Why the runner cannot run plugins, once isAvailable() or isHealthy()
+   * has returned false. A lowercase clause without a final period: callers
+   * append it to their own message after a colon.
+   *
+   * Making this required breaks runners implemented outside this repository.
+   */
+  unavailableReason?(): string;
+  /**
+   * Load a sandboxed plugin from code.
+   *
+   * @param manifest - Plugin manifest with metadata and capabilities
+   * @param code - The bundled plugin JavaScript code
+   * @returns A sandboxed plugin instance
+   * @throws If sandboxing is not available or plugin can't be loaded
+   */
+  load(manifest: PluginManifest, code: string): Promise<SandboxedPluginInstance>;
+  /**
+   * Set the email send callback for sandboxed plugins.
+   * Called after the EmailPipeline is created, since the pipeline
+   * doesn't exist when the sandbox runner is constructed.
+   */
+  setEmailSend(callback: SandboxEmailSendCallback | null): void;
+  setCommentModerate?(callback: SandboxCommentModerateCallback | null): void;
+  setContentCreate?(callback: SandboxContentCreateCallback | null): void;
+  setContentActions?(callback: ContentActionCallbacks | null): void;
+  /** Wake a long-lived scheduler after a sandboxed plugin changes its tasks. */
+  setCronReschedule?(callback: (() => void) | null): void;
+  /**
+   * Terminate all loaded sandboxed plugins.
+   * Called during shutdown or when reconfiguring.
+   */
+  terminateAll(): Promise<void>;
+}
+/**
+ * Error thrown when the sandbox runtime is unavailable.
+ * This happens when the sidecar process has crashed or hasn't started.
+ */
+declare class SandboxUnavailableError extends Error {
+  constructor(pluginId: string, reason: string);
+}
+/**
+ * Factory function type for creating sandbox runners.
+ * Exported by platform adapters (e.g., @emdash-cms/cloudflare/sandbox).
+ *
+ * @example
+ * ```typescript
+ * // In @emdash-cms/cloudflare/sandbox
+ * export const createSandboxRunner: SandboxRunnerFactory = (options) => {
+ *   return new CloudflareSandboxRunner(options);
+ * };
+ * ```
+ */
+type SandboxRunnerFactory = (options: SandboxOptions) => SandboxRunner;
+//#endregion
+//#region src/plugins/cron.d.ts
+/**
+ * Callback to invoke a plugin's cron hook.
+ * Provided by PluginManager so CronExecutor stays decoupled from the hook pipeline.
+ */
+type InvokeCronHookFn = (pluginId: string, event: CronEvent) => Promise<void>;
+/**
+ * Callback to notify the scheduler that the next due time may have changed.
+ */
+type RescheduleFn = () => void;
+/**
+ * Executes overdue cron tasks.
+ *
+ * Called by the platform driver: the NodeCronScheduler timer on Node, or the
+ * Worker's `scheduled()` handler (via runScheduledTasks) on Cloudflare.
+ * Stateless — all state lives in the database.
+ */
+declare class CronExecutor {
+  private invokeCronHook;
+  private readonly now;
+  /**
+   * Resolves the database connection to use for this tick. A resolver (not a
+   * captured instance) so connection-backed adapters work across events: on
+   * Cloudflare the `scheduled()` handler installs an event-scoped connection
+   * in ALS, and this resolves to it instead of the per-isolate singleton
+   * whose socket belongs to an earlier request. Accepts a plain `Kysely` too
+   * (wrapped in a constant resolver) for callers/tests that don't need ALS.
+   */
+  private readonly resolveDb;
+  constructor(db: Kysely<Database> | (() => Kysely<Database>), invokeCronHook: InvokeCronHookFn, now?: () => Date);
+  private get db();
+  /**
+   * Process all overdue tasks.
+   *
+   * 1. Atomically claim tasks whose next_run_at <= now, status = idle, enabled = 1.
+   * 2. For each claimed task, invoke the plugin's cron hook.
+   * 3. On success: compute next_run_at and reset to idle, or delete one-shots.
+   * 4. On failure: reset to idle (retry on next tick).
+   */
+  tick(): Promise<number>;
+  /**
+   * Recover tasks stuck in 'running' for more than STALE_LOCK_MINUTES.
+   * These likely crashed mid-execution.
+   */
+  recoverStaleLocks(): Promise<number>;
+  /**
+   * Get the next due time across all enabled tasks.
+   * Returns null if no tasks are scheduled.
+   */
+  getNextDueTime(): Promise<string | null>;
+}
+/**
+ * Per-plugin cron API implementation.
+ * Scoped to a single plugin ID — plugins cannot see or modify other plugins' tasks.
+ */
+declare class CronAccessImpl implements CronAccess {
+  private db;
+  private pluginId;
+  private reschedule;
+  private readonly now;
+  constructor(db: Kysely<Database>, pluginId: string, reschedule: RescheduleFn, now?: () => Date);
+  schedule(name: string, opts: {
+    schedule: string;
+    data?: Record<string, unknown>;
+  }): Promise<void>;
+  cancel(name: string): Promise<void>;
+  list(): Promise<CronTaskInfo[]>;
+}
+//#endregion
+//#region src/plugins/byline-access.d.ts
+/**
+ * Create read-only byline access (gated on `bylines:read`).
+ */
+declare function createBylineAccess(db: Kysely<Database>): BylineAccess;
+//#endregion
+//#region src/plugins/media.d.ts
+declare const DEFAULT_PLUGIN_MEDIA_READ_BYTES: number;
+declare const MAX_PLUGIN_MEDIA_READ_BYTES: number;
+declare function toPluginMediaItem(item: MediaItem): MediaItem$1;
+declare function readPluginMediaBytes(db: Kysely<Database>, storage: Pick<Storage, "download"> | undefined, id: string, options?: {
+  maxBytes?: number;
+}): Promise<MediaBytes>;
+declare function updatePluginMediaMetadata(db: Kysely<Database>, id: string, patch: MediaMetadataPatch): Promise<MediaItem$1>;
+declare function parsePluginMediaMetadataPatch(value: unknown): MediaMetadataPatch;
+//#endregion
+//#region src/plugins/storage-query.d.ts
+/**
+ * Error thrown when a guarded `updateIf` loses a concurrent race by aborting
+ * rather than resolving to `{ applied: false }`.
+ *
+ * `updateIf`'s `{ applied: false }` contract (row absent OR guard failed)
+ * assumes READ COMMITTED — the default. There, a losing concurrent writer
+ * re-evaluates the guard against the winner's freshly committed row and
+ * cleanly resolves to `{ applied: false }`. Two aborts escape that contract:
+ *
+ * - `40001` (serialization_failure), only above READ COMMITTED, where the
+ *   loser cannot re-read against a newer snapshot.
+ * - `40P01` (deadlock_detected), at any isolation level, when transactions
+ *   take row locks in opposite order.
+ *
+ * This error surfaces either abort so the caller can retry the write.
+ *
+ * The no-oversell SAFETY invariant holds either way: a losing writer NEVER
+ * applies its update — it either sees `{ applied: false }` or throws here.
+ */
+declare class StorageSerializationError extends Error {
+  readonly code = "STORAGE_SERIALIZATION_FAILURE";
+  readonly retryable = true;
+  /** The Postgres SQLSTATE that triggered this error (`40001` / `40P01`). */
+  readonly sqlState?: string;
+  constructor(message: string, options?: {
+    cause?: unknown;
+    sqlState?: string;
+  });
+}
+//#endregion
+export { MediaItem as $, ContentActionCallbacks as A, createContentAccess as B, SandboxUnavailableError as C, createSandboxRouteErrorEnvelope as D, createSandboxRouteError as E, createHttpAccess as F, encryptPluginSetting as G, PluginSettingEncryptionError as H, createMediaAccess as I, HookPipeline as J, isEncryptedPluginSetting as K, createRedirectAccess as L, RedirectAccessError as M, createCommentAccess as N, getSandboxRouteErrorDetails as O, createContentAccessWithWrite as P, CreateMediaInput as Q, createSchemaAccess as R, SandboxRunnerFactory as S, SerializedRequest as T, createSettingsAccess as U, EncryptedPluginSetting as V, decodePluginSettingValue as W, createHookPipeline as X, HookResult as Y, PluginStorageRepository as Z, SandboxOptions as _, readPluginMediaBytes as a, SandboxRouteErrorEnvelope as b, createBylineAccess as c, SandboxCommentModerateCallback as d, MediaRepository as et, SandboxContentCreateCallback as f, SandboxInvocationOptions as g, SandboxHttpFetchCallback as h, parsePluginMediaMetadataPatch as i, resolvePluginEncryptionKeys as it, ContentWriteGuard as j, getSandboxRouteErrorEnvelope as k, CronAccessImpl as l, SandboxEmailSendCallback as m, DEFAULT_PLUGIN_MEDIA_READ_BYTES as n, ContentRepository as nt, toPluginMediaItem as o, SandboxEmailMessage as p, EmailPipeline as q, MAX_PLUGIN_MEDIA_READ_BYTES as r, DatetimeContextCache as rt, updatePluginMediaMetadata as s, StorageSerializationError as t, FocalPointUpdate as tt, CronExecutor as u, SandboxRouteErrorCode as v, SandboxedPluginInstance as w, SandboxRunner as x, SandboxRouteErrorDetails as y, createUnrestrictedHttpAccess as z };
+//# sourceMappingURL=storage-query-Cy0SZ8iG.d.mts.map