@hraness/sponge 0.2.5 → 0.3.0

package/dist/src/pdf/errors.js

@@ -8,6 +8,17 @@ export function pdfFailure(value, requestId) {
         return failure(requestId, 'unclassified');
     if (record.captureError)
         return upstreamFailure(value, requestId);
-    const codes = { 'invalid-input': 'invalid-input', encrypted: 'unsupported', 'limit-exceeded': 'limit-exceeded', 'tool-unavailable': 'runtime-missing', 'extraction-failed': 'unavailable', timeout: 'unavailable', cancelled: 'cancelled', integrity: 'integrity', 'unsupported-schema': 'schema-newer', unknown: 'unclassified' };
+    const codes = {
+        'invalid-input': 'invalid-input',
+        encrypted: 'unsupported',
+        'limit-exceeded': 'limit-exceeded',
+        'tool-unavailable': 'runtime-missing',
+        'extraction-failed': 'unavailable',
+        timeout: 'unavailable',
+        cancelled: 'cancelled',
+        integrity: 'integrity',
+        'unsupported-schema': 'schema-newer',
+        unknown: 'unclassified',
+    };
     return failure(requestId, typeof record.code === 'string' && Object.hasOwn(codes, record.code) ? codes[record.code] : 'unclassified');
 }

package/dist/src/pdf/handler.d.ts

@@ -2,7 +2,7 @@ import type { ErrorEnvelope, JobCheckpoint } from '../../contracts/index.js';
 import { type CaptureRuntime, type CaptureConnection } from '../acquisition/index.js';
 import { type PdfCaptureRequest as CaptureRequest, type CaptureOutcome } from './capture.js';
 import type { LibraryStore, AttemptToken } from '../store/index.js';
-export interface PdfResult {
+interface PdfResult {
     ok: true;
     itemId: string;
     revisionId: string;
@@ -22,3 +22,4 @@ export interface PdfOptions {
 }
 /** One attempt. Durable queue policy and process recovery live above this function. */
 export declare function ingestPdf(store: LibraryStore, token: AttemptToken, options: PdfOptions): Promise<PdfOutcome>;
+export {};

package/dist/src/pdf/handler.js

@@ -1,84 +1,83 @@
-import { createHash } from 'node:crypto';
 import { join } from 'node:path';
 import { validateCapture } from '../../contracts/validate.js';
 import { capturePdf } from './capture.js';
-import { failure } from '../acquisition/errors.js';
+import { runAttempt, classifyErrors } from '../ingest/attempt.js';
+import { sha256 } from '../util/hash.js';
 import { bundleBytes, bundleText } from '../app/bundle-files.js';
 import { selectedMetadata } from '../metadata/article.js';
 import { localizeMarkdown } from '../app/markdown.js';
-const known = new Set(['integrity', 'limit-exceeded', 'cancelled', 'invalid-input', 'owner-busy', 'unavailable']);
+import { SpongeError } from '../errors.js';
+const classify = classifyErrors([
+    'integrity',
+    'limit-exceeded',
+    'cancelled',
+    'invalid-input',
+    'owner-busy',
+    'unavailable',
+]);
 /** One attempt. Durable queue policy and process recovery live above this function. */
-export async function ingestPdf(store, token, options) {
-    let captured, committed = false;
-    let outcome = failure(token.attemptId, 'unclassified', 'storage');
-    let cleanup = 'settled';
-    try {
-        const source = store.sourceForJob(token.jobId);
+export function ingestPdf(store, token, options) {
+    return runAttempt(store, token, classify, async (attempt) => {
+        const source = store.queue.source(token.jobId);
         if (!source || source.kind !== 'pdf')
-            throw Object.assign(Error('unsupported'), { code: 'invalid-input' });
-        const result = await (options.capture ?? capturePdf)({ runProcess: options.runProcess, runtime: options.runtime, stagingRoot: join(store.root, 'staging'), sourceUrl: source.locator, requestId: token.attemptId, connection: options.connection, signal: options.signal, allowPrivateNetwork: options.allowPrivateNetwork });
+            throw new SpongeError('invalid-input');
+        const result = await (options.capture ?? capturePdf)({
+            runProcess: options.runProcess,
+            runtime: options.runtime,
+            stagingRoot: join(store.root, 'staging'),
+            sourceUrl: source.locator,
+            requestId: token.attemptId,
+            connection: options.connection,
+            signal: options.signal,
+            allowPrivateNetwork: options.allowPrivateNetwork,
+        });
         if (!result.ok) {
-            outcome = result;
-            cleanup = result.code === 'cleanup-required' ? 'pending' : 'settled';
+            if (result.code === 'cleanup-required')
+                attempt.cleanup = 'pending';
+            return result;
         }
-        else {
-            captured = result;
-            await options.checkpoint?.('extracting');
-            const capture = result.capture;
-            validateCapture(capture);
-            if (capture.kind !== 'pdf' || capture.requestId !== token.attemptId || capture.sourceUrl !== source.locator)
-                throw Object.assign(Error('integrity'), { code: 'integrity' });
-            const original = await bundleText(result.bundleRoot, capture.markdown);
-            const allAssets = [...capture.assets, capture.sourcePdf];
-            const localized = localizeMarkdown(original.replace(/^<!-- pdf-page: ([1-9][0-9]*) -->$/gm, '## Page $1'), allAssets);
-            const assets = [];
-            for (const asset of allAssets) {
-                if (options.signal?.aborted)
-                    throw Object.assign(Error('cancelled'), { code: 'cancelled' });
-                const blob = await store.putBlob(token, asset.sha256, asset.bytes, bundleBytes(result.bundleRoot, asset));
-                assets.push({ ...blob, mediaType: asset.mediaType, relationship: asset === capture.sourcePdf ? 'source-pdf' : 'image' });
-            }
-            if (options.signal?.aborted) {
-                store.requestCancellation(token.jobId);
-                throw Object.assign(Error('cancelled'), { code: 'cancelled' });
-            }
-            const selectedTitle = selectedMetadata(capture.metadata, 'title')?.value;
-            const title = typeof selectedTitle === 'string' ? selectedTitle : undefined;
-            const status = localized.missingImages ? 'partial' : capture.status;
-            // Representation algorithm participates in identity: later extraction changes cannot reuse an old payload.
-            const bundleHash = createHash('sha256').update(JSON.stringify(['pdf-local-markdown-v1', capture.manifestSha256])).digest('hex');
-            await options.checkpoint?.('promoting');
-            const revision = store.commitRevision({ ...token, itemId: source.itemId, bundleHash, markdown: localized.markdown, title, extractor: capture.extractor, status, metadata: capture.metadata, assets, warnings: [...new Set([...capture.warnings, ...(localized.missingImages ? ['partial'] : [])])] });
-            committed = true;
-            outcome = { ok: true, itemId: source.itemId, revisionId: revision.revisionId, status };
+        attempt.hold(result);
+        await options.checkpoint?.('extracting');
+        const capture = result.capture;
+        validateCapture(capture);
+        if (capture.kind !== 'pdf' || capture.requestId !== token.attemptId || capture.sourceUrl !== source.locator)
+            throw new SpongeError('integrity');
+        const original = await bundleText(result.bundleRoot, capture.markdown);
+        const allAssets = [...capture.assets, capture.sourcePdf];
+        const localized = localizeMarkdown(original.replace(/^<!-- pdf-page: ([1-9][0-9]*) -->$/gm, '## Page $1'), allAssets);
+        const assets = [];
+        for (const asset of allAssets) {
+            if (options.signal?.aborted)
+                throw new SpongeError('cancelled');
+            const blob = await store.blobs.put(token, asset.sha256, asset.bytes, bundleBytes(result.bundleRoot, asset));
+            assets.push({
+                ...blob,
+                mediaType: asset.mediaType,
+                relationship: asset === capture.sourcePdf ? 'source-pdf' : 'image',
+            });
         }
-    }
-    catch (error) {
-        const code = error?.code;
-        outcome = failure(token.attemptId, code && known.has(code) ? code : 'unclassified', 'storage');
-    }
-    if (captured)
-        try {
-            await captured.dispose();
+        if (options.signal?.aborted) {
+            store.queue.cancel(token.jobId);
+            throw new SpongeError('cancelled');
         }
-        catch {
-            cleanup = 'pending';
-        }
-    if (!committed)
-        try {
-            store.failAttempt(token, outcome.ok ? 'unclassified' : outcome.code, outcome.ok ? {} : { retryable: outcome.retryable, retryAfterMs: outcome.retryAfterMs });
-        }
-        catch {
-            cleanup = 'pending';
-        }
-    if (cleanup === 'settled')
-        try {
-            store.settleAttempt(token);
-        }
-        catch {
-            cleanup = 'pending';
-        }
-    if (cleanup === 'pending')
-        return { ...failure(token.attemptId, 'cleanup-required', 'cleanup'), cleanup };
-    return { ...outcome, cleanup };
+        const selectedTitle = selectedMetadata(capture.metadata, 'title')?.value;
+        const title = typeof selectedTitle === 'string' ? selectedTitle : undefined;
+        const status = localized.missingImages ? 'partial' : capture.status;
+        // Representation algorithm participates in identity: later extraction changes cannot reuse an old payload.
+        const bundleHash = sha256(JSON.stringify(['pdf-local-markdown-v1', capture.manifestSha256]));
+        await options.checkpoint?.('promoting');
+        const revision = store.revisions.commit({
+            ...token,
+            itemId: source.itemId,
+            bundleHash,
+            markdown: localized.markdown,
+            title,
+            extractor: capture.extractor,
+            status,
+            metadata: capture.metadata,
+            assets,
+            warnings: [...new Set([...capture.warnings, ...(localized.missingImages ? ['partial'] : [])])],
+        });
+        return { ok: true, itemId: source.itemId, revisionId: revision.revisionId, status };
+    });
 }

package/dist/src/pdf/index.d.ts

@@ -1,4 +1,2 @@
-export { capturePdf, type PdfCaptureRequest, type CaptureOutcome } from './capture.js';
-export { ingestPdf, type PdfOptions, type PdfOutcome, type PdfResult } from './handler.js';
-export { pdfFailure } from './errors.js';
+export { ingestPdf } from './handler.js';
 export { pdfSource } from './source.js';

package/dist/src/pdf/index.js

@@ -1,4 +1,2 @@
-export { capturePdf } from './capture.js';
 export { ingestPdf } from './handler.js';
-export { pdfFailure } from './errors.js';
 export { pdfSource } from './source.js';

package/dist/src/pdf/input.js

@@ -2,30 +2,31 @@ import { open } from 'node:fs/promises';
 import { constants } from 'node:fs';
 import { createHash } from 'node:crypto';
 import { limits } from '../../contracts/index.js';
+import { SpongeError } from '../errors.js';
 /** Copy a bounded stable regular file; never pass the user's source to a converter. */
 export async function copyPdfInput(source, target, signal) {
     const input = await open(source, constants.O_RDONLY | constants.O_NOFOLLOW);
     try {
         const before = await input.stat();
         if (!before.isFile())
-            throw Error('invalid-input');
+            throw new SpongeError('invalid-input');
         if (before.size > limits.pdfBytes)
-            throw Error('limit-exceeded');
+            throw new SpongeError('limit-exceeded');
         const output = await open(target, 'wx', 0o600), hash = createHash('sha256');
         let total = 0;
         try {
             const buffer = Buffer.alloc(1024 ** 2);
             for (;;) {
                 if (signal?.aborted)
-                    throw Error('cancelled');
+                    throw new SpongeError('cancelled');
                 const { bytesRead } = await input.read(buffer, 0, buffer.length, null);
                 if (!bytesRead)
                     break;
                 total += bytesRead;
                 if (total > limits.pdfBytes)
-                    throw Error('limit-exceeded');
+                    throw new SpongeError('limit-exceeded');
                 if (total === bytesRead && buffer.subarray(0, 5).toString() !== '%PDF-')
-                    throw Error('invalid-input');
+                    throw new SpongeError('invalid-input');
                 const bytes = buffer.subarray(0, bytesRead);
                 hash.update(bytes);
                 await output.writeFile(bytes);
@@ -36,8 +37,12 @@ export async function copyPdfInput(source, target, signal) {
             await output.close();
         }
         const after = await input.stat();
-        if (total < 5 || total !== before.size || after.size !== before.size || after.mtimeMs !== before.mtimeMs || after.ctimeMs !== before.ctimeMs)
-            throw Error('integrity');
+        if (total < 5 ||
+            total !== before.size ||
+            after.size !== before.size ||
+            after.mtimeMs !== before.mtimeMs ||
+            after.ctimeMs !== before.ctimeMs)
+            throw new SpongeError('integrity');
         return hash.digest('hex');
     }
     finally {

package/dist/src/pdf/normalize.js

@@ -1,64 +1,123 @@
 import { limits } from '../../contracts/index.js';
 import { validateCapture, validateAsset } from '../../contracts/validate.js';
-import { readConfined, hash } from '../acquisition/files.js';
+import { readConfined } from '../acquisition/files.js';
+import { sha256 as hash } from '../util/hash.js';
 import { object } from '../acquisition/normalize.js';
+import { SpongeError } from '../errors.js';
 export async function normalizePdfBundle(input) {
     const verified = object(input.inspection), inspection = object(verified.inspection), summary = object(input.summary);
     if (verified.ok !== true || inspection.schemaVersion !== 1 || !Array.isArray(inspection.assets))
-        throw Error('integrity');
+        throw new SpongeError('integrity');
     const manifestBytes = await readConfined(input.bundleRoot, 'capture.json', limits.metadataBytes), manifest = object(JSON.parse(manifestBytes.toString('utf8')));
-    if (manifest.schemaVersion !== 1 || manifest.kind !== 'pdf' || !['complete', 'partial'].includes(String(manifest.status)))
-        throw Error('integrity');
-    function asset(raw, mediaType) { const value = object(raw); const result = { relativePath: String(value.path), bytes: Number(value.bytes), sha256: String(value.sha256), mediaType }; validateAsset(result); return result; }
-    function assertVerified(value, checked) { const record = object(checked); if (record.integrity !== 'verified' || record.path !== value.relativePath || record.sha256 !== value.sha256 || record.bytes !== value.bytes)
-        throw Error('integrity'); }
+    if (manifest.schemaVersion !== 1 ||
+        manifest.kind !== 'pdf' ||
+        !['complete', 'partial'].includes(String(manifest.status)))
+        throw new SpongeError('integrity');
+    function asset(raw, mediaType) {
+        const value = object(raw);
+        const result = {
+            relativePath: String(value.path),
+            bytes: Number(value.bytes),
+            sha256: String(value.sha256),
+            mediaType,
+        };
+        validateAsset(result);
+        return result;
+    }
+    function assertVerified(value, checked) {
+        const record = object(checked);
+        if (record.integrity !== 'verified' ||
+            record.path !== value.relativePath ||
+            record.sha256 !== value.sha256 ||
+            record.bytes !== value.bytes)
+            throw new SpongeError('integrity');
+    }
     const markdown = asset(manifest.markdown, 'text/markdown'), sourcePdf = asset(manifest.source, 'application/pdf');
     assertVerified(markdown, inspection.markdown);
     assertVerified(sourcePdf, inspection.source);
     if (input.sourceHash && sourcePdf.sha256 !== input.sourceHash)
-        throw Error('integrity');
+        throw new SpongeError('integrity');
     const source = object(manifest.source);
-    if (!input.sourceHash && (typeof verified.expectedSourceUrl !== 'string' || source.requestedUrl !== verified.expectedSourceUrl))
-        throw Error('integrity');
+    if (!input.sourceHash &&
+        (typeof verified.expectedSourceUrl !== 'string' || source.requestedUrl !== verified.expectedSourceUrl))
+        throw new SpongeError('integrity');
     const markdownBytes = await readConfined(input.bundleRoot, markdown.relativePath, limits.markdownBytes);
     if (hash(markdownBytes) !== markdown.sha256 || markdownBytes.length !== markdown.bytes)
-        throw Error('integrity');
+        throw new SpongeError('integrity');
     if (!Array.isArray(manifest.images) || manifest.images.length > limits.imagesPerItem)
-        throw Error('limit-exceeded');
+        throw new SpongeError('limit-exceeded');
     const byPath = new Map();
     for (const raw of manifest.images) {
         const image = object(raw), record = object(image.asset), value = asset(record, String(record.mimeType));
         if (!value.mediaType.startsWith('image/'))
-            throw Error('integrity');
-        assertVerified(value, inspection.assets.find(raw => object(raw).path === value.relativePath));
+            throw new SpongeError('integrity');
+        assertVerified(value, inspection.assets.find((raw) => object(raw).path === value.relativePath));
         const prior = byPath.get(value.relativePath);
         if (prior && JSON.stringify(prior) !== JSON.stringify(value))
-            throw Error('integrity');
+            throw new SpongeError('integrity');
         byPath.set(value.relativePath, value);
     }
     if (byPath.size !== inspection.assets.length)
-        throw Error('integrity');
+        throw new SpongeError('integrity');
     const metadata = [], document = object(manifest.document), observedAt = String(manifest.capturedAt);
     for (const field of ['title', 'author', 'subject', 'creator', 'producer', 'createdAt', 'modifiedAt']) {
         const value = document[field];
         if (typeof value === 'string' && value.length > 0 && value.length <= 16384)
             metadata.push({ field, value, source: 'pdf', observedAt, rule: 'wordcell-pdf-v1', selected: true });
     }
-    metadata.push({ field: 'pageCount', value: String(document.pageCount), source: 'pdf', observedAt, rule: 'wordcell-pdf-v1' });
+    metadata.push({
+        field: 'pageCount',
+        value: String(document.pageCount),
+        source: 'pdf',
+        observedAt,
+        rule: 'wordcell-pdf-v1',
+    });
     if (manifest.quality) {
         const quality = object(manifest.quality);
         if (Array.isArray(quality.issues)) {
-            metadata.push({ field: 'pdfQualityIssueCount', value: String(quality.issues.length), source: 'pdf', observedAt, rule: 'wordcell-pdf-v1' });
+            metadata.push({
+                field: 'pdfQualityIssueCount',
+                value: String(quality.issues.length),
+                source: 'pdf',
+                observedAt,
+                rule: 'wordcell-pdf-v1',
+            });
             if (quality.issues.length > 400)
-                metadata.push({ field: 'pdfQualityIssuesTruncated', value: 'true', source: 'pdf', observedAt, rule: 'wordcell-pdf-v1' });
+                metadata.push({
+                    field: 'pdfQualityIssuesTruncated',
+                    value: 'true',
+                    source: 'pdf',
+                    observedAt,
+                    rule: 'wordcell-pdf-v1',
+                });
             for (const issue of quality.issues.slice(0, 400)) {
                 const row = object(issue);
-                metadata.push({ field: 'pdfQuality', value: JSON.stringify({ code: row.code, page: row.page }), source: 'pdf', observedAt, rule: 'wordcell-pdf-v1' });
+                metadata.push({
+                    field: 'pdfQuality',
+                    value: JSON.stringify({ code: row.code, page: row.page }),
+                    source: 'pdf',
+                    observedAt,
+                    rule: 'wordcell-pdf-v1',
+                });
             }
         }
     }
     const partial = manifest.status !== 'complete' || inspection.status !== 'complete' || summary.status !== 'complete';
-    const result = { schemaVersion: 1, requestId: input.requestId, kind: 'pdf', status: partial ? 'partial' : 'complete', sourceUrl: input.sourceUrl, markdown, sourcePdf, assets: [...byPath.values()], metadata, warnings: partial ? ['partial'] : [], extractor: { name: 'wordcell', version: input.wordcellVersion }, manifestSha256: hash(manifestBytes), completeness: { text: partial ? 'partial' : 'complete', images: partial ? 'partial' : 'complete' } };
+    const result = {
+        schemaVersion: 1,
+        requestId: input.requestId,
+        kind: 'pdf',
+        status: partial ? 'partial' : 'complete',
+        sourceUrl: input.sourceUrl,
+        markdown,
+        sourcePdf,
+        assets: [...byPath.values()],
+        metadata,
+        warnings: partial ? ['partial'] : [],
+        extractor: { name: 'wordcell', version: input.wordcellVersion },
+        manifestSha256: hash(manifestBytes),
+        completeness: { text: partial ? 'partial' : 'complete', images: partial ? 'partial' : 'complete' },
+    };
     validateCapture(result);
     return result;
 }

package/dist/src/pdf/source-identity.js

@@ -1,12 +1,13 @@
+import { SpongeError } from '../errors.js';
 /** Local PDFs are bound to copied bytes; only remote sources use Wordcell's URL sanitizer. */
 export function pdfSourceIdentity(sourceUrl, sanitize) {
     const url = new URL(sourceUrl);
     if (url.protocol === 'file:') {
         if (url.host || url.username || url.password || url.search || url.hash)
-            throw Error('integrity');
+            throw new SpongeError('integrity');
         return {};
     }
     if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password)
-        throw Error('integrity');
+        throw new SpongeError('integrity');
     return { expectedSourceUrl: sanitize(sourceUrl) };
 }

package/dist/src/pdf/source.js

@@ -1,22 +1,26 @@
-import { createHash } from 'node:crypto';
+import { sha256 } from '../util/hash.js';
 import { resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { InputError } from '../app/source.js';
+import { SpongeError } from '../errors.js';
 /** PDF identity includes its kind and account realm. Local files stay separate from URLs. */
 export function pdfSource(input, realm = 'public') {
-    if (!input || Buffer.byteLength(input) > 8192 || !realm || Buffer.byteLength(realm) > 256 || /[\u0000-\u001f\u007f]/u.test(input + realm))
-        throw new InputError();
+    if (!input ||
+        Buffer.byteLength(input) > 8192 ||
+        !realm ||
+        Buffer.byteLength(realm) > 256 ||
+        /[\u0000-\u001f\u007f]/u.test(input + realm))
+        throw new SpongeError('invalid-input');
     let url;
     try {
         url = /^[a-z][a-z0-9+.-]*:/i.test(input) ? new URL(input) : pathToFileURL(resolve(input));
     }
     catch {
-        throw new InputError();
+        throw new SpongeError('invalid-input');
     }
     if (!['file:', 'https:', 'http:'].includes(url.protocol) || url.username || url.password)
-        throw new InputError();
+        throw new SpongeError('invalid-input');
     if (url.protocol === 'file:' && (url.host || url.hash || url.search || realm !== 'public'))
-        throw new InputError();
-    const locator = url.href, sourceKey = createHash('sha256').update(JSON.stringify(['pdf', realm, locator])).digest('hex');
+        throw new SpongeError('invalid-input');
+    const locator = url.href, sourceKey = sha256(JSON.stringify(['pdf', realm, locator]));
     return { sourceKey, locator, realm };
 }

package/dist/src/pdf/verify-helper.js

@@ -1,14 +1,26 @@
 // Public PDF verifier, executed only by the integrity-checked pinned Bun runtime.
 import { pdfSourceIdentity } from './source-identity.js';
+import { SpongeError } from '../errors.js';
 const runtime = process.argv[2], bundle = process.argv[3];
 try {
     const { sanitizeArtifactUrl } = await import(import.meta.resolve('@hraness/wordcell/clip/persist', `${runtime}/package.json`));
     const { verifyPdfCaptureBundle } = await import(import.meta.resolve('@hraness/wordcell/pdf', `${runtime}/package.json`));
-    const result = await verifyPdfCaptureBundle(bundle, { maxDocumentBytes: 16 * 1024 ** 2, maxSourceBytes: 100 * 1024 ** 2, maxVerifiedAssets: 200, maxAssetBytes: 20 * 1024 ** 2, maxTotalAssetBytes: 500 * 1024 ** 2, maxVerificationMs: 30000 });
+    const result = await verifyPdfCaptureBundle(bundle, {
+        maxDocumentBytes: 16 * 1024 ** 2,
+        maxSourceBytes: 100 * 1024 ** 2,
+        maxVerifiedAssets: 200,
+        maxAssetBytes: 20 * 1024 ** 2,
+        maxTotalAssetBytes: 500 * 1024 ** 2,
+        maxVerificationMs: 30000,
+    });
     const { markdown, ...document } = result.inspection.markdown;
-    const output = JSON.stringify({ ...result, ...pdfSourceIdentity(process.argv[4], sanitizeArtifactUrl), inspection: { ...result.inspection, markdown: document } });
+    const output = JSON.stringify({
+        ...result,
+        ...pdfSourceIdentity(process.argv[4], sanitizeArtifactUrl),
+        inspection: { ...result.inspection, markdown: document },
+    });
     if (Buffer.byteLength(output) > 65536)
-        throw Error('frame-limit');
+        throw new SpongeError('limit-exceeded');
     process.stdout.write(output);
 }
 catch {

package/dist/src/portability/backup.d.ts

@@ -1,18 +1,10 @@
 import type { LibraryStore } from '../store/index.js';
-import { type FileRecord } from './files.js';
-export interface BackupManifest {
-    format: 'sponge-backup';
-    version: 1;
-    schemaVersion: number;
-    libraryId: string;
-    revisionEpoch: number;
-    files: FileRecord[];
-}
 export declare function backupLibrary(store: LibraryStore, output: string): Promise<{
     output: string;
     sha256: string;
     bytes: number;
     itemsSnapshotEpoch: number;
+    publishKey: boolean;
 }>;
 /** Versioned length-framed archive: no tar links, executable hooks or path extraction. */
 export declare function restoreLibrary(input: string, into: string): Promise<{
@@ -20,4 +12,5 @@ export declare function restoreLibrary(input: string, into: string): Promise<{
     libraryId: string;
     incarnation: string;
     heldJobs: number;
+    publishKey: boolean;
 }>;