includio-cms 0.36.7 → 0.36.9

package/dist/core/cms.js

@@ -178,6 +178,13 @@ export function initCMS(config) {
     import('./server/media/operations/backgroundMaintenance.js')
         .then((m) => m.startBackgroundMaintenance())
         .catch((e) => console.warn('[cms] Failed to start background maintenance:', e));
+    // Start in-process media optimization worker (generuje warianty poza ścieżką renderu).
+    // Wyłączalny przez media.optimization.worker = false.
+    if (cms.mediaConfig.optimization?.worker !== false) {
+        import('./server/media/jobs/startWorker.js')
+            .then((m) => m.startMediaOptimizationWorker())
+            .catch((e) => console.warn('[cms] Failed to start media worker:', e));
+    }
     // Apply shop variantAttribute GIN indexes (idempotent CREATE INDEX IF NOT EXISTS).
     // Pass shop + drizzle explicitly so the dynamic import doesn't depend on a
     // shared CMS singleton (vitest can give the dynamic module a fresh instance).

package/dist/core/fields/dotPath.d.ts

@@ -0,0 +1,4 @@
+/** Read a value at a dot-path. Returns undefined if any segment is missing. */
+export declare function getAtPath(obj: Record<string, any>, path: string): any;
+/** Set a value at a dot-path, creating intermediate objects. Mutates `obj` in place. */
+export declare function setAtPath(obj: Record<string, unknown>, path: string, value: unknown): void;

package/dist/core/fields/dotPath.js

@@ -0,0 +1,18 @@
+/** Read a value at a dot-path. Returns undefined if any segment is missing. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function getAtPath(obj, path) {
+    const parts = path.split('.');
+    return parts.reduce((acc, key) => (acc && acc[key] !== undefined ? acc[key] : undefined), obj);
+}
+/** Set a value at a dot-path, creating intermediate objects. Mutates `obj` in place. */
+export function setAtPath(obj, path, value) {
+    const parts = path.split('.');
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const key = parts[i];
+        if (!current[key] || typeof current[key] !== 'object')
+            current[key] = {};
+        current = current[key];
+    }
+    current[parts[parts.length - 1]] = value;
+}

package/dist/core/fields/slugify.d.ts

@@ -0,0 +1,3 @@
+import slugify from 'slugify';
+declare const _default: typeof slugify.default;
+export default _default;

package/dist/core/fields/slugify.js

@@ -0,0 +1,4 @@
+import slugify from 'slugify';
+// `slugify` ships as CJS; mirror the interop cast used across the app so core
+// code can import it without depending on `$lib/admin`.
+export default slugify;

package/dist/core/server/entries/operations/duplicate.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Duplicate a collection entry as an unpublished copy. Copies the freshest
+ * content per language (draft ?? published ?? scheduled), prefixes the admin
+ * title, makes each slug unique (`-kopia`), and creates draft (publishedAt:
+ * null) versions on a fresh entry. Media/relation references are shared
+ * (shallow). Throws on archived source. Returns the new entry id.
+ */
+export declare function duplicateEntry(sourceId: string): Promise<{
+    id: string;
+}>;

package/dist/core/server/entries/operations/duplicate.js

@@ -0,0 +1,73 @@
+import slugify from '../../../fields/slugify.js';
+import { getCMS } from '../../../cms.js';
+import { getFieldsFromConfig } from '../../../fields/layoutUtils.js';
+import { getAtPath, setAtPath } from '../../../fields/dotPath.js';
+import { _getRawEntryOrThrow as getRawEntryOrThrow } from './get.js';
+import { createEntryVersion } from './create.js';
+import { collectSlugFieldPaths, deriveUniqueSlug } from './slugUniqueness.js';
+const TITLE_PREFIX = 'Kopia — ';
+/**
+ * Duplicate a collection entry as an unpublished copy. Copies the freshest
+ * content per language (draft ?? published ?? scheduled), prefixes the admin
+ * title, makes each slug unique (`-kopia`), and creates draft (publishedAt:
+ * null) versions on a fresh entry. Media/relation references are shared
+ * (shallow). Throws on archived source. Returns the new entry id.
+ */
+export async function duplicateEntry(sourceId) {
+    const cms = getCMS();
+    const source = await getRawEntryOrThrow({ id: sourceId });
+    if (source.archivedAt != null) {
+        throw new Error('Cannot duplicate an archived entry');
+    }
+    const config = cms.getBySlug(source.slug);
+    const slugPaths = collectSlugFieldPaths(getFieldsFromConfig(config));
+    const titlePath = 'entryAdminTitle' in config ? config.entryAdminTitle : undefined;
+    // Languages that have any content; freshest version wins per language.
+    const langs = new Set([
+        ...Object.keys(source.draftVersions ?? {}),
+        ...Object.keys(source.publishedVersions ?? {}),
+        ...Object.keys(source.scheduledVersions ?? {})
+    ]);
+    const perLang = {};
+    for (const lang of langs) {
+        const version = source.draftVersions?.[lang] ??
+            source.publishedVersions?.[lang] ??
+            source.scheduledVersions?.[lang] ??
+            null;
+        if (!version)
+            continue;
+        perLang[lang] = structuredClone(version.data);
+    }
+    // Transform each copy: title prefix + unique, slugified slug.
+    for (const [lang, data] of Object.entries(perLang)) {
+        if (titlePath) {
+            const title = getAtPath(data, titlePath);
+            if (typeof title === 'string' && title.trim() !== '') {
+                setAtPath(data, titlePath, `${TITLE_PREFIX}${title}`);
+            }
+        }
+        for (const path of slugPaths) {
+            const value = getAtPath(data, path);
+            if (typeof value === 'string' && value.trim() !== '') {
+                const base = slugify(value, { lower: true, strict: true, trim: true });
+                const unique = await deriveUniqueSlug({ collection: source.slug, lang, path, base });
+                setAtPath(data, path, unique);
+            }
+        }
+    }
+    const newEntry = await cms.databaseAdapter.createEntry({
+        type: source.type,
+        slug: source.slug
+    });
+    const entries = Object.entries(perLang);
+    if (entries.length === 0) {
+        // Source had no content — seed an empty default-language draft.
+        await createEntryVersion({ entryId: newEntry.id, lang: cms.languages[0], data: {}, publishedAt: null }, { skipValidation: true });
+    }
+    else {
+        for (const [lang, data] of entries) {
+            await createEntryVersion({ entryId: newEntry.id, lang, data, publishedAt: null }, { skipValidation: true });
+        }
+    }
+    return { id: newEntry.id };
+}

package/dist/core/server/entries/operations/slugNormalize.d.ts

@@ -0,0 +1,8 @@
+import type { CollectionConfigWithType } from '../../../../types/collections.js';
+import type { SingleConfigWithType } from '../../../../types/singles.js';
+/**
+ * Return a copy of `data` where every slug-typed field (SlugField / seo.slug /
+ * nested) is normalized through slugify. Non-string / empty values and non-slug
+ * fields are left untouched. Does not mutate the input.
+ */
+export declare function normalizeSlugFields(config: CollectionConfigWithType | SingleConfigWithType, data: Record<string, unknown>): Record<string, unknown>;

package/dist/core/server/entries/operations/slugNormalize.js

@@ -0,0 +1,20 @@
+import slugify from '../../../fields/slugify.js';
+import { getFieldsFromConfig } from '../../../fields/layoutUtils.js';
+import { getAtPath, setAtPath } from '../../../fields/dotPath.js';
+import { collectSlugFieldPaths } from './slugUniqueness.js';
+/**
+ * Return a copy of `data` where every slug-typed field (SlugField / seo.slug /
+ * nested) is normalized through slugify. Non-string / empty values and non-slug
+ * fields are left untouched. Does not mutate the input.
+ */
+export function normalizeSlugFields(config, data) {
+    const slugPaths = collectSlugFieldPaths(getFieldsFromConfig(config));
+    const out = structuredClone(data);
+    for (const path of slugPaths) {
+        const value = getAtPath(out, path);
+        if (typeof value === 'string' && value.trim() !== '') {
+            setAtPath(out, path, slugify(value, { lower: true, strict: true, trim: true }));
+        }
+    }
+    return out;
+}

package/dist/core/server/entries/operations/slugUniqueness.d.ts

@@ -35,3 +35,20 @@ export interface AssertSlugUniqueArgs {
  *   which slug-field collided).
  */
 export declare function assertSlugUnique({ collection, lang, data, excludeEntryId }: AssertSlugUniqueArgs): Promise<void>;
+export interface DeriveUniqueSlugArgs {
+    /** Collection slug (config slug). */
+    collection: string;
+    /** Content language whose slugs must not collide. */
+    lang: string;
+    /** Dot-path of the slug field. */
+    path: string;
+    /** Already-slugified base value to build the copy from. */
+    base: string;
+}
+/**
+ * Build a slug based on `base` that does not collide with any published-or-
+ * scheduled slug at `path` in `collection` + `lang`. Always appends the
+ * `-kopia` marker; on further collision appends `-kopia-2`, `-kopia-3`, … .
+ * Drafts, archived entries and other languages are ignored.
+ */
+export declare function deriveUniqueSlug({ collection, lang, path, base }: DeriveUniqueSlugArgs): Promise<string>;

package/dist/core/server/entries/operations/slugUniqueness.js

@@ -114,3 +114,42 @@ export async function assertSlugUnique({ collection, lang, data, excludeEntryId
         }
     }
 }
+/**
+ * Build a slug based on `base` that does not collide with any published-or-
+ * scheduled slug at `path` in `collection` + `lang`. Always appends the
+ * `-kopia` marker; on further collision appends `-kopia-2`, `-kopia-3`, … .
+ * Drafts, archived entries and other languages are ignored.
+ */
+export async function deriveUniqueSlug({ collection, lang, path, base }) {
+    const cms = getCMS();
+    const dbEntries = await cms.databaseAdapter.getEntries({ slug: collection });
+    const ids = dbEntries.filter((e) => e.archivedAt == null).map((e) => e.id);
+    const used = new Set();
+    if (ids.length > 0) {
+        const versions = await cms.databaseAdapter.getEntryVersions({ entryIds: ids, lang });
+        const latestPerEntry = new Map();
+        for (const v of versions) {
+            if (v.publishedAt == null)
+                continue;
+            const cur = latestPerEntry.get(v.entryId);
+            if (!cur || v.versionNumber > cur.versionNumber) {
+                latestPerEntry.set(v.entryId, {
+                    versionNumber: v.versionNumber,
+                    data: v.data
+                });
+            }
+        }
+        for (const { data } of latestPerEntry.values()) {
+            const s = readSlugAtPath(data, path, lang);
+            if (typeof s === 'string' && s.trim() !== '')
+                used.add(s);
+        }
+    }
+    let candidate = `${base}-kopia`;
+    let n = 2;
+    while (used.has(candidate)) {
+        candidate = `${base}-kopia-${n}`;
+        n++;
+    }
+    return candidate;
+}

package/dist/core/server/fields/utils/imageStyles.js

@@ -2,6 +2,8 @@ import { getImageStylesBatch } from '../../media/styles/operations/getImageStyle
 import { imageStyleKey } from '../../../../types/adapters/db.js';
 import { getCMS } from '../../../cms.js';
 import { generateBlurDataUrl } from '../../media/utils/generateBlurDataUrl.js';
+import { buildStyleSpecs } from '../../media/styles/buildStyleSpecs.js';
+import { resolveImagesConfig } from '../../media/styles/imagesConfig.js';
 export const defaultStyles = [
     { name: 'default', srcset: [640, 1024, 1920, 2560] }
 ];
@@ -72,10 +74,45 @@ function variantStyleFor(style, w) {
 }
 export async function getImageStyles(field, val) {
     const hasCustomStyles = field.styles && field.styles.length > 0;
-    const rawStyles = [...(isProcessableImage(val) && !hasCustomStyles ? defaultStyles : []), ...(field.styles || [])];
-    const originalFormat = getOriginalFormat(val);
-    const stylesArr = expandStyleFormats(rawStyles, originalFormat);
-    // Collect every (mediaFileId, style) request — base styles + srcset variants — into one batch.
+    // Custom field.styles: zachowaj dotychczasową semantykę (expand formatów + baza pełno-res + srcset).
+    if (hasCustomStyles) {
+        return resolveLegacyStyles(expandStyleFormats(field.styles, getOriginalFormat(val)), val);
+    }
+    // Domyślnie: nowa lekka matryca z configu (avif+webp × szerokości, BEZ bazy pełno-res).
+    // Grupujemy warianty po formacie → jeden <source> per format ze srcset (bez bramki bazy).
+    const specs = isProcessableImage(val)
+        ? buildStyleSpecs(val, undefined, resolveImagesConfig(getCMS().mediaConfig.images))
+        : [];
+    const requests = specs.map((style) => ({ mediaFileId: val.id, style }));
+    const [styleMap, blurDataUrl] = await Promise.all([
+        getImageStylesBatch(requests),
+        ensureBlurDataUrl(val)
+    ]);
+    const byFormat = new Map();
+    for (const style of specs) {
+        const data = styleMap.get(imageStyleKey(val.id, style));
+        if (!data || typeof style.width !== 'number')
+            continue;
+        const fmt = style.format ?? 'orig';
+        const group = byFormat.get(fmt) ?? { media: data.media, mimeType: data.mimeType, variants: [] };
+        group.variants.push({ url: data.url, w: style.width });
+        byFormat.set(fmt, group);
+    }
+    const styles = {};
+    for (const [fmt, group] of byFormat) {
+        group.variants.sort((a, b) => a.w - b.w);
+        const largest = group.variants[group.variants.length - 1];
+        styles[`default_${fmt}`] = {
+            url: largest.url,
+            media: group.media,
+            mimeType: group.mimeType,
+            srcset: group.variants.map((v) => `${v.url} ${v.w}w`).join(', ')
+        };
+    }
+    return { styles, blurDataUrl };
+}
+/** Stara ścieżka dla custom field.styles: styl bazowy pełno-res (bramka istnienia) + srcset wariantów. */
+async function resolveLegacyStyles(stylesArr, val) {
     const requests = [];
     for (const style of stylesArr) {
         requests.push({ mediaFileId: val.id, style });

package/dist/core/server/index.d.ts

@@ -2,3 +2,6 @@ export { getCMS } from '../cms.js';
 export { resolveMediaWithStyles, type ResolvedMedia } from './fields/utils/resolveMedia.js';
 export { createEntityAPI } from '../../entity/index.js';
 export { getAuth } from '../../server/auth.js';
+export { enqueueStyleSpecs } from './media/jobs/enqueue.js';
+export { startMediaWorker, stopMediaWorker } from './media/jobs/worker.js';
+export type { MediaJob, MediaJobStatus } from '../../types/adapters/db.js';

package/dist/core/server/index.js

@@ -2,3 +2,6 @@ export { getCMS } from '../cms.js';
 export { resolveMediaWithStyles } from './fields/utils/resolveMedia.js';
 export { createEntityAPI } from '../../entity/index.js';
 export { getAuth } from '../../server/auth.js';
+// Optymalizacja obrazów w tle (media_job)
+export { enqueueStyleSpecs } from './media/jobs/enqueue.js';
+export { startMediaWorker, stopMediaWorker } from './media/jobs/worker.js';

package/dist/core/server/media/jobs/enqueue.d.ts

@@ -0,0 +1,6 @@
+import type { ImageFieldStyle } from '../../../../types/fields.js';
+import type { MediaFile } from '../../../../types/media.js';
+/** Kolejkuje generację wszystkich wariantów dla media (upload / render-miss / sweep). Idempotentne po dedupeKey. */
+export declare function enqueueStyleSpecs(mediaFile: Pick<MediaFile, 'id' | 'width' | 'height'>, fieldStyles: ImageFieldStyle[] | undefined, opts?: {
+    priority?: number;
+}): Promise<void>;

package/dist/core/server/media/jobs/enqueue.js

@@ -0,0 +1,20 @@
+import { getCMS } from '../../../cms.js';
+import { resolveImagesConfig } from '../styles/imagesConfig.js';
+import { buildStyleSpecs, styleDedupeKey } from '../styles/buildStyleSpecs.js';
+/** Kolejkuje generację wszystkich wariantów dla media (upload / render-miss / sweep). Idempotentne po dedupeKey. */
+export async function enqueueStyleSpecs(mediaFile, fieldStyles, opts = {}) {
+    const cms = getCMS();
+    const cfg = resolveImagesConfig(cms.mediaConfig.images);
+    const specs = buildStyleSpecs(mediaFile, fieldStyles, cfg);
+    for (const style of specs) {
+        await cms.databaseAdapter
+            .enqueueMediaJob({
+            type: 'image_style',
+            mediaFileId: mediaFile.id,
+            payload: JSON.stringify(style),
+            dedupeKey: styleDedupeKey(mediaFile.id, style),
+            priority: opts.priority ?? 0
+        })
+            .catch((e) => console.warn('[media] enqueue failed:', e));
+    }
+}

package/dist/core/server/media/jobs/processImageStyleJob.d.ts

@@ -0,0 +1,19 @@
+import type { MediaJob } from '../../../../types/adapters/db.js';
+import type { MediaFile, ImageStyle } from '../../../../types/media.js';
+import type { ImageFieldStyle } from '../../../../types/fields.js';
+export type JobResult = {
+    ok: true;
+} | {
+    ok: false;
+    retry: boolean;
+    error: string;
+};
+type CreateImageStyleFn = (mediaFileId: string, style: ImageFieldStyle) => Promise<ImageStyle>;
+export interface ProcessImageStyleDeps {
+    createImageStyle: CreateImageStyleFn;
+    getMediaFile: (id: string) => Promise<MediaFile | null>;
+    limitPixels: number;
+}
+/** Przetwarza pojedynczy job typu image_style. Klasyfikuje błędy: poison/not-found → retry:false. */
+export declare function processImageStyleJob(job: MediaJob, deps: ProcessImageStyleDeps): Promise<JobResult>;
+export {};

package/dist/core/server/media/jobs/processImageStyleJob.js

@@ -0,0 +1,23 @@
+import { assertWithinPixelLimit } from '../styles/sharp/sharpConfig.js';
+/** Przetwarza pojedynczy job typu image_style. Klasyfikuje błędy: poison/not-found → retry:false. */
+export async function processImageStyleJob(job, deps) {
+    const style = JSON.parse(job.payload);
+    const media = await deps.getMediaFile(job.mediaFileId);
+    if (!media)
+        return { ok: false, retry: false, error: 'media file not found' };
+    try {
+        if (media.width && media.height) {
+            assertWithinPixelLimit(media.width, media.height, deps.limitPixels);
+        }
+    }
+    catch (e) {
+        return { ok: false, retry: false, error: e.message };
+    }
+    try {
+        await deps.createImageStyle(job.mediaFileId, style);
+        return { ok: true };
+    }
+    catch (e) {
+        return { ok: false, retry: true, error: e.message };
+    }
+}

package/dist/core/server/media/jobs/startWorker.d.ts

@@ -0,0 +1,2 @@
+/** Składa zależności i startuje in-process worker generacji wariantów. */
+export declare function startMediaOptimizationWorker(): void;

package/dist/core/server/media/jobs/startWorker.js

@@ -0,0 +1,29 @@
+import { randomUUID } from 'node:crypto';
+import { getCMS } from '../../../cms.js';
+import { startMediaWorker } from './worker.js';
+import { processImageStyleJob } from './processImageStyleJob.js';
+import { createImageStyle } from '../styles/operations/createMediaStyle.js';
+import { applySharpLimits } from '../styles/sharp/sharpConfig.js';
+/** Składa zależności i startuje in-process worker generacji wariantów. */
+export function startMediaOptimizationWorker() {
+    const cms = getCMS();
+    const opt = cms.mediaConfig.optimization ?? {};
+    const cfg = {
+        concurrency: opt.concurrency ?? 1,
+        maxAttempts: opt.maxAttempts ?? 3,
+        backoffBaseMs: opt.backoffBaseMs ?? 30_000,
+        staleLockMs: opt.staleLockMs ?? 300_000,
+        pollIntervalMs: opt.pollIntervalMs ?? 2_000,
+        limitPixels: opt.limitPixels ?? 100_000_000,
+        lockedBy: randomUUID()
+    };
+    applySharpLimits({ concurrency: cfg.concurrency, cacheMemoryMB: opt.cacheMemoryMB ?? 50 });
+    startMediaWorker(cfg, {
+        adapter: cms.databaseAdapter,
+        process: (job) => processImageStyleJob(job, {
+            createImageStyle,
+            getMediaFile: (id) => cms.databaseAdapter.getMediaFile({ data: { id } }),
+            limitPixels: cfg.limitPixels
+        })
+    });
+}

package/dist/core/server/media/jobs/worker.d.ts

@@ -0,0 +1,29 @@
+import type { MediaJob } from '../../../../types/adapters/db.js';
+import type { JobResult } from './processImageStyleJob.js';
+export interface WorkerConfig {
+    concurrency: number;
+    maxAttempts: number;
+    backoffBaseMs: number;
+    staleLockMs: number;
+    pollIntervalMs: number;
+    limitPixels: number;
+    lockedBy: string;
+}
+export interface WorkerAdapter {
+    claimNextMediaJob: (lockedBy: string) => Promise<MediaJob | null>;
+    completeMediaJob: (id: string) => Promise<void>;
+    failMediaJob: (id: string, error: string, opts: {
+        retry: boolean;
+        runAfter?: Date;
+    }) => Promise<void>;
+    resetStaleMediaJobs: (olderThan: Date) => Promise<number>;
+}
+export interface RunOnceDeps {
+    adapter: WorkerAdapter;
+    process: (job: MediaJob) => Promise<JobResult>;
+}
+/** Jeden cykl: claim → process → complete/fail (backoff + circuit-breaker). */
+export declare function runOnce(cfg: WorkerConfig, deps: RunOnceDeps): Promise<'processed' | 'idle'>;
+/** Startuje ciągłą pętlę workera (idempotentne). Concurrency=1: jeden job naraz. */
+export declare function startMediaWorker(cfg: WorkerConfig, deps: RunOnceDeps): void;
+export declare function stopMediaWorker(): void;

package/dist/core/server/media/jobs/worker.js

@@ -0,0 +1,54 @@
+/** Jeden cykl: claim → process → complete/fail (backoff + circuit-breaker). */
+export async function runOnce(cfg, deps) {
+    const job = await deps.adapter.claimNextMediaJob(cfg.lockedBy);
+    if (!job)
+        return 'idle';
+    const res = await deps.process(job);
+    if (res.ok) {
+        await deps.adapter.completeMediaJob(job.id);
+        return 'processed';
+    }
+    const willExhaust = job.attempts + 1 >= (job.maxAttempts ?? cfg.maxAttempts);
+    const retry = res.retry && !willExhaust;
+    const runAfter = new Date(Date.now() + cfg.backoffBaseMs * 2 ** job.attempts);
+    await deps.adapter.failMediaJob(job.id, res.error, { retry, runAfter });
+    return 'processed';
+}
+let running = false;
+let started = false;
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+/** Startuje ciągłą pętlę workera (idempotentne). Concurrency=1: jeden job naraz. */
+export function startMediaWorker(cfg, deps) {
+    if (started)
+        return;
+    started = true;
+    running = true;
+    const staleEvery = Math.max(1, Math.floor(cfg.staleLockMs / Math.max(1, cfg.pollIntervalMs)));
+    let cyclesSinceStale = 0;
+    const loop = async () => {
+        console.info(`[media] worker started (${cfg.lockedBy})`);
+        while (running) {
+            try {
+                if (cyclesSinceStale++ >= staleEvery) {
+                    cyclesSinceStale = 0;
+                    await deps.adapter.resetStaleMediaJobs(new Date(Date.now() - cfg.staleLockMs));
+                }
+                const r = await runOnce(cfg, deps);
+                if (r === 'idle')
+                    await sleep(cfg.pollIntervalMs);
+            }
+            catch (e) {
+                console.warn('[media] worker cycle error:', e);
+                await sleep(cfg.pollIntervalMs);
+            }
+        }
+        started = false;
+        console.info('[media] worker stopped');
+    };
+    void loop();
+}
+export function stopMediaWorker() {
+    running = false;
+}

package/dist/core/server/media/operations/replaceFile.js

@@ -1,7 +1,7 @@
 import { getCMS } from '../../../cms.js';
 import { generateBlurDataUrl } from '../utils/generateBlurDataUrl.js';
 import { generateAdminThumbnail } from '../utils/generateAdminThumbnail.js';
-import { generateDefaultStylesInBackground } from '../styles/operations/generateDefaultStyles.js';
+import { enqueueStyleSpecs } from '../jobs/enqueue.js';
 import { generateDefaultVideoStylesInBackground } from '../styles/operations/generateDefaultVideoStyles.js';
 export async function replaceFile(fileId, newFile) {
     const cms = getCMS();
@@ -76,7 +76,7 @@ export async function replaceFile(fileId, newFile) {
             blurDataUrl
         }
     });
-    generateDefaultStylesInBackground(updated);
+    void enqueueStyleSpecs(updated, undefined, {}).catch((e) => console.warn('[media] replace enqueue failed:', e));
     generateDefaultVideoStylesInBackground(updated);
     return updated;
 }

package/dist/core/server/media/operations/uploadFile.js

@@ -1,7 +1,9 @@
 import { getCMS } from '../../../cms.js';
 import { generateBlurDataUrl } from '../utils/generateBlurDataUrl.js';
 import { generateAdminThumbnail } from '../utils/generateAdminThumbnail.js';
-import { generateDefaultStylesInBackground } from '../styles/operations/generateDefaultStyles.js';
+import { generateFallbackVariant } from '../styles/operations/generateFallbackVariant.js';
+import { resolveImagesConfig } from '../styles/imagesConfig.js';
+import { enqueueStyleSpecs } from '../jobs/enqueue.js';
 import { generateDefaultVideoStylesInBackground } from '../styles/operations/generateDefaultVideoStyles.js';
 import sharp from 'sharp';
 import { withTimeout, sharpTimeoutMs } from '../../../../server/utils/withTimeout.js';
@@ -40,15 +42,18 @@ export async function uploadFile(file) {
     const uploadedFile = await getCMS().filesAdapter.uploadFile(file);
     let blurDataUrl = null;
     let thumbnailUrl = uploadedFile.thumbnailUrl ?? null;
+    let fallbackUrl = null;
     const isProcessableImage = uploadedFile.type === 'image' && !file.name.toLowerCase().endsWith('.svg');
     if (isProcessableImage) {
         try {
             const buffer = Buffer.from(await file.arrayBuffer());
             blurDataUrl = await generateBlurDataUrl(buffer);
             thumbnailUrl = await generateAdminThumbnail(buffer, uploadedFile);
+            const fallbackCfg = resolveImagesConfig(getCMS().mediaConfig.images).fallback;
+            fallbackUrl = await generateFallbackVariant(buffer, uploadedFile, fallbackCfg);
         }
         catch (e) {
-            console.warn('LQIP/thumbnail generation failed:', e);
+            console.warn('LQIP/thumbnail/fallback generation failed:', e);
         }
     }
     const created = await getCMS().databaseAdapter.createMediaFile({
@@ -61,12 +66,14 @@ export async function uploadFile(file) {
         posterUrl: uploadedFile.posterUrl ?? null,
         mimeType: uploadedFile.mimeType ?? null,
         blurDataUrl,
+        fallbackUrl,
         focalX: null,
         focalY: null,
         transcriptFileId: null,
         audioDescriptionFileId: null
     });
-    generateDefaultStylesInBackground(created);
+    // Kolejkuj generację wariantów w tle (worker media_job) zamiast fire-and-forget bez retry.
+    await enqueueStyleSpecs(created, undefined, {});
     generateDefaultVideoStylesInBackground(created);
     return created;
 }

package/dist/core/server/media/styles/buildStyleSpecs.d.ts

@@ -0,0 +1,12 @@
+import type { ImageFieldStyle } from '../../../../types/fields.js';
+import type { MediaFile } from '../../../../types/media.js';
+import type { ImagesConfig } from '../../../../types/cms.js';
+/**
+ * Zestaw konkretnych specyfikacji styli do wygenerowania dla danego media.
+ * - Jeśli pole ma własne `fieldStyles` — honorujemy je (mogą mieć własny format/crop/width).
+ * - Inaczej z configu: każdy format × każda szerokość ≤ min(oryginał, maxDimension).
+ *   BEZ wariantu bazowego pełno-res (to była bomba CPU i redundancja).
+ */
+export declare function buildStyleSpecs(mediaFile: Pick<MediaFile, 'id' | 'width' | 'height'>, fieldStyles: ImageFieldStyle[] | undefined, cfg: ImagesConfig): ImageFieldStyle[];
+/** Kanoniczny klucz dedupu po EFEKTYWNEJ specyfikacji (nie po nazwie). */
+export declare function styleDedupeKey(mediaFileId: string, s: ImageFieldStyle): string;

package/dist/core/server/media/styles/buildStyleSpecs.js

@@ -0,0 +1,36 @@
+/**
+ * Zestaw konkretnych specyfikacji styli do wygenerowania dla danego media.
+ * - Jeśli pole ma własne `fieldStyles` — honorujemy je (mogą mieć własny format/crop/width).
+ * - Inaczej z configu: każdy format × każda szerokość ≤ min(oryginał, maxDimension).
+ *   BEZ wariantu bazowego pełno-res (to była bomba CPU i redundancja).
+ */
+export function buildStyleSpecs(mediaFile, fieldStyles, cfg) {
+    if (fieldStyles && fieldStyles.length)
+        return fieldStyles;
+    const maxW = Math.min(mediaFile.width ?? cfg.maxDimension, cfg.maxDimension);
+    const widths = cfg.widths.filter((w) => w <= maxW);
+    const specs = [];
+    for (const format of cfg.formats) {
+        for (const w of widths) {
+            specs.push({
+                name: `default_${format}_${w}w`,
+                format: format,
+                width: w,
+                quality: cfg.quality[format]
+            });
+        }
+    }
+    return specs;
+}
+/** Kanoniczny klucz dedupu po EFEKTYWNEJ specyfikacji (nie po nazwie). */
+export function styleDedupeKey(mediaFileId, s) {
+    return [
+        mediaFileId,
+        s.format ?? '',
+        s.width ?? 0,
+        s.height ?? 0,
+        s.crop ? 1 : 0,
+        s.quality ?? 0,
+        s.aspectRatio ?? 0
+    ].join(':');
+}

package/dist/core/server/media/styles/imagesConfig.d.ts

@@ -0,0 +1,3 @@
+import type { ImagesConfig, ImagesConfigInput } from '../../../../types/cms.js';
+/** Łączy wejściową (płytko-partial) konfigurację obrazów z domyślną. */
+export declare function resolveImagesConfig(cfg?: ImagesConfigInput): ImagesConfig;

package/dist/core/server/media/styles/imagesConfig.js

@@ -0,0 +1,16 @@
+const DEFAULTS = {
+    formats: ['avif', 'webp'],
+    widths: [640, 1024, 1536, 2560],
+    quality: { avif: 52, webp: 78, jpeg: 80 },
+    maxDimension: 2560,
+    fallback: { width: 1280, format: 'jpeg' }
+};
+/** Łączy wejściową (płytko-partial) konfigurację obrazów z domyślną. */
+export function resolveImagesConfig(cfg) {
+    return {
+        ...DEFAULTS,
+        ...cfg,
+        quality: { ...DEFAULTS.quality, ...(cfg?.quality ?? {}) },
+        fallback: { ...DEFAULTS.fallback, ...(cfg?.fallback ?? {}) }
+    };
+}