@qvac/core 0.0.0 → 0.1.0

package/dist-lib/lib/core/files/index.js

@@ -0,0 +1,585 @@
+import b4a from 'b4a';
+import { Buffer } from 'buffer';
+import EventEmitter from 'bare-events';
+import { attachmentFiles } from "./attachments.js";
+import { isKnowledgeRoutedAttachment, getKnowledge, listKnowledge, getKnowledgeArtifact, listKnowledgeArtifactsByKnowledge, addKnowledgeArtifact, hasLiveSource, syncAttachmentChunk, syncKnowledgeTombstone, syncArtifactArrival, sweepTombstonedBlobs, referencedBlobs, scopedFile, attachmentRecord, isProcessorOutput, isProcessorArtifactId } from "./records/index.js";
+import { knowledgeFiles } from "./knowledge.js";
+import { randomId } from "../id.js";
+import { getChunk, listChunks } from "../chunk.js";
+import { settleFiles, isClaimLive, listIndexingByChat, FileState, FileProcessing } from "./processing/index.js";
+import { DeadlineScheduler } from "../../deadline.js";
+import { liveDeviceForWriter } from "../contract/activity.js";
+import { BlobStore, parseBlobReference } from "./store/index.js";
+import { AbortedError } from '@qvac/harness/race-abort';
+import { RagProcessor } from "./rag/index.js";
+import { PreviewProcessor, PREVIEW_VERSION, previewId } from "./preview/index.js";
+export { fullTextBudgetChars, fullTextHits, retrieveRagKnowledge, searchRagChunks, referencesPendingFile } from "./rag/index.js";
+export { isKnowledgeRoutedAttachment } from "./records/index.js";
+export { assertRemovableAt } from "./records/index.js";
+export { assertArtifactOutput } from "./records/index.js";
+export { claimSource } from "./records/index.js";
+export class Files extends EventEmitter {
+    _mesh;
+    _uploads = new Map();
+    state = new FileState();
+    _states = new Map([['rag', this.state]]);
+    _processors = new Map();
+    _store;
+    _deadline = new DeadlineScheduler(() => {
+        this._pruneUploads();
+        this._updated();
+    });
+    _updated = () => this.emit('update');
+    _model = null;
+    _paused = false;
+    closed = false;
+    constructor(mesh) {
+        super();
+        this._mesh = mesh;
+        mesh.watch(this._updated);
+        this._store = new BlobStore(mesh);
+        this._store.on('update', this._updated);
+    }
+    read(reference, options = {}) {
+        return this._store.read(reference, options);
+    }
+    readBytes(reference, options = {}) {
+        return this._store.readBytes(reference, options);
+    }
+    download(reference, options) {
+        return this._store.download(reference, options);
+    }
+    write(chunks, options = {}) {
+        return this._store.write(chunks, options);
+    }
+    put(bytes) {
+        return this._store.put(bytes);
+    }
+    inline(bytes, mimeType) {
+        return this._store.inline(bytes, mimeType);
+    }
+    reference(id) {
+        return this._store.reference(id);
+    }
+    clear(reference, id) {
+        return this._store.clear(reference, id);
+    }
+    attachments(options = {}) {
+        return attachmentFiles(this._mesh, options);
+    }
+    knowledge(options = {}) {
+        return knowledgeFiles(this._mesh, options);
+    }
+    listKnowledge(chatId) {
+        return listKnowledge(this._mesh, { chatId });
+    }
+    record(id) {
+        return getKnowledge(this._mesh, id);
+    }
+    async resolve(request) {
+        const snap = this._mesh.view.snapshot();
+        try {
+            return await scopedFile(snap, request);
+        }
+        finally {
+            await snap.close();
+        }
+    }
+    async *fileRead(request, options = {}) {
+        const file = await this.resolve(request);
+        if (options.signal?.aborted)
+            throw new AbortedError();
+        if (!file)
+            return;
+        yield { metadata: file };
+        if (!request.metadataOnly)
+            yield* this.read(file.blobId, options);
+    }
+    async preview(request) {
+        const file = await this.resolve(request);
+        if (!file || !this._processors.get('preview')?.processor.applies(file))
+            return {};
+        const output = await this.artifact(previewId(file));
+        if (!output || output.embedderVersion !== PREVIEW_VERSION)
+            return {};
+        const reference = parseBlobReference(output.artifactBlobId);
+        if (reference.inline?.mimeType !== 'image/jpeg')
+            throw new Error('invalid preview output');
+        return {
+            outputId: output.id,
+            mimeType: reference.inline.mimeType,
+            data: await this.readBytes(output.artifactBlobId)
+        };
+    }
+    async retry(request) {
+        const file = await this.resolve(request);
+        const entry = this._processors.get(request.processorId);
+        if (!file || !entry)
+            return;
+        this.processorState(request.processorId).retry(file.id);
+        await entry.work.enqueue([file.id]);
+        this._updated();
+    }
+    artifact(id) {
+        return getKnowledgeArtifact(this._mesh, id);
+    }
+    artifacts(id) {
+        return listKnowledgeArtifactsByKnowledge(this._mesh, { knowledgeId: id });
+    }
+    publish(input) {
+        return addKnowledgeArtifact(this._mesh, input);
+    }
+    hasLiveSource(chatId, reference) {
+        return hasLiveSource(this._mesh, chatId, reference);
+    }
+    syncAttachment(chunk) {
+        return syncAttachmentChunk(this._mesh, chunk);
+    }
+    syncKnowledge(row) {
+        return syncKnowledgeTombstone(this._mesh, row);
+    }
+    syncArtifact(row) {
+        return syncArtifactArrival(this._mesh, row);
+    }
+    sweepTombstones(deviceId = null) {
+        return sweepTombstonedBlobs(this._mesh, deviceId);
+    }
+    async sweepOrphans(coreLength) {
+        if (!coreLength)
+            return;
+        const references = await referencedBlobs(this._mesh);
+        if (!this._mesh.closing)
+            await this._store.sweep(references, coreLength);
+    }
+    processorState(id) {
+        let state = this._states.get(id);
+        if (!state)
+            this._states.set(id, (state = new FileState()));
+        return state;
+    }
+    start(options) {
+        this.startProcessor(new PreviewProcessor(options), options);
+    }
+    startProcessor(processor, options) {
+        if (this._processors.has(processor.id)) {
+            throw new Error(`processor already started: ${processor.id}`);
+        }
+        const work = new FileProcessing(this._mesh, { processor, ...options });
+        this._processors.set(processor.id, { processor, work });
+        if (this._paused)
+            void work.suspend();
+        work.start();
+        this._updated();
+    }
+    async stopProcessor(id) {
+        const entry = this._processors.get(id);
+        if (!entry)
+            return true;
+        await entry.work.suspend();
+        await entry.work.close();
+        this._processors.delete(id);
+        this.processorState(id).reset();
+        this._updated();
+        return entry.work.indexCleared;
+    }
+    get _processing() {
+        return this._processors.get('rag')?.work;
+    }
+    startProcessing(options) {
+        this.setModel(options.embedder.model);
+        this.startProcessor(new RagProcessor({
+            ...options,
+            model: options.embedder.model
+        }), { deviceId: options.deviceId });
+    }
+    async stopProcessing() {
+        const cleared = await this.stopProcessor('rag');
+        this.setModel(null);
+        return cleared;
+    }
+    async suspend() {
+        this._paused = true;
+        await Promise.all([...this._processors.values()].map(({ work }) => work.suspend()));
+    }
+    resume() {
+        this._paused = false;
+        for (const { work } of this._processors.values())
+            work.resume();
+    }
+    async listIndexing(chatId) {
+        const rows = await listIndexingByChat(this._mesh, { chatId });
+        let statuses = rows
+            .filter((row) => !isProcessorArtifactId(row.id))
+            .map((row) => ({ ...row, claimLive: isClaimLive(row, Date.now()) }));
+        for (const file of (await this.status(chatId)).files) {
+            const processor = file.processors.find((entry) => entry.processorId === 'rag');
+            if (!processor || file.readyForChat || processor.state === 'not-applicable')
+                continue;
+            if (processor.claimedBy)
+                continue;
+            if (!processor.published && (this.state.get(file.fileId)?.sourceMisses ?? 0) < 2)
+                continue;
+            const attempts = statuses.filter((row) => row.knowledgeId === file.fileId);
+            const latest = attempts.reduce((current, row) => (!current || row.at > current.at ? row : current), undefined);
+            statuses = statuses.filter((row) => row.knowledgeId !== file.fileId);
+            statuses.push({
+                id: latest?.id ?? file.fileId,
+                knowledgeId: file.fileId,
+                chatId,
+                status: processor.state === 'running' ? 'indexing' : 'failed',
+                claimId: '',
+                claimedBy: Buffer.alloc(0),
+                at: Math.max(latest?.at ?? 0, processor.retryAt ?? 0),
+                expiresAt: 0,
+                error: processor.reason ?? 'waiting for local index',
+                claimLive: false
+            });
+        }
+        return { statuses };
+    }
+    watch(listener) {
+        this.on('update', listener);
+    }
+    unwatch(listener) {
+        this.off('update', listener);
+        if (!this.listenerCount('update')) {
+            this._deadline.clear();
+            this._pruneUploads();
+        }
+    }
+    setModel(model) {
+        if (model === this._model)
+            return;
+        this._model = model;
+        this.state.reset();
+        this._updated();
+    }
+    work(id, state, processorId = 'rag') {
+        const entry = this.processorState(processorId).document(id);
+        entry.sourceMisses = state.reason === 'source unavailable' ? (entry.sourceMisses ?? 0) + 1 : 0;
+        entry.work = state;
+        this._updated();
+    }
+    load(id, state, options = {}) {
+        const { artifactId, processorId = 'rag' } = options;
+        const entry = this.processorState(processorId).document(id);
+        if (entry.load?.state !== 'failed' || state.state !== 'pending')
+            entry.load = state;
+        if (!artifactId)
+            entry.loaded = undefined;
+        else if (entry.loaded?.artifactId !== artifactId)
+            entry.loaded = { artifactId };
+        this._updated();
+    }
+    clearLoaded(processorId = 'rag') {
+        this.processorState(processorId).clearLoaded();
+        this._updated();
+    }
+    hydratedArtifact(id) {
+        return this.state.get(id)?.loaded?.artifactId ?? null;
+    }
+    async settle(ids, options = {}) {
+        if (!this._processing)
+            return;
+        await settleFiles(this, {
+            ...options,
+            ids,
+            processing: this._processing,
+            chatIds: async () => {
+                const rows = await Promise.all(ids.map((id) => getKnowledge(this._mesh, id)));
+                return [...new Set(rows.flatMap((row) => (row ? [row.chatId] : [])))];
+            }
+        });
+    }
+    reconnect() {
+        for (const { work } of this._processors.values())
+            work.reconnect();
+        this._updated();
+    }
+    report = (update, processorId = 'rag') => {
+        if (this.closed)
+            return;
+        this.processorState(processorId).document(update.knowledgeId).progress = {
+            ...update,
+            error: update.error ?? null
+        };
+        this._updated();
+    };
+    progress(chatId) {
+        return this.state.progress(chatId);
+    }
+    async beginUpload(input) {
+        const { chatId, fileName, mimeType } = input;
+        if (!chatId || !fileName || !mimeType)
+            throw new Error('upload metadata is incomplete');
+        const id = input.fileId || randomId();
+        this._pruneUploads();
+        const previous = this._uploads.get(id);
+        if (previous && !previous.expiresAt)
+            throw new Error('file id already exists');
+        this._uploads.set(id, {
+            status: {
+                fileId: id,
+                chatId,
+                fileName,
+                mimeType,
+                state: 'uploading',
+                processors: [],
+                readyForChat: false,
+                uploadProgress: {
+                    completed: input.data?.length ?? 0,
+                    total: input.totalBytes || undefined,
+                    unit: 'bytes'
+                }
+            }
+        });
+        try {
+            if (input.fileId &&
+                ((await getKnowledge(this._mesh, id)) ||
+                    (await getChunk(this._mesh, id)) ||
+                    (await listChunks(this._mesh, { chatId, type: 'attachment' })).some((chunk) => chunk.attachment?.id === id))) {
+                throw new Error('file id already exists');
+            }
+        }
+        catch (error) {
+            if (previous)
+                this._uploads.set(id, previous);
+            else
+                this._uploads.delete(id);
+            this._updated();
+            throw error;
+        }
+        this._updated();
+        return { id };
+    }
+    uploadProgress(id, bytes) {
+        const upload = this._uploads.get(id)?.status;
+        if (!upload?.uploadProgress)
+            return;
+        upload.uploadProgress.completed += bytes;
+        this._updated();
+    }
+    uploadComplete(id) {
+        const upload = this._uploads.get(id)?.status;
+        if (upload)
+            upload.state = 'pending';
+        this._updated();
+    }
+    uploadFailed(id, error) {
+        const upload = this._uploads.get(id)?.status;
+        if (!upload)
+            return;
+        upload.state = error instanceof AbortedError ? 'cancelled' : 'failed';
+        upload.reason = error instanceof Error ? error.message : String(error);
+        this._updated();
+    }
+    uploadClosed(id) {
+        const upload = this._uploads.get(id);
+        if (!upload || this.closed)
+            return;
+        upload.expiresAt = Date.now() + 60_000;
+        this._deadline.schedule(upload.expiresAt);
+    }
+    _pruneUploads() {
+        for (const [id, upload] of this._uploads) {
+            if (!upload.expiresAt)
+                continue;
+            if (upload.expiresAt <= Date.now())
+                this._uploads.delete(id);
+            else
+                this._deadline.schedule(upload.expiresAt);
+        }
+    }
+    async status(chatId) {
+        this._pruneUploads();
+        const snap = this._mesh.view.snapshot();
+        const range = { gte: { chatId }, lte: { chatId } };
+        try {
+            const chat = await snap.get('@qvac/chats', { id: chatId });
+            if (!chat || chat.deletedAt)
+                return { files: [] };
+            const agent = await snap.get('@qvac/agents', { id: chat.agentId });
+            const knowledge = await snap
+                .find('@qvac/active-knowledge-by-chat', range)
+                .toArray();
+            const chunks = await snap.find('@qvac/chunks-by-chat', range).toArray();
+            const statuses = await snap
+                .find('@qvac/indexing-status-by-chat', range)
+                .toArray();
+            const sources = new Map(knowledge.map((row) => [row.id, row]));
+            const ragIds = new Set(sources.keys());
+            for (const chunk of chunks) {
+                const file = chunk.attachment;
+                if (file && !file.deletedAt && !sources.has(file.id)) {
+                    sources.set(file.id, { ...file, chatId, updatedAt: file.createdAt });
+                    if (!chunk.runId && isKnowledgeRoutedAttachment(file)) {
+                        const record = await snap.get('@qvac/knowledge', { id: file.id });
+                        if (!record?.deletedAt)
+                            ragIds.add(file.id);
+                    }
+                }
+            }
+            const result = new Map();
+            for (const { status: upload } of this._uploads.values()) {
+                if (upload.chatId === chatId && upload.state !== 'pending') {
+                    result.set(upload.fileId, {
+                        ...upload,
+                        uploadProgress: upload.uploadProgress ? { ...upload.uploadProgress } : undefined
+                    });
+                }
+            }
+            for (const [id, source] of sources) {
+                const rows = await snap
+                    .find('@qvac/knowledge-artifacts-by-knowledge', {
+                    gte: { knowledgeId: id },
+                    lte: { knowledgeId: id }
+                })
+                    .toArray();
+                const applicable = ragIds.has(id);
+                const local = this.state.get(id);
+                const output = rows.find((row) => !isProcessorOutput(row.embedderVersion) &&
+                    (!this._model || row.embedderVersion.startsWith(`${this._model}|`)));
+                const published = !!output;
+                const attempts = statuses.filter((row) => row.knowledgeId === id && !isProcessorArtifactId(row.id));
+                const claim = attempts.find((row) => isClaimLive(row, Date.now()));
+                const failures = attempts.some((row) => row.status === 'ready')
+                    ? []
+                    : attempts.filter((row) => row.status === 'failed');
+                const terminalFailure = failures.find((row) => row.error !== 'source unavailable' && row.error !== 'interrupted: suspend');
+                const failed = terminalFailure ?? failures[0];
+                const processor = {
+                    processorId: 'rag',
+                    state: 'pending',
+                    published
+                };
+                processor.outputId = local?.loaded?.artifactId ?? output?.id;
+                if (!applicable)
+                    processor.state = 'not-applicable';
+                else if (local?.loaded)
+                    processor.state = 'ready';
+                else if (claim) {
+                    processor.state = 'running';
+                    processor.claimedBy = claim.claimedBy;
+                    processor.expiresAt = claim.expiresAt;
+                    this._deadline.schedule(claim.expiresAt);
+                    const device = await liveDeviceForWriter(snap, claim.claimedBy);
+                    if (device && agent && b4a.equals(device.id, agent.providerDeviceId)) {
+                        processor.agentId = agent.id;
+                    }
+                }
+                else if (local?.work &&
+                    !published &&
+                    local.work.state !== 'running' &&
+                    (!terminalFailure || local.work.state !== 'pending')) {
+                    Object.assign(processor, local.work);
+                }
+                else if (local?.load && published)
+                    Object.assign(processor, local.load);
+                else if (failed && !published && failed.error !== 'interrupted: suspend') {
+                    processor.state = failed.error === 'source unavailable' ? 'pending' : 'failed';
+                    processor.reason = failed.error || 'processing failed';
+                }
+                else {
+                    processor.reason = !this._model
+                        ? 'model unavailable on this device'
+                        : published
+                            ? 'waiting for local index'
+                            : 'waiting for agent';
+                }
+                if (local?.progress &&
+                    processor.state !== 'not-applicable' &&
+                    (!claim || b4a.equals(claim.claimedBy, this._mesh.localWriterKey))) {
+                    processor.progress = {
+                        completed: local.progress.processedChunks,
+                        total: local.progress.totalChunks || undefined,
+                        unit: 'chunks'
+                    };
+                }
+                const readyForChat = applicable
+                    ? processor.state === 'ready'
+                    : await this._store.available(source.blobId);
+                const processors = [processor];
+                for (const { processor: descriptor } of this._processors.values()) {
+                    if (descriptor.id === 'rag')
+                        continue;
+                    const chunk = chunks.find((entry) => entry.attachment?.id === id);
+                    const record = descriptor.input === 'attachment'
+                        ? chunk && attachmentRecord(chunk)
+                        : knowledge.find((entry) => entry.id === id);
+                    const input = record ? { ...record, kind: descriptor.input } : null;
+                    processors.push(!input || !descriptor.applies(input)
+                        ? { processorId: descriptor.id, state: 'not-applicable', published: false }
+                        : await this._processorStatus(descriptor, input, rows, statuses));
+                }
+                result.set(id, {
+                    fileId: id,
+                    chatId,
+                    fileName: source.fileName,
+                    mimeType: source.mimeType,
+                    state: readyForChat ? 'ready' : applicable ? processor.state : 'pending',
+                    reason: readyForChat
+                        ? undefined
+                        : applicable
+                            ? processor.reason
+                            : 'source unavailable on this device',
+                    uploadProgress: this._uploads.get(id)?.status.uploadProgress
+                        ? { ...this._uploads.get(id).status.uploadProgress }
+                        : undefined,
+                    processors,
+                    readyForChat
+                });
+            }
+            return { files: [...result.values()] };
+        }
+        finally {
+            await snap.close();
+        }
+    }
+    async _processorStatus(processor, file, rows, attempts) {
+        const output = rows.find((row) => processor.accepts ? processor.accepts(row, file) : row.embedderVersion === processor.version);
+        const local = this.processorState(processor.id).get(file.id);
+        const status = {
+            processorId: processor.id,
+            state: 'pending',
+            published: !!output,
+            outputId: output?.id
+        };
+        if (output &&
+            (processor.load ? !!local?.loaded : await this._store.available(output.artifactBlobId))) {
+            status.state = 'ready';
+            return status;
+        }
+        const claim = attempts.find((row) => row.knowledgeId === file.id &&
+            row.id.startsWith(`${processor.id}:`) &&
+            isClaimLive(row, Date.now()));
+        if (claim) {
+            Object.assign(status, {
+                state: 'running',
+                claimedBy: claim.claimedBy,
+                expiresAt: claim.expiresAt
+            });
+            this._deadline.schedule(claim.expiresAt);
+        }
+        else if (local?.work)
+            Object.assign(status, local.work);
+        else
+            status.reason = output ? 'output unavailable on this device' : 'waiting for processor';
+        return status;
+    }
+    async close() {
+        this.closed = true;
+        await Promise.all([...this._processors.keys()].map((id) => this.stopProcessor(id)));
+        this._mesh.unwatch(this._updated);
+        this._deadline.clear();
+        this._uploads.clear();
+        for (const state of this._states.values())
+            state.close();
+        this._states.clear();
+        this.emit('close');
+        this.removeAllListeners();
+        await this._store.close();
+    }
+}
+export { MemoryVectorIndex, RAG_KNOWLEDGE_OFF_NOTICE, RAG_TRUNCATED_NOTICE, RAG_UNAVAILABLE_NOTICE, WEB_TOOLS, chooseRagNotice, citedByPhraseOverlap, createRagSourceTagFilter, formatFullDocumentContext, formatRagContext, isFullTextHit, isWholeDocumentQuery, referencedDocuments, isTruncatedFullTextHit, sourcesFromHits, webSourcesFromToolResult, withoutDataChannel } from "./rag/index.js";
+export { attachTurnDocumentIds, groupAttachmentsByMessage } from "./records/index.js";
+export { CoreBlobServer } from "./store/index.js";

package/dist-lib/lib/core/files/knowledge.d.ts

@@ -0,0 +1,9 @@
+import { MAX_KNOWLEDGE_BYTES } from './rag/index.ts';
+import type { Mesh } from '../mesh.ts';
+import type { CapabilityHandlers } from '../../../spec/capabilities.d.ts';
+export { MAX_KNOWLEDGE_BYTES };
+export declare function knowledgeFiles(mesh: Mesh, { maxBytes, inactivityMs, deviceId }?: {
+    maxBytes?: number;
+    inactivityMs?: number;
+    deviceId?: Buffer | null;
+}): Pick<CapabilityHandlers, 'uploadKnowledge' | 'downloadKnowledge' | 'listKnowledge' | 'removeKnowledge' | 'listIndexing'>;

package/dist-lib/lib/core/files/knowledge.js

@@ -0,0 +1,31 @@
+import { listKnowledge, removeKnowledge } from "./records/index.js";
+import { MAX_KNOWLEDGE_BYTES } from "./rag/index.js";
+import { uploadFile } from "./upload.js";
+export { MAX_KNOWLEDGE_BYTES };
+export function knowledgeFiles(mesh, { maxBytes = MAX_KNOWLEDGE_BYTES, inactivityMs, deviceId } = {}) {
+    const list = async ({ chatId }) => ({
+        knowledge: await listKnowledge(mesh, { chatId })
+    });
+    const indexingList = async ({ chatId }) => mesh.files.listIndexing(chatId);
+    return {
+        async *uploadKnowledge(frames) {
+            for await (const frame of uploadFile(mesh, frames, {
+                kind: 'knowledge',
+                maxBytes,
+                deviceId,
+                inactivityMs
+            })) {
+                yield {
+                    bytesWritten: frame.bytesWritten,
+                    knowledge: 'knowledge' in frame ? frame.knowledge : undefined
+                };
+            }
+        },
+        downloadKnowledge: async function* ({ blobId }) {
+            yield* mesh.files.read(blobId);
+        },
+        listKnowledge: list,
+        listIndexing: indexingList,
+        removeKnowledge: async ({ knowledgeId, at }) => removeKnowledge(mesh, { knowledgeId, at })
+    };
+}

package/dist-lib/lib/core/files/preview/image.d.ts

@@ -0,0 +1,4 @@
+import { Buffer } from 'buffer';
+import type { AbortSignal } from 'bare-abort-controller';
+export type PreviewEncoder = (bytes: Buffer, signal: AbortSignal) => Promise<Buffer>;
+export declare function previewEncoder(): Promise<PreviewEncoder | null>;

package/dist-lib/lib/core/files/preview/image.js

@@ -0,0 +1,42 @@
+import { Buffer } from 'buffer';
+import { AbortedError } from '@qvac/harness/race-abort';
+import { MAX_INLINE_BYTES } from "../store/index.js";
+export async function previewEncoder() {
+    let media;
+    try {
+        media = await import('bare-media');
+    }
+    catch {
+        return null;
+    }
+    return async (bytes, signal) => {
+        const decoded = await media.image.decode(bytes, { maxFrames: 1 });
+        if (signal.aborted)
+            throw new AbortedError();
+        const first = decoded.frames ? decoded.frames[0] : decoded;
+        if (!first)
+            throw new Error('image has no frames');
+        const upright = await media.image.orientate(first, { file: bytes });
+        const resized = await media.image.resize(upright, { maxWidth: 768, maxHeight: 768 });
+        if (signal.aborted)
+            throw new AbortedError();
+        try {
+            return Buffer.from(await media.image.encode(resized, {
+                mimetype: 'image/jpeg',
+                quality: 75,
+                maxBytes: 80 * 1024
+            }));
+        }
+        catch (error) {
+            if (!(error instanceof Error) ||
+                !error.message.startsWith('Could not create preview under maxBytes')) {
+                throw error;
+            }
+            return Buffer.from(await media.image.encode(resized, {
+                mimetype: 'image/jpeg',
+                quality: 60,
+                maxBytes: MAX_INLINE_BYTES
+            }));
+        }
+    };
+}