@aglyn/tenant-data-admin 1.0.0-beta.221 → 1.0.0-beta.222

package/src/lib/server/transfer-jobs.js

@@ -0,0 +1,2368 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /*==========================================
+ * THE TRANSFER JOB ENGINE (AGL-3524) — an import as a durable job.
+ *
+ * The core (`@aglyn/aglyn/data-transfer`) says what a file means and what
+ * each row would do; the resource's plugin (`plugin-transfer-resources.ts`)
+ * reads and writes its own records. This module is everything between: the
+ * stored file, the job document and its subcollections, the dry run over
+ * every row, the chunked and idempotent apply, the result file and the
+ * seven-day undo. The console's `/api/transfer/*` routes are wiring over it,
+ * and the cron sweep resumes what a closed tab left behind.
+ *
+ * ## Where things are
+ *
+ *   orgs/{orgId}/transferJobs/{jobId}            the job (`TransferJobRecord`)
+ *     chunks/{n}                                 the dry run, 200 rows a chunk
+ *     ledger/{jobId}:{row}                       a row's write, recorded the moment it lands
+ *     results/{n}                                a written chunk's per-row results
+ *     undo/{n}                                   a written chunk's undo entries
+ *   Storage orgs/{orgId}/transfers/{jobId}/source   the file, inspected before it is stored
+ *
+ * The engine never writes a resource's record itself. A row reaches its
+ * store only through the plugin's `apply` and `revert`, on the plugin's
+ * own write paths, so what a record write must derive is derived there:
+ * a dataset record's `datasetIntegrityFields` / `datasetIntegrityUpdate`
+ * (referenced ids and filter fields) by the data plugin, as on every other
+ * path that writes `records`. The `'records'` and `values` in this file are
+ * the transfer kind and planned rows in the job's own subcollections.
+ *
+ * Every document is written with the Admin SDK only; the rules let members
+ * holding `data.manage` read the job and nobody write anything.
+ *
+ * ## Applying never writes a row twice
+ *
+ * The plugin's `apply` is handed a writer whose `markApplied` creates the
+ * row's ledger document the moment its write lands, and whose
+ * `alreadyApplied` answers from that ledger — so a chunk retried after a
+ * crash, a timeout or a second driver skips every row it already wrote. A
+ * chunk is complete when every planned write has a ledger entry; then its
+ * results, its undo entries and the job's cursor commit in ONE batch, and
+ * only after that are its ledger entries cleared.
+ *
+ * One driver at a time: a request takes a lease on the job for its time
+ * budget, and a second request (a second tab, the sweep) is refused while it
+ * holds. One running import per resource per workspace: starting one while
+ * another of the same resource is `applying` is refused.
+ *
+ * ## Undo asks before it overwrites a later edit
+ *
+ * Undo is two calls. `planTransferJobUndo` reads every record the import
+ * touched and runs the core's `planTransferUndo` — restore, delete, nothing,
+ * or a conflict for a record edited since — and writes nothing.
+ * `applyTransferJobUndo` hands each chunk's snapshot to the plugin's
+ * `revert` with the person's decision for every record, chunk by chunk.
+ *=========================================*/ import { TRANSFER_DEFAULT_MAX_ROWS, TRANSFER_DRAFT_RETENTION_MS, TRANSFER_ID_FIELD, TRANSFER_PLAN_CONFLICTS_MAX, TRANSFER_PLAN_PAGE_MAX, TRANSFER_RESULT_COLUMNS, TRANSFER_UNDO_PAGE_MAX, TRANSFER_UPLOAD_MAX_BYTES, TRANSFER_UPLOAD_MAX_PARTS, TRANSFER_UPLOAD_PART_MAX_BYTES, TRANSFER_WRITE_CONCURRENCY, canApplyTransferPlan, collectPicklistValues, createTransferPolicy, withTransferPolicyDefaults, deriveTransferCell, deriveTransferRow, mapTransferRow, mappingIsUsable, mappingProblems, matchHeaders, matchLookupRequests, matchPicklistValues, missingAcknowledgements, picklistChoiceProblems, planTransferUndo, proposePicklistChoice, readTransferSource, resolveMultiPicklistCell, resolvePicklistCell, resolvePicklistChoices, sniffTransferFormat, summarizeMatches, summarizeTransferDerivations, summarizeTransferResults, transferAmbiguities, transferCellText, transferChunkRanges, transferContentType, transferDateOrderOptions, transferFormatFromFileName, transferLedgerKey, transferMatchReview, transferMatchedRecordIds, transferPlanConflicts, transferPlanFeature, transferPlanSample, transferPolicyProblems, transferRowLabel, transferUndoAvailable, transferUndoExpiresAt, transitionTransferJob, transferLookupKey, transferResourceImports, transferLookupNewValue, mayBeTransferRecordId, normalizeMatchValue, matchLookupKey, isBlankTransferValue, isTransferLookupField, TRANSFER_UNDO_WINDOW_MS, TRANSFER_UNFINISHED_IMPORTS_MAX, TRANSFER_JOBS_PAGE_MAX, parseTransferResourceKey } from "@aglyn/aglyn/data-transfer";
+import { normalizePicklistLabel, picklistLabelKey } from "@aglyn/aglyn/app-utils/picklists";
+import { createResourceUid } from "@aglyn/aglyn/app-utils/create-resource-uid";
+import { escapeCsvCell } from "@aglyn/aglyn/app-utils/csv";
+import { inspectUploadBytes } from "@aglyn/aglyn/app-utils/upload-inspection";
+import { matchTransferResourceRows, planTransferResourceRows, transferResourcePolicyDefaults, resolveTransferResource, transferInvariantFailures, transferRecordsHooks, transferResourceCatalog, transferResourceLockedRules, transferResourceMatchKeys, TransferResourceUnavailableError, transferPlanRefusal } from "@aglyn/aglyn/plugin-manager/plugin-transfer-resources";
+/** A refusal a route answers as `{ error, code, details }` with `status`. */ export class TransferEngineError extends Error {
+    constructor(code, status, message, details){
+        super(message), this.code = code, this.status = status, this.details = details;
+        this.name = 'TransferEngineError';
+    }
+}
+/**
+ * A refusal for the workspace's plan (AGL-3555): a route answers its
+ * `refusal` as it stands — the owning plugin's flat 403 body, with
+ * `reason: 'plan_required'` and the plan feature as `code` — rather than
+ * as `{ error, code, details }`. Its own `code` is `planRequired`, what a
+ * client reads that body as.
+ */ export class TransferPlanRefusedError extends TransferEngineError {
+    constructor(refusal){
+        super('planRequired', refusal.status, refusal.body.error, refusal.body), this.refusal = refusal;
+        this.name = 'TransferPlanRefusedError';
+    }
+}
+/** The collection an organization's jobs live in. */ export const TRANSFER_JOBS_COLLECTION = 'transferJobs';
+/** How long a driver's lease outlives its budget, so a crashed request's job is resumed soon after. */ export const TRANSFER_LEASE_GRACE_MS = 30000;
+/** How long an `applying` job sits untouched before the sweep resumes it. */ export const TRANSFER_STALE_MS = 2 * 60 * 1000;
+/** Below this much budget, a request stops rather than starting another chunk. */ export const TRANSFER_MIN_CHUNK_BUDGET_MS = 2000;
+/** The most ids one undo lookup asks for. */ const UNDO_LOOKUP_SLICE = 500;
+/** The most values one match lookup request carries. */ const MATCH_LOOKUP_SLICE = 500;
+/** The most characters of JSON one document holds before it is split into pieces. */ const JSON_PIECE_CHARS = 900000;
+/** Where an organization's jobs are. */ export function transferJobsCollection(firestore, orgId) {
+    return firestore.collection('orgs').doc(orgId).collection(TRANSFER_JOBS_COLLECTION);
+}
+/** Where a job's file is stored. */ export function transferSourcePath(orgId, jobId) {
+    return `orgs/${orgId}/transfers/${jobId}/source`;
+}
+/** Where one part of a file sent in parts waits until the rest arrives. */ export function transferPartPath(orgId, jobId, part) {
+    return `orgs/${orgId}/transfers/${jobId}/parts/${part}`;
+}
+export const clock = (deps)=>{
+    var _deps_now;
+    return ((_deps_now = deps.now) != null ? _deps_now : Date.now)();
+};
+/** A value as Firestore can store it: no `undefined`, no class instances. */ export function stored(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+export function emptyResults() {
+    return {
+        created: 0,
+        updated: 0,
+        unchanged: 0,
+        skipped: 0,
+        failed: 0,
+        total: 0
+    };
+}
+export function emptyUndoCounts() {
+    return {
+        restore: 0,
+        delete: 0,
+        conflict: 0,
+        nothing: 0
+    };
+}
+/** `fn` over `items`, at most `limit` at once. */ export async function eachLimited(items, limit, fn) {
+    let next = 0;
+    const workers = Array.from({
+        length: Math.min(limit, items.length)
+    }, async ()=>{
+        while(next < items.length){
+            const item = items[next];
+            next += 1;
+            await fn(item);
+        }
+    });
+    await Promise.all(workers);
+}
+export function isAlreadyExists(error) {
+    var _ref;
+    const failure = error;
+    return (failure == null ? void 0 : failure.code) === 6 || /ALREADY_EXISTS/i.test(String((_ref = failure == null ? void 0 : failure.message) != null ? _ref : ''));
+}
+/*------------------------------------------
+ * JSON documents that may outgrow one document
+ *-----------------------------------------*/ /**
+ * Writes `value` as JSON on `ref` beside `fields`. JSON, because a plan row
+ * holds whatever the file held — a nested list from a JSON file is a value
+ * Firestore refuses — and past {@link JSON_PIECE_CHARS} the text goes into
+ * `pieces/{k}` documents, so a chunk of long notes is never refused for size.
+ */ export async function writeJsonDoc(ref, fields, value) {
+    const json = JSON.stringify(value);
+    if (json.length <= JSON_PIECE_CHARS) {
+        await ref.set(stored(_extends({}, fields, {
+            json
+        })));
+        return;
+    }
+    const pieces = [];
+    for(let at = 0; at < json.length; at += JSON_PIECE_CHARS)pieces.push(json.slice(at, at + JSON_PIECE_CHARS));
+    await eachLimited(pieces.map((json, index)=>({
+            json,
+            index
+        })), TRANSFER_WRITE_CONCURRENCY, async (piece)=>{
+        await ref.collection('pieces').doc(String(piece.index)).set({
+            json: piece.json
+        });
+    });
+    await ref.set(stored(_extends({}, fields, {
+        pieces: pieces.length
+    })));
+}
+/** The value {@link writeJsonDoc} wrote, or `null` when the document is absent. */ export async function readJsonDoc(ref) {
+    var _data_pieces;
+    const snapshot = await ref.get();
+    if (!snapshot.exists) return null;
+    const data = snapshot.data();
+    if (typeof data.json === 'string') return JSON.parse(data.json);
+    const count = Number((_data_pieces = data.pieces) != null ? _data_pieces : 0);
+    const parts = [];
+    for(let index = 0; index < count; index += 1){
+        var _ref;
+        var _piece_data;
+        const piece = await ref.collection('pieces').doc(String(index)).get();
+        parts.push(String((_ref = (_piece_data = piece.data()) == null ? void 0 : _piece_data.json) != null ? _ref : ''));
+    }
+    return JSON.parse(parts.join(''));
+}
+/** Deletes every document of a collection (and a JSON document's pieces), eight at a time. */ export async function clearCollection(collection) {
+    const snapshot = await collection.get();
+    await eachLimited(snapshot.docs, TRANSFER_WRITE_CONCURRENCY, async (doc)=>{
+        const pieces = await doc.ref.collection('pieces').get();
+        for (const piece of pieces.docs)await piece.ref.delete();
+        await doc.ref.delete();
+    });
+}
+/*==========================================
+ * JOBS
+ *=========================================*/ export async function readJob(deps, orgId, jobId) {
+    if (!jobId || jobId.includes('/')) throw new TransferEngineError('invalid', 400, 'Name the import.');
+    const snapshot = await transferJobsCollection(deps.firestore, orgId).doc(jobId).get();
+    if (!snapshot.exists) throw new TransferEngineError('notFound', 404, 'No such import.');
+    return _extends({}, snapshot.data(), {
+        id: jobId
+    });
+}
+/**
+ * When the sweep may clean a job up, and how (see the sweep below): never
+ * while it runs or undoes, nor once trimmed; a job that never wrote expires
+ * {@link TRANSFER_DRAFT_RETENTION_MS} after it was last touched; one that
+ * wrote is trimmed once its undo window has closed.
+ */ export function transferJobRetention(job) {
+    var _job_appliedAt;
+    var _job_undo;
+    if (job.trimmedAt !== undefined || job.status === 'applying' || ((_job_undo = job.undo) == null ? void 0 : _job_undo.status) === 'running') return null;
+    const wrote = job.applyStartedAt !== undefined || job.status === 'applied' || job.status === 'undone';
+    if (!wrote) return {
+        retention: 'expire',
+        retainUntil: job.updatedAt + TRANSFER_DRAFT_RETENTION_MS
+    };
+    return {
+        retention: 'trim',
+        retainUntil: ((_job_appliedAt = job.appliedAt) != null ? _job_appliedAt : job.updatedAt) + TRANSFER_UNDO_WINDOW_MS
+    };
+}
+/** A job as it is stored: Firestore-safe, with its retention stamped for the sweep's query. */ function storedJob(job) {
+    var _transferJobRetention;
+    const rest = _extends({}, job);
+    delete rest.retention;
+    delete rest.retainUntil;
+    return stored(_extends({}, rest, (_transferJobRetention = transferJobRetention(job)) != null ? _transferJobRetention : {}));
+}
+export async function saveJob(deps, job) {
+    await transferJobsCollection(deps.firestore, job.orgId).doc(job.id).set(storedJob(job));
+}
+/** The job as a route returns it. */ export async function readTransferJob(deps, input) {
+    return readJob(deps, input.orgId, input.jobId);
+}
+/** A `records` resource, joined to its server half, or the refusal a route answers. */ export async function resolveTransferRecordsResource(deps, key) {
+    return resolveResource(deps, key);
+}
+async function resolveResource(deps, key) {
+    try {
+        var _deps_resolveResource;
+        const resource = await ((_deps_resolveResource = deps.resolveResource) != null ? _deps_resolveResource : resolveTransferResource)(key);
+        if (!resource.kinds.includes('records')) {
+            throw new TransferEngineError('invalid', 400, `${resource.label} is moved as a package, not imported as rows.`);
+        }
+        return resource;
+    } catch (error) {
+        if (error instanceof TransferResourceUnavailableError) {
+            throw error.reason === 'undeclared' ? new TransferEngineError('notFound', 404, `Nothing called "${key}" can be imported.`) : new TransferEngineError('unavailable', 500, 'Importing this is unavailable right now. Try again in a minute.');
+        }
+        throw error;
+    }
+}
+/**
+ * The site a transfer concerns: required for a `host` resource; for an
+ * `org` resource the site the person named, or `null` — a workspace's
+ * records can be read through one site's view of them and imported as
+ * that site's captures (the CRM's, AGL-3541), and the gate has already
+ * checked `data.manage` on that site.
+ */ export function transferHostIdFor(resource, hostId) {
+    const site = typeof hostId === 'string' && hostId.trim() && !hostId.includes('/') ? hostId.trim() : null;
+    if (resource.scope === 'host' && !site) {
+        throw new TransferEngineError('invalid', 400, `${resource.label} belong to a site; name the site.`);
+    }
+    return site;
+}
+export function contextFor(job, actorUid) {
+    var _job_hostId;
+    return _extends({
+        resource: job.resource,
+        orgId: job.orgId,
+        hostId: (_job_hostId = job.hostId) != null ? _job_hostId : null,
+        actorUid,
+        jobId: job.id
+    }, job.extras ? {
+        extras: job.extras
+    } : {}, job.headers ? {
+        headers: job.headers
+    } : {});
+}
+export function moveJob(job, to, now, patch = {}) {
+    try {
+        return transitionTransferJob(job, to, now, patch);
+    } catch (unused) {
+        throw new TransferEngineError('state', 409, `This import is ${job.status} and cannot be ${to} now.`);
+    }
+}
+/** Where a job stands, for a progress bar. */ export function transferJobProgress(job) {
+    var _ref, _job_chunkCount, _ref1, _job_rowCount, _job_results;
+    var _job_cursor, _job_cursor1;
+    return {
+        status: job.status,
+        chunk: (_ref = (_job_cursor = job.cursor) == null ? void 0 : _job_cursor.chunk) != null ? _ref : 0,
+        chunkCount: (_job_chunkCount = job.chunkCount) != null ? _job_chunkCount : 0,
+        rowsDone: (_ref1 = (_job_cursor1 = job.cursor) == null ? void 0 : _job_cursor1.rowsDone) != null ? _ref1 : 0,
+        rowCount: (_job_rowCount = job.rowCount) != null ? _job_rowCount : 0,
+        results: (_job_results = job.results) != null ? _job_results : emptyResults()
+    };
+}
+/*==========================================
+ * FIELDS — what a resource offers
+ *=========================================*/ /** The resource's starting policy as a `TransferResourceInfo` entry: absent when it starts from the core's. */ async function policyDefaultsEntry(resource, ctx, fields) {
+    const defaultPolicy = await transferResourcePolicyDefaults(resource, ctx, fields);
+    return Object.keys(defaultPolicy).length ? {
+        defaultPolicy
+    } : {};
+}
+/**
+ * What a resource offers the wizard and the export dialog: its descriptor,
+ * every field and group, its match keys (and the ones a person starts with,
+ * which the Re-importable preset leads with), the presets' hints and its own
+ * presets, its locked rules and aliases. `prefs` is the person's own
+ * and is filled by the caller; a custom field cannot be created from here.
+ */ export async function readTransferResourceInfo(deps, input) {
+    var _input_resource;
+    var _hooks_presets, _hooks_aliases;
+    const resource = await resolveResource(deps, String((_input_resource = input.resource) != null ? _input_resource : '').trim());
+    const filter = input.filter;
+    const ctx = _extends({
+        resource: resource.key,
+        orgId: input.orgId,
+        hostId: transferHostIdFor(resource, input.hostId),
+        actorUid: input.actorUid
+    }, filter && typeof filter === 'object' && !Array.isArray(filter) ? {
+        filter: filter
+    } : {});
+    const hooks = transferRecordsHooks(resource);
+    const catalog = await transferResourceCatalog(resource, ctx);
+    const offer = await transferResourceMatchKeys(resource, ctx);
+    const matchKeys = offer.keys;
+    return _extends({
+        resource: _extends({
+            key: resource.key,
+            label: resource.label
+        }, resource.singularLabel ? {
+            singularLabel: resource.singularLabel
+        } : {}, {
+            scope: resource.scope,
+            kinds: [
+                ...resource.kinds
+            ],
+            formats: [
+                ...resource.formats
+            ]
+        }, resource.limits ? {
+            limits: resource.limits
+        } : {}, resource.description ? {
+            description: resource.description
+        } : {}, resource.exportOnly ? {
+            exportOnly: true
+        } : {}),
+        fields: catalog.fields,
+        groups: catalog.groups,
+        matchKeys,
+        defaultMatchKeys: offer.defaults,
+        presetHints: {
+            matchKeyFieldIds: offer.defaults
+        }
+    }, ((_hooks_presets = hooks.presets) == null ? void 0 : _hooks_presets.length) ? {
+        resourcePresets: hooks.presets.map((preset)=>_extends({}, preset, {
+                // Only fields the catalog has: a preset never names a column the export would refuse.
+                fieldIds: preset.fieldIds.filter((fieldId)=>catalog.byId.has(fieldId))
+            }))
+    } : {}, {
+        locked: [
+            ...await transferResourceLockedRules(resource, ctx)
+        ]
+    }, await policyDefaultsEntry(resource, ctx, catalog.fields), ((_hooks_aliases = hooks.aliases) == null ? void 0 : _hooks_aliases.length) ? {
+        dictionaries: [
+            ...hooks.aliases
+        ]
+    } : {}, {
+        canCreateCustomField: false
+    });
+}
+const CSV_DELIMITERS = [
+    ',',
+    ';',
+    '\t',
+    '|'
+];
+/** How the person said the CSV reads, or nothing for detection to decide. */ function readOptionsOf(input) {
+    const options = {};
+    if (input.delimiter !== undefined) {
+        if (!CSV_DELIMITERS.includes(input.delimiter)) throw new TransferEngineError('invalid', 400, 'That separator is not one a CSV can use.');
+        options.delimiter = input.delimiter;
+    }
+    if (input.headerRow === false) options.headerRow = false;
+    return Object.keys(options).length ? options : undefined;
+}
+/**
+ * The structure check every stored upload passes (`inspectUploadBytes`):
+ * an executable or a test signature named as a CSV is refused before a byte
+ * of it is stored. It is a structural check, not an antivirus scan.
+ */ function inspectTransferBytes(bytes, format, fileName) {
+    const refusal = inspectUploadBytes({
+        bytes,
+        contentType: transferContentType(format),
+        fileName
+    });
+    if (refusal) throw new TransferEngineError('rejectedFile', 422, refusal.message, {
+        code: refusal.code
+    });
+}
+function textOf(bytes) {
+    return bytes.toString('utf8');
+}
+/**
+ * Stores a file, or one part of it, and makes the job on the first part.
+ * Each part is inspected before it is stored; the whole file is inspected
+ * again, read, counted against the resource's limits and stored as the
+ * source once the last part lands. A part sent twice is accepted once.
+ */ export async function uploadTransferSource(deps, input) {
+    var _input_resource, _input_fileName, _ref, _input_format, _input_parts, _input_part, _ref1, _ref2, _job_read, _ref3;
+    var _resource_limits, _job_upload, _resource_limits1;
+    const resource = await resolveResource(deps, String((_input_resource = input.resource) != null ? _input_resource : '').trim());
+    if (!transferResourceImports(resource)) {
+        throw new TransferEngineError('invalid', 400, `${resource.label} are exported, not imported.`);
+    }
+    const hostId = transferHostIdFor(resource, input.hostId);
+    const fileName = String((_input_fileName = input.fileName) != null ? _input_fileName : '').trim().slice(0, 240) || 'import';
+    const content = typeof input.content === 'string' ? input.content : '';
+    const format = (_ref = (_input_format = input.format) != null ? _input_format : transferFormatFromFileName(fileName)) != null ? _ref : sniffTransferFormat(content);
+    if (!resource.formats.includes(format)) {
+        throw new TransferEngineError('unsupportedFormat', 415, `${resource.label} can be imported from ${resource.formats.join(', ').toUpperCase()}, not ${format.toUpperCase()}.`);
+    }
+    const parts = (_input_parts = input.parts) != null ? _input_parts : 1;
+    const part = (_input_part = input.part) != null ? _input_part : 0;
+    if (!Number.isInteger(parts) || parts < 1 || parts > TRANSFER_UPLOAD_MAX_PARTS) {
+        throw new TransferEngineError('invalid', 400, `A file is sent in 1 to ${TRANSFER_UPLOAD_MAX_PARTS} parts.`);
+    }
+    if (!Number.isInteger(part) || part < 0 || part >= parts) {
+        throw new TransferEngineError('invalid', 400, `Part ${part} is not one of ${parts}.`);
+    }
+    const bytes = Buffer.from(content, 'utf8');
+    if (bytes.length > TRANSFER_UPLOAD_PART_MAX_BYTES) {
+        throw new TransferEngineError('tooLarge', 413, 'Send the file in parts of at most 3 MB.');
+    }
+    const maxBytes = Math.min((_ref1 = (_resource_limits = resource.limits) == null ? void 0 : _resource_limits.maxBytes) != null ? _ref1 : TRANSFER_UPLOAD_MAX_BYTES, TRANSFER_UPLOAD_MAX_BYTES);
+    inspectTransferBytes(bytes, format, fileName);
+    const now = clock(deps);
+    const jobs = transferJobsCollection(deps.firestore, input.orgId);
+    let job;
+    if (input.jobId) {
+        job = await readJob(deps, input.orgId, input.jobId);
+        if (job.status !== 'draft' || job.resource !== resource.key || !job.upload || job.upload.complete) {
+            throw new TransferEngineError('state', 409, 'This import is not waiting for a file.');
+        }
+        if (job.upload.parts !== parts) throw new TransferEngineError('invalid', 400, 'The part count changed.');
+        if (job.upload.received.includes(part)) return {
+            job,
+            complete: false
+        };
+    } else {
+        var _ref4;
+        if (part !== 0) throw new TransferEngineError('invalid', 400, 'Send the first part first.');
+        const id = (_ref4 = deps.newJobId == null ? void 0 : deps.newJobId.call(deps)) != null ? _ref4 : createResourceUid();
+        job = _extends({
+            id,
+            resource: resource.key,
+            kind: 'records',
+            direction: 'import',
+            format,
+            status: 'draft',
+            orgId: input.orgId
+        }, hostId ? {
+            hostId
+        } : {}, {
+            createdBy: input.actorUid,
+            createdAt: now,
+            updatedAt: now,
+            fileName
+        }, format === 'csv' && readOptionsOf(input) ? {
+            read: readOptionsOf(input)
+        } : {}, {
+            upload: {
+                parts,
+                received: [],
+                bytes: 0,
+                complete: false
+            }
+        });
+    }
+    if (((_ref2 = (_job_upload = job.upload) == null ? void 0 : _job_upload.bytes) != null ? _ref2 : 0) + bytes.length > maxBytes) {
+        throw new TransferEngineError('tooLarge', 413, `A file may be at most ${Math.round(maxBytes / 1000000)} MB.`);
+    }
+    let whole;
+    if (parts === 1) {
+        whole = bytes;
+    } else {
+        var _ref5;
+        var _job_upload1;
+        await deps.bucket.file(transferPartPath(input.orgId, job.id, part)).save(bytes, {
+            contentType: 'application/octet-stream',
+            resumable: false
+        });
+        const received = await deps.firestore.runTransaction(async (transaction)=>{
+            var _current_upload;
+            const ref = jobs.doc(job.id);
+            const snapshot = await transaction.get(ref);
+            const current = snapshot.exists ? _extends({}, snapshot.data(), {
+                id: job.id
+            }) : job;
+            const upload = (_current_upload = current.upload) != null ? _current_upload : {
+                parts,
+                received: [],
+                bytes: 0,
+                complete: false
+            };
+            const next = _extends({}, current, {
+                updatedAt: now,
+                upload: _extends({}, upload, {
+                    received: [
+                        ...new Set([
+                            ...upload.received,
+                            part
+                        ])
+                    ].sort((a, b)=>a - b),
+                    bytes: upload.received.includes(part) ? upload.bytes : upload.bytes + bytes.length
+                })
+            });
+            transaction.set(ref, storedJob(next));
+            return next;
+        });
+        job = received;
+        if (((_ref5 = (_job_upload1 = job.upload) == null ? void 0 : _job_upload1.received.length) != null ? _ref5 : 0) < parts) return {
+            job,
+            complete: false
+        };
+        const pieces = [];
+        for(let index = 0; index < parts; index += 1){
+            const [piece] = await deps.bucket.file(transferPartPath(input.orgId, job.id, index)).download();
+            pieces.push(piece);
+        }
+        whole = Buffer.concat(pieces);
+        if (whole.length > maxBytes) {
+            throw new TransferEngineError('tooLarge', 413, `A file may be at most ${Math.round(maxBytes / 1000000)} MB.`);
+        }
+        inspectTransferBytes(whole, format, fileName);
+    }
+    const read = readTransferSource(textOf(whole), format, (_job_read = job.read) != null ? _job_read : {});
+    if ('problem' in read) {
+        await saveJob(deps, moveJob(job, 'failed', now, {
+            error: {
+                code: read.problem.code,
+                message: read.problem.message
+            }
+        }));
+        throw new TransferEngineError('invalid', 422, read.problem.message, read.problem);
+    }
+    const maxRows = (_ref3 = (_resource_limits1 = resource.limits) == null ? void 0 : _resource_limits1.maxRows) != null ? _ref3 : TRANSFER_DEFAULT_MAX_ROWS;
+    const rowCount = read.table.rows.length;
+    if (rowCount > maxRows) {
+        const message = `${resource.label} are imported at most ${maxRows.toLocaleString('en-US')} rows at a time; this file has ${rowCount.toLocaleString('en-US')}. Split it and import each part.`;
+        await saveJob(deps, moveJob(job, 'failed', now, {
+            error: {
+                code: 'tooManyRows',
+                message
+            }
+        }));
+        throw new TransferEngineError('tooLarge', 413, message);
+    }
+    if (!rowCount) throw new TransferEngineError('invalid', 422, 'The file has a header and no rows.');
+    const sourcePath = transferSourcePath(input.orgId, job.id);
+    await deps.bucket.file(sourcePath).save(whole, {
+        contentType: transferContentType(format),
+        resumable: false
+    });
+    if (parts > 1) {
+        await eachLimited(Array.from({
+            length: parts
+        }, (_unused, index)=>index), TRANSFER_WRITE_CONCURRENCY, async (index)=>{
+            await deps.bucket.file(transferPartPath(input.orgId, job.id, index)).delete({
+                ignoreNotFound: true
+            });
+        });
+    }
+    const done = _extends({}, job, {
+        updatedAt: now,
+        sourcePath,
+        rowCount,
+        chunkCount: transferChunkRanges(rowCount).length,
+        headers: read.table.headers,
+        upload: {
+            parts,
+            received: Array.from({
+                length: parts
+            }, (_unused, index)=>index),
+            bytes: whole.length,
+            complete: true
+        }
+    });
+    await saveJob(deps, done);
+    return {
+        job: done,
+        complete: true
+    };
+}
+async function loadTable(deps, job) {
+    var _job_read;
+    var _job_upload;
+    if (!job.sourcePath || !((_job_upload = job.upload) == null ? void 0 : _job_upload.complete)) {
+        throw new TransferEngineError('state', 409, 'The file has not finished uploading.');
+    }
+    const [bytes] = await deps.bucket.file(job.sourcePath).download();
+    const read = readTransferSource(textOf(bytes), job.format, (_job_read = job.read) != null ? _job_read : {});
+    if ('problem' in read) throw new TransferEngineError('invalid', 422, read.problem.message, read.problem);
+    return read.table;
+}
+/*==========================================
+ * ANALYZE
+ *=========================================*/ function assertBeforeWrites(job, what) {
+    if (job.applyStartedAt !== undefined || job.status === 'applying' || job.status === 'applied' || job.status === 'undone') {
+        throw new TransferEngineError('state', 409, `This import has started writing; it cannot be ${what} again.`);
+    }
+}
+function usableMapping(mapping) {
+    const out = {};
+    for (const [column, fieldId] of Object.entries(mapping != null ? mapping : {})){
+        if (typeof fieldId === 'string' && fieldId && /^\d+$/.test(column)) out[Number(column)] = fieldId;
+    }
+    return out;
+}
+function isPicklistField(field) {
+    return Boolean(field && (field.type === 'picklist' || field.type === 'multiPicklist') && field.picklistId);
+}
+async function picklistLists(hooks, ctx, fields) {
+    const ids = [
+        ...new Set(fields.filter(isPicklistField).map((field)=>field.picklistId))
+    ];
+    if (!ids.length || !hooks.picklists) return {};
+    return hooks.picklists(ctx, ids);
+}
+/** The picklist values each mapped picklist column carries, matched to the organization's list. */ function analyzePicklistColumns(table, mapping, byId, lists) {
+    const analyses = [];
+    for (const [column, fieldId] of Object.entries(mapping)){
+        const field = byId.get(fieldId);
+        if (!isPicklistField(field)) continue;
+        const list = lists[field.picklistId];
+        if (!list) continue;
+        const incoming = collectPicklistValues(table.rows.map((cells, row)=>{
+            const derived = deriveTransferCell(field, cells[Number(column)]);
+            return {
+                row,
+                value: derived.ok ? derived.value : null
+            };
+        }));
+        const result = matchPicklistValues(list.set, incoming);
+        analyses.push({
+            fieldId,
+            picklistId: field.picklistId,
+            spec: list.spec,
+            set: list.set,
+            matched: result.matched,
+            unmatched: result.unmatched,
+            proposals: Object.fromEntries(result.unmatched.map((value)=>[
+                    value.key,
+                    proposePicklistChoice(list.spec, value)
+                ]))
+        });
+    }
+    return analyses;
+}
+/** Record id → a name for it, for the records `ids` names that `records` holds. */ function recordLabelsFor(records, ids) {
+    const labels = {};
+    for (const id of ids){
+        const label = transferRowLabel(records.get(id));
+        if (label) labels[id] = label;
+    }
+    return labels;
+}
+/**
+ * Reads the file and proposes a mapping: every column against the
+ * resource's catalog and aliases, with the first rows as samples, and each
+ * mapped picklist column's values against the organization's list. With
+ * `mapping`, the values are read under that mapping instead of the proposal,
+ * and the answer adds what reading every mapped field did over the whole
+ * file and how the rows match existing records under `matchKeys`.
+ */ export async function analyzeTransferJob(deps, input) {
+    var _hooks_aliases;
+    const job = await readJob(deps, input.orgId, input.jobId);
+    assertBeforeWrites(job, 'analyzed');
+    const resource = await resolveResource(deps, job.resource);
+    const hooks = transferRecordsHooks(resource);
+    const ctx = contextFor(job, input.actorUid);
+    const table = await loadTable(deps, job);
+    const catalog = await transferResourceCatalog(resource, ctx);
+    const samples = table.rows.slice(0, 20);
+    const match = matchHeaders(table.headers, catalog.fields, {
+        dictionaries: (_hooks_aliases = hooks.aliases) != null ? _hooks_aliases : [],
+        samples
+    });
+    const mapping = input.mapping ? usableMapping(input.mapping) : match.mapping;
+    const byId = new Map(catalog.fields.map((field)=>[
+            field.id,
+            field
+        ]));
+    const lists = await picklistLists(hooks, ctx, catalog.fields);
+    const picklists = analyzePicklistColumns(table, mapping, byId, lists);
+    const lockedRules = [
+        ...await transferResourceLockedRules(resource, ctx)
+    ];
+    const offer = await transferResourceMatchKeys(resource, ctx);
+    let review = {};
+    if (input.mapping) {
+        var _input_matchKeys;
+        const fieldOptions = transferDateOrderOptions(input.dateOrders);
+        const read = table.rows.map((cells, index)=>{
+            const mapped = mapTransferRow(cells, mapping);
+            return _extends({
+                index,
+                cells: mapped
+            }, deriveTransferRow(byId, mapped, {}, fieldOptions));
+        });
+        const mappedFields = [
+            ...new Set(Object.values(mapping))
+        ].map((fieldId)=>byId.get(fieldId)).filter((field)=>Boolean(field));
+        const keys = chosenMatchKeys(offer.keys, (_input_matchKeys = input.matchKeys) != null ? _input_matchKeys : offer.defaults);
+        const values = read.map((row)=>row.values);
+        const found = keys.length ? await lookupAll(hooks, ctx, matchLookupRequests(values, keys)) : {
+            lookup: new Map(),
+            records: new Map()
+        };
+        // The resource's own matching, when it has one: the Matching step shows
+        // the outcome the dry run will act on.
+        const matched = await matchTransferResourceRows(resource, ctx, {
+            rows: values,
+            keys,
+            lookup: found.lookup,
+            records: found.records
+        });
+        const outcomes = matched.outcomes;
+        const lookups = await lookupReviews(await resolveLookupColumns(deps, hooks, ctx, mapping, byId, read));
+        review = _extends({
+            derivations: summarizeTransferDerivations(mappedFields, read)
+        }, lookups.length ? {
+            lookups
+        } : {}, {
+            matches: transferMatchReview(keys, outcomes, values),
+            recordLabels: recordLabelsFor(matched.records, transferMatchedRecordIds(outcomes))
+        });
+    }
+    const now = clock(deps);
+    const next = moveJob(job, 'analyzed', now, {
+        headers: table.headers,
+        rowCount: table.rows.length,
+        chunkCount: transferChunkRanges(table.rows.length).length,
+        mapping
+    });
+    await saveJob(deps, next);
+    return _extends({
+        job: next,
+        headers: table.headers,
+        rowCount: table.rows.length,
+        samples: samples.map((cells)=>cells.map(transferCellText)),
+        catalog,
+        match,
+        mappingProblems: mappingProblems(mapping, catalog.fields),
+        matchKeys: offer.keys,
+        lockedRules,
+        picklists
+    }, review);
+}
+/*==========================================
+ * LOOKUPS — cells that name another record (AGL-3541)
+ *=========================================*/ /** The most suggestions one unresolved value carries. */ const LOOKUP_SUGGESTIONS_MAX = 5;
+/** The most rows one unresolved value lists. */ const LOOKUP_ROWS_MAX = 20;
+/**
+ * The names a lookup cell holds, trimmed, blanks dropped: one for a `lookup`
+ * field, each item of a `list` field that names a target. `null` for a cell
+ * that is neither text nor a list — a value no record could be named by.
+ */ function lookupCellNames(raw) {
+    if (isBlankTransferValue(raw)) return [];
+    const items = Array.isArray(raw) ? raw : [
+        raw
+    ];
+    if (items.some((item)=>item !== null && item !== undefined && typeof item === 'object')) return null;
+    return items.map((item)=>String(item != null ? item : '').trim()).filter(Boolean);
+}
+/**
+ * The target of a lookup field: one the resource answers itself
+ * (`lookupTargets`), or the declared resource it names, asked as that
+ * resource in the same workspace and site.
+ */ async function lookupTargetFor(deps, hooks, ctx, key) {
+    var _hooks_lookupTargets;
+    const own = (_hooks_lookupTargets = hooks.lookupTargets) == null ? void 0 : _hooks_lookupTargets[key];
+    if (own) return {
+        hooks: own,
+        ctx
+    };
+    const target = await resolveResource(deps, key);
+    const targetCtx = _extends({}, ctx, {
+        resource: target.key
+    });
+    // Linking rows to another resource's records is part of the import, so
+    // it asks that resource's plan as an import does (AGL-3555): a workspace
+    // without the feature cannot reach those records through a lookup either.
+    if (transferPlanFeature('import', target)) {
+        var _org_data;
+        const org = await deps.firestore.collection('orgs').doc(ctx.orgId).get();
+        const refusal = await transferPlanRefusal({
+            resource: target.key,
+            orgId: ctx.orgId,
+            hostId: ctx.hostId,
+            org: (_org_data = org.data()) != null ? _org_data : {}
+        }, 'import');
+        if (refusal) throw new TransferPlanRefusedError(refusal);
+    }
+    // The target's keys as they stand for it — read for the context when
+    // they depend on it (one dataset's own fields).
+    const { keys } = await transferResourceMatchKeys(target, targetCtx);
+    return {
+        hooks: _extends({}, transferRecordsHooks(target), {
+            matchKeys: keys
+        }),
+        ctx: targetCtx
+    };
+}
+/**
+ * A record's name for the person: the first text it holds — the name a
+ * resource lists first, as every record label the wizard shows is — else
+ * its first `by` value.
+ */ function lookupRecordLabel(record, by) {
+    if (!record) return undefined;
+    const label = transferRowLabel(record);
+    if (label) return label;
+    for (const fieldId of by){
+        const value = record[fieldId];
+        if (value !== null && value !== undefined && String(value).trim()) return String(value).trim();
+    }
+    return undefined;
+}
+/**
+ * Every mapped lookup column's values resolved against its target: each
+ * distinct value asked by id (when it could be one) and then by each `by`
+ * field in order; the first key that names exactly one record decides. A
+ * value that names several records, or none, is unresolved.
+ */ async function resolveLookupColumns(deps, hooks, ctx, mapping, byId, rows) {
+    const columns = [];
+    for (const fieldId of new Set(Object.values(mapping))){
+        const field = byId.get(fieldId);
+        if (!isTransferLookupField(field)) continue;
+        const values = new Map();
+        for (const row of rows){
+            var _lookupCellNames;
+            // A value is counted once per row, however often a list repeats it.
+            const inRow = new Set();
+            for (const text of (_lookupCellNames = lookupCellNames(row.values[field.id])) != null ? _lookupCellNames : []){
+                const key = transferLookupKey(text);
+                if (inRow.has(key)) continue;
+                inRow.add(key);
+                const seen = values.get(key);
+                if (seen) {
+                    seen.count += 1;
+                    if (seen.rows.length < LOOKUP_ROWS_MAX) seen.rows.push(row.index);
+                } else {
+                    values.set(key, {
+                        value: text,
+                        key,
+                        count: 1,
+                        rows: [
+                            row.index
+                        ]
+                    });
+                }
+            }
+        }
+        const target = await lookupTargetFor(deps, hooks, ctx, field.lookup.resource);
+        const column = {
+            field,
+            target,
+            resolved: new Map(),
+            unresolved: new Map(),
+            records: new Map()
+        };
+        columns.push(column);
+        if (!values.size) continue;
+        const keys = [
+            {
+                fieldId: TRANSFER_ID_FIELD,
+                normalizer: 'aglynId'
+            },
+            ...field.lookup.by.map((by)=>{
+                var _ref;
+                var _target_hooks_matchKeys;
+                return (_ref = (_target_hooks_matchKeys = target.hooks.matchKeys) == null ? void 0 : _target_hooks_matchKeys.find((key)=>key.fieldId === by)) != null ? _ref : {
+                    fieldId: by,
+                    normalizer: 'caseless'
+                };
+            })
+        ];
+        const requests = keys.map((key)=>{
+            const wanted = new Set();
+            for (const entry of values.values()){
+                if (key.normalizer === 'aglynId' && !mayBeTransferRecordId(entry.value)) continue;
+                const normalized = normalizeMatchValue(key.normalizer, entry.value);
+                if (normalized) wanted.add(normalized);
+            }
+            return _extends({}, key, {
+                values: [
+                    ...wanted
+                ]
+            });
+        }).filter((request)=>request.values.length);
+        const found = await lookupAll(target.hooks, target.ctx, requests);
+        for (const [id, record] of found.records)column.records.set(id, record);
+        for (const entry of values.values()){
+            let candidates = [];
+            for (const key of keys){
+                var _found_lookup_get;
+                if (key.normalizer === 'aglynId' && !mayBeTransferRecordId(entry.value)) continue;
+                const normalized = normalizeMatchValue(key.normalizer, entry.value);
+                const ids = normalized ? [
+                    ...new Set((_found_lookup_get = found.lookup.get(matchLookupKey(key.fieldId, normalized))) != null ? _found_lookup_get : [])
+                ] : [];
+                if (ids.length === 1) {
+                    column.resolved.set(entry.key, ids[0]);
+                    candidates = [];
+                    break;
+                }
+                if (ids.length > 1 && !candidates.length) candidates = ids;
+            }
+            if (!column.resolved.has(entry.key)) column.unresolved.set(entry.key, _extends({}, entry, {
+                candidates
+            }));
+        }
+    }
+    return columns;
+}
+/** The review the values step shows: every unresolved value, with records it may mean. */ async function lookupReviews(columns) {
+    const reviews = [];
+    for (const column of columns){
+        const unresolved = [
+            ...column.unresolved.values()
+        ];
+        const asked = unresolved.length && column.target.hooks.suggest ? await column.target.hooks.suggest(column.target.ctx, {
+            by: column.field.lookup.by,
+            values: unresolved.map((entry)=>entry.value)
+        }) : {};
+        reviews.push({
+            fieldId: column.field.id,
+            resolved: column.resolved.size,
+            unresolved: unresolved.map((entry)=>{
+                var _asked_entry_value;
+                const several = entry.candidates.map((recordId)=>{
+                    var _lookupRecordLabel;
+                    return {
+                        recordId,
+                        label: (_lookupRecordLabel = lookupRecordLabel(column.records.get(recordId), column.field.lookup.by)) != null ? _lookupRecordLabel : recordId
+                    };
+                });
+                const seen = new Set();
+                const suggestions = [
+                    ...several,
+                    ...(_asked_entry_value = asked[entry.value]) != null ? _asked_entry_value : []
+                ].filter((suggestion)=>{
+                    if (!(suggestion == null ? void 0 : suggestion.recordId) || seen.has(suggestion.recordId)) return false;
+                    seen.add(suggestion.recordId);
+                    return true;
+                }).slice(0, LOOKUP_SUGGESTIONS_MAX).map((suggestion)=>({
+                        recordId: suggestion.recordId,
+                        label: String(suggestion.label || suggestion.recordId)
+                    }));
+                return {
+                    value: entry.value,
+                    key: entry.key,
+                    count: entry.count,
+                    rows: entry.rows,
+                    suggestions
+                };
+            })
+        });
+    }
+    return reviews;
+}
+/**
+ * What the person must still decide about the lookup columns, by field: a
+ * value with no choice, a "create" the target does not allow, and a record
+ * chosen that does not exist. The records chosen are looked up by id.
+ */ async function lookupChoiceProblems(columns, choices) {
+    const problems = {};
+    for (const column of columns){
+        var _ref;
+        const fieldChoices = (_ref = choices == null ? void 0 : choices[column.field.id]) != null ? _ref : {};
+        const found = [];
+        const mapped = new Set();
+        for (const entry of column.unresolved.values()){
+            const choice = fieldChoices[entry.key];
+            if (!choice) found.push(`Choose what to do with “${entry.value}”.`);
+            else if (choice.action === 'create' && !column.field.lookup.creatable) {
+                found.push(`“${entry.value}” cannot be created by this import; use a record, leave it blank or refuse the rows.`);
+            } else if (choice.action === 'mapTo') {
+                if (typeof choice.recordId !== 'string' || !choice.recordId) found.push(`Choose the record “${entry.value}” means.`);
+                else if (!column.records.has(choice.recordId)) mapped.add(choice.recordId);
+            }
+        }
+        if (mapped.size) {
+            const known = await lookupAll(column.target.hooks, column.target.ctx, [
+                {
+                    fieldId: TRANSFER_ID_FIELD,
+                    normalizer: 'aglynId',
+                    values: [
+                        ...mapped
+                    ]
+                }
+            ]);
+            for (const id of mapped){
+                if (known.records.has(id)) column.records.set(id, known.records.get(id));
+                else found.push(`The record chosen for a value no longer exists (${id}); choose again.`);
+            }
+        }
+        if (found.length) problems[column.field.id] = found;
+    }
+    return problems;
+}
+/**
+ * The person's lookup choices applied to the rows: a resolved value becomes
+ * its record's id; an unresolved one its choice — the chosen record's id, a
+ * record to create, nothing written, or the row refused — each noted on the
+ * row as `unresolvedLookup`. A value left blank by choice is not written at
+ * all: it must never read as "clear the field". In a list, each item is
+ * decided on its own and an item left blank is dropped from the list; a
+ * list whose every item was left blank is not written.
+ */ function applyLookupChoices(rows, columns, choices) {
+    for (const row of rows){
+        var _row_notes;
+        const values = row.values;
+        const notes = [
+            ...(_row_notes = row.notes) != null ? _row_notes : []
+        ];
+        for (const column of columns){
+            const raw = values[column.field.id];
+            const names = lookupCellNames(raw);
+            if (!(names == null ? void 0 : names.length)) continue;
+            const ids = [];
+            let refused = false;
+            for (const text of names){
+                var _choices_column_field_id;
+                const key = transferLookupKey(text);
+                const id = column.resolved.get(key);
+                if (id) {
+                    ids.push(id);
+                    continue;
+                }
+                const choice = choices == null ? void 0 : (_choices_column_field_id = choices[column.field.id]) == null ? void 0 : _choices_column_field_id[key];
+                const note = {
+                    class: 'unresolvedLookup',
+                    fieldId: column.field.id,
+                    value: text
+                };
+                if ((choice == null ? void 0 : choice.action) === 'mapTo') {
+                    ids.push(choice.recordId);
+                    const label = lookupRecordLabel(column.records.get(choice.recordId), column.field.lookup.by);
+                    notes.push(_extends({}, note, {
+                        detail: label ? `Uses “${label}”` : 'Uses a chosen record'
+                    }));
+                } else if ((choice == null ? void 0 : choice.action) === 'create') {
+                    ids.push(transferLookupNewValue(text));
+                    notes.push(_extends({}, note, {
+                        detail: 'Creates it'
+                    }));
+                } else if ((choice == null ? void 0 : choice.action) === 'refuseRow') {
+                    refused = true;
+                    notes.push(_extends({}, note, {
+                        refuse: true,
+                        detail: 'Refuses the row'
+                    }));
+                } else {
+                    notes.push(_extends({}, note, {
+                        detail: 'Left blank'
+                    }));
+                }
+            }
+            if (refused || !ids.length) delete values[column.field.id];
+            else values[column.field.id] = Array.isArray(raw) ? [
+                ...new Set(ids)
+            ] : ids[0];
+        }
+        if (notes.length) row.notes = notes;
+    }
+}
+/** The rows read, picklists resolved: what `buildTransferPlan` takes. */ function readPlanRows(table, mapping, byId, columns, choices) {
+    return table.rows.map((cells, index)=>{
+        var _choices_derive;
+        const derived = deriveTransferRow(byId, mapTransferRow(cells, mapping), (_choices_derive = choices.derive) != null ? _choices_derive : {}, transferDateOrderOptions(choices.dateOrders));
+        const notes = [];
+        for (const column of columns){
+            const fieldId = column.field.id;
+            const value = derived.values[fieldId];
+            if (value === null || value === undefined) continue;
+            const noteFor = (raw)=>{
+                const label = normalizePicklistLabel(raw);
+                if (!label) return;
+                const key = picklistLabelKey(label);
+                if (column.added.has(key)) notes.push({
+                    class: 'newPicklistValue',
+                    fieldId,
+                    value: String(raw)
+                });
+                else if (column.blank.has(key)) notes.push({
+                    class: 'unmatchedPicklist',
+                    fieldId,
+                    value: String(raw),
+                    detail: 'Left blank'
+                });
+            };
+            if (column.field.type === 'multiPicklist' && Array.isArray(value)) {
+                const outcome = resolveMultiPicklistCell(column.resolution, value);
+                if (outcome.kind === 'refuse') {
+                    notes.push({
+                        class: 'unmatchedPicklist',
+                        fieldId,
+                        value: value.join(', '),
+                        refuse: true,
+                        detail: 'Refuses the row'
+                    });
+                    continue;
+                }
+                for (const raw of value)noteFor(raw);
+                if (outcome.labels.length) derived.values[fieldId] = outcome.labels;
+                else delete derived.values[fieldId];
+                continue;
+            }
+            const outcome = resolvePicklistCell(column.resolution, value);
+            if (outcome.kind === 'refuse') {
+                notes.push({
+                    class: 'unmatchedPicklist',
+                    fieldId,
+                    value: String(value),
+                    refuse: true,
+                    detail: 'Refuses the row'
+                });
+                continue;
+            }
+            noteFor(value);
+            // A value left blank by choice is not written at all: a blank here
+            // must never read as "clear the field".
+            if (outcome.kind === 'value') derived.values[fieldId] = outcome.label;
+            else delete derived.values[fieldId];
+        }
+        return _extends({
+            index,
+            values: derived.values,
+            derivations: derived.derivations,
+            problems: derived.problems
+        }, notes.length ? {
+            notes
+        } : {});
+    });
+}
+/** The match keys the person chose, in their order, from the resource's own. */ function chosenMatchKeys(keys, chosen) {
+    return chosen.map((fieldId)=>{
+        const key = keys.find((entry)=>entry.fieldId === fieldId);
+        if (!key) throw new TransferEngineError('invalid', 400, `"${fieldId}" is not a key records can be matched by.`);
+        return key;
+    });
+}
+/** Every lookup request, cut so no single request carries more than {@link MATCH_LOOKUP_SLICE} values. */ function sliceLookupRequests(requests) {
+    const slices = [];
+    for (const request of requests){
+        for(let at = 0; at < request.values.length; at += MATCH_LOOKUP_SLICE){
+            slices.push([
+                _extends({}, request, {
+                    values: request.values.slice(at, at + MATCH_LOOKUP_SLICE)
+                })
+            ]);
+        }
+    }
+    return slices;
+}
+async function lookupAll(hooks, ctx, requests) {
+    const lookup = new Map();
+    const records = new Map();
+    for (const slice of sliceLookupRequests(requests)){
+        var _lookup_get;
+        const found = await hooks.lookup(ctx, slice);
+        for (const [key, ids] of found.lookup)lookup.set(key, [
+            ...new Set([
+                ...(_lookup_get = lookup.get(key)) != null ? _lookup_get : [],
+                ...ids
+            ])
+        ]);
+        for (const [id, values] of found.records)records.set(id, values);
+    }
+    return {
+        lookup,
+        records
+    };
+}
+/**
+ * The dry run: every row read, its picklist values resolved, matched to the
+ * records that exist and planned under the policy — without writing a
+ * record. The planned rows are stored chunk by chunk for Apply; the summary,
+ * the warnings and the first page answer the wizard.
+ */ export async function planTransferJob(deps, input) {
+    var _choices_policy, _choices_matchKeys, _choices_picklistChoices, _choices_lookupChoices;
+    const job = await readJob(deps, input.orgId, input.jobId);
+    assertBeforeWrites(job, 'planned');
+    if (job.status === 'draft') throw new TransferEngineError('state', 409, 'Analyze the file before planning it.');
+    const resource = await resolveResource(deps, job.resource);
+    const hooks = transferRecordsHooks(resource);
+    const choices = input.choices;
+    // The plugin steps' answers as sent with this dry run, not the last one's.
+    const ctx = _extends({}, contextFor(job, input.actorUid));
+    delete ctx.extras;
+    if (choices.extras) ctx.extras = choices.extras;
+    const table = await loadTable(deps, job);
+    const catalog = await transferResourceCatalog(resource, ctx);
+    const byId = new Map(catalog.fields.map((field)=>[
+            field.id,
+            field
+        ]));
+    const mapping = usableMapping(choices.mapping);
+    const problems = mappingProblems(mapping, catalog.fields);
+    if (!mappingIsUsable(problems)) {
+        throw new TransferEngineError('invalid', 422, 'Resolve the mapping before the dry run.', problems);
+    }
+    const lockedRules = await transferResourceLockedRules(resource, ctx);
+    // The person's choices over the resource's starting point (AGL-3548).
+    const defaults = await transferResourcePolicyDefaults(resource, ctx, catalog.fields);
+    const policy = createTransferPolicy(_extends({}, withTransferPolicyDefaults(defaults, (_choices_policy = choices.policy) != null ? _choices_policy : {}), {
+        locked: lockedRules
+    }));
+    const policyProblems = transferPolicyProblems(policy, catalog.fields);
+    if (policyProblems.length) throw new TransferEngineError('invalid', 422, policyProblems[0], policyProblems);
+    const offer = await transferResourceMatchKeys(resource, ctx);
+    const keys = chosenMatchKeys(offer.keys, (_choices_matchKeys = choices.matchKeys) != null ? _choices_matchKeys : offer.defaults);
+    // Picklists: every unmatched value needs the person's choice.
+    const lists = await picklistLists(hooks, ctx, catalog.fields);
+    const analyses = analyzePicklistColumns(table, mapping, byId, lists);
+    const columns = [];
+    const choiceProblems = {};
+    const additions = {};
+    for (const analysis of analyses){
+        var _ref, _additions, _analysis_picklistId, _;
+        var _choices_picklistChoices1;
+        const fieldChoices = (_ref = (_choices_picklistChoices1 = choices.picklistChoices) == null ? void 0 : _choices_picklistChoices1[analysis.fieldId]) != null ? _ref : {};
+        const found = picklistChoiceProblems(analysis.spec, analysis.set, analysis.unmatched, fieldChoices);
+        if (found.length) {
+            choiceProblems[analysis.fieldId] = found;
+            continue;
+        }
+        const resolution = resolvePicklistChoices(analysis.spec, analysis.set, {
+            matched: analysis.matched,
+            unmatched: analysis.unmatched
+        }, fieldChoices);
+        const added = new Set();
+        const blank = new Set();
+        for (const value of analysis.unmatched){
+            const choice = fieldChoices[value.key];
+            if ((choice == null ? void 0 : choice.action) === 'addValue') added.add(value.key);
+            else if ((choice == null ? void 0 : choice.action) !== 'mapTo' && (choice == null ? void 0 : choice.action) !== 'refuseRow') blank.add(value.key);
+        }
+        const list = (_ = (_additions = additions)[_analysis_picklistId = analysis.picklistId]) != null ? _ : _additions[_analysis_picklistId] = [];
+        for (const value of resolution.added){
+            if (!list.some((entry)=>entry.id === value.id)) list.push(value);
+        }
+        columns.push({
+            field: byId.get(analysis.fieldId),
+            resolution,
+            added,
+            blank
+        });
+    }
+    for (const [picklistId, values] of Object.entries(additions))if (!values.length) delete additions[picklistId];
+    const rows = readPlanRows(table, mapping, byId, columns, choices);
+    // Lookups: every value that names no record needs the person's choice too.
+    const lookupColumns = await resolveLookupColumns(deps, hooks, ctx, mapping, byId, rows);
+    const lookupProblems = await lookupChoiceProblems(lookupColumns, choices.lookupChoices);
+    for (const [fieldId, found] of Object.entries(lookupProblems)){
+        var _choiceProblems_fieldId;
+        choiceProblems[fieldId] = [
+            ...(_choiceProblems_fieldId = choiceProblems[fieldId]) != null ? _choiceProblems_fieldId : [],
+            ...found
+        ];
+    }
+    if (Object.keys(choiceProblems).length) {
+        throw new TransferEngineError('choicesNeeded', 422, Object.keys(lookupProblems).length ? 'Choose what to do with every value the list does not hold and every record the file names that was not found.' : 'Choose what to do with every value the list does not hold.', choiceProblems);
+    }
+    applyLookupChoices(rows, lookupColumns, choices.lookupChoices);
+    const values = rows.map((row)=>row.values);
+    const looked = keys.length ? await lookupAll(hooks, ctx, matchLookupRequests(values, keys)) : {
+        lookup: new Map(),
+        records: new Map()
+    };
+    const { outcomes: matches, records } = await matchTransferResourceRows(resource, ctx, {
+        rows: values,
+        keys,
+        lookup: looked.lookup,
+        records: looked.records
+    });
+    const found = {
+        lookup: looked.lookup,
+        records
+    };
+    const plan = await planTransferResourceRows(resource, ctx, {
+        fields: catalog.fields,
+        rows,
+        matches,
+        existing: found.records,
+        policy
+    });
+    const failures = transferInvariantFailures(hooks.invariants, plan.rows, found.records);
+    if (failures.length) {
+        const failing = new Set(failures.map((failure)=>failure.row));
+        plan.rows = plan.rows.map((row)=>failing.has(row.index) ? _extends({}, row, {
+                verdict: 'fail',
+                reason: 'refusedValue',
+                diff: []
+            }) : row);
+        plan.summary = {
+            create: 0,
+            update: 0,
+            unchanged: 0,
+            skip: 0,
+            fail: 0,
+            total: plan.rows.length
+        };
+        for (const row of plan.rows)plan.summary[row.verdict] += 1;
+    }
+    // The stored dry run, replaced whole.
+    const jobRef = transferJobsCollection(deps.firestore, job.orgId).doc(job.id);
+    await clearCollection(jobRef.collection('chunks'));
+    const ranges = transferChunkRanges(plan.rows.length);
+    await eachLimited(ranges, TRANSFER_WRITE_CONCURRENCY, async (range)=>{
+        await writeJsonDoc(jobRef.collection('chunks').doc(String(range.index)), {
+            jobId: job.id,
+            index: range.index,
+            start: range.start,
+            end: range.end
+        }, plan.rows.slice(range.start, range.end));
+    });
+    const now = clock(deps);
+    const matchSummary = summarizeMatches(matches);
+    const allConflicts = transferPlanConflicts(_extends({
+        fields: byId,
+        rows,
+        matches,
+        existing: found.records,
+        policy
+    }, hooks.valuesEqual ? {
+        valuesEqual: hooks.valuesEqual
+    } : {}));
+    const conflicts = allConflicts.slice(0, TRANSFER_PLAN_CONFLICTS_MAX);
+    const ambiguous = transferAmbiguities(matches);
+    const sample = transferPlanSample(plan.rows);
+    const labelled = new Set();
+    for (const row of sample)if (row.recordId) labelled.add(row.recordId);
+    for (const conflict of conflicts)labelled.add(conflict.recordId);
+    for (const row of ambiguous)for (const id of row.recordIds)labelled.add(id);
+    const next = moveJob(job, 'planned', now, _extends({
+        mapping,
+        matchKeys: keys.map((key)=>key.fieldId),
+        policy,
+        picklistChoices: (_choices_picklistChoices = choices.picklistChoices) != null ? _choices_picklistChoices : {},
+        lookupChoices: (_choices_lookupChoices = choices.lookupChoices) != null ? _choices_lookupChoices : {}
+    }, choices.derive ? {
+        derive: choices.derive
+    } : {}, choices.dateOrders ? {
+        dateOrders: choices.dateOrders
+    } : {}, choices.extras ? {
+        extras: choices.extras
+    } : {}, {
+        picklistAdditions: additions,
+        summary: plan.summary,
+        warnings: plan.warnings,
+        acknowledgementsRequired: plan.acknowledgementsRequired,
+        acknowledged: [],
+        matchSummary,
+        invariantFailures: failures.slice(0, 50),
+        invariantFailureCount: failures.length,
+        rowCount: plan.rows.length,
+        chunkCount: ranges.length,
+        plannedAt: now
+    }));
+    await saveJob(deps, next);
+    const first = plan.rows.slice(0, 50);
+    return {
+        job: next,
+        summary: plan.summary,
+        warnings: plan.warnings,
+        acknowledgementsRequired: plan.acknowledgementsRequired,
+        matchSummary,
+        invariantFailures: failures.slice(0, 50),
+        invariantFailureCount: failures.length,
+        picklistAdditions: additions,
+        rows: {
+            rows: first,
+            offset: 0,
+            next: plan.rows.length > first.length ? first.length : null
+        },
+        sample,
+        conflicts,
+        conflictCount: allConflicts.length,
+        ambiguous,
+        recordLabels: recordLabelsFor(found.records, labelled)
+    };
+}
+async function readChunkRows(jobRef, index) {
+    var _ref;
+    const ref = jobRef.collection('chunks').doc(String(index));
+    const snapshot = await ref.get();
+    if (!snapshot.exists) return null;
+    const data = snapshot.data();
+    const rows = (_ref = await readJsonDoc(ref)) != null ? _ref : [];
+    return {
+        range: {
+            index: data.index,
+            start: data.start,
+            end: data.end
+        },
+        rows
+    };
+}
+/** One page of the stored dry run, optionally only rows with some verdicts. */ export async function readTransferPlanRows(deps, input) {
+    var _input_offset, _input_limit, _job_chunkCount;
+    var _input_verdicts;
+    const job = await readJob(deps, input.orgId, input.jobId);
+    if (job.plannedAt === undefined) throw new TransferEngineError('state', 409, 'This import has no dry run yet.');
+    const offset = Math.max(0, Math.floor(Number((_input_offset = input.offset) != null ? _input_offset : 0)) || 0);
+    const limit = Math.min(TRANSFER_PLAN_PAGE_MAX, Math.max(1, Math.floor(Number((_input_limit = input.limit) != null ? _input_limit : 50)) || 50));
+    const filter = ((_input_verdicts = input.verdicts) == null ? void 0 : _input_verdicts.length) ? new Set(input.verdicts) : null;
+    const jobRef = transferJobsCollection(deps.firestore, job.orgId).doc(job.id);
+    const rows = [];
+    let seen = 0;
+    let more = false;
+    scan: for(let index = 0; index < ((_job_chunkCount = job.chunkCount) != null ? _job_chunkCount : 0); index += 1){
+        const chunk = await readChunkRows(jobRef, index);
+        if (!chunk) break;
+        for (const row of chunk.rows){
+            if (filter && !filter.has(row.verdict)) continue;
+            if (seen >= offset) {
+                if (rows.length >= limit) {
+                    more = true;
+                    break scan;
+                }
+                rows.push(row);
+            }
+            seen += 1;
+        }
+    }
+    return {
+        rows,
+        offset,
+        next: more ? offset + rows.length : null
+    };
+}
+/** A row the plan does not write, as its result. */ function plannedResult(row) {
+    if (row.verdict === 'unchanged') return _extends({
+        row: row.index,
+        outcome: 'unchanged'
+    }, row.recordId ? {
+        recordId: row.recordId
+    } : {});
+    if (row.verdict === 'skip') return _extends({
+        row: row.index,
+        outcome: 'skipped'
+    }, row.reason ? {
+        reason: row.reason
+    } : {});
+    return _extends({
+        row: row.index,
+        outcome: 'failed'
+    }, row.recordId ? {
+        recordId: row.recordId
+    } : {}, row.reason ? {
+        reason: row.reason
+    } : {});
+}
+export function addResults(total, more) {
+    return {
+        created: total.created + more.created,
+        updated: total.updated + more.updated,
+        unchanged: total.unchanged + more.unchanged,
+        skipped: total.skipped + more.skipped,
+        failed: total.failed + more.failed,
+        total: total.total + more.total
+    };
+}
+/** Takes the job for `driver`, or refuses: another driver holds it, or another import of the resource is running. */ export async function takeLease(deps, job, driver, expiresAt, enter) {
+    const jobs = transferJobsCollection(deps.firestore, job.orgId);
+    return deps.firestore.runTransaction(async (transaction)=>{
+        const ref = jobs.doc(job.id);
+        const snapshot = await transaction.get(ref);
+        if (!snapshot.exists) throw new TransferEngineError('notFound', 404, 'No such import.');
+        const current = _extends({}, snapshot.data(), {
+            id: job.id
+        });
+        const now = clock(deps);
+        if (current.lease && current.lease.expiresAt > now && current.lease.owner !== driver) {
+            throw new TransferEngineError('busy', 409, 'This import is already running in another window. Its progress shows here.');
+        }
+        const running = await transaction.get(jobs.where('resource', '==', current.resource).where('status', '==', 'applying').limit(5));
+        const other = running.docs.find((doc)=>doc.id !== job.id);
+        if (other) {
+            throw new TransferEngineError('busy', 409, 'Another import of the same records is running. Wait for it to finish.', {
+                jobId: other.id
+            });
+        }
+        const next = _extends({}, enter(current, now), {
+            lease: {
+                owner: driver,
+                expiresAt
+            }
+        });
+        transaction.set(ref, storedJob(next));
+        return next;
+    });
+}
+/**
+ * Writes chunks until the budget runs out (see the block header). The first
+ * call needs every required acknowledgement; later calls — the browser's
+ * next, or the sweep's — resume at the cursor. A plugin `apply` that throws
+ * fails the job with the chunk named, and calling again resumes it.
+ */ export async function applyTransferJob(deps, input) {
+    var _ref, _input_acknowledged, _ref1, _job_chunkCount;
+    var _job_cursor;
+    let job = await readJob(deps, input.orgId, input.jobId);
+    if (job.status === 'applied') {
+        return {
+            job,
+            progress: transferJobProgress(job),
+            done: true,
+            started: false,
+            resumed: false,
+            results: []
+        };
+    }
+    if (job.status !== 'planned' && job.status !== 'applying' && job.status !== 'failed') {
+        throw new TransferEngineError('state', 409, `This import is ${job.status}; plan it before applying.`);
+    }
+    if (job.plannedAt === undefined || !job.summary) {
+        throw new TransferEngineError('state', 409, 'This import has no dry run yet.');
+    }
+    const acknowledged = [
+        ...(_ref = (_input_acknowledged = input.acknowledged) != null ? _input_acknowledged : job.acknowledged) != null ? _ref : []
+    ];
+    if (job.applyStartedAt === undefined) {
+        var _job_acknowledgementsRequired;
+        const plan = {
+            acknowledgementsRequired: (_job_acknowledgementsRequired = job.acknowledgementsRequired) != null ? _job_acknowledgementsRequired : [],
+            summary: job.summary
+        };
+        if (!canApplyTransferPlan(plan, acknowledged)) {
+            const missing = missingAcknowledgements(plan, acknowledged);
+            if (!missing.length) throw new TransferEngineError('state', 409, 'The dry run writes nothing.');
+            throw new TransferEngineError('acknowledgementsMissing', 422, 'Acknowledge every warning before applying.', {
+                missing
+            });
+        }
+    }
+    const resource = await resolveResource(deps, job.resource);
+    const hooks = transferRecordsHooks(resource);
+    const ctx = contextFor(job, input.actorUid);
+    let started = false;
+    let resumed = false;
+    job = await takeLease(deps, job, input.driver, input.deadlineMs + TRANSFER_LEASE_GRACE_MS, (current, now)=>{
+        var _current_cursor, _current_applyStartedAt, _current_results;
+        if (current.status === 'applying') return current;
+        started = true;
+        resumed = current.status === 'failed';
+        return moveJob(current, 'applying', now, {
+            acknowledged: current.applyStartedAt === undefined ? acknowledged : current.acknowledged,
+            cursor: (_current_cursor = current.cursor) != null ? _current_cursor : {
+                chunk: 0,
+                rowsDone: 0
+            },
+            applyStartedAt: (_current_applyStartedAt = current.applyStartedAt) != null ? _current_applyStartedAt : now,
+            results: (_current_results = current.results) != null ? _current_results : emptyResults()
+        });
+    });
+    const jobRef = transferJobsCollection(deps.firestore, job.orgId).doc(job.id);
+    const timeLeft = ()=>input.deadlineMs - clock(deps);
+    const written = [];
+    try {
+        var _job_chunkCount1, _ref2;
+        var _job_cursor1;
+        if (!job.picklistsAdded) {
+            var _job_picklistAdditions;
+            for (const [picklistId, values] of Object.entries((_job_picklistAdditions = job.picklistAdditions) != null ? _job_picklistAdditions : {})){
+                if (values.length) await (hooks.addPicklistValues == null ? void 0 : hooks.addPicklistValues.call(hooks, ctx, picklistId, values));
+            }
+            job = _extends({}, job, {
+                picklistsAdded: true,
+                updatedAt: clock(deps)
+            });
+            await saveJob(deps, job);
+        }
+        const chunkCount = (_job_chunkCount1 = job.chunkCount) != null ? _job_chunkCount1 : 0;
+        while(((_ref2 = (_job_cursor1 = job.cursor) == null ? void 0 : _job_cursor1.chunk) != null ? _ref2 : 0) < chunkCount && timeLeft() > TRANSFER_MIN_CHUNK_BUDGET_MS){
+            const next = await applyChunk(deps, job, jobRef, hooks, ctx, timeLeft);
+            if (!next) break;
+            job = next.job;
+            written.push(...next.results);
+        }
+    } catch (error) {
+        var _ref3;
+        var _job_cursor2;
+        const chunk = (_ref3 = (_job_cursor2 = job.cursor) == null ? void 0 : _job_cursor2.chunk) != null ? _ref3 : 0;
+        const message = error instanceof Error ? error.message : String(error);
+        job = moveJob(job, 'failed', clock(deps), {
+            error: {
+                code: 'applyFailed',
+                message: `Chunk ${chunk + 1} could not be written: ${message}`,
+                chunk
+            },
+            lease: null
+        });
+        await saveJob(deps, job);
+        return {
+            job,
+            progress: transferJobProgress(job),
+            done: false,
+            started,
+            resumed,
+            results: written
+        };
+    }
+    const done = ((_ref1 = (_job_cursor = job.cursor) == null ? void 0 : _job_cursor.chunk) != null ? _ref1 : 0) >= ((_job_chunkCount = job.chunkCount) != null ? _job_chunkCount : 0);
+    job = done ? moveJob(job, 'applied', clock(deps), {
+        lease: null
+    }) : _extends({}, job, {
+        lease: null,
+        updatedAt: clock(deps)
+    });
+    await saveJob(deps, job);
+    return {
+        job,
+        progress: transferJobProgress(job),
+        done,
+        started,
+        resumed,
+        results: written
+    };
+}
+/**
+ * One chunk, through the plugin's `apply` and the ledger. Answers the job
+ * with the cursor moved past the chunk and the chunk's results, or `null`
+ * when the chunk is not complete yet (the budget ran short and the plugin
+ * stopped at a row).
+ */ async function applyChunk(deps, job, jobRef, hooks, ctx, timeLeft) {
+    var _ref, _job_results;
+    var _job_cursor;
+    const index = (_ref = (_job_cursor = job.cursor) == null ? void 0 : _job_cursor.chunk) != null ? _ref : 0;
+    const chunk = await readChunkRows(jobRef, index);
+    if (!chunk) throw new Error(`the dry run has no chunk ${index + 1}`);
+    const ledgerCollection = jobRef.collection('ledger');
+    const ledger = new Map();
+    for (const doc of (await ledgerCollection.where('chunk', '==', index).get()).docs){
+        const data = doc.data();
+        ledger.set(data.row, {
+            result: data.result,
+            undo: data.undoJson ? JSON.parse(data.undoJson) : null
+        });
+    }
+    const writer = {
+        async alreadyApplied (row) {
+            var _ref;
+            var _ledger_get;
+            return (_ref = (_ledger_get = ledger.get(row)) == null ? void 0 : _ledger_get.result) != null ? _ref : null;
+        },
+        async markApplied (result, undo) {
+            if (ledger.has(result.row)) return;
+            try {
+                await ledgerCollection.doc(transferLedgerKey(job.id, result.row)).create(stored({
+                    row: result.row,
+                    chunk: index,
+                    result,
+                    undoJson: undo ? JSON.stringify(undo) : null,
+                    at: clock(deps)
+                }));
+            } catch (error) {
+                if (!isAlreadyExists(error)) throw error;
+            }
+            ledger.set(result.row, {
+                result,
+                undo: undo != null ? undo : null
+            });
+        },
+        timeLeftMs: timeLeft
+    };
+    const writes = chunk.rows.filter((row)=>row.verdict === 'create' || row.verdict === 'update');
+    if (writes.some((row)=>!ledger.has(row.index))) {
+        const applied = await hooks.apply(ctx, {
+            jobId: job.id,
+            index,
+            start: chunk.range.start,
+            end: chunk.range.end,
+            rows: writes
+        }, writer);
+        const planned = new Set(writes.map((row)=>row.index));
+        for (const result of applied.results){
+            if (!planned.has(result.row) || ledger.has(result.row)) continue;
+            await writer.markApplied(result, applied.undo.find((entry)=>entry.row === result.row));
+        }
+    }
+    if (writes.some((row)=>!ledger.has(row.index))) return null;
+    const results = chunk.rows.map((row)=>row.verdict === 'create' || row.verdict === 'update' ? ledger.get(row.index).result : plannedResult(row));
+    const undo = writes.map((row)=>{
+        var _ref;
+        var _ledger_get;
+        return (_ref = (_ledger_get = ledger.get(row.index)) == null ? void 0 : _ledger_get.undo) != null ? _ref : null;
+    }).filter((entry)=>entry !== null);
+    const now = clock(deps);
+    const next = _extends({}, job, {
+        cursor: {
+            chunk: index + 1,
+            rowsDone: chunk.range.end
+        },
+        results: addResults((_job_results = job.results) != null ? _job_results : emptyResults(), summarizeTransferResults(results)),
+        updatedAt: now
+    });
+    const undoJson = JSON.stringify(undo);
+    const batch = deps.firestore.batch();
+    batch.set(jobRef.collection('results').doc(String(index)), stored({
+        jobId: job.id,
+        index,
+        results,
+        completedAt: now
+    }));
+    if (undoJson.length <= JSON_PIECE_CHARS) {
+        batch.set(jobRef.collection('undo').doc(String(index)), {
+            jobId: job.id,
+            chunk: index,
+            json: undoJson
+        });
+    }
+    batch.set(jobRef, storedJob(next));
+    if (undoJson.length > JSON_PIECE_CHARS) {
+        // Too large for the batch: the undo snapshot is written whole first, so
+        // the cursor never moves past a chunk whose undo is missing.
+        await writeJsonDoc(jobRef.collection('undo').doc(String(index)), {
+            jobId: job.id,
+            chunk: index
+        }, undo);
+    }
+    await batch.commit();
+    // The ledger has done its work once the results are committed.
+    const entries = (await ledgerCollection.where('chunk', '==', index).get()).docs;
+    await eachLimited(entries, TRANSFER_WRITE_CONCURRENCY, async (doc)=>{
+        await doc.ref.delete();
+    });
+    return {
+        job: next,
+        results
+    };
+}
+/*==========================================
+ * STATUS AND THE RESULT FILE
+ *=========================================*/ /** The job, its progress, and whether undo is open. */ export async function readTransferJobStatus(deps, input) {
+    var _job_undo;
+    var _job_undo1;
+    const job = await readJob(deps, input.orgId, input.jobId);
+    const rows = input.include === 'results' ? [
+        ...(await readResults(transferJobsCollection(deps.firestore, job.orgId).doc(job.id))).values()
+    ].sort((a, b)=>a.row - b.row) : undefined;
+    return _extends({}, rows ? {
+        rows
+    } : {}, {
+        job,
+        progress: transferJobProgress(job),
+        undo: {
+            available: transferUndoAvailable(job, clock(deps)) && ((_job_undo1 = job.undo) == null ? void 0 : _job_undo1.status) !== 'done',
+            expiresAt: transferUndoExpiresAt(job),
+            state: (_job_undo = job.undo) != null ? _job_undo : null
+        }
+    });
+}
+async function readResults(jobRef) {
+    const results = new Map();
+    for (const doc of (await jobRef.collection('results').get()).docs){
+        var _doc_data_results;
+        for (const result of (_doc_data_results = doc.data().results) != null ? _doc_data_results : [])results.set(result.row, result);
+    }
+    return results;
+}
+/**
+ * The result file: every row of the file as it was sent, then what happened
+ * to it, why, and the record it wrote. A row not written yet says `pending`.
+ */ export async function transferResultFile(deps, input) {
+    var _job_fileName;
+    const job = await readJob(deps, input.orgId, input.jobId);
+    if (job.applyStartedAt === undefined) throw new TransferEngineError('state', 409, 'Nothing has been written yet.');
+    if (job.kind === 'package') {
+        const { transferPackageResultFile } = await import("./transfer-packages.js");
+        return transferPackageResultFile(deps, job);
+    }
+    if (job.trimmedAt !== undefined) {
+        throw new TransferEngineError('state', 409, 'The file behind this import was cleared once its undo window closed; its results are still counted.');
+    }
+    const table = await loadTable(deps, job);
+    const results = await readResults(transferJobsCollection(deps.firestore, job.orgId).doc(job.id));
+    // Every cell through the one escaper, so a formula the file carried is not
+    // armed again in the copy handed back (a number from a JSON file stays one).
+    const lines = [
+        [
+            ...table.headers,
+            ...TRANSFER_RESULT_COLUMNS
+        ].map((cell)=>escapeCsvCell(cell)).join(',')
+    ];
+    table.rows.forEach((cells, row)=>{
+        var _result_message, _result_recordId;
+        const result = results.get(row);
+        const tail = result ? [
+            result.outcome,
+            (_result_message = result.message) != null ? _result_message : result.reason ? String(result.reason) : '',
+            (_result_recordId = result.recordId) != null ? _result_recordId : ''
+        ] : [
+            'pending',
+            '',
+            ''
+        ];
+        lines.push([
+            ...table.headers.map((_header, column)=>escapeCsvCell(transferCellText(cells[column]), {
+                    numeric: typeof cells[column] === 'number'
+                })),
+            ...tail.map((cell)=>escapeCsvCell(cell))
+        ].join(','));
+    });
+    const base = ((_job_fileName = job.fileName) != null ? _job_fileName : 'import').replace(/\.[a-z0-9]+$/i, '');
+    return {
+        csv: `${lines.join('\r\n')}\r\n`,
+        rows: table.rows.length,
+        fileName: `${base}-results.csv`
+    };
+}
+/*==========================================
+ * THE HISTORY — the workspace's imports, for the hub (AGL-3535)
+ *=========================================*/ /**
+ * The workspace's imports, newest first, a page at a time, as the hub's
+ * history lists them. Clients cannot read the jobs' subcollections, and
+ * the hub needs more than the job document says — whether undo is still
+ * open, whether the result file can still be made — so the route answers
+ * this. `labels` names each resource; `emailsOf` says who each member is.
+ */ export async function listTransferJobs(deps, input) {
+    var _input_limit;
+    const limit = Math.min(TRANSFER_JOBS_PAGE_MAX, Math.max(1, Math.floor(Number((_input_limit = input.limit) != null ? _input_limit : 20)) || 20));
+    let query = transferJobsCollection(deps.firestore, input.orgId).orderBy('createdAt', 'desc');
+    if (typeof input.after === 'number' && Number.isFinite(input.after)) query = query.where('createdAt', '<', input.after);
+    const snapshot = await query.limit(limit + 1).get();
+    const page = snapshot.docs.slice(0, limit).map((doc)=>_extends({}, doc.data(), {
+            id: doc.id
+        }));
+    const uids = [
+        ...new Set(page.map((job)=>job.createdBy).filter(Boolean))
+    ];
+    const emails = input.emailsOf && uids.length ? await input.emailsOf(uids).catch(()=>new Map()) : new Map();
+    const now = clock(deps);
+    const jobs = page.map((job)=>{
+        var _ref, _ref1, _job_hostId, _job_fileName, _emails_get, _job_rowCount, _job_results, _job_appliedAt, _ref2, _ref3;
+        var _input_labels, _input_labels1, _job_undo, _job_undo1, _job_error;
+        return {
+            id: job.id,
+            resource: job.resource,
+            // One instance's job (`data.dataset:<id>`) is named by its resource.
+            label: (_ref = (_ref1 = (_input_labels = input.labels) == null ? void 0 : _input_labels[job.resource]) != null ? _ref1 : (_input_labels1 = input.labels) == null ? void 0 : _input_labels1[parseTransferResourceKey(job.resource).key]) != null ? _ref : job.kind === 'package' ? 'Package' : job.resource,
+            kind: job.kind,
+            status: job.status,
+            hostId: (_job_hostId = job.hostId) != null ? _job_hostId : null,
+            fileName: (_job_fileName = job.fileName) != null ? _job_fileName : null,
+            createdAt: job.createdAt,
+            updatedAt: job.updatedAt,
+            createdBy: job.createdBy,
+            createdByEmail: (_emails_get = emails.get(job.createdBy)) != null ? _emails_get : null,
+            rowCount: (_job_rowCount = job.rowCount) != null ? _job_rowCount : 0,
+            results: (_job_results = job.results) != null ? _job_results : null,
+            appliedAt: (_job_appliedAt = job.appliedAt) != null ? _job_appliedAt : null,
+            undo: {
+                available: transferUndoAvailable(job, now) && ((_job_undo = job.undo) == null ? void 0 : _job_undo.status) !== 'done',
+                expiresAt: transferUndoExpiresAt(job),
+                status: (_ref2 = (_job_undo1 = job.undo) == null ? void 0 : _job_undo1.status) != null ? _ref2 : null
+            },
+            resultFile: job.applyStartedAt !== undefined && job.trimmedAt === undefined,
+            error: (_ref3 = (_job_error = job.error) == null ? void 0 : _job_error.message) != null ? _ref3 : null
+        };
+    });
+    const last = page[page.length - 1];
+    return {
+        jobs,
+        next: snapshot.docs.length > limit && last ? last.createdAt : null
+    };
+}
+/*==========================================
+ * UNFINISHED IMPORTS (AGL-3549)
+ *
+ * An import the person left before it wrote anything — a tab closed
+ * mid-wizard — is a job whose retention is `expire`: the cleanup deletes it
+ * seven days after it was last touched. Until then the surface that started
+ * it, and the hub, offer it back (`openImport({ jobId })` reopens the
+ * wizard on its step) or throw it away now. Only its own creator's: a
+ * colleague's half-made import is theirs to finish, and a statement of
+ * permission made in it is theirs alone.
+ *=========================================*/ const UNFINISHED_STATUSES = new Set([
+    'draft',
+    'analyzed',
+    'planned',
+    'failed'
+]);
+/**
+ * The caller's unfinished imports of records, newest first — a Firestore
+ * query on `(createdBy, retention, updatedAt ↓)`, never a page of the
+ * history filtered.
+ */ export async function listUnfinishedTransferJobs(deps, input) {
+    const snapshot = await transferJobsCollection(deps.firestore, input.orgId).where('createdBy', '==', input.actorUid).where('retention', '==', 'expire').orderBy('updatedAt', 'desc').limit(TRANSFER_UNFINISHED_IMPORTS_MAX).get();
+    return snapshot.docs.map((doc)=>_extends({}, doc.data(), {
+            id: doc.id
+        })).filter((job)=>job.kind !== 'package' && UNFINISHED_STATUSES.has(job.status)).map((job)=>{
+        var _job_hostId, _job_fileName, _ref, _ref1;
+        var _input_labels, _input_labels1;
+        return {
+            jobId: job.id,
+            resource: job.resource,
+            hostId: (_job_hostId = job.hostId) != null ? _job_hostId : null,
+            fileName: (_job_fileName = job.fileName) != null ? _job_fileName : null,
+            status: job.status,
+            updatedAt: job.updatedAt,
+            label: (_ref = (_ref1 = (_input_labels = input.labels) == null ? void 0 : _input_labels[job.resource]) != null ? _ref1 : (_input_labels1 = input.labels) == null ? void 0 : _input_labels1[parseTransferResourceKey(job.resource).key]) != null ? _ref : job.resource
+        };
+    });
+}
+/**
+ * Throws one of the caller's unfinished imports away now: its job, its
+ * pieces and its file, as the cleanup would a week on. Refused for someone
+ * else's import, and for one that has written anything — that is undone.
+ */ export async function discardTransferJob(deps, input) {
+    var _transferJobRetention;
+    const job = await readJob(deps, input.orgId, input.jobId);
+    if (job.createdBy !== input.actorUid) {
+        throw new TransferEngineError('forbidden', 403, 'Only the person who started an import can discard it.');
+    }
+    if (((_transferJobRetention = transferJobRetention(job)) == null ? void 0 : _transferJobRetention.retention) !== 'expire') {
+        throw new TransferEngineError('state', 409, 'This import has written records; undo it instead of discarding it.');
+    }
+    await expireTransferJob(deps, job);
+}
+/*==========================================
+ * UNDO
+ *=========================================*/ async function readUndoSnapshots(jobRef, chunkCount, from = 0) {
+    const snapshots = [];
+    for(let index = from; index < chunkCount; index += 1){
+        const entries = await readJsonDoc(jobRef.collection('undo').doc(String(index)));
+        snapshots.push({
+            jobId: jobRef.id,
+            chunk: index,
+            entries: entries != null ? entries : []
+        });
+    }
+    return snapshots;
+}
+function assertUndoOpen(job, now) {
+    var _job_undo;
+    if (job.status !== 'applied') throw new TransferEngineError('state', 409, `This import is ${job.status}; only an applied import can be undone.`);
+    if (((_job_undo = job.undo) == null ? void 0 : _job_undo.status) === 'done') throw new TransferEngineError('state', 409, 'This import was already undone.');
+    if (!job.undo && !transferUndoAvailable(job, now)) {
+        throw new TransferEngineError('undoExpired', 410, 'An import can be undone for seven days; this one is older.');
+    }
+}
+/**
+ * What undo would do, writing nothing: every record the import touched,
+ * read as it is now, and planned with the core's `planTransferUndo`. A
+ * record edited since comes back as a conflict, with what it holds now and
+ * what undo would put back, for the person to decide.
+ */ export async function planTransferJobUndo(deps, input) {
+    var _job_chunkCount, _ref, _input_offset, _input_limit;
+    var _job_undo;
+    const job = await readJob(deps, input.orgId, input.jobId);
+    assertUndoOpen(job, clock(deps));
+    const resource = await resolveResource(deps, job.resource);
+    const hooks = transferRecordsHooks(resource);
+    const ctx = contextFor(job, input.actorUid);
+    const jobRef = transferJobsCollection(deps.firestore, job.orgId).doc(job.id);
+    const snapshots = await readUndoSnapshots(jobRef, (_job_chunkCount = job.chunkCount) != null ? _job_chunkCount : 0, (_ref = (_job_undo = job.undo) == null ? void 0 : _job_undo.chunk) != null ? _ref : 0);
+    const entries = snapshots.flatMap((snapshot)=>snapshot.entries);
+    const ids = [
+        ...new Set(entries.map((entry)=>entry.recordId))
+    ];
+    const records = new Map();
+    for(let at = 0; at < ids.length; at += UNDO_LOOKUP_SLICE){
+        const found = await hooks.lookup(ctx, [
+            {
+                fieldId: TRANSFER_ID_FIELD,
+                normalizer: 'aglynId',
+                values: ids.slice(at, at + UNDO_LOOKUP_SLICE)
+            }
+        ]);
+        for (const [id, values] of found.records)records.set(id, values);
+    }
+    const counts = emptyUndoCounts();
+    const conflicts = [];
+    for (const entry of entries){
+        var _records_get;
+        const current = (_records_get = records.get(entry.recordId)) != null ? _records_get : null;
+        const step = planTransferUndo(entry, current);
+        if (step.action === 'conflict') {
+            counts.conflict += 1;
+            const label = transferRowLabel(current);
+            conflicts.push(_extends({
+                row: entry.row,
+                recordId: entry.recordId
+            }, label ? {
+                label
+            } : {}, {
+                action: entry.action,
+                fields: step.fields,
+                current: Object.fromEntries(step.fields.map((fieldId)=>{
+                    var _ref;
+                    return [
+                        fieldId,
+                        (_ref = current == null ? void 0 : current[fieldId]) != null ? _ref : null
+                    ];
+                })),
+                restore: step.values
+            }));
+        } else if (step.action === 'restore') counts.restore += 1;
+        else if (step.action === 'delete') counts.delete += 1;
+        else counts.nothing += 1;
+    }
+    const offset = Math.max(0, Math.floor(Number((_input_offset = input.offset) != null ? _input_offset : 0)) || 0);
+    const limit = Math.min(TRANSFER_UNDO_PAGE_MAX, Math.max(1, Math.floor(Number((_input_limit = input.limit) != null ? _input_limit : 50)) || 50));
+    const page = conflicts.slice(offset, offset + limit);
+    return {
+        job,
+        counts,
+        conflicts: page,
+        offset,
+        next: offset + page.length < conflicts.length ? offset + page.length : null,
+        expiresAt: transferUndoExpiresAt(job)
+    };
+}
+/**
+ * Carries undo out, chunk by chunk, through the plugin's `revert`, each
+ * record with the person's decision (`otherwise` for one the decisions do
+ * not name). Called again until `done`; the last chunk moves the job to
+ * `undone`. Reverting a chunk twice is harmless: a field already restored
+ * plans as nothing.
+ */ export async function applyTransferJobUndo(deps, input) {
+    var _input_decisions, _job_chunkCount, _undo_decisions, _input_decisions1;
+    if (input.otherwise !== 'keep' && input.otherwise !== 'revert') {
+        throw new TransferEngineError('invalid', 400, 'Say what happens to a record edited since the import.');
+    }
+    let job = await readJob(deps, input.orgId, input.jobId);
+    assertUndoOpen(job, clock(deps));
+    const resource = await resolveResource(deps, job.resource);
+    const hooks = transferRecordsHooks(resource);
+    const ctx = contextFor(job, input.actorUid);
+    const decisions = _extends({}, (_input_decisions = input.decisions) != null ? _input_decisions : {});
+    let started = false;
+    job = await takeLease(deps, job, input.driver, input.deadlineMs + TRANSFER_LEASE_GRACE_MS, (current, now)=>{
+        if (current.undo) {
+            return _extends({}, current, {
+                undo: _extends({}, current.undo, {
+                    otherwise: input.otherwise,
+                    decisions: _extends({}, current.undo.decisions, decisions)
+                }),
+                updatedAt: now
+            });
+        }
+        started = true;
+        return _extends({}, current, {
+            updatedAt: now,
+            undo: {
+                status: 'running',
+                chunk: 0,
+                startedAt: now,
+                startedBy: input.actorUid,
+                otherwise: input.otherwise,
+                decisions,
+                counts: emptyUndoCounts()
+            }
+        });
+    });
+    const jobRef = transferJobsCollection(deps.firestore, job.orgId).doc(job.id);
+    const chunkCount = (_job_chunkCount = job.chunkCount) != null ? _job_chunkCount : 0;
+    let undo = job.undo;
+    // The person's decisions, this call's and every earlier call's: a resumed undo decides the same way.
+    Object.assign(decisions, (_undo_decisions = undo.decisions) != null ? _undo_decisions : {}, (_input_decisions1 = input.decisions) != null ? _input_decisions1 : {});
+    try {
+        while(undo.chunk < chunkCount && input.deadlineMs - clock(deps) > TRANSFER_MIN_CHUNK_BUDGET_MS){
+            const [snapshot] = await readUndoSnapshots(jobRef, undo.chunk + 1, undo.chunk);
+            const counts = _extends({}, undo.counts);
+            if (snapshot && snapshot.entries.length) {
+                const chosen = Object.fromEntries(snapshot.entries.map((entry)=>{
+                    var _decisions_entry_recordId;
+                    return [
+                        entry.recordId,
+                        (_decisions_entry_recordId = decisions[entry.recordId]) != null ? _decisions_entry_recordId : input.otherwise
+                    ];
+                }));
+                const reverted = await hooks.revert(ctx, snapshot, chosen);
+                for (const step of reverted.done)counts[step.action] += 1;
+                counts.conflict += reverted.conflicts.length;
+            }
+            undo = _extends({}, undo, {
+                chunk: undo.chunk + 1,
+                counts
+            });
+            job = _extends({}, job, {
+                undo,
+                updatedAt: clock(deps)
+            });
+            await saveJob(deps, job);
+        }
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        job = _extends({}, job, {
+            lease: null,
+            updatedAt: clock(deps),
+            error: {
+                code: 'undoFailed',
+                message,
+                chunk: undo.chunk
+            }
+        });
+        await saveJob(deps, job);
+        throw new TransferEngineError('failed', 500, `Undo stopped at chunk ${undo.chunk + 1}: ${message}. Try again to continue.`);
+    }
+    const done = undo.chunk >= chunkCount;
+    if (done) {
+        undo = _extends({}, undo, {
+            status: 'done'
+        });
+        job = moveJob(_extends({}, job, {
+            undo
+        }), 'undone', clock(deps), {
+            lease: null
+        });
+    } else {
+        job = _extends({}, job, {
+            lease: null,
+            updatedAt: clock(deps)
+        });
+    }
+    await saveJob(deps, job);
+    return {
+        job,
+        undo,
+        done,
+        started
+    };
+}
+/*==========================================
+ * THE SWEEP — what a closed tab left behind, and what has outlived its use
+ *
+ *  - an import left `applying`, or an undo left running, untouched for
+ *    {@link TRANSFER_STALE_MS}: resumed through the same engine, under the
+ *    sweep's lease (undo with the person's stored decisions);
+ *  - a job that never wrote, untouched for seven days
+ *    (`TRANSFER_DRAFT_RETENTION_MS`): deleted with its subcollections and
+ *    its file;
+ *  - a job that wrote, once its seven-day undo window has closed: its dry
+ *    run, undo snapshots, ledger and file are cleared, and the job and its
+ *    per-row results kept (`trimmedAt`).
+ *
+ * The last two are found by the `retention` and `retainUntil` every job
+ * write stamps (`transferJobRetention`), so a trimmed job never matches
+ * again.
+ *=========================================*/ /** The most jobs one sweep expires or trims. */ const CLEANUP_LIMIT = 50;
+/** Deletes a Storage object, if it is there. */ async function deleteObject(deps, path) {
+    await deps.bucket.file(path).delete({
+        ignoreNotFound: true
+    });
+}
+/** The job's stored file and any parts still waiting for the rest. */ async function deleteSourceFiles(deps, job) {
+    var _ref;
+    var _job_upload;
+    await deleteObject(deps, transferSourcePath(job.orgId, job.id));
+    const parts = (_ref = (_job_upload = job.upload) == null ? void 0 : _job_upload.parts) != null ? _ref : 0;
+    await eachLimited(Array.from({
+        length: parts > 1 ? parts : 0
+    }, (_unused, index)=>index), TRANSFER_WRITE_CONCURRENCY, async (index)=>deleteObject(deps, transferPartPath(job.orgId, job.id, index)));
+}
+/** A job that never wrote, gone: its subcollections, its file, then the job. */ export async function expireTransferJob(deps, job) {
+    const jobRef = transferJobsCollection(deps.firestore, job.orgId).doc(job.id);
+    for (const name of [
+        'chunks',
+        'ledger',
+        'results',
+        'undo'
+    ])await clearCollection(jobRef.collection(name));
+    await deleteSourceFiles(deps, job);
+    await jobRef.delete();
+}
+/** A job past its undo window, kept as the job and its results: the dry run, undo snapshots, ledger and file cleared. */ export async function trimTransferJob(deps, job) {
+    const jobRef = transferJobsCollection(deps.firestore, job.orgId).doc(job.id);
+    for (const name of [
+        'chunks',
+        'ledger',
+        'undo'
+    ])await clearCollection(jobRef.collection(name));
+    await deleteSourceFiles(deps, job);
+    const trimmed = _extends({}, job, {
+        trimmedAt: clock(deps)
+    });
+    delete trimmed.sourcePath;
+    await saveJob(deps, trimmed);
+    return trimmed;
+}
+function jobOf(doc) {
+    var _ref, _ref1;
+    var _doc_ref_parent_parent, _doc_ref_parent_parent1;
+    const job = _extends({}, doc.data(), {
+        id: doc.id
+    });
+    return {
+        orgId: (_ref = (_doc_ref_parent_parent = doc.ref.parent.parent) == null ? void 0 : _doc_ref_parent_parent.id) != null ? _ref : job.orgId,
+        job: _extends({}, job, {
+            orgId: (_ref1 = (_doc_ref_parent_parent1 = doc.ref.parent.parent) == null ? void 0 : _doc_ref_parent_parent1.id) != null ? _ref1 : job.orgId
+        })
+    };
+}
+/**
+ * The sweep (see the block header). Each resume runs under the sweep's
+ * lease until the budget is spent; the ledger makes overlapping with a
+ * returning browser harmless. `dryRun` lists what it would do and does
+ * nothing.
+ */ export async function sweepAbandonedTransferJobs(deps, input) {
+    var _input_staleMs, _input_limit, _input_limit1;
+    const now = clock(deps);
+    const stale = now - ((_input_staleMs = input.staleMs) != null ? _input_staleMs : TRANSFER_STALE_MS);
+    const jobs = deps.firestore.collectionGroup(TRANSFER_JOBS_COLLECTION);
+    const budgetLeft = ()=>input.deadlineMs - clock(deps) > TRANSFER_MIN_CHUNK_BUDGET_MS;
+    const snapshot = await jobs.where('status', '==', 'applying').where('updatedAt', '<=', stale).orderBy('updatedAt', 'asc').limit((_input_limit = input.limit) != null ? _input_limit : 10).get();
+    const outcome = {
+        found: snapshot.docs.length,
+        resumed: [],
+        skipped: [],
+        undone: [],
+        expired: [],
+        trimmed: []
+    };
+    for (const doc of snapshot.docs){
+        const { orgId, job } = jobOf(doc);
+        if (input.dryRun) {
+            outcome.skipped.push({
+                orgId,
+                jobId: doc.id,
+                reason: 'dryRun'
+            });
+            continue;
+        }
+        if (!budgetLeft()) {
+            outcome.skipped.push({
+                orgId,
+                jobId: doc.id,
+                reason: 'budget'
+            });
+            continue;
+        }
+        try {
+            const resume = {
+                orgId,
+                jobId: doc.id,
+                actorUid: job.createdBy,
+                deadlineMs: input.deadlineMs,
+                driver: `sweep:${doc.id}`
+            };
+            // A workspace package is resumed by its own engine, under the same lease and ledger.
+            const applied = job.kind === 'package' ? await (await import("./transfer-packages.js")).applyTransferPackage(deps, resume) : await applyTransferJob(deps, resume);
+            outcome.resumed.push({
+                orgId,
+                jobId: doc.id,
+                status: applied.job.status,
+                done: applied.done
+            });
+        } catch (error) {
+            outcome.skipped.push({
+                orgId,
+                jobId: doc.id,
+                reason: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    // An undo the browser left part-way, finished with the person's own decisions.
+    const undoing = await jobs.where('undo.status', '==', 'running').where('updatedAt', '<=', stale).orderBy('updatedAt', 'asc').limit((_input_limit1 = input.limit) != null ? _input_limit1 : 10).get();
+    for (const doc of undoing.docs){
+        const { orgId, job } = jobOf(doc);
+        if (input.dryRun || !budgetLeft() || !job.undo) {
+            outcome.skipped.push({
+                orgId,
+                jobId: doc.id,
+                reason: input.dryRun ? 'dryRun' : 'budget'
+            });
+            continue;
+        }
+        try {
+            var _job_undo_decisions;
+            const finish = {
+                orgId,
+                jobId: doc.id,
+                actorUid: job.undo.startedBy,
+                decisions: (_job_undo_decisions = job.undo.decisions) != null ? _job_undo_decisions : {},
+                otherwise: job.undo.otherwise,
+                deadlineMs: input.deadlineMs,
+                driver: `sweep-undo:${doc.id}`
+            };
+            const undone = job.kind === 'package' ? await (await import("./transfer-packages.js")).applyTransferPackageUndo(deps, finish) : await applyTransferJobUndo(deps, finish);
+            outcome.undone.push({
+                orgId,
+                jobId: doc.id,
+                done: undone.done
+            });
+        } catch (error) {
+            outcome.skipped.push({
+                orgId,
+                jobId: doc.id,
+                reason: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    // What has outlived its use: drafts that never wrote, and applied jobs past their undo window.
+    for (const retention of [
+        'expire',
+        'trim'
+    ]){
+        const due = await jobs.where('retention', '==', retention).where('retainUntil', '<=', now).orderBy('retainUntil', 'asc').limit(CLEANUP_LIMIT).get();
+        for (const doc of due.docs){
+            const { orgId } = jobOf(doc);
+            if (input.dryRun || !budgetLeft()) {
+                outcome.skipped.push({
+                    orgId,
+                    jobId: doc.id,
+                    reason: input.dryRun ? 'dryRun' : 'budget'
+                });
+                continue;
+            }
+            // Read again: the job may have moved on since the query, and is decided as it is now.
+            const current = await readJob(deps, orgId, doc.id).catch(()=>null);
+            const verdict = current ? transferJobRetention(current) : null;
+            if (!current || !verdict || verdict.retention !== retention || verdict.retainUntil > clock(deps)) continue;
+            try {
+                if (retention === 'expire') {
+                    await expireTransferJob(deps, current);
+                    outcome.expired.push({
+                        orgId,
+                        jobId: doc.id
+                    });
+                } else {
+                    await trimTransferJob(deps, current);
+                    outcome.trimmed.push({
+                        orgId,
+                        jobId: doc.id
+                    });
+                }
+            } catch (error) {
+                outcome.skipped.push({
+                    orgId,
+                    jobId: doc.id,
+                    reason: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+    }
+    return outcome;
+}
+
+//# sourceMappingURL=transfer-jobs.js.map