@iwonz/ywtc 3.1.0 → 3.2.1

package/dist/migrator.js

@@ -1,15 +1,16 @@
 import { createHash } from 'node:crypto';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import PQueue from 'p-queue';
 import { createProviderAdapter } from './adapters/factory.js';
-import { appendGridSnapshots, normalizePageContent, normalizedPreviewHtml, renderedPreviewHtml, renderConfluenceStorage, renderYfm, } from './content-model.js';
+import { appendGridSnapshots, assertDestinationContent, isLegacyTransferPlaceholder, normalizePageContent, normalizedPreviewHtml, rawContentFallback, renderedPreviewHtml, renderConfluenceStorage, renderYfm, setSourceResourceBinding, sourceResourceBindings, verifyDestinationContent, } from './content-model.js';
+import { ConfirmedDestinationMissingError, verifyConfirmedDestinationPage } from './consistency.js';
 import { assertTransferCapabilities } from './domain.js';
 import { FilesystemExporter } from './filesystem-export.js';
 import { discoverPageGraph } from './graph.js';
-import { safeFilename } from './input.js';
 import { profileBaseUrl, sameRemoteInstance } from './locators.js';
 import { TransferReport } from './report.js';
+import { DestinationNameAllocator, preferredDestinationName, verifiedCacheFile } from './resource-reconciliation.js';
 import { resolveStateLocation, StateStore, } from './state.js';
 function sourceIdentity(locator, root) {
     return {
@@ -62,11 +63,6 @@ async function cacheDocument(cacheDirectory, canonicalId, document) {
 async function loadCachedDocument(cacheDirectory, canonicalId) {
     return JSON.parse(await readFile(cachedDocumentPath(cacheDirectory, canonicalId), 'utf8'));
 }
-function placeholder(adapter, page) {
-    return adapter.kind === 'confluence'
-        ? `<p><em>ywtc transfer in progress from <a href="${page.url.replaceAll('&', '&amp;').replaceAll('"', '&quot;')}">${page.provider}</a>.</em></p>`
-        : `_ywtc transfer in progress from [${page.provider}](${page.url})._`;
-}
 function collisionTitle(page) {
     const suffix = page.locator.split('/').filter(Boolean).at(-1) ?? page.id;
     return `${page.title} [${suffix}]`;
@@ -74,7 +70,37 @@ function collisionTitle(page) {
 function cachePath(cacheDirectory, page, resource) {
     const pageKey = sha256(page.canonicalId).slice(0, 12);
     const resourceKey = sha256(`${resource.id}:${resource.name}`).slice(0, 12);
-    return path.join(cacheDirectory, pageKey, `${resourceKey}-${safeFilename(resource.name)}`);
+    return path.join(cacheDirectory, pageKey, `${resourceKey}-${preferredDestinationName(resource)}`);
+}
+function containedCachePath(cacheDirectory, candidate) {
+    if (!candidate)
+        return undefined;
+    const relative = path.relative(path.resolve(cacheDirectory), path.resolve(candidate));
+    return relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative)
+        ? path.resolve(candidate)
+        : undefined;
+}
+function resetResourceDestinations(resources) {
+    return Object.fromEntries(Object.entries(resources).map(([id, resource]) => [id, {
+            sourceId: resource.sourceId,
+            sourceName: resource.sourceName,
+            destinationName: resource.destinationName,
+            ...(resource.sha256 ? { sha256: resource.sha256 } : {}),
+            ...(resource.size !== undefined ? { size: resource.size } : {}),
+            ...(resource.cachePath ? { cachePath: resource.cachePath } : {}),
+            ...(resource.mimeType ? { mimeType: resource.mimeType } : {}),
+            status: 'planned',
+            updatedAt: new Date().toISOString(),
+        }]));
+}
+function sourceDerivedTextMatches(expectedBody, actualBody, provider, page) {
+    if (actualBody === undefined)
+        return false;
+    const result = verifyDestinationContent(expectedBody, actualBody, provider, page);
+    if (result.status === 'complete')
+        return true;
+    const text = (value) => renderedPreviewHtml(value, provider).replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim();
+    return text(expectedBody) === text(actualBody);
 }
 function destinationFromState(state, adapter) {
     if (!state.destinationId || !state.destinationCanonicalId || !state.destinationLocator) {
@@ -92,6 +118,9 @@ function destinationFromState(state, adapter) {
     };
 }
 function reportPage(input) {
+    const transferable = input.resources.filter((resource) => resource.kind !== 'grid');
+    const sizes = transferable.map((resource) => input.resourceSizes?.[resource.id]?.size ?? resource.size);
+    const knownBytes = sizes.reduce((total, size) => total + (size ?? 0), 0);
     return {
         sourceCanonicalId: input.page.canonicalId,
         sourceId: input.page.id,
@@ -105,14 +134,17 @@ function reportPage(input) {
         ...(input.page.projectedParentId ? { parentId: input.page.projectedParentId } : {}),
         depth: input.page.depth,
         status: input.status,
-        resources: input.resources.filter((resource) => resource.kind !== 'grid').length,
-        bytes: input.resources.reduce((total, resource) => total + (resource.size ?? 0), 0),
+        resources: transferable.length,
+        ...(transferable.length === 0 || sizes.some((size) => size !== undefined) ? { bytes: knownBytes } : {}),
+        bytesUnknown: sizes.filter((size) => size === undefined).length,
         links: input.document.metrics.links,
         images: input.document.metrics.images,
         tables: input.document.metrics.tables,
         codeBlocks: input.document.metrics.codeBlocks,
-        degraded: input.document.degraded,
-        warnings: [...input.document.warnings, ...(input.warnings ?? [])],
+        degraded: input.document.degraded || (input.resourceFallbacks?.length ?? 0) > 0,
+        resourceFallbacks: input.resourceFallbacks ?? [],
+        warnings: [...new Set([...input.document.warnings, ...(input.warnings ?? [])])],
+        normalizations: [...new Set([...(input.document.normalizations ?? []), ...(input.normalizations ?? [])])],
         ...(input.error ? { error: input.error } : {}),
     };
 }
@@ -121,14 +153,39 @@ function runStatus(errors, warnings) {
         return 'partial';
     return warnings > 0 ? 'completed-with-warnings' : 'completed';
 }
+export class MigrationRunError extends Error {
+    reportPaths;
+    stateFilename;
+    constructor(message, reportPaths, stateFilename, options) {
+        super(message, options);
+        this.reportPaths = reportPaths;
+        this.stateFilename = stateFilename;
+        this.name = 'MigrationRunError';
+    }
+}
+async function renderRemoteDocument(input) {
+    try {
+        const rendered = input.destination.kind === 'confluence'
+            ? await renderConfluenceStorage(input.document, input.page, input.context, input.container.space ?? '')
+            : await renderYfm(input.document, input.context);
+        if (!rendered.body.trim())
+            return rawContentFallback(input.page, input.destination.kind, 'renderer returned an empty body');
+        return rendered;
+    }
+    catch (error) {
+        return rawContentFallback(input.page, input.destination.kind, error instanceof Error ? error.message : String(error));
+    }
+}
 export class Migrator {
     config;
     logger;
     adapterFactory;
-    constructor(config, logger, adapterFactory = createProviderAdapter) {
+    consistencyOptions;
+    constructor(config, logger, adapterFactory = createProviderAdapter, consistencyOptions = {}) {
         this.config = config;
         this.logger = logger;
         this.adapterFactory = adapterFactory;
+        this.consistencyOptions = consistencyOptions;
     }
     async run(options) {
         const source = this.adapterFactory(options.source.profile, this.config);
@@ -207,12 +264,16 @@ export class Migrator {
             report.finish(finalStatus);
             const reportPaths = await report.write(options.reportsDirectory);
             if (!options.dryRun)
-                await store.finishRun(run.id, finalStatus, { pages: 0, warnings: 0, errors: 1 });
-            throw new Error(`${message}. State: ${stateLocation.filename}. Report: ${reportPaths.html}`, { cause: error });
+                await store.finishRun(run.id, finalStatus, {
+                    pages: 0,
+                    warnings: report.data.summary.warnings,
+                    errors: report.data.summary.errors,
+                });
+            throw new MigrationRunError(message, reportPaths, stateLocation.filename, { cause: error });
         }
         const resourcesByPage = new Map();
         const inventoryQueue = new PQueue({ concurrency: options.concurrency });
-        const inventory = { resources: 0, bytes: 0, grids: 0, links: 0, images: 0, tables: 0, codeBlocks: 0 };
+        const inventory = { resources: 0, bytes: 0, unknownSizes: 0, grids: 0, links: 0, images: 0, tables: 0, codeBlocks: 0 };
         status(`Inspecting content and resources for ${graph.pages.length} pages`);
         const inventoryErrors = [];
         await Promise.all(graph.pages.map((page) => inventoryQueue.add(async () => {
@@ -226,6 +287,7 @@ export class Migrator {
                 await cacheDocument(options.cacheDirectory, page.canonicalId, document);
                 inventory.resources += resources.filter((resource) => resource.kind !== 'grid').length;
                 inventory.bytes += resources.reduce((total, resource) => total + (resource.size ?? 0), 0);
+                inventory.unknownSizes += resources.filter((resource) => resource.kind !== 'grid' && resource.size === undefined).length;
                 inventory.grids += resources.filter((resource) => resource.kind === 'grid').length;
                 inventory.links += document.metrics.links;
                 inventory.images += document.metrics.images;
@@ -244,23 +306,23 @@ export class Migrator {
             report.finish(finalStatus);
             const reportPaths = await report.write(options.reportsDirectory);
             if (!options.dryRun)
-                await store.finishRun(run.id, finalStatus, { pages: graph.pages.length, warnings: graph.warnings.length, errors: inventoryErrors.length });
-            throw new Error(`Resource preflight failed before destination mutation. State: ${stateLocation.filename}. Report: ${reportPaths.html}`);
+                await store.finishRun(run.id, finalStatus, {
+                    pages: graph.pages.length,
+                    warnings: report.data.summary.warnings,
+                    errors: report.data.summary.errors,
+                });
+            throw new MigrationRunError('Resource preflight failed before destination mutation', reportPaths, stateLocation.filename);
         }
-        const planSummary = `Plan ready: ${graph.pages.length} pages · ${inventory.resources} files (${inventory.bytes} bytes) · ${inventory.links} links · ${inventory.images} images · ${inventory.tables} tables (${inventory.grids} grids) · ${inventory.codeBlocks} code blocks`;
+        const planSummary = `Plan ready: ${graph.pages.length} pages · ${inventory.resources} files (${inventory.bytes} known bytes${inventory.unknownSizes > 0 ? ` · ${inventory.unknownSizes} sizes unknown` : ''}) · ${inventory.links} links · ${inventory.images} images · ${inventory.tables} tables (${inventory.grids} grids) · ${inventory.codeBlocks} code blocks`;
         status(planSummary);
         this.logger.info(planSummary);
         let output;
         let archive;
-        let transferErrors = 0;
-        let transferWarnings = graph.warnings.length;
         try {
             if (options.destination.type === 'directory') {
                 const result = await this.exportFilesystem(source, graph, options.destination, options, stateLocation.id, store, report, sourceFingerprints, resourcesByPage);
                 output = result.directory;
                 archive = result.archive;
-                transferErrors += result.errors.length;
-                transferWarnings += result.warnings.length;
                 report.output('directory', result.directory);
                 if (result.archive)
                     report.output('archive', result.archive);
@@ -268,7 +330,7 @@ export class Migrator {
                     report.output('backup', result.backup);
             }
             else {
-                const result = await this.transferRemote({
+                await this.transferRemote({
                     source,
                     destination: destination,
                     container: container,
@@ -279,27 +341,30 @@ export class Migrator {
                     sourceFingerprints,
                     resourcesByPage,
                 });
-                transferErrors += result.errors;
-                transferWarnings += result.warnings;
                 output = container.url;
                 report.output('destination', container.url);
             }
-            const finalStatus = runStatus(transferErrors, transferWarnings);
+            report.finish('completed');
+            const finalStatus = runStatus(report.data.summary.errors, report.data.summary.warnings);
             report.finish(finalStatus);
             const reportPaths = await report.write(options.reportsDirectory);
             if (!options.dryRun)
-                await store.finishRun(run.id, finalStatus, { pages: graph.pages.length, warnings: transferWarnings, errors: transferErrors });
-            status(`${finalStatus}: ${graph.pages.length} pages · ${transferErrors} errors · ${transferWarnings} warnings`);
+                await store.finishRun(run.id, finalStatus, {
+                    pages: graph.pages.length,
+                    warnings: report.data.summary.warnings,
+                    errors: report.data.summary.errors,
+                });
+            status(`${finalStatus}: ${graph.pages.length} pages · ${report.data.summary.errors} errors · ${report.data.summary.warnings} warnings`);
             return {
                 status: finalStatus,
-                hasErrors: transferErrors > 0,
+                hasErrors: report.data.summary.errors > 0,
                 reportPaths,
                 stateId: stateLocation.id,
                 stateFilename: stateLocation.filename,
                 ...(store.loadInfo.backupFilename ? { stateBackupFilename: store.loadInfo.backupFilename } : {}),
                 ...(output ? { output } : {}),
                 ...(archive ? { archive } : {}),
-                summary: { ...report.data.summary, warnings: transferWarnings, errors: transferErrors },
+                summary: report.data.summary,
             };
         }
         catch (error) {
@@ -310,9 +375,13 @@ export class Migrator {
             report.finish(finalStatus);
             const reportPaths = await report.write(options.reportsDirectory);
             if (!options.dryRun)
-                await store.finishRun(run.id, finalStatus, { pages: graph.pages.length, warnings: transferWarnings, errors: transferErrors + 1 });
+                await store.finishRun(run.id, finalStatus, {
+                    pages: graph.pages.length,
+                    warnings: report.data.summary.warnings,
+                    errors: report.data.summary.errors,
+                });
             this.logger.error(`${message}. Report: ${reportPaths.html}`);
-            throw error;
+            throw new MigrationRunError(message, reportPaths, stateLocation.filename, { cause: error });
         }
     }
     async exportFilesystem(source, graph, destination, options, identity, store, report, sourceFingerprints, resourcesByPage) {
@@ -341,16 +410,22 @@ export class Migrator {
             const document = await loadCachedDocument(options.cacheDirectory, page.canonicalId);
             const manifestPage = result.manifest.pages.find((item) => item.sourceCanonicalId === page.canonicalId);
             const previous = store.value.pages[page.canonicalId];
-            const resources = Object.fromEntries((manifestPage?.resources ?? []).map((resource, index) => [String(index), {
-                    sourceId: String(index),
-                    sourceName: resource.name,
-                    destinationId: resource.path,
-                    destinationName: resource.name,
-                    ...(resource.sha256 ? { sha256: resource.sha256 } : {}),
-                    ...(resource.size !== undefined ? { size: resource.size } : {}),
-                    status: 'complete',
-                    updatedAt: new Date().toISOString(),
-                }]));
+            const sourceResources = resourcesByPage.get(page.canonicalId) ?? [];
+            const transferableResources = sourceResources.filter((resource) => resource.kind !== 'grid');
+            const resources = Object.fromEntries((manifestPage?.resources ?? []).map((resource, index) => {
+                const sourceResource = transferableResources[index];
+                const sourceId = sourceResource?.id ?? String(index);
+                return [sourceId, {
+                        sourceId,
+                        sourceName: sourceResource?.name ?? resource.name,
+                        destinationId: resource.path,
+                        destinationName: resource.name,
+                        ...(resource.sha256 ? { sha256: resource.sha256 } : {}),
+                        ...(resource.size !== undefined ? { size: resource.size } : {}),
+                        status: 'complete',
+                        updatedAt: new Date().toISOString(),
+                    }];
+            }));
             await store.setPage({
                 sourceId: page.id,
                 sourceCanonicalId: page.canonicalId,
@@ -371,8 +446,9 @@ export class Migrator {
             report.addPage(reportPage({
                 page,
                 status: options.dryRun ? 'planned' : result.errors.length ? 'partial' : 'complete',
-                resources: resourcesByPage.get(page.canonicalId) ?? [],
+                resources: sourceResources,
                 document,
+                resourceSizes: resources,
                 ...(manifestPage?.warnings ? { warnings: manifestPage.warnings } : {}),
             }), { source: normalizedPreviewHtml(document), destination: normalizedPreviewHtml(document) });
         }
@@ -385,15 +461,34 @@ export class Migrator {
     async transferRemote(input) {
         const { source, destination, container, graph, options, store, report, sourceFingerprints, resourcesByPage } = input;
         const destinationPages = new Map();
-        let errors = 0;
-        let warnings = 0;
+        const sourcePages = new Map(graph.pages.map((page) => [page.canonicalId, page]));
+        const bootstrapBodies = new Map();
         const totalResources = [...resourcesByPage.values()].reduce((total, resources) => total + resources.filter((resource) => resource.kind !== 'grid').length, 0);
-        const progress = { skeletons: 0, pages: 0, resources: 0 };
+        const progress = { staged: 0, pages: 0, resources: 0 };
         const totalUnits = Math.max(1, graph.pages.length * 2 + totalResources);
         const updateProgress = (active) => {
-            const completed = progress.skeletons + progress.pages + progress.resources;
+            const completed = progress.staged + progress.pages + progress.resources;
             options.onStatus?.(`Progress ${Math.min(100, Math.floor((completed / totalUnits) * 100))}% · pages ${progress.pages}/${graph.pages.length} · files ${progress.resources}/${totalResources} · ${active}`);
         };
+        for (const page of graph.pages) {
+            const [document, cachedPage] = await Promise.all([
+                loadCachedDocument(options.cacheDirectory, page.canonicalId),
+                loadCachedPage(options.cacheDirectory, page.canonicalId),
+            ]);
+            const resources = resourcesByPage.get(page.canonicalId) ?? [];
+            bootstrapBodies.set(page.canonicalId, await renderRemoteDocument({
+                destination,
+                container,
+                document,
+                page: cachedPage,
+                context: {
+                    pages: new Map(),
+                    resources: sourceResourceBindings(cachedPage, resources),
+                    sourcePages,
+                    currentPageId: page.canonicalId,
+                },
+            }));
+        }
         for (const page of graph.pages) {
             if (options.signal?.aborted)
                 throw options.signal.reason ?? new Error('Transfer cancelled');
@@ -401,20 +496,88 @@ export class Migrator {
             const parent = page.projectedParentId ? destinationPages.get(page.projectedParentId) : container;
             if (!parent) {
                 const message = `Destination parent is unavailable for ${page.title}`;
-                errors += 1;
                 report.error(message);
-                progress.skeletons += 1;
+                progress.staged += 1;
                 updateProgress(message);
                 continue;
             }
             try {
+                const cachedPage = await loadCachedPage(options.cacheDirectory, page.canonicalId);
+                const bootstrap = bootstrapBodies.get(page.canonicalId);
                 let created;
                 let title = saved?.destinationTitle ?? page.title;
+                let resourcesForState = saved?.resources ?? {};
+                let previousDestinationIds = saved?.previousDestinationIds ?? [];
+                let mappingRecovered = false;
                 if (saved?.destinationId) {
-                    created = await destination.verifyPage(destinationFromState(saved, destination));
-                    if (['complete', 'partial'].includes(saved.status) && saved.destinationFingerprint && created.fingerprint !== saved.destinationFingerprint) {
+                    const mapped = destinationFromState(saved, destination);
+                    try {
+                        created = await verifyConfirmedDestinationPage(destination, mapped, {
+                            ...this.consistencyOptions,
+                            onRetry: (attempt, delayMs) => report.issue({
+                                code: 'destination-consistency-retry',
+                                severity: 'warning',
+                                phase: 'verification',
+                                pageId: page.canonicalId,
+                                retryable: true,
+                                message: `${page.title}: destination page ${mapped.id} returned 404; consistency retry ${attempt} in ${delayMs} ms`,
+                            }),
+                        });
+                    }
+                    catch (error) {
+                        if (!(error instanceof ConfirmedDestinationMissingError) || options.dryRun)
+                            throw error;
+                        if (page.projectedParentId) {
+                            await verifyConfirmedDestinationPage(destination, parent, this.consistencyOptions);
+                        }
+                        const candidate = await (destination.findRecoverablePage?.(parent, title) ?? destination.findChild(parent, title));
+                        if (candidate && sourceDerivedTextMatches(bootstrap.body, candidate.content, destination.kind, cachedPage)) {
+                            created = candidate;
+                        }
+                        else {
+                            let recoveryTitle = title;
+                            const occupied = candidate ?? await destination.findChild(parent, recoveryTitle);
+                            if (occupied) {
+                                const base = collisionTitle(page);
+                                const hash = sha256(page.canonicalId).slice(0, 8);
+                                recoveryTitle = base;
+                                let sequence = 0;
+                                while (await destination.findChild(parent, recoveryTitle)) {
+                                    sequence += 1;
+                                    recoveryTitle = `${base} [${hash}${sequence > 1 ? `-${sequence}` : ''}]`;
+                                }
+                            }
+                            created = await destination.createPage({ container: parent, title: recoveryTitle, body: bootstrap.body });
+                            created = await verifyConfirmedDestinationPage(destination, created, this.consistencyOptions);
+                            assertDestinationContent(bootstrap.body, created.content, destination.kind, cachedPage);
+                        }
+                        previousDestinationIds = [...new Set([...previousDestinationIds, mapped.id])];
+                        resourcesForState = resetResourceDestinations(saved.resources);
+                        mappingRecovered = true;
+                        report.issue({
+                            code: 'destination-mapping-recovered',
+                            severity: 'warning',
+                            phase: 'page',
+                            pageId: page.canonicalId,
+                            retryable: false,
+                            message: `${page.title}: replaced unavailable destination mapping ${mapped.id} with ${created.id}`,
+                        });
+                    }
+                    const generatedPlaceholder = created.title === saved.destinationTitle
+                        && isLegacyTransferPlaceholder(created.content, destination.kind, cachedPage);
+                    if (!mappingRecovered && ['complete', 'partial'].includes(saved.status) && saved.destinationFingerprint && created.fingerprint !== saved.destinationFingerprint && !generatedPlaceholder) {
                         throw new Error(`Destination conflict for ${page.title}: content changed since the last verified run`);
                     }
+                    if (generatedPlaceholder && !options.dryRun) {
+                        created = await destination.updatePage({
+                            page: created,
+                            title: created.title,
+                            body: bootstrap.body,
+                            ...(created.fingerprint ? { expectedFingerprint: created.fingerprint } : {}),
+                        });
+                        created = await verifyConfirmedDestinationPage(destination, created, this.consistencyOptions);
+                        assertDestinationContent(bootstrap.body, created.content, destination.kind, cachedPage);
+                    }
                 }
                 else if (options.dryRun) {
                     created = {
@@ -425,6 +588,8 @@ export class Migrator {
                         title,
                         url: container.url,
                         locator: `dry-run:${page.id}`,
+                        content: bootstrap.body,
+                        contentLength: Buffer.byteLength(bootstrap.body),
                         ...(container.space ? { space: container.space } : {}),
                     };
                 }
@@ -439,7 +604,9 @@ export class Migrator {
                             title = `${base} [${hash}${sequence > 1 ? `-${sequence}` : ''}]`;
                         }
                     }
-                    created = await destination.createPage({ container: parent, title, body: placeholder(destination, page) });
+                    created = await destination.createPage({ container: parent, title, body: bootstrap.body });
+                    created = await verifyConfirmedDestinationPage(destination, created, this.consistencyOptions);
+                    assertDestinationContent(bootstrap.body, created.content, destination.kind, cachedPage);
                 }
                 destinationPages.set(page.canonicalId, created);
                 const next = {
@@ -452,18 +619,18 @@ export class Migrator {
                     destinationCanonicalId: created.canonicalId,
                     destinationLocator: created.url,
                     destinationTitle: created.title,
+                    ...(previousDestinationIds.length > 0 ? { previousDestinationIds } : {}),
                     sourceFingerprint: sourceFingerprints.get(page.canonicalId),
                     ...(created.fingerprint ? { destinationFingerprint: created.fingerprint } : {}),
                     status: options.dryRun ? 'planned' : saved?.status ?? 'skeleton-created',
-                    resources: saved?.resources ?? {},
+                    resources: resourcesForState,
                     degradations: saved?.degradations ?? [],
                     updatedAt: new Date().toISOString(),
                 };
                 await store.setPage(next);
-                options.onStatus?.(`${options.dryRun ? 'Planned' : 'Created'} page ${page.title}`);
+                options.onStatus?.(`${options.dryRun ? 'Planned' : 'Staged content for'} ${page.title}`);
             }
             catch (error) {
-                errors += 1;
                 const message = `${page.title}: ${error instanceof Error ? error.message : String(error)}`;
                 report.error(message);
                 const savedState = store.value.pages[page.canonicalId];
@@ -471,8 +638,8 @@ export class Migrator {
                     await store.setPage({ ...savedState, status: /conflict/i.test(message) ? 'conflict' : 'failed', lastError: message, updatedAt: new Date().toISOString() });
             }
             finally {
-                progress.skeletons += 1;
-                updateProgress(`structure ${page.title}`);
+                progress.staged += 1;
+                updateProgress(`content staged ${page.title}`);
             }
         }
         const contentQueue = new PQueue({ concurrency: options.concurrency });
@@ -490,74 +657,247 @@ export class Migrator {
                     status: failedState?.status ?? 'blocked',
                     resources,
                     document,
-                    error: failedState?.lastError ?? 'Destination skeleton was not created',
+                    error: failedState?.lastError ?? 'Destination page with source-derived content was not created',
                 }));
                 progress.pages += 1;
                 updateProgress(`blocked ${page.title}`);
                 return;
             }
             const state = store.value.pages[page.canonicalId];
-            const uploaded = new Map();
+            const bootstrap = bootstrapBodies.get(page.canonicalId);
+            const bindings = sourceResourceBindings(cachedPage, resources);
+            const transferableResources = resources.filter((item) => item.kind !== 'grid');
+            const resourceProblems = [];
+            const failedResourceIds = new Set();
+            const recordResourceFailure = async (resource, detail) => {
+                if (!failedResourceIds.has(resource.id)) {
+                    failedResourceIds.add(resource.id);
+                    resourceProblems.push(detail);
+                    report.issue({
+                        code: 'resource-transfer-failed',
+                        severity: 'error',
+                        phase: 'resource',
+                        pageId: page.canonicalId,
+                        resourceId: resource.id,
+                        retryable: true,
+                        message: `${page.title}: ${detail}`,
+                    });
+                }
+                const previous = state.resources[resource.id];
+                state.resources[resource.id] = {
+                    sourceId: resource.id,
+                    sourceName: resource.name,
+                    ...(previous?.destinationId ? { destinationId: previous.destinationId } : {}),
+                    destinationName: previous?.destinationName ?? preferredDestinationName(resource),
+                    ...(previous?.sha256 ? { sha256: previous.sha256 } : {}),
+                    ...(previous?.size !== undefined ? { size: previous.size } : resource.size !== undefined ? { size: resource.size } : {}),
+                    ...(previous?.cachePath ? { cachePath: previous.cachePath } : {}),
+                    ...(previous?.mimeType ? { mimeType: previous.mimeType } : {}),
+                    status: 'failed',
+                    lastError: detail,
+                    updatedAt: new Date().toISOString(),
+                };
+                await store.setPage({ ...state, status: 'partial', lastError: detail, updatedAt: new Date().toISOString() });
+            };
             try {
-                for (const resource of resources.filter((item) => item.kind !== 'grid')) {
-                    const key = resource.name.toLocaleLowerCase();
-                    const existing = state.resources[resource.id];
-                    if (existing?.status === 'complete' && existing.destinationId) {
-                        uploaded.set(key, {
-                            id: existing.destinationId,
-                            name: existing.destinationName,
-                            ...(existing.size !== undefined ? { size: existing.size } : {}),
-                            ...(existing.sha256 ? { fingerprint: existing.sha256 } : {}),
-                        });
-                        progress.resources += 1;
-                        updateProgress(`reused ${resource.name}`);
-                        continue;
+                let remoteResources = options.dryRun ? [] : await destination.listUploadedResources(destinationPage);
+                const nameAllocator = new DestinationNameAllocator(remoteResources.map((resource) => resource.name));
+                for (const resourceState of Object.values(state.resources)) {
+                    if (resourceState.status === 'complete')
+                        nameAllocator.reserve(resourceState.destinationName);
+                }
+                const fallbackBinding = (resource) => [...sourceResourceBindings(cachedPage, [resource]).values()][0];
+                const remoteMatches = async (remote, downloaded, trustedMapping = false) => {
+                    if (remote.size !== undefined && remote.size !== downloaded.size)
+                        return false;
+                    if (!destination.downloadUploadedResource) {
+                        return remote.fingerprint === downloaded.sha256
+                            || (trustedMapping && (remote.size === undefined || remote.size === downloaded.size));
+                    }
+                    const comparisonPath = `${downloaded.path}.destination-${sha256(remote.id).slice(0, 8)}`;
+                    try {
+                        const actual = await destination.downloadUploadedResource({ page: destinationPage, resource: remote, destination: comparisonPath });
+                        return actual.size === downloaded.size && actual.sha256 === downloaded.sha256;
                     }
+                    finally {
+                        await rm(comparisonPath, { force: true });
+                    }
+                };
+                for (const resource of transferableResources) {
+                    const existing = state.resources[resource.id];
                     if (options.dryRun) {
-                        uploaded.set(key, {
-                            id: `dry-run:${resource.id}`,
-                            name: safeFilename(resource.name),
-                            ...(resource.size !== undefined ? { size: resource.size } : {}),
-                        });
+                        const destinationName = nameAllocator.allocate(resource, existing?.status === 'complete' ? existing.destinationName : undefined);
+                        setSourceResourceBinding(bindings, cachedPage, resources, resource, { kind: 'uploaded', resource: {
+                                id: `dry-run:${resource.id}`,
+                                name: destinationName,
+                                ...(resource.size !== undefined ? { size: resource.size } : {}),
+                            } });
                         progress.resources += 1;
                         updateProgress(`planned ${resource.name}`);
                         continue;
                     }
-                    const filename = cachePath(options.cacheDirectory, page, resource);
-                    const downloaded = await source.downloadResource(resource, filename);
-                    const result = await destination.uploadResource({
-                        page: destinationPage,
-                        name: safeFilename(resource.name),
-                        filePath: downloaded.path,
-                        size: downloaded.size,
-                        ...(downloaded.mimeType ?? resource.mimeType ? { mimeType: downloaded.mimeType ?? resource.mimeType } : {}),
-                        ...(existing?.destinationId ? { existingId: existing.destinationId } : {}),
-                    });
-                    uploaded.set(key, result);
-                    state.resources[resource.id] = {
-                        sourceId: resource.id,
-                        sourceName: resource.name,
-                        destinationId: result.id,
-                        destinationName: result.name,
-                        sha256: downloaded.sha256,
-                        size: downloaded.size,
-                        status: 'complete',
-                        updatedAt: new Date().toISOString(),
-                    };
-                    await store.setPage({ ...state, updatedAt: new Date().toISOString() });
-                    progress.resources += 1;
-                    updateProgress(`uploaded ${resource.name} → ${page.title}`);
+                    try {
+                        const filename = containedCachePath(options.cacheDirectory, existing?.cachePath)
+                            ?? cachePath(options.cacheDirectory, page, resource);
+                        const cached = await verifiedCacheFile(filename, existing?.sha256 ? {
+                            sha256: existing.sha256,
+                            ...(existing.size !== undefined ? { size: existing.size } : {}),
+                            ...(existing.mimeType ? { mimeType: existing.mimeType } : {}),
+                        } : undefined);
+                        const downloaded = cached ?? await source.downloadResource(resource, filename);
+                        const mimeType = downloaded.mimeType ?? existing?.mimeType ?? resource.mimeType;
+                        const mappedRemote = existing?.destinationId
+                            ? remoteResources.find((item) => item.id === existing.destinationId)
+                            : undefined;
+                        if (mappedRemote && await remoteMatches(mappedRemote, downloaded, true)) {
+                            setSourceResourceBinding(bindings, cachedPage, resources, resource, { kind: 'uploaded', resource: mappedRemote });
+                            state.resources[resource.id] = {
+                                sourceId: resource.id,
+                                sourceName: resource.name,
+                                destinationId: mappedRemote.id,
+                                destinationName: mappedRemote.name,
+                                sha256: downloaded.sha256,
+                                size: downloaded.size,
+                                cachePath: downloaded.path,
+                                ...(mimeType ? { mimeType } : {}),
+                                status: 'complete',
+                                updatedAt: new Date().toISOString(),
+                            };
+                            await store.setPage({ ...state, updatedAt: new Date().toISOString() });
+                            updateProgress(`reused ${resource.name}`);
+                            continue;
+                        }
+                        const reconciliationNames = new Set([
+                            preferredDestinationName(resource),
+                            ...(existing?.sha256 ? [existing.destinationName] : []),
+                        ].map((name) => name.toLocaleLowerCase()));
+                        const reconciled = remoteResources.find((item) => reconciliationNames.has(item.name.toLocaleLowerCase()));
+                        if (reconciled && await remoteMatches(reconciled, downloaded)) {
+                            setSourceResourceBinding(bindings, cachedPage, resources, resource, { kind: 'uploaded', resource: reconciled });
+                            state.resources[resource.id] = {
+                                sourceId: resource.id,
+                                sourceName: resource.name,
+                                destinationId: reconciled.id,
+                                destinationName: reconciled.name,
+                                sha256: downloaded.sha256,
+                                size: downloaded.size,
+                                cachePath: downloaded.path,
+                                ...(mimeType ? { mimeType } : {}),
+                                status: 'complete',
+                                updatedAt: new Date().toISOString(),
+                            };
+                            await store.setPage({ ...state, updatedAt: new Date().toISOString() });
+                            updateProgress(`reconciled ${resource.name}`);
+                            continue;
+                        }
+                        const updateExisting = existing?.status === 'complete' && mappedRemote ? mappedRemote : undefined;
+                        const destinationName = updateExisting?.name ?? nameAllocator.allocate(resource, existing?.status === 'complete' && !nameAllocator.isOccupied(existing.destinationName) ? existing.destinationName : undefined);
+                        state.resources[resource.id] = {
+                            sourceId: resource.id,
+                            sourceName: resource.name,
+                            destinationName,
+                            sha256: downloaded.sha256,
+                            size: downloaded.size,
+                            cachePath: downloaded.path,
+                            ...(mimeType ? { mimeType } : {}),
+                            status: 'planned',
+                            updatedAt: new Date().toISOString(),
+                        };
+                        await store.setPage({ ...state, updatedAt: new Date().toISOString() });
+                        const matchingName = remoteResources.find((item) => item.name.toLocaleLowerCase() === destinationName.toLocaleLowerCase());
+                        let result = matchingName && await remoteMatches(matchingName, downloaded) ? matchingName : undefined;
+                        if (!result) {
+                            try {
+                                result = await destination.uploadResource({
+                                    page: destinationPage,
+                                    name: destinationName,
+                                    filePath: downloaded.path,
+                                    size: downloaded.size,
+                                    ...(mimeType ? { mimeType } : {}),
+                                    ...(updateExisting ? { existingId: updateExisting.id } : {}),
+                                });
+                            }
+                            catch (uploadError) {
+                                remoteResources = await destination.listUploadedResources(destinationPage);
+                                const uncertain = remoteResources.find((item) => item.name.toLocaleLowerCase() === destinationName.toLocaleLowerCase());
+                                if (uncertain && await remoteMatches(uncertain, downloaded))
+                                    result = uncertain;
+                                else {
+                                    const retryName = nameAllocator.allocate(resource);
+                                    result = await destination.uploadResource({
+                                        page: destinationPage,
+                                        name: retryName,
+                                        filePath: downloaded.path,
+                                        size: downloaded.size,
+                                        ...(mimeType ? { mimeType } : {}),
+                                    }).catch((retryError) => { throw new Error(`${retryError instanceof Error ? retryError.message : String(retryError)} (initial upload: ${uploadError instanceof Error ? uploadError.message : String(uploadError)})`); });
+                                }
+                            }
+                        }
+                        if (!remoteResources.some((item) => item.id === result.id))
+                            remoteResources.push(result);
+                        setSourceResourceBinding(bindings, cachedPage, resources, resource, { kind: 'uploaded', resource: result });
+                        state.resources[resource.id] = {
+                            sourceId: resource.id,
+                            sourceName: resource.name,
+                            destinationId: result.id,
+                            destinationName: result.name,
+                            sha256: downloaded.sha256,
+                            size: downloaded.size,
+                            cachePath: downloaded.path,
+                            ...(mimeType ? { mimeType } : {}),
+                            status: 'complete',
+                            updatedAt: new Date().toISOString(),
+                        };
+                        await store.setPage({ ...state, updatedAt: new Date().toISOString() });
+                        updateProgress(`uploaded ${resource.name} → ${page.title}`);
+                    }
+                    catch (error) {
+                        await recordResourceFailure(resource, `Resource ${resource.name} was not transferred: ${error instanceof Error ? error.message : String(error)}`);
+                        updateProgress(`fallback ${resource.name} → ${page.title}`);
+                    }
+                    finally {
+                        progress.resources += 1;
+                    }
+                }
+                if (!options.dryRun && transferableResources.length > 0) {
+                    try {
+                        remoteResources = await destination.listUploadedResources(destinationPage);
+                        for (const resource of transferableResources) {
+                            const transferred = state.resources[resource.id];
+                            if (transferred?.status !== 'complete')
+                                continue;
+                            const remote = remoteResources.find((item) => item.id === transferred.destinationId || item.name === transferred.destinationName);
+                            const sizeMismatch = transferred.size !== undefined
+                                && remote?.size !== undefined
+                                && transferred.size !== remote.size;
+                            if (!remote || sizeMismatch) {
+                                setSourceResourceBinding(bindings, cachedPage, resources, resource, fallbackBinding(resource));
+                                await recordResourceFailure(resource, !remote
+                                    ? `Verification did not find destination resource for ${resource.name}`
+                                    : `Verification size mismatch for ${resource.name}: ${transferred.size} source bytes, ${remote.size} destination bytes`);
+                            }
+                            else {
+                                setSourceResourceBinding(bindings, cachedPage, resources, resource, { kind: 'uploaded', resource: remote });
+                            }
+                        }
+                    }
+                    catch (error) {
+                        for (const resource of transferableResources) {
+                            if (state.resources[resource.id]?.status !== 'complete')
+                                continue;
+                            setSourceResourceBinding(bindings, cachedPage, resources, resource, fallbackBinding(resource));
+                            await recordResourceFailure(resource, `Destination resource verification failed for ${resource.name}: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    }
                 }
                 const context = {
                     pages: destinationPages,
-                    resources: uploaded,
-                    sourcePages: new Map(graph.pages.map((item) => [item.canonicalId, item])),
+                    resources: bindings,
+                    sourcePages,
                     currentPageId: page.canonicalId,
                 };
-                const rendered = destination.kind === 'confluence'
-                    ? await renderConfluenceStorage(document, cachedPage, context, container.space ?? '')
-                    : await renderYfm(document, context);
-                warnings += rendered.warnings.length;
+                const rendered = await renderRemoteDocument({ destination, container, document, page: cachedPage, context });
                 if (rendered.degraded && !options.dryRun) {
                     const extension = page.rawFormat === 'yfm' ? 'yfm' : 'storage.xml';
                     const snapshotName = `ywtc-source-${sha256(page.canonicalId).slice(0, 8)}.${extension}`;
@@ -566,92 +906,144 @@ export class Migrator {
                     await writeFile(snapshotPath, cachedPage.rawContent, { mode: 0o600 });
                     const snapshotKey = `snapshot:${page.canonicalId}`;
                     const existingSnapshot = state.resources[snapshotKey];
-                    const snapshot = existingSnapshot?.status === 'complete' && existingSnapshot.destinationId
-                        ? {
-                            id: existingSnapshot.destinationId,
-                            name: existingSnapshot.destinationName,
-                            ...(existingSnapshot.size !== undefined ? { size: existingSnapshot.size } : {}),
-                        }
-                        : await destination.uploadResource({
-                            page: destinationPage,
-                            name: snapshotName,
-                            filePath: snapshotPath,
-                            size: Buffer.byteLength(cachedPage.rawContent),
-                            mimeType: page.rawFormat === 'yfm' ? 'text/markdown' : 'application/xml',
-                            ...(existingSnapshot?.destinationId ? { existingId: existingSnapshot.destinationId } : {}),
-                        });
-                    uploaded.set(snapshotName.toLocaleLowerCase(), snapshot);
-                    state.resources[snapshotKey] = {
-                        sourceId: snapshotKey,
-                        sourceName: snapshotName,
-                        destinationId: snapshot.id,
-                        destinationName: snapshot.name,
-                        ...(snapshot.size !== undefined ? { size: snapshot.size } : {}),
-                        sha256: sha256(cachedPage.rawContent),
-                        status: 'complete',
-                        updatedAt: new Date().toISOString(),
-                    };
-                    state.degradations = [...new Set([...state.degradations, ...rendered.warnings])];
+                    try {
+                        const snapshot = existingSnapshot?.status === 'complete' && existingSnapshot.destinationId
+                            ? {
+                                id: existingSnapshot.destinationId,
+                                name: existingSnapshot.destinationName,
+                                ...(existingSnapshot.size !== undefined ? { size: existingSnapshot.size } : {}),
+                            }
+                            : await destination.uploadResource({
+                                page: destinationPage,
+                                name: snapshotName,
+                                filePath: snapshotPath,
+                                size: Buffer.byteLength(cachedPage.rawContent),
+                                mimeType: page.rawFormat === 'yfm' ? 'text/markdown' : 'application/xml',
+                                ...(existingSnapshot?.destinationId ? { existingId: existingSnapshot.destinationId } : {}),
+                            });
+                        state.resources[snapshotKey] = {
+                            sourceId: snapshotKey,
+                            sourceName: snapshotName,
+                            destinationId: snapshot.id,
+                            destinationName: snapshot.name,
+                            ...(snapshot.size !== undefined ? { size: snapshot.size } : {}),
+                            sha256: sha256(cachedPage.rawContent),
+                            status: 'complete',
+                            updatedAt: new Date().toISOString(),
+                        };
+                    }
+                    catch (error) {
+                        const detail = `Raw source snapshot was not transferred: ${error instanceof Error ? error.message : String(error)}`;
+                        resourceProblems.push(detail);
+                        report.error(`${page.title}: ${detail}`);
+                        state.resources[snapshotKey] = {
+                            sourceId: snapshotKey,
+                            sourceName: snapshotName,
+                            destinationName: snapshotName,
+                            status: 'failed',
+                            lastError: detail,
+                            updatedAt: new Date().toISOString(),
+                        };
+                    }
+                    state.degradations = [...new Set([...rendered.warnings, ...resourceProblems])];
                 }
                 let verified = destinationPage;
+                let verificationDegradations = [];
                 if (!options.dryRun) {
+                    const current = await verifyConfirmedDestinationPage(destination, destinationPage, this.consistencyOptions);
+                    if (destinationPage.contentFingerprint
+                        && current.contentFingerprint
+                        && current.contentFingerprint !== destinationPage.contentFingerprint) {
+                        throw new Error(`Destination conflict for ${page.title}: content changed while resources were transferred`);
+                    }
                     verified = await destination.updatePage({
-                        page: destinationPage,
-                        title: destinationPage.title,
+                        page: current,
+                        title: current.title,
                         body: rendered.body,
-                        ...(['complete', 'partial'].includes(state.status) && state.destinationFingerprint ? { expectedFingerprint: state.destinationFingerprint } : {}),
+                        ...(current.fingerprint ? { expectedFingerprint: current.fingerprint } : {}),
                     });
                     if (verified.fingerprint) {
                         state.destinationFingerprint = verified.fingerprint;
                         await store.setPage({ ...state, updatedAt: new Date().toISOString() });
                     }
-                    verified = await destination.verifyPage(verified);
-                    if ((verified.contentLength ?? 0) === 0) {
-                        throw new Error(`Verification found empty destination content for ${page.title}`);
-                    }
-                    const remoteResources = await destination.listUploadedResources(verified);
-                    for (const resource of resources.filter((item) => item.kind !== 'grid')) {
-                        const transferred = state.resources[resource.id];
-                        const remote = transferred && remoteResources.find((item) => (item.id === transferred.destinationId || item.name === transferred.destinationName));
-                        if (!transferred || !remote) {
-                            throw new Error(`Verification did not find destination resource for ${resource.name}`);
-                        }
-                        if (destination.kind === 'confluence'
-                            && transferred.size !== undefined
-                            && remote.size !== undefined
-                            && transferred.size !== remote.size) {
-                            throw new Error(`Verification size mismatch for ${resource.name}: ${transferred.size} source bytes, ${remote.size} destination bytes`);
-                        }
-                    }
+                    verified = await verifyConfirmedDestinationPage(destination, verified, this.consistencyOptions);
+                    const verification = assertDestinationContent(rendered.body, verified.content, destination.kind, cachedPage);
+                    verificationDegradations = verification.status === 'partial' ? verification.differences : [];
                 }
+                const partial = rendered.degraded || resourceProblems.length > 0 || verificationDegradations.length > 0;
+                const lastResourceProblem = resourceProblems.at(-1);
+                const clearedState = { ...state };
+                delete clearedState.lastError;
                 const finalState = {
-                    ...state,
+                    ...clearedState,
                     destinationId: verified.id,
                     destinationCanonicalId: verified.canonicalId,
                     destinationLocator: verified.url,
                     destinationTitle: verified.title,
                     ...(verified.fingerprint ? { destinationFingerprint: verified.fingerprint } : {}),
-                    status: options.dryRun ? 'planned' : rendered.degraded ? 'partial' : 'complete',
-                    degradations: [...new Set([...state.degradations, ...rendered.warnings])],
+                    status: options.dryRun ? 'planned' : partial ? 'partial' : 'complete',
+                    degradations: [...new Set([...rendered.warnings, ...resourceProblems, ...verificationDegradations])],
+                    ...(lastResourceProblem ? { lastError: lastResourceProblem } : {}),
                     updatedAt: new Date().toISOString(),
                 };
                 await store.setPage(finalState);
+                const fallbackDetails = resources.flatMap((resource) => {
+                    const resourceState = finalState.resources[resource.id];
+                    return resourceState?.status === 'failed'
+                        ? [{ name: resource.name, error: resourceState.lastError ?? 'Resource was not transferred' }]
+                        : [];
+                });
                 report.addPage(reportPage({
                     page,
                     destination: verified,
                     status: finalState.status,
                     resources,
                     document,
-                    warnings: rendered.warnings,
-                }), { source: normalizedPreviewHtml(document), destination: renderedPreviewHtml(rendered.body, destination.kind) });
+                    resourceSizes: finalState.resources,
+                    resourceFallbacks: fallbackDetails,
+                    warnings: [...rendered.warnings, ...verificationDegradations],
+                    normalizations: rendered.normalizations,
+                }), { source: normalizedPreviewHtml(document), destination: renderedPreviewHtml(verified.content ?? rendered.body, destination.kind) });
             }
             catch (error) {
-                errors += 1;
                 const message = `${page.title}: ${error instanceof Error ? error.message : String(error)}`;
-                const failureStatus = /conflict/i.test(message) ? 'conflict' : 'partial';
+                let failureStatus = /conflict/i.test(message) ? 'conflict' : 'failed';
+                let actual;
+                if (failureStatus !== 'conflict' && !options.dryRun) {
+                    try {
+                        actual = await verifyConfirmedDestinationPage(destination, destinationPage, this.consistencyOptions);
+                        assertDestinationContent(bootstrap.body, actual.content, destination.kind, cachedPage);
+                        failureStatus = 'partial';
+                    }
+                    catch {
+                        failureStatus = 'failed';
+                    }
+                }
                 report.error(message);
-                await store.setPage({ ...state, status: failureStatus, lastError: message, updatedAt: new Date().toISOString() });
-                report.addPage(reportPage({ page, destination: destinationPage, status: failureStatus, resources, document, error: message }));
+                await store.setPage({
+                    ...state,
+                    ...(actual?.fingerprint ? { destinationFingerprint: actual.fingerprint } : {}),
+                    status: failureStatus,
+                    lastError: message,
+                    updatedAt: new Date().toISOString(),
+                });
+                const fallbackDetails = resources.flatMap((resource) => {
+                    const resourceState = state.resources[resource.id];
+                    return resourceState?.status === 'failed'
+                        ? [{ name: resource.name, error: resourceState.lastError ?? 'Resource was not transferred' }]
+                        : [];
+                });
+                report.addPage(reportPage({
+                    page,
+                    destination: actual ?? destinationPage,
+                    status: failureStatus,
+                    resources,
+                    document,
+                    resourceSizes: state.resources,
+                    resourceFallbacks: fallbackDetails,
+                    warnings: resourceProblems,
+                    error: message,
+                }), actual?.content ? { source: normalizedPreviewHtml(document), destination: renderedPreviewHtml(actual.content, destination.kind) } : undefined);
             }
             finally {
                 progress.pages += 1;
@@ -663,7 +1055,6 @@ export class Migrator {
         const rejected = settled.find((result) => result.status === 'rejected');
         if (rejected)
             throw rejected.reason;
-        return { errors, warnings };
     }
 }
 //# sourceMappingURL=migrator.js.map