@will-17173/telegram-cli 0.2.0 → 0.4.0

package/dist/services/archive-service.js

@@ -0,0 +1,718 @@
+import { closeSync, copyFileSync, constants, createReadStream, existsSync, fstatSync, fsyncSync, linkSync, lstatSync, mkdirSync, openSync, realpathSync, renameSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { randomBytes } from 'node:crypto';
+import { basename, dirname, isAbsolute, join, relative, sep } from 'node:path';
+import { isTelegramAuthSessionError } from '../telegram/errors.js';
+import { archiveChatFile, archiveMediaFile } from './archive-layout.js';
+import { readArchiveManifest, validateArchiveAccount, writeArchiveManifest, } from './archive-manifest.js';
+import { renderArchiveHeader, renderArchiveMessage, scanArchiveRecovery, } from './archive-markdown.js';
+const DEFAULT_HISTORY_MS = 7 * 86_400_000;
+const MANIFEST_FILE = 'archive-manifest.json';
+const BLOCK_SEPARATOR = '\n\n---\n\n';
+class ArchiveOperationError extends Error {
+    fatal;
+    constructor(message, fatal = false) {
+        super(message);
+        this.fatal = fatal;
+    }
+}
+export class ArchiveService {
+    source;
+    writeManifest;
+    writeArchive;
+    restoreManifest;
+    transaction;
+    constructor(source, dependencies = {}) {
+        this.source = source;
+        this.writeManifest = dependencies.writeManifest ?? writeArchiveManifest;
+        this.writeArchive = dependencies.writeArchive ?? writeArchiveFile;
+        this.restoreManifest = dependencies.restoreManifest ?? restoreManifestSnapshot;
+        const sync = dependencies.transaction?.syncDirectory ?? syncDirectory;
+        this.transaction = {
+            backupDestination: dependencies.transaction?.backupDestination
+                ?? ((source, backup) => backupFile(source, backup, sync)),
+            replaceDestination: dependencies.transaction?.replaceDestination
+                ?? ((temporary, destination) => {
+                    renameSync(temporary, destination);
+                    sync(dirname(destination));
+                }),
+            rollbackDestination: dependencies.transaction?.rollbackDestination
+                ?? ((destination, backup) => {
+                    if (backup == null) {
+                        try {
+                            unlinkSync(destination);
+                        }
+                        catch (error) {
+                            if (error.code !== 'ENOENT')
+                                throw error;
+                        }
+                    }
+                    else {
+                        renameSync(backup, destination);
+                    }
+                    sync(dirname(destination));
+                }),
+            cleanupBackup: dependencies.transaction?.cleanupBackup
+                ?? ((backup) => {
+                    unlinkSync(backup);
+                    sync(dirname(backup));
+                }),
+            syncDirectory: sync,
+        };
+    }
+    async archive(input) {
+        validateInput(input);
+        const now = input.now ?? new Date();
+        const timestamp = now.toISOString();
+        const manifestPath = join(input.output, MANIFEST_FILE);
+        const existing = readArchiveManifest(manifestPath);
+        if (existing != null)
+            validateArchiveAccount(existing, input.account);
+        let manifest = existing ?? {
+            schema_version: 1,
+            account_name: input.account.name,
+            account_user_id: input.account.userId,
+            created_at: timestamp,
+            updated_at: timestamp,
+            chats: {},
+        };
+        let manifestPersisted = existing != null;
+        const chats = await this.source.resolveChats({
+            chats: input.all ? undefined : input.chats,
+            all: input.all,
+        });
+        mkdirSync(input.output, { recursive: true });
+        const result = {
+            manifest: manifestPath,
+            completed: [],
+            failed: [],
+            warnings: [],
+        };
+        for (const chat of chats) {
+            const previous = manifest.chats[String(chat.id)];
+            try {
+                const range = effectiveRange(input, previous, now);
+                validateEffectiveRange(range);
+                const archived = await this.archiveChat(chat, input.output, range, now, previous, input.rebuild === true, input.media === true);
+                const candidate = {
+                    ...manifest,
+                    account_name: input.account.name,
+                    updated_at: timestamp,
+                    chats: {
+                        ...manifest.chats,
+                        [String(chat.id)]: archived.state,
+                    },
+                };
+                try {
+                    this.writeManifest(manifestPath, candidate);
+                }
+                catch {
+                    const failures = ['archive_manifest_commit_failed'];
+                    let fatal = false;
+                    try {
+                        this.restoreManifest(manifestPath, manifestPersisted ? manifest : null);
+                    }
+                    catch {
+                        failures.push('archive_manifest_recovery_failed');
+                        fatal = true;
+                    }
+                    try {
+                        archived.rollback();
+                    }
+                    catch {
+                        failures.push('archive_rollback_failed');
+                        fatal = true;
+                    }
+                    throw new ArchiveOperationError(failures.join(';'), fatal);
+                }
+                manifest = candidate;
+                manifestPersisted = true;
+                let cleanupFailed = false;
+                try {
+                    archived.finalize();
+                }
+                catch {
+                    cleanupFailed = true;
+                }
+                result.completed.push({
+                    chat_id: chat.id,
+                    title: chat.title,
+                    file: archived.state.file,
+                    messages_archived: archived.messages,
+                    media_archived: archived.media,
+                });
+                result.warnings.push(...archived.warnings);
+                if (cleanupFailed) {
+                    result.warnings.push({
+                        chat_id: chat.id,
+                        code: 'archive_backup_cleanup_failed',
+                        message: 'Archive committed, but recovery-backup cleanup could not be confirmed.',
+                    });
+                }
+            }
+            catch (error) {
+                if (isTelegramAuthSessionError(error))
+                    throw error;
+                const failure = publicArchiveFailure(error);
+                result.failed.push({
+                    chat_id: chat.id,
+                    title: chat.title,
+                    error: failure.message,
+                });
+                if (failure.fatal)
+                    break;
+            }
+        }
+        if (result.failed.length === 0 && result.warnings.length === 0) {
+            return { ok: true, data: result };
+        }
+        return {
+            ok: false,
+            error: {
+                code: 'archive_partial_failure',
+                message: 'Archive completed with one or more chat or attachment failures.',
+                details: {
+                    completed: result.completed,
+                    failed: result.failed,
+                    warnings: result.warnings,
+                },
+            },
+        };
+    }
+    async archiveChat(chat, output, range, now, previous, rebuild = false, downloadMedia = false) {
+        const file = previous?.file ?? archiveChatFile(chat.id, chat.title);
+        const destination = join(output, file);
+        const token = `${process.pid}-${randomBytes(8).toString('hex')}`;
+        const ownedPaths = [];
+        const segments = [];
+        let backup;
+        let replacementAttempted = false;
+        let newest;
+        let messages = 0;
+        let media = 0;
+        const warnings = [];
+        try {
+            const incremental = previous != null && !rebuild && existsSync(destination);
+            const recovery = incremental
+                ? await scanArchiveRecovery(createReadStream(destination), {
+                    expectedChatId: chat.id,
+                    onMedia: downloadMedia ? async (link) => {
+                        const downloaded = await this.downloadMediaFile(output, chat, link.messageId, link.path, token);
+                        if (downloaded.archived && !downloaded.reused)
+                            media += 1;
+                        if (downloaded.warning != null)
+                            warnings.push(downloaded.warning);
+                    } : undefined,
+                })
+                : { maxId: null, maxTimestamp: null };
+            const effectiveMinId = incremental
+                ? maxDefined(previous.last_message_id, recovery.maxId)
+                : undefined;
+            const fetchedIds = new Set();
+            let pageNumber = 0;
+            for await (const page of this.source.iterHistoryPages({
+                chat: chat.id,
+                since: range.since,
+                until: range.until,
+                minId: effectiveMinId,
+            })) {
+                if (page.length === 0)
+                    continue;
+                const unseen = page.filter((item) => {
+                    if (effectiveMinId != null && item.msg_id <= effectiveMinId)
+                        return false;
+                    if (fetchedIds.has(item.msg_id))
+                        return false;
+                    fetchedIds.add(item.msg_id);
+                    return true;
+                });
+                if (unseen.length === 0)
+                    continue;
+                const segment = join(output, `.${basename(file)}.${token}.${pageNumber}.segment`);
+                pageNumber += 1;
+                ownedPaths.push(segment);
+                const chronological = [...unseen].reverse();
+                const rendered = [];
+                for (const item of chronological) {
+                    const downloaded = downloadMedia
+                        ? await this.downloadAttachment(output, chat, item, token)
+                        : { path: undefined, archived: false, warning: undefined };
+                    if (downloaded.archived)
+                        media += 1;
+                    if (downloaded.warning != null)
+                        warnings.push(downloaded.warning);
+                    rendered.push(renderArchiveMessage(item, downloaded.path));
+                }
+                writeExclusive(segment, rendered.join(BLOCK_SEPARATOR));
+                segments.push(segment);
+                messages += chronological.length;
+                for (const item of unseen) {
+                    if (newest == null || item.msg_id > newest.msg_id)
+                        newest = item;
+                }
+            }
+            const temporary = join(output, `.${basename(file)}.${token}.tmp`);
+            ownedPaths.push(temporary);
+            await this.writeArchive(temporary, renderArchiveHeader(chat, now), segments.reverse(), incremental ? destination : undefined);
+            removeOwned(segments);
+            backup = existsSync(destination)
+                ? join(output, `.${basename(file)}.${token}.backup`)
+                : undefined;
+            if (backup != null) {
+                this.transaction.backupDestination(destination, backup);
+            }
+            replacementAttempted = true;
+            this.transaction.replaceDestination(temporary, destination);
+            return {
+                messages,
+                media,
+                warnings,
+                finalize: () => {
+                    if (backup != null)
+                        this.transaction.cleanupBackup(backup);
+                },
+                rollback: () => this.transaction.rollbackDestination(destination, backup),
+                state: {
+                    title: chat.title,
+                    file,
+                    initial_since: incremental
+                        ? previous.initial_since
+                        : range.since?.toISOString() ?? null,
+                    initial_until: incremental
+                        ? previous.initial_until
+                        : range.until?.toISOString() ?? null,
+                    full_history: incremental ? previous.full_history : range.full,
+                    last_message_id: newest?.msg_id ?? effectiveMinId ?? null,
+                    last_message_date: newest?.timestamp == null
+                        ? recoveredCursorTimestamp(previous, recovery, effectiveMinId)
+                        : new Date(newest.timestamp).toISOString(),
+                    last_run: now.toISOString(),
+                },
+            };
+        }
+        catch (error) {
+            removeOwnedQuietly(ownedPaths);
+            if (replacementAttempted) {
+                try {
+                    this.transaction.rollbackDestination(destination, backup);
+                }
+                catch {
+                    throw new ArchiveOperationError('archive_persistence_failed;archive_rollback_failed', true);
+                }
+                throw new ArchiveOperationError('archive_persistence_failed');
+            }
+            if (backup != null) {
+                try {
+                    this.transaction.cleanupBackup(backup);
+                }
+                catch {
+                    throw new ArchiveOperationError('archive_backup_cleanup_failed');
+                }
+            }
+            throw error;
+        }
+    }
+    async downloadAttachment(output, chat, message, token) {
+        const attachment = message.attachment;
+        if (attachment == null || !attachment.downloadable)
+            return { archived: false };
+        const relativePath = archiveMediaFile(chat.id, message.msg_id, attachment.file_name ?? 'attachment');
+        return this.downloadMediaFile(output, chat, message.msg_id, relativePath, token);
+    }
+    async downloadMediaFile(output, chat, messageId, relativePath, token) {
+        let prepared;
+        try {
+            prepared = this.prepareMediaTarget(output, chat.id, messageId, relativePath);
+        }
+        catch {
+            return mediaDownloadFailure(chat.id, messageId, relativePath);
+        }
+        if (prepared.reused)
+            return { path: relativePath, archived: true, reused: true };
+        const { destination, directory, root } = prepared;
+        const temporary = join(root, `.media-stage.${token}.${chat.id}.${messageId}.tmp`);
+        let stagingOwned = false;
+        let stagingIdentity = '';
+        try {
+            stagingIdentity = createOwnedStagingFile(temporary);
+            stagingOwned = true;
+            const beforeDownload = this.prepareMediaTarget(output, chat.id, messageId, relativePath);
+            assertSameMediaTarget(prepared, beforeDownload);
+            if (beforeDownload.reused) {
+                removeOwnedStagingFile(temporary, stagingIdentity);
+                stagingOwned = false;
+                return { path: relativePath, archived: true, reused: true };
+            }
+            await this.source.downloadMedia({
+                chat: chat.id,
+                messageId,
+                destination: temporary,
+            });
+            assertOwnedRegularNonEmptyFile(temporary, stagingIdentity);
+            const descriptor = openSync(temporary, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+            try {
+                const status = fstatSync(descriptor, { bigint: true });
+                if (!status.isFile()
+                    || status.size === 0n
+                    || fileIdentity(status) !== stagingIdentity) {
+                    throw new Error('archive_unsafe_media_temp');
+                }
+                fsyncSync(descriptor);
+            }
+            finally {
+                closeSync(descriptor);
+            }
+            const current = this.prepareMediaTarget(output, chat.id, messageId, relativePath);
+            assertSameMediaTarget(prepared, current);
+            if (current.reused) {
+                removeOwnedStagingFile(temporary, stagingIdentity);
+                stagingOwned = false;
+                return { path: relativePath, archived: true, reused: true };
+            }
+            assertOwnedRegularNonEmptyFile(temporary, stagingIdentity);
+            // Node has no openat/renameat. Revalidation pins every parent identity immediately
+            // before this commit, but a same-user directory swap can still race the rename itself.
+            renameSync(temporary, destination);
+            stagingOwned = false;
+            this.transaction.syncDirectory(directory);
+            return { path: relativePath, archived: true };
+        }
+        catch (error) {
+            if (stagingOwned)
+                removeOwnedStagingFile(temporary, stagingIdentity);
+            if (isTelegramAuthSessionError(error))
+                throw error;
+            return mediaDownloadFailure(chat.id, messageId, relativePath);
+        }
+    }
+    prepareMediaTarget(output, chatId, messageId, relativePath) {
+        const expectedPrefix = `${messageId}-`;
+        const components = relativePath.split('/');
+        if (components.length !== 3
+            || components[0] !== 'media'
+            || components[1] !== String(chatId)
+            || !components[2]?.startsWith(expectedPrefix)
+            || archiveMediaFile(chatId, messageId, components[2].slice(expectedPrefix.length))
+                !== relativePath) {
+            throw new Error('archive_unsafe_media_path');
+        }
+        const root = realpathSync(output);
+        const rootStatus = lstatSync(root, { bigint: true });
+        if (!rootStatus.isDirectory())
+            throw new Error('archive_unsafe_media_root');
+        const identities = [fileIdentity(rootStatus)];
+        let directory = root;
+        for (const component of components.slice(0, -1)) {
+            const next = join(directory, component);
+            let status;
+            try {
+                status = lstatSync(next, { bigint: true });
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+                mkdirSync(next, { mode: 0o700 });
+                this.transaction.syncDirectory(directory);
+                status = lstatSync(next, { bigint: true });
+            }
+            if (status.isSymbolicLink() || !status.isDirectory()) {
+                throw new Error('archive_unsafe_media_directory');
+            }
+            const realDirectory = realpathSync(next);
+            if (!pathIsWithin(root, realDirectory))
+                throw new Error('archive_unsafe_media_directory');
+            identities.push(fileIdentity(status));
+            directory = realDirectory;
+        }
+        const destination = join(directory, components.at(-1));
+        if (!pathIsWithin(root, destination))
+            throw new Error('archive_unsafe_media_destination');
+        try {
+            const status = lstatSync(destination, { bigint: true });
+            if (status.isSymbolicLink() || !status.isFile()) {
+                throw new Error('archive_unsafe_media_destination');
+            }
+            return { root, destination, directory, identities, reused: status.size > 0n };
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+            return { root, destination, directory, identities, reused: false };
+        }
+    }
+}
+function validateInput(input) {
+    const chats = input.chats ?? [];
+    if (!input.all && chats.length === 0)
+        throw new Error('archive_scope_required');
+    if (input.all && chats.length > 0)
+        throw new Error('archive_scope_conflict');
+    if (input.full && input.range?.since != null)
+        throw new Error('archive_full_range_conflict');
+    const now = input.now ?? new Date();
+    const since = input.range?.since;
+    const until = input.range?.until;
+    const effectiveSince = input.full || (input.rebuild && since == null && until == null)
+        ? since
+        : since ?? new Date(now.getTime() - DEFAULT_HISTORY_MS);
+    if (!validDate(now)
+        || (since != null && !validDate(since))
+        || (until != null && !validDate(until))
+        || (effectiveSince != null && until != null && effectiveSince.getTime() >= until.getTime())) {
+        throw new Error('archive_invalid_time_range');
+    }
+}
+function effectiveRange(input, previous, now) {
+    const explicitRange = input.range?.since != null || input.range?.until != null;
+    if (input.rebuild && previous != null && !input.full && !explicitRange) {
+        return {
+            since: previous.initial_since == null ? undefined : new Date(previous.initial_since),
+            until: previous.initial_until == null ? undefined : new Date(previous.initial_until),
+            full: previous.full_history,
+        };
+    }
+    return {
+        since: input.full
+            ? undefined
+            : input.range?.since ?? new Date(now.getTime() - DEFAULT_HISTORY_MS),
+        until: input.range?.until,
+        full: input.full === true,
+    };
+}
+function validDate(value) {
+    return value instanceof Date && Number.isFinite(value.getTime());
+}
+function maxDefined(left, right) {
+    if (left == null)
+        return right ?? undefined;
+    if (right == null)
+        return left;
+    return Math.max(left, right);
+}
+function recoveredCursorTimestamp(previous, recovery, effectiveMinId) {
+    if (effectiveMinId == null)
+        return null;
+    if (recovery.maxId === effectiveMinId)
+        return recovery.maxTimestamp;
+    if (previous?.last_message_id === effectiveMinId)
+        return previous.last_message_date;
+    return null;
+}
+function pathIsWithin(root, candidate) {
+    const fromRoot = relative(root, candidate);
+    return fromRoot !== ''
+        && fromRoot !== '..'
+        && !fromRoot.startsWith(`..${sep}`)
+        && !isAbsolute(fromRoot);
+}
+function createOwnedStagingFile(path) {
+    const descriptor = openSync(path, constants.O_CREAT
+        | constants.O_EXCL
+        | constants.O_WRONLY
+        | (constants.O_NOFOLLOW ?? 0), 0o600);
+    try {
+        const status = fstatSync(descriptor, { bigint: true });
+        if (!status.isFile())
+            throw new Error('archive_unsafe_media_temp');
+        return fileIdentity(status);
+    }
+    finally {
+        closeSync(descriptor);
+    }
+}
+function assertSameMediaTarget(expected, actual) {
+    if (expected.root !== actual.root
+        || expected.destination !== actual.destination
+        || expected.directory !== actual.directory
+        || expected.identities.length !== actual.identities.length
+        || expected.identities.some((identity, index) => identity !== actual.identities[index])) {
+        throw new Error('archive_unsafe_media_destination');
+    }
+}
+function fileIdentity(status) {
+    if (status.ino <= 0n || status.dev < 0n)
+        throw new Error('archive_unusable_file_identity');
+    return `${status.dev}:${status.ino}`;
+}
+function assertOwnedRegularNonEmptyFile(path, identity) {
+    const status = lstatSync(path, { bigint: true });
+    if (status.isSymbolicLink()
+        || !status.isFile()
+        || status.size === 0n
+        || fileIdentity(status) !== identity) {
+        throw new Error('archive_unsafe_media_temp');
+    }
+}
+function removeOwnedStagingFile(path, identity) {
+    try {
+        const status = lstatSync(path, { bigint: true });
+        if (status.isSymbolicLink() || !status.isFile() || fileIdentity(status) !== identity)
+            return;
+        unlinkSync(path);
+    }
+    catch {
+        // Never follow or remove a staging path whose ownership can no longer be proven.
+    }
+}
+function mediaDownloadFailure(chatId, messageId, relativePath) {
+    const fileName = basename(relativePath).slice(`${messageId}-`.length);
+    return {
+        path: relativePath,
+        archived: false,
+        warning: {
+            chat_id: chatId,
+            code: 'archive_media_failed',
+            message: `Media download failed for message #${messageId} attachment ${fileName}.`,
+        },
+    };
+}
+function validateEffectiveRange(range) {
+    if ((range.since != null && !validDate(range.since))
+        || (range.until != null && !validDate(range.until))
+        || (range.since != null
+            && range.until != null
+            && range.since.getTime() >= range.until.getTime())) {
+        throw new ArchiveOperationError('archive_invalid_time_range');
+    }
+}
+function publicArchiveFailure(error) {
+    if (error instanceof ArchiveOperationError) {
+        return { message: error.message, fatal: error.fatal };
+    }
+    return { message: 'archive_chat_failed', fatal: false };
+}
+function writeExclusive(path, value) {
+    let descriptor = null;
+    try {
+        descriptor = openSync(path, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 0o600);
+        writeFileSync(descriptor, value, 'utf8');
+        fsyncSync(descriptor);
+    }
+    finally {
+        if (descriptor != null)
+            closeSync(descriptor);
+    }
+}
+function backupFile(source, backup, sync) {
+    try {
+        linkSync(source, backup);
+    }
+    catch {
+        copyFileSync(source, backup, constants.COPYFILE_EXCL);
+        const descriptor = openSync(backup, constants.O_RDONLY);
+        try {
+            fsyncSync(descriptor);
+        }
+        finally {
+            closeSync(descriptor);
+        }
+    }
+    sync(dirname(backup));
+}
+function restoreManifestSnapshot(path, manifest) {
+    let failure;
+    try {
+        if (manifest == null) {
+            try {
+                unlinkSync(path);
+                syncDirectory(dirname(path));
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+        else {
+            writeArchiveManifest(path, manifest);
+        }
+    }
+    catch (error) {
+        failure = error;
+    }
+    try {
+        const restored = readArchiveManifest(path);
+        if (JSON.stringify(restored) === JSON.stringify(manifest))
+            return;
+    }
+    catch {
+        // Report the recovery failure below without exposing filesystem paths.
+    }
+    throw failure ?? new Error('archive_manifest_recovery_failed');
+}
+const UNSUPPORTED_DIRECTORY_SYNC_CODES = new Set([
+    'EACCES',
+    'EINVAL',
+    'EISDIR',
+    'ENOSYS',
+    'ENOTSUP',
+    'EPERM',
+]);
+function syncDirectory(path) {
+    let descriptor = null;
+    try {
+        descriptor = openSync(path, constants.O_RDONLY);
+        fsyncSync(descriptor);
+    }
+    catch (error) {
+        const code = error.code;
+        if (!code || !UNSUPPORTED_DIRECTORY_SYNC_CODES.has(code))
+            throw error;
+    }
+    finally {
+        if (descriptor != null)
+            closeSync(descriptor);
+    }
+}
+async function writeArchiveFile(path, header, segments, source) {
+    let descriptor = null;
+    try {
+        descriptor = openSync(path, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 0o600);
+        if (source == null) {
+            writeFileSync(descriptor, header, 'utf8');
+        }
+        else {
+            for await (const chunk of createReadStream(source)) {
+                writeFileSync(descriptor, chunk);
+            }
+        }
+        for (const segment of segments) {
+            writeFileSync(descriptor, BLOCK_SEPARATOR, 'utf8');
+            for await (const chunk of createReadStream(segment)) {
+                writeFileSync(descriptor, chunk);
+            }
+        }
+        if (segments.length > 0 || source == null)
+            writeFileSync(descriptor, '\n', 'utf8');
+        fsyncSync(descriptor);
+        const completed = descriptor;
+        descriptor = null;
+        closeSync(completed);
+    }
+    finally {
+        if (descriptor != null)
+            closeSync(descriptor);
+    }
+}
+function removeOwned(paths) {
+    let firstError;
+    for (const path of paths) {
+        try {
+            unlinkSync(path);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT' && firstError == null) {
+                firstError = error;
+            }
+        }
+    }
+    if (firstError != null)
+        throw firstError;
+}
+function removeOwnedQuietly(paths) {
+    try {
+        removeOwned(paths);
+    }
+    catch {
+        // Preserve the archive failure after attempting every owned path.
+    }
+}
+//# sourceMappingURL=archive-service.js.map