@beechcms/api 0.6.0-preview.4 → 0.6.0

package/dist/{middleware.d.ts → middleware/auth.middleware.d.ts}

@@ -1,5 +1,5 @@
 import type { Context, Next } from 'hono';
-import type { Env, Variables } from './types';
+import type { Env, Variables } from '../types';
 /**
  * JWT authentication middleware. Reads the Bearer token from the Authorization
  * header and delegates verification to the ITokenService injected in context.

package/dist/middleware/repository.middleware.d.ts

@@ -1,4 +1,4 @@
-import type { ContentRepository, IdempotencyRepository, MediaRepository, SystemStatsRepository, IUserRepository, ISessionRepository, IPasswordResetTokenRepository, IActivityLogRepository, INotificationRepository, IWidgetRepository, ISearchRepository, IAnalyticsRepository, IContentScanRepository, IClock, IIdGenerator, IAutomationRunner, IAutomationRepository, IScheduler, ISiteSettingsRepository, IDemoDataRepository, ISeedLayoutRepository, ISeedRepository, ISchemaMutator, IDashboardLayoutRepository, BeechHooks } from '@beechcms/core';
+import type { ContentRepository, IdempotencyRepository, MediaRepository, SystemStatsRepository, IUserRepository, ISessionRepository, IPasswordResetTokenRepository, IActivityLogRepository, INotificationRepository, IWidgetRepository, ISearchRepository, IAnalyticsRepository, IContentScanRepository, IClock, IIdGenerator, IAutomationRunner, IAutomationRepository, IScheduler, ISiteSettingsRepository, IDemoDataRepository, ISeedLayoutRepository, ISeedRepository, ISchemaMutator, IDashboardLayoutRepository, BeechHooks, IKanbanPositionRepository } from '@beechcms/core';
 import type { Env, Variables } from '../types';
 interface RepositoryOverrides {
     repository?: ContentRepository;
@@ -25,6 +25,7 @@ interface RepositoryOverrides {
     seedRepository?: ISeedRepository;
     schemaMutator?: ISchemaMutator;
     dashboardLayoutRepository?: IDashboardLayoutRepository;
+    kanbanPositionRepository?: IKanbanPositionRepository;
     hooks?: BeechHooks;
 }
 export declare const repositoryMiddleware: (overrides?: RepositoryOverrides) => import("hono").MiddlewareHandler<{

package/dist/public/access-policy.d.ts

@@ -6,7 +6,7 @@ export declare function checkPublicOperation(seed: Seed, operation: PublicOperat
 } | {
     readonly ok: false;
     readonly error: {
-        readonly error: "Forbidden";
+        readonly error: 'Forbidden';
         readonly message: `Public ${string} is not allowed for content type '${string}'.`;
     };
 };

package/dist/public/problem-details.d.ts

@@ -20,6 +20,7 @@ type PublicProblemInput = {
     status: 400 | 401 | 403 | 404 | 405 | 409 | 422 | 429 | 500 | 501;
     detail: string;
     errors?: PublicProblemDetailItem[];
+    headers?: Record<string, string>;
 };
 export declare function internalErrorDetail(env: {
     ENV?: string;

package/dist/public/public-errors.d.ts

@@ -3,11 +3,11 @@
  */
 export declare const PUBLIC_ERRORS: {
     readonly API_KEY_UNAUTHORIZED: {
-        readonly error: "Unauthorized";
-        readonly message: "Missing or invalid API key. Provide a valid key via X-API-Key header.";
+        readonly error: 'Unauthorized';
+        readonly message: 'Missing or invalid API key. Provide a valid key via X-API-Key header.';
     };
     readonly API_KEY_FORBIDDEN: {
-        readonly error: "Forbidden";
-        readonly message: "Public API access is not configured for this instance.";
+        readonly error: 'Forbidden';
+        readonly message: 'Public API access is not configured for this instance.';
     };
 };

package/dist/rate-limit/cloudflare-rate-limiter.d.ts

@@ -1,6 +1,9 @@
 import type { IRateLimiter, RateLimitResult } from '@beechcms/core';
 export declare class CloudflareRateLimiter implements IRateLimiter {
     private readonly binding;
-    constructor(binding: RateLimit);
+    private readonly options;
+    constructor(binding: RateLimit, options?: {
+        failClosed?: boolean;
+    });
     checkLimit(key: string): Promise<RateLimitResult>;
 }

package/dist/rate-limit/in-memory-rate-limiter.d.ts

@@ -1,7 +1,8 @@
 import type { IRateLimiter, RateLimitResult } from '@beechcms/core';
 export declare class InMemoryRateLimiter implements IRateLimiter {
     private readonly maxAllowedHits;
+    private readonly windowSeconds;
     private readonly hitCounts;
-    constructor(maxAllowedHits: number);
+    constructor(maxAllowedHits: number, windowSeconds?: number);
     checkLimit(key: string): Promise<RateLimitResult>;
 }

package/dist/shared/{schema-mutator.d1.d.ts → db/migrations/schema-mutator.d1.d.ts}

@@ -9,4 +9,5 @@ export declare class D1SchemaMutator implements ISchemaMutator {
     dropColumn(table: string, column: string): Promise<void>;
     renameColumn(table: string, from: string, to: string): Promise<void>;
     execDestructive(statements: string[]): Promise<void>;
+    fetchRows(table: string, columns: string[]): Promise<Record<string, unknown>[]>;
 }

package/dist/shared/db/repositories/content.repository.d1.d.ts

@@ -0,0 +1,259 @@
+import { ContentRepository, type BulkFieldUpdate, type BatchWrite, type DraftSummary, type Seed, type SelectOptions, type RepositoryOptions, type BeechHooks } from '@beechcms/core';
+import { BaseD1Repository } from './base.repository.d1';
+/**
+ * D1 (Cloudflare SQLite) implementation of {@link ContentRepository}.
+ *
+ * Persists each seed's entries in a dedicated `content_{slug}` table, with multi-relation
+ * branches stored in separate junction tables (`rel_{slug}_{alias}`) rather than as columns,
+ * since D1/SQLite has no native array column type. Draft data mirrors this shape in
+ * `content_{slug}_drafts` and `rel_{slug}_{alias}_drafts` tables.
+ *
+ * Lifecycle hooks ({@link BeechHooks}) fire around create/update/delete: `before*` hooks run
+ * inside the try block and may transform the payload or abort by throwing; `after*` hooks run
+ * once the write has already committed and therefore cannot roll back the mutation.
+ */
+export declare class D1ContentRepository extends BaseD1Repository implements ContentRepository {
+    private readonly hooks?;
+    constructor(database: D1Database, hooks?: BeechHooks | undefined);
+    /** Assembles the {@link HookContext} passed to every lifecycle hook invocation. */
+    private hookCtx;
+    /**
+     * Deserializes a DB row using the Seed's branch definitions.
+     * Skips multi-relation branches — their values come from junction tables.
+     */
+    private rowToData;
+    /**
+     * Fetches multi-relation arrays for a single entry and attaches them to `data`.
+     *
+     * @param seed The seed schema definition.
+     * @param entryId Id of the entry to fetch relation targets for.
+     * @param data Mutated in place: one array property per multi-relation branch alias.
+     */
+    private attachMultiRelations;
+    /**
+     * Builds one junction-table statement per multi-relation branch, selecting the rows whose
+     * `parent_id` falls within the page defined by `idQuery` (the page selection re-projected to
+     * ids only). Using a subquery instead of a bound `IN (?, ...)` id list keeps the statements
+     * eligible for the same batch as the page query and avoids D1's bound-parameter limit.
+     *
+     * The subquery is wrapped in `SELECT id FROM (...)` because `kanbanOrder` projections carry an
+     * extra `kp.position` column, and `IN` requires a single-column subselect.
+     */
+    private multiRelStatements;
+    /**
+     * Groups junction rows by parent and attaches them to the entries: one array property per
+     * multi-relation branch alias, per entry. `relResults[i]` must correspond to `branches[i]`.
+     *
+     * @param entries Mutated in place.
+     */
+    private attachMultiRelationRows;
+    /**
+     * Finds multiple entries for a given seed table based on the provided query options.
+     * Executes a single batch (one D1 round-trip) containing:
+     * 1. A selection query to retrieve the items for the current page (with columns, limits, offsets, and ordering).
+     * 2. A count query (using `isCount: true`) to retrieve the total number of matched items matching the same filters.
+     * 3. One junction-table query per multi-relation branch, scoped to the page via an id subquery.
+     *
+     * @param seed The seed schema definition.
+     * @param options Filtering, search, ordering, and pagination options.
+     * @returns An object containing the list of serialized entries and the total count of matched items.
+     * @throws RepositoryError if the database batch execution fails.
+     */
+    findMany(seed: Seed, options: SelectOptions): Promise<{
+        items: Record<string, any>[];
+        total: number;
+    }>;
+    /**
+     * Fetches a single entry by id, including its multi-relation arrays.
+     * @throws EntryNotFoundError if no row with `id` exists in the seed's table.
+     * @throws RepositoryError on any other database failure.
+     */
+    findById(seed: Seed, id: string): Promise<Record<string, any>>;
+    /**
+     * Fetches a single entry by its unique `slug`, including its multi-relation arrays.
+     * @throws EntryNotFoundError if no row with `slug` exists in the seed's table.
+     * @throws RepositoryError on any other database failure.
+     */
+    findBySlug(seed: Seed, slug: string): Promise<Record<string, any>>;
+    /**
+     * Computes aggregate facets for a seed: entry counts per `status`, and the distinct set
+     * of tag values present across all entries for each `tags`-typed branch (via `json_each`
+     * over the JSON-serialized tag column).
+     */
+    getFacets(seed: Seed): Promise<{
+        statuses: Record<string, number>;
+        tagsByColumn: Record<string, string[]>;
+    }>;
+    /**
+     * Checks whether `slug` is already taken in the seed's table.
+     * @param excludeId When provided (e.g. during an update), excludes that entry's own row from the check.
+     */
+    existsSlug(seed: Seed, slug: string, excludeId?: string): Promise<boolean>;
+    /**
+     * Builds the `INSERT` statement for an entry's main table row. Multi-relation branch
+     * values are skipped (they're written as separate junction-table inserts by the caller).
+     */
+    private buildCreateMainStmt;
+    /**
+     * Builds the `UPDATE` statement for an entry's main table row from whichever branch
+     * aliases are present in `data` (partial update — absent keys are left untouched).
+     * Multi-relation branches present in `data` are returned as `junctionUpdates` instead
+     * of being included in the SQL, since they require separate delete+insert statements.
+     *
+     * @returns `stmt: null` when there is nothing to update on the main row (no scalar
+     *   fields and no `status` change) even if junction updates are still needed.
+     */
+    private buildUpdateMainStmt;
+    /** Builds one `INSERT` per target id into a live multi-relation junction table, preserving array order via `position`. */
+    private buildJunctionInserts;
+    /** Builds one `INSERT` per target id into a draft multi-relation junction table, preserving array order via `position`. */
+    private buildDraftJunctionInserts;
+    /**
+     * Validates that every relation target referenced by a draft still exists before publish,
+     * for both single-relation columns and multi-relation draft junction rows.
+     *
+     * @throws RelationTargetNotFoundError if any referenced target id is missing from its target seed's table.
+     * @returns The multi-relation branches and their resolved (validated) draft target ids,
+     *   so the caller can reuse them without re-querying the draft junction tables.
+     */
+    private validatePublishDraftRelations;
+    /**
+     * Builds the junction-table statements for one array-typed {@link BulkFieldUpdate}:
+     * `array_replace` (delete-all + reinsert), `array_add` (append via `INSERT OR IGNORE`
+     * with position computed from current max), or `array_remove` (targeted delete).
+     * Returns an empty array for a no-op (e.g. `array_remove` with an empty value list).
+     */
+    private getBulkArrayUpdateStmts;
+    /**
+     * Applies a bulk field update to a single entry as one batch: a main-table `UPDATE` for
+     * `set`-kind fields plus any junction statements for array-kind fields.
+     * @throws Error('not-found') if the main `UPDATE` affects zero rows (id doesn't exist).
+     */
+    private processBulkUpdateSingle;
+    /**
+     * Sequentially applies a bulk field update to each id in `chunk`, isolating per-id
+     * failures (not-found, FK violation, or other error) into the `failed` list rather than
+     * aborting the whole chunk.
+     */
+    private processBulkUpdateChunk;
+    /**
+     * Creates a new entry: runs `beforeCreate` (which may transform the payload), inserts the
+     * main row plus any multi-relation junction rows as a single batch, then runs `afterCreate`.
+     *
+     * @throws SlugConflictError if `slug` already exists for this seed.
+     * @throws RepositoryError on any other database failure.
+     * @remarks `afterCreate` runs after the batch has committed, so it cannot roll back the write.
+     */
+    create(seed: Seed, id: string, slug: string, status: string, data: Record<string, any>, options?: RepositoryOptions): Promise<void>;
+    /**
+     * Partially updates an existing entry: runs `beforeUpdate`, applies main-row and
+     * junction-table changes as a batch, then runs `afterUpdate`. A no-op payload (no scalar
+     * fields, no multi-relation fields, no status change) returns without touching the database.
+     *
+     * @throws EntryNotFoundError if the main-row `UPDATE` affects zero rows.
+     * @throws RepositoryError on any other database failure.
+     * @remarks `afterUpdate` runs after the batch has committed, so it cannot roll back the write.
+     */
+    update(seed: Seed, id: string, data: Record<string, any>, status?: string, options?: RepositoryOptions): Promise<void>;
+    /**
+     * Deletes an entry: runs `beforeDelete`, reads the row (for the return value), deletes it,
+     * then runs `afterDelete`. Relies on database-level `ON DELETE CASCADE` for junction rows.
+     *
+     * @returns The deserialized row as it existed immediately before deletion.
+     * @throws EntryNotFoundError if no row with `id` exists.
+     * @remarks `afterDelete` runs after the delete has committed, so it cannot roll back the write.
+     */
+    delete(seed: Seed, id: string, options?: RepositoryOptions): Promise<{
+        row: Record<string, any>;
+    }>;
+    /**
+     * Atomically increments/decrements a numeric field in a single conditional `UPDATE`
+     * (guarded by optional `min`/`max` bounds evaluated against the new value), avoiding
+     * read-modify-write races.
+     *
+     * @throws RepositoryError if `fieldName` isn't a `number`-typed branch on `seed`, or if
+     *   the conditional `UPDATE` affects zero rows (entry not found, or bound exceeded).
+     */
+    mutateField(seed: Seed, id: string, fieldName: string, operation: {
+        type: 'increment' | 'decrement';
+        value: number;
+    }, options?: {
+        min?: number;
+        max?: number;
+    }): Promise<{
+        newValue: number;
+    }>;
+    /**
+     * Executes a heterogeneous list of {@link BatchWrite} operations (create/update/mutateField)
+     * as a single atomic `database.batch` call. Does not invoke lifecycle hooks — callers needing
+     * hook side effects should use {@link create}/{@link update}/{@link mutateField} instead.
+     *
+     * @throws RepositoryError if any operation references a non-numeric field for `mutateField`,
+     *   or on any other database failure.
+     */
+    runBatch(operations: BatchWrite[]): Promise<void>;
+    /**
+     * Upserts a draft row for `entryId` (`INSERT ... ON CONFLICT DO UPDATE` keyed on `entry_id`)
+     * plus a full delete+reinsert of each multi-relation branch's draft junction rows.
+     * @throws RepositoryError if `seed.allowDrafts` is false, or on any database failure.
+     */
+    saveDraft(seed: Seed, entryId: string, data: Record<string, any>): Promise<void>;
+    /**
+     * Fetches the draft row for `entryId`, if any, merged with its multi-relation draft arrays.
+     * @returns `null` if `seed.allowDrafts` is false or no draft row exists.
+     */
+    getDraft(seed: Seed, entryId: string): Promise<Record<string, any> | null>;
+    /** Checks whether a draft row exists for `entryId`. Always `false` if `seed.allowDrafts` is false. */
+    hasDraft(seed: Seed, entryId: string): Promise<boolean>;
+    /**
+     * Promotes a draft to the live entry: validates all relation targets referenced by the
+     * draft still exist, copies the draft's scalar fields into the live row, replaces the
+     * live junction rows with the draft's, and deletes the draft — all as one batch.
+     * A no-op if `seed.allowDrafts` is false.
+     *
+     * @throws EntryNotFoundError if no draft row exists for `entryId`.
+     * @throws RelationTargetNotFoundError if any relation the draft references no longer exists.
+     */
+    publishDraft(seed: Seed, entryId: string): Promise<void>;
+    /**
+     * Applies the same set of field updates across many entries, chunked at 50 ids per batch
+     * to bound per-call payload size. Per-id failures are collected rather than aborting the
+     * whole operation — see {@link processBulkUpdateSingle} for failure classification.
+     */
+    bulkUpdate(seed: Seed, ids: string[], fields: Record<string, BulkFieldUpdate>): Promise<{
+        updated: number;
+        failed: Array<{
+            id: string;
+            reason: string;
+        }>;
+    }>;
+    /** Deletes the draft row for `entryId`, if any. A no-op if `seed.allowDrafts` is false. */
+    deleteDraft(seed: Seed, entryId: string): Promise<void>;
+    /**
+     * Finds every pending draft across the given seeds, `UNION ALL`-ing one query per seed
+     * so results span heterogeneous `content_{slug}_drafts` tables, then left-joins each
+     * against `activity_logs` to attribute the most recent "draft saved" action.
+     *
+     * @param seeds Seeds to search; drafts are looked up per-seed since draft tables aren't unified.
+     * @returns Draft summaries ordered by most-recently-updated first. `title` falls back to the
+     *   draft's own `id` if the display-name column is blank on both the draft and its live counterpart.
+     */
+    findPendingDrafts(seeds: Seed[]): Promise<DraftSummary[]>;
+    /**
+     * Updates an entry's field values (optional) and its kanban board position atomically in one
+     * batch: an optional main-row/junction update via {@link buildUpdateMainStmt}, plus an upsert
+     * into `kanban_positions` keyed on `(seed_slug, entry_id, axis_branch_id)`.
+     *
+     * @param patch Field changes to apply alongside the drag/drop, or `null` if only position changed.
+     * @param position Opaque fractional-index (or similar) position value used for ordering within the axis bucket.
+     * @param axisBranchId Identifies which branch/column axis this position is relative to (e.g. status column).
+     * @remarks Unlike {@link create}/{@link update}, this method does not invoke `beforeUpdate`/`afterUpdate`
+     *   lifecycle hooks — the `_ctx.actor` parameter is currently unused. Kanban drag-and-drop writes
+     *   therefore bypass hook-based side effects (e.g. audit logging) that `update()` would trigger.
+     */
+    updateWithKanbanPosition(seed: Seed, id: string, patch: Record<string, unknown> | null, position: string, axisBranchId: string, _ctx: {
+        actor: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+}

package/dist/shared/db/repositories/kanban-position.repository.d1.d.ts

@@ -0,0 +1,9 @@
+import type { IKanbanPositionRepository, KanbanPositionRecord } from '@beechcms/core';
+export declare class D1KanbanPositionRepository implements IKanbanPositionRepository {
+    private readonly db;
+    constructor(db: D1Database);
+    getColumn(seedSlug: string, axisBranchId: string): Promise<Map<string, string>>;
+    setPosition(seedSlug: string, entryId: string, axisBranchId: string, position: string): Promise<void>;
+    remove(seedSlug: string, entryId: string, axisBranchId: string): Promise<void>;
+    rebalance(seedSlug: string, axisBranchId: string, ordered: KanbanPositionRecord[]): Promise<void>;
+}

package/dist/shared/{seed-layout.repository.d1.d.ts → db/repositories/seed-layout.repository.d1.d.ts}

@@ -1,4 +1,4 @@
-import type { ISeedLayoutRepository, SeedLayoutRecord, FormLayout } from '@beechcms/core';
+import { type ISeedLayoutRepository, type SeedLayoutRecord, type FormLayout, type SeedViewConfig } from '@beechcms/core';
 export declare class D1SeedLayoutRepository implements ISeedLayoutRepository {
     private readonly db;
     constructor(db: D1Database);
@@ -6,4 +6,6 @@ export declare class D1SeedLayoutRepository implements ISeedLayoutRepository {
     getAllAsMap(): Promise<Map<string, FormLayout>>;
     upsert(slug: string, layout: FormLayout, updatedBy: string): Promise<void>;
     remove(slug: string): Promise<void>;
+    getViewConfig(slug: string): Promise<SeedViewConfig | null>;
+    setViewConfig(slug: string, config: SeedViewConfig, updatedBy: string): Promise<void>;
 }

package/dist/shared/email/email.provider.d.ts

@@ -0,0 +1 @@
+export type { EmailProvider, OutboundEmail } from '@beechcms/core';

package/dist/{features → shared}/email/email.types.d.ts

@@ -12,7 +12,7 @@
  *  2. Add the corresponding translation in the `COPY` object of every
  *     file in `templates/`. TypeScript will flag missing keys.
  */
-export declare const SUPPORTED_EMAIL_LOCALES: readonly ["en", "it"];
+export declare const SUPPORTED_EMAIL_LOCALES: readonly ['en', 'it'];
 export type EmailLocale = (typeof SUPPORTED_EMAIL_LOCALES)[number];
 /**
  * Resolves an unverified locale string (e.g., from a request body)
@@ -23,20 +23,6 @@ export type EmailLocale = (typeof SUPPORTED_EMAIL_LOCALES)[number];
  * @returns A valid `EmailLocale`, always.
  */
 export declare function resolveEmailLocale(raw: unknown): EmailLocale;
-/**
- * The resolved email message that the provider receives and sends.
- * It is constructed by the service by combining the call parameters
- * with the template builder output.
- */
-export interface OutboundEmail {
-    /** Sender address in RFC 5321 format (e.g., "Beech CMS <noreply@beechcms.dev>"). */
-    from: string;
-    /** List of recipient addresses. Must contain at least one element. */
-    to: string[];
-    subject: string;
-    /** Complete HTML body. Must be a valid HTML document (see `templates/shell.ts`). */
-    html: string;
-}
 /**
  * Shared parameters for every email sending function in `email.service.ts`.
  * Specific functions extend this type with the additional fields
@@ -87,7 +73,6 @@ export interface AutomationMailParams {
     /** Plain text or HTML — passed verbatim to provider. */
     body: string;
     apiKey?: string;
-    resendApiKey?: string;
     from?: string;
     provider?: 'smtp' | 'resend';
     smtpBaseUrl?: string;

package/dist/{features → shared}/email/providers/resend.d.ts

@@ -1,5 +1,4 @@
-import type { EmailProvider } from '../email.provider';
-import type { OutboundEmail } from '../email.types';
+import type { EmailProvider, OutboundEmail } from '@beechcms/core';
 /**
  * Resend implementation of EmailProvider.
  *

package/dist/{features → shared}/email/providers/smtp.d.ts

@@ -1,5 +1,4 @@
-import type { EmailProvider } from '../email.provider';
-import type { OutboundEmail } from '../email.types';
+import type { EmailProvider, OutboundEmail } from '@beechcms/core';
 export interface SmtpProviderConfig {
     /** Base URL of the Mailpit HTTP API, e.g. http://localhost:8025 */
     baseUrl: string;

package/dist/shared/jobs/queue-consumer.d.ts

@@ -0,0 +1,9 @@
+import type { JobRegistry, QueueMessage } from '@beechcms/core';
+import type { Env } from '../../types';
+/**
+ * Consumer-side dispatch. Mirrors index.ts `scheduled()`: builds an
+ * engine-mediated JobContext from bindings (NEVER exposes env.DB to jobs) and
+ * routes each message to its handler. ack() on success/unknown-name (drop),
+ * retry() on throw so Cloudflare re-delivers.
+ */
+export declare function dispatchQueueBatch(batch: MessageBatch<QueueMessage>, env: Env, _ctx: ExecutionContext, jobs: JobRegistry): Promise<void>;

package/dist/shared/services/queue/cloudflare-queue-service.d.ts

@@ -0,0 +1,11 @@
+import type { IQueueService, QueueMessage } from '@beechcms/core';
+/**
+ * Production producer. Sends a QueueMessage envelope onto the Cloudflare Queue
+ * binding. Cloudflare guarantees at-least-once delivery + retries on the
+ * consumer side, so enqueue only needs to hand off the message.
+ */
+export declare class CloudflareQueueService implements IQueueService {
+    private readonly queue;
+    constructor(queue: Queue<QueueMessage>);
+    enqueue<T>(name: string, payload: T): Promise<void>;
+}

package/dist/shared/services/queue/in-memory-queue-service.d.ts

@@ -0,0 +1,16 @@
+import type { IQueueService, JobRegistry, JobContext } from '@beechcms/core';
+type ScheduleBackgroundTask = (task: Promise<unknown>) => void;
+/**
+ * Dev/offline + test fallback used when the QUEUE binding is absent. Runs the
+ * matching handler in-process. In production this is never selected. Uses
+ * executionCtx.waitUntil when available so enqueue stays non-blocking; falls
+ * back to awaiting inline (tests) otherwise.
+ */
+export declare class InMemoryQueueService implements IQueueService {
+    private readonly jobs;
+    private readonly context;
+    private readonly scheduleBackgroundTask?;
+    constructor(jobs: JobRegistry, context: JobContext, scheduleBackgroundTask?: ScheduleBackgroundTask | undefined);
+    enqueue<T>(name: string, payload: T): Promise<void>;
+}
+export {};

package/dist/shared/storage/s3-bucket.d.ts

@@ -17,7 +17,6 @@ export declare class S3Bucket implements BeechBucket {
         cdnUrl?: string;
     });
     put(key: string, body: ArrayBuffer | Uint8Array | ReadableStream, options?: PutBucketOptions): Promise<void>;
-    private streamToUint8Array;
     get(key: string): Promise<GetBucketResult | null>;
     delete(key: string): Promise<void>;
     head(key: string): Promise<{

package/dist/shared/storage/upload.d.ts

@@ -0,0 +1,7 @@
+export declare function deleteR2Objects(c: {
+    var: {
+        bucket: any;
+        mediaRepository: any;
+        systemStatsRepository: any;
+    };
+}, objectKeys: string[]): Promise<void>;

package/dist/{media-utils.d.ts → shared/utils/media-utils.d.ts}

@@ -10,9 +10,10 @@ import type { Seed } from '@beechcms/core';
  * Es: "https://x.com/api/media/1739123456-avatar.png" → "1739123456-avatar.png"
  *
  * @param mediaUrl - URL completo o path (es. /api/media/123-foto.png)
+ * @param cdnUrl - URL CDN opzionale configurato
  * @returns Chiave R2 o null se l'URL non è valido
  */
-export declare function extractMediaKey(mediaUrl: string): string | null;
+export declare function extractMediaKey(mediaUrl: string, cdnUrl?: string): string | null;
 /**
  * Estrae tutte le chiavi R2 dal data di un'entry.
  * Cerca nei campi `file` (stringa URL) e `json` (array/oggetto con URL).
@@ -20,6 +21,7 @@ export declare function extractMediaKey(mediaUrl: string): string | null;
  *
  * @param seed - Schema del tipo di contenuto
  * @param entryData - Payload in formato DB (chiavi = branch ID)
+ * @param cdnUrl - URL CDN opzionale configurato
  * @returns Array di chiavi R2 uniche da eliminare
  */
-export declare function extractMediaKeysFromData(seed: Seed, entryData: Record<string, unknown>): string[];
+export declare function extractMediaKeysFromData(seed: Seed, entryData: Record<string, unknown>, cdnUrl?: string): string[];