@aglyn/plugins-redirects 1.0.0-beta.221 → 1.0.0-beta.223

package/src/lib/transfer/redirects-transfer.js

@@ -0,0 +1,986 @@
+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.
+ */ import { createResourceUid } from "@aglyn/aglyn/app-utils/create-resource-uid";
+import { TENANT_APEX } from "@aglyn/aglyn/app-utils/tenant-apex";
+import { hostRoleCanPublish, hostRoleCanWrite } from "@aglyn/aglyn/app-utils/organizations";
+import { checkEntitlement, checkQuota } from "@aglyn/aglyn/app-utils/plan-entitlements";
+import { ACKNOWLEDGED_WARNING_CLASSES, TRANSFER_ID_FIELD, TRANSFER_WARNING_CLASSES, buildTransferPlan, isBlankTransferValue, matchLookupKey, planTransferUndo, transferValuesEqual, withTransferResourceFindings } from "@aglyn/aglyn/data-transfer";
+import { pluginHostResource } from "@aglyn/aglyn/plugin-manager/plugin-host-resources";
+import { dropPluginSiteCache } from "@aglyn/aglyn/plugin-manager/plugin-site-cache";
+import { FieldPath, FieldValue, Timestamp } from "firebase-admin/firestore";
+import { REDIRECT_DEFAULT_PRIORITY, REDIRECT_STATUS_CODES, findDuplicateRedirect, isExternalRedirectDestination, isSelfRedirect, normalizeRedirectDestination, normalizeRedirectSource, redirectHitKey, redirectSourceIsLivePage, validateRedirectRule, walkRedirectChain } from "../model/redirects.js";
+import { REDIRECTS_ALIAS_DICTIONARIES, REDIRECTS_DEFAULT_POLICY, REDIRECTS_MATCH_KEYS, REDIRECT_FIELD, REDIRECT_HOST_RESOURCE_KIND, REDIRECT_WRITABLE_FIELDS, canonicalRedirectKind, redirectValuesEqual, redirectsTransferCatalog } from "./redirects-transfer-fields.js";
+/** How long before the chunk's budget runs out a row is not started. */ const ROW_RESERVE_MS = 2000;
+/** The most rows one export page reads. */ const PAGE_SIZE_DEFAULT = 500;
+const PAGE_SIZE_MAX = 1000;
+/** Values one `in` query may name. */ const IN_QUERY_MAX = 30;
+/** Documents one `getAll` reads. */ const GET_ALL_MAX = 100;
+/** Days the hit count sums, as the redirects page does. */ const HIT_DAYS = 30;
+const DAY_MS = 24 * 60 * 60 * 1000;
+function text(value) {
+    return typeof value === 'string' ? value : '';
+}
+/** A stored time as ISO text, or `null`. */ function isoOf(value) {
+    if (value === null || value === undefined) return null;
+    if (typeof value.toMillis === 'function') {
+        return new Date(value.toMillis()).toISOString();
+    }
+    if (value instanceof Date) return value.toISOString();
+    if (typeof value === 'number' && Number.isFinite(value)) return new Date(value).toISOString();
+    return null;
+}
+function validStatusCode(value) {
+    return REDIRECT_STATUS_CODES.includes(value);
+}
+/**
+ * A stored rule's fields as the redirects page reads them into its editor: a
+ * missing mode is exact, a missing priority 100, a status code outside the
+ * four is 302 (as the serve path reads it), and a rule is on unless it says
+ * `false`. The export, the dry run's "before" and undo all read this, so a
+ * file exported and imported back is unchanged.
+ */ export function redirectRuleValues(id, data) {
+    const priority = data['priority'];
+    return {
+        [TRANSFER_ID_FIELD]: id,
+        source: text(data['source']),
+        kind: typeof data['kind'] === 'string' && data['kind'] ? data['kind'] : 'exact',
+        destination: text(data['destination']),
+        statusCode: validStatusCode(data['statusCode']) ? data['statusCode'] : 302,
+        priority: priority !== null && priority !== undefined && Number.isFinite(Number(priority)) ? Number(priority) : REDIRECT_DEFAULT_PRIORITY,
+        enabled: data['enabled'] !== false,
+        [REDIRECT_FIELD.approvedBy]: typeof data[REDIRECT_FIELD.approvedBy] === 'string' && data[REDIRECT_FIELD.approvedBy] ? data[REDIRECT_FIELD.approvedBy] : null,
+        createdAt: isoOf(data['createdAt']),
+        updatedAt: isoOf(data['updatedAt']),
+        createdBy: typeof data['createdBy'] === 'string' ? data['createdBy'] : null,
+        lastHitAt: isoOf(data['lastHitAt'])
+    };
+}
+/** A rule as the whole-set checks read it: as stored, like the page's rows. */ function ruleRow(id, data) {
+    return {
+        $id: id,
+        source: data['source'],
+        destination: data['destination'],
+        kind: data['kind']
+    };
+}
+function isLive(data) {
+    return Boolean(data) && !(data == null ? void 0 : data['deletedAt']);
+}
+/**
+ * The from-path as a rule of `kind` stores it: a pattern trimmed, a path
+ * normalized (lowercase, no trailing slash, no query); `null` when a path
+ * cannot be one.
+ */ function storedSource(kind, source) {
+    if (kind === 'regex') return source.trim() || null;
+    return normalizeRedirectSource(source);
+}
+/** What makes two rules one: their mode and their from-path, as stored. */ function ruleKey(kind, source) {
+    const stored = storedSource(kind, source);
+    return stored === null ? null : `${kind}\u0000${stored}`;
+}
+/** The address a rule answers at, for the site cache: a pattern names no one path, so `/`. */ function announcedPath(rule) {
+    var _rule_kind;
+    const source = text(rule.source);
+    if (((_rule_kind = rule.kind) != null ? _rule_kind : 'exact') === 'regex') return '/';
+    return source.startsWith('/') ? source : null;
+}
+/** The rule a row leaves: what the record held (or the defaults), with the row's changes. */ function finalRule(before, diff) {
+    const values = _extends({}, before != null ? before : {});
+    for (const change of diff)values[change.fieldId] = change.after;
+    return withDefaults(values);
+}
+/**
+ * The six fields with the page's defaults where a value is missing:
+ * exact, 302, priority 100, on.
+ */ function withDefaults(values) {
+    const priority = values['priority'];
+    const kind = canonicalRedirectKind(values['kind']);
+    return {
+        source: text(values['source']),
+        kind: isBlankTransferValue(values['kind']) ? 'exact' : kind != null ? kind : String(values['kind']),
+        destination: text(values['destination']),
+        statusCode: isBlankTransferValue(values['statusCode']) ? 302 : Number(values['statusCode']),
+        priority: priority !== null && priority !== undefined && Number.isFinite(Number(priority)) ? Number(priority) : REDIRECT_DEFAULT_PRIORITY,
+        enabled: values['enabled'] !== false
+    };
+}
+/** The site's own addresses, which a destination may always name. */ function ownDomains(host) {
+    return [
+        typeof host['cname'] === 'string' ? host['cname'] : null,
+        typeof host['subdomain'] === 'string' && host['subdomain'] ? `${host['subdomain']}.${TENANT_APEX}` : null
+    ];
+}
+/**
+ * Why the page would refuse to save this rule, or `null`: an unknown mode, a
+ * from-path or pattern it cannot use, a destination it cannot use or that
+ * wears another company's address, a status code it does not offer, or a
+ * path redirected to itself.
+ */ function ruleProblem(rule, host) {
+    const problem = validateRedirectRule({
+        kind: rule.kind,
+        source: rule.source,
+        destination: rule.destination
+    }, {
+        ownDomains: ownDomains(host)
+    });
+    if (problem) {
+        var _rule_fieldId;
+        const fieldId = problem === 'Unknown match mode' ? REDIRECT_FIELD.kind : /destination/i.test(problem) ? REDIRECT_FIELD.destination : REDIRECT_FIELD.source;
+        return {
+            detail: problem,
+            fieldId,
+            value: String((_rule_fieldId = rule[fieldId]) != null ? _rule_fieldId : '')
+        };
+    }
+    if (!validStatusCode(rule.statusCode)) {
+        return {
+            detail: 'Status codes are 301, 302, 307 or 308',
+            fieldId: REDIRECT_FIELD.statusCode,
+            value: String(rule.statusCode)
+        };
+    }
+    if (rule.kind !== 'regex' && isSelfRedirect({
+        source: rule.source,
+        destination: rule.destination
+    })) {
+        return {
+            detail: 'That would redirect the path to itself',
+            fieldId: REDIRECT_FIELD.destination,
+            value: rule.destination
+        };
+    }
+    return null;
+}
+/** The rule's fields as stored: the page's normalization, and only what the create route's allow-list names. */ function storedFields(rule, allowed) {
+    var _normalizeRedirectSource, _normalizeRedirectDestination;
+    const normalized = {
+        source: rule.kind === 'regex' ? rule.source.trim() : (_normalizeRedirectSource = normalizeRedirectSource(rule.source)) != null ? _normalizeRedirectSource : rule.source,
+        destination: (_normalizeRedirectDestination = normalizeRedirectDestination(rule.destination)) != null ? _normalizeRedirectDestination : rule.destination,
+        statusCode: rule.statusCode,
+        kind: rule.kind,
+        priority: rule.priority,
+        enabled: rule.enabled
+    };
+    return Object.fromEntries(Object.entries(normalized).filter(([key])=>allowed.includes(key)));
+}
+function hostnameOf(destination) {
+    try {
+        return new URL(destination).hostname || destination;
+    } catch (unused) {
+        return destination;
+    }
+}
+function requireHost(ctx) {
+    if (!ctx.hostId) throw new Error('Redirects belong to a site; open the import from the site.');
+    return ctx.hostId;
+}
+/** The redirect kind's declaration, which the create route reads too. */ function redirectDeclaration() {
+    const declared = pluginHostResource(REDIRECT_HOST_RESOURCE_KIND);
+    if (!declared) throw new Error(`The "${REDIRECT_HOST_RESOURCE_KIND}" kind is not declared.`);
+    return declared;
+}
+/** Field ids → values, holding only `fieldIds`. */ function pick(values, fieldIds) {
+    var _values_fieldId;
+    const row = {};
+    for (const fieldId of fieldIds)row[fieldId] = (_values_fieldId = values[fieldId]) != null ? _values_fieldId : null;
+    return row;
+}
+/** Each `size` items of `items`. */ function slices(items, size) {
+    const out = [];
+    for(let at = 0; at < items.length; at += size)out.push(items.slice(at, at + size));
+    return out;
+}
+/**
+ * The plan with every create past `remaining` failed as `planLimit`, counted
+ * after the rows the plugin refused — a refused row takes no slot.
+ */ function withCreateLimit(plan, remaining, limit) {
+    var _ref, _ref1, _ref2, _ref3;
+    if (!Number.isFinite(remaining)) return plan;
+    let creates = 0;
+    const held = [];
+    const rows = plan.rows.map((row)=>{
+        if (row.verdict !== 'create') return row;
+        if (creates < remaining) {
+            creates += 1;
+            return row;
+        }
+        const failed = _extends({}, row, {
+            verdict: 'fail',
+            reason: 'planLimit',
+            diff: [],
+            warnings: row.warnings.includes('planLimit') ? row.warnings : [
+                ...row.warnings,
+                'planLimit'
+            ]
+        });
+        held.push(failed);
+        return failed;
+    });
+    if (!held.length) return plan;
+    const summary = {
+        create: 0,
+        update: 0,
+        unchanged: 0,
+        skip: 0,
+        fail: 0,
+        total: rows.length
+    };
+    for (const row of rows)summary[row.verdict] += 1;
+    const detail = `Your plan includes ${limit} redirects on this site`;
+    const prior = plan.warnings.find((entry)=>entry.class === 'planLimit');
+    const raised = {
+        class: 'planLimit',
+        count: ((_ref = prior == null ? void 0 : prior.count) != null ? _ref : 0) + held.length,
+        rows: ((_ref1 = prior == null ? void 0 : prior.rows) != null ? _ref1 : 0) + held.length,
+        fieldIds: (_ref2 = prior == null ? void 0 : prior.fieldIds) != null ? _ref2 : [],
+        samples: [
+            ...(_ref3 = prior == null ? void 0 : prior.samples) != null ? _ref3 : [],
+            ...held.map((row)=>({
+                    row: row.index,
+                    detail
+                }))
+        ].slice(0, 5),
+        requiresAcknowledgement: ACKNOWLEDGED_WARNING_CLASSES.includes('planLimit')
+    };
+    const warnings = TRANSFER_WARNING_CLASSES.flatMap((entry)=>entry === 'planLimit' ? [
+            raised
+        ] : plan.warnings.filter((warning)=>warning.class === entry));
+    return {
+        rows,
+        summary,
+        warnings,
+        acknowledgementsRequired: warnings.filter((entry)=>entry.requiresAcknowledgement).map((entry)=>entry.class)
+    };
+}
+/*==========================================
+ * MATCHING, DEFAULTS AND SAMENESS (AGL-3548)
+ *=========================================*/ /**
+ * Each row's rule, as the page tells rules apart: a row the engine found by
+ * its id keeps that rule; any other row is the rule of its mode (exact when
+ * the file gives none) at its from-path as stored — so `/blog` names the
+ * exact rule or the prefix rule beside it by the row's mode, never both.
+ * Two rows naming one rule are both matched to it here, and the plan refuses
+ * the later one, saying which row it repeats, rather than holding it back as
+ * a duplicate. `existing` holds every live rule's values by id; running this
+ * over its own outcomes changes nothing.
+ */ export function redirectMatchOutcomes(rows, engine, existing, live) {
+    // Each live rule under its mode and stored from-path.
+    const byKey = new Map();
+    for (const { id, data } of live){
+        var _byKey_get;
+        const key = ruleKey(text(data['kind']) || 'exact', text(data['source']));
+        if (key) byKey.set(key, [
+            ...(_byKey_get = byKey.get(key)) != null ? _byKey_get : [],
+            id
+        ]);
+    }
+    return rows.map((values, at)=>{
+        var _engine_at, _byKey_get;
+        const found = (_engine_at = engine[at]) != null ? _engine_at : {
+            kind: 'new'
+        };
+        const byId = found.kind !== 'new' && found.via.fieldId === TRANSFER_ID_FIELD;
+        const record = found.kind === 'matched' && byId ? existing.get(found.recordId) : undefined;
+        const rowKind = isBlankTransferValue(values['kind']) ? text(record == null ? void 0 : record['kind']) || 'exact' : canonicalRedirectKind(values['kind']);
+        const source = isBlankTransferValue(values['source']) ? text(record == null ? void 0 : record['source']) : text(values['source']);
+        const key = rowKind && source ? ruleKey(rowKind, source) : null;
+        if (byId || !key || !rowKind) return found;
+        const candidates = (_byKey_get = byKey.get(key)) != null ? _byKey_get : [];
+        const via = {
+            fieldId: REDIRECT_FIELD.source,
+            value: storedSource(rowKind, source)
+        };
+        if (!candidates.length) return {
+            kind: 'new'
+        };
+        return candidates.length === 1 ? {
+            kind: 'matched',
+            recordId: candidates[0],
+            via
+        } : {
+            kind: 'ambiguous',
+            recordIds: candidates,
+            via
+        };
+    });
+}
+/*==========================================
+ * THE RESOURCE
+ *=========================================*/ /**
+ * The id a rule an import creates is written under: the job's row, so a
+ * write retried after it landed and before the ledger recorded it finds its
+ * own rule instead of making a second one. Without a job, a fresh resource id.
+ */ export function importedRedirectId(jobId, row) {
+    return jobId ? `${jobId}-${row}` : createResourceUid();
+}
+/**
+ * The redirects resource over `deps.firestore`: `hosts/{hostId}/redirects`,
+ * with every hook the job engine and the export route call. See the block
+ * above for what each write checks.
+ */ export function createRedirectsTransferResource(deps) {
+    var _deps_now, _deps_announcePaths;
+    const now = (_deps_now = deps.now) != null ? _deps_now : ()=>Date.now();
+    const { firestore } = deps;
+    const announce = (_deps_announcePaths = deps.announcePaths) != null ? _deps_announcePaths : async (hostId, paths)=>{
+        await dropPluginSiteCache({
+            hostIds: [
+                hostId
+            ],
+            paths: {
+                [hostId]: [
+                    ...paths
+                ]
+            },
+            reason: 'redirect rules were imported'
+        });
+    };
+    const hostRef = (hostId)=>firestore.collection('hosts').doc(hostId);
+    const rulesOf = (hostId)=>hostRef(hostId).collection('redirects');
+    async function readSite(ctx) {
+        var _ref, _host_memberRoles;
+        const hostId = requireHost(ctx);
+        const [snapshot, org] = await Promise.all([
+            hostRef(hostId).get(),
+            deps.loadOrg(hostId)
+        ]);
+        const host = (_ref = snapshot.exists ? snapshot.data() : null) != null ? _ref : {};
+        const declared = redirectDeclaration();
+        const role = ctx.actorUid ? ((_host_memberRoles = host['memberRoles']) != null ? _host_memberRoles : {})[ctx.actorUid] : undefined;
+        // The route's question, on the route's axis: a kind that is live the
+        // moment it exists needs the publishing role, never just the write role.
+        const roleOk = declared.requiresPublishRole ? hostRoleCanPublish(role) : hostRoleCanWrite(role);
+        // A plan-less workspace resolves as the free plan, which has no redirects.
+        const billing = org != null ? org : {};
+        let refusal = null;
+        if (!snapshot.exists) refusal = 'This site no longer exists.';
+        else if (!roleOk) refusal = 'Importing redirects needs a publishing role on this site — ask an editor or admin';
+        else if (declared.entitlement && !checkEntitlement(billing, declared.entitlement)) {
+            refusal = 'URL redirects are not included in this workspace’s plan — see Billing';
+        }
+        const limit = declared.quotaKey ? checkQuota(billing, declared.quotaKey, 0).limit : Number.POSITIVE_INFINITY;
+        return {
+            hostId,
+            host,
+            org: billing,
+            declared,
+            refusal,
+            limit
+        };
+    }
+    /** Every rule document of the site, soft-deleted ones included. */ async function readAllRules(hostId) {
+        const snapshot = await rulesOf(hostId).get();
+        return snapshot.docs.map((doc)=>({
+                id: doc.id,
+                data: doc.data()
+            }));
+    }
+    async function readByIds(hostId, ids) {
+        const found = new Map();
+        for (const slice of slices([
+            ...new Set(ids)
+        ], GET_ALL_MAX)){
+            if (!slice.length) continue;
+            const snapshots = await firestore.getAll(...slice.map((id)=>rulesOf(hostId).doc(id)));
+            for (const snapshot of snapshots){
+                const data = snapshot.exists ? snapshot.data() : undefined;
+                if (isLive(data)) found.set(snapshot.id, data);
+            }
+        }
+        return found;
+    }
+    /** Each rule's sampled hits over the last thirty days, by its hit key. */ async function readHits(hostId) {
+        const today = now();
+        const refs = Array.from({
+            length: HIT_DAYS
+        }, (_, index)=>hostRef(hostId).collection('analytics').doc(new Date(today - index * DAY_MS).toISOString().slice(0, 10)));
+        const totals = {};
+        for (const snapshot of (await firestore.getAll(...refs))){
+            var _snapshot_data_redirects;
+            if (!snapshot.exists) continue;
+            const day = (_snapshot_data_redirects = snapshot.data()['redirects']) != null ? _snapshot_data_redirects : {};
+            for (const [key, count] of Object.entries(day)){
+                var _totals_key;
+                const value = Number(count);
+                if (Number.isFinite(value)) totals[key] = ((_totals_key = totals[key]) != null ? _totals_key : 0) + value;
+            }
+        }
+        return totals;
+    }
+    function exportRow(id, data, fieldIds, hits) {
+        var _hits_redirectHitKey;
+        const values = redirectRuleValues(id, data);
+        if (hits) values[REDIRECT_FIELD.hits] = (_hits_redirectHitKey = hits[redirectHitKey(id)]) != null ? _hits_redirectHitKey : 0;
+        return pick(values, fieldIds);
+    }
+    const resource = {
+        fields: ()=>redirectsTransferCatalog(),
+        matchKeys: REDIRECTS_MATCH_KEYS,
+        aliases: REDIRECTS_ALIAS_DICTIONARIES,
+        defaultPolicy: REDIRECTS_DEFAULT_POLICY,
+        valuesEqual: redirectValuesEqual,
+        /*
+     * Rows matched as the page tells rules apart (`redirectMatchOutcomes`),
+     * over every live rule of the site — so the Matching step and the
+     * Conflicts step show the rule the dry run will update.
+     */ async match (ctx, input) {
+            const hostId = requireHost(ctx);
+            const live = (await readAllRules(hostId)).filter((entry)=>isLive(entry.data));
+            const existing = new Map(input.records);
+            for (const { id, data } of live)existing.set(id, redirectRuleValues(id, data));
+            const outcomes = redirectMatchOutcomes(input.rows, input.outcomes, existing, live);
+            const records = new Map();
+            for (const outcome of outcomes){
+                const ids = outcome.kind === 'matched' ? [
+                    outcome.recordId
+                ] : outcome.kind === 'ambiguous' ? outcome.recordIds : [];
+                for (const id of ids){
+                    const values = existing.get(id);
+                    if (values && !input.records.has(id)) records.set(id, values);
+                }
+            }
+            return {
+                outcomes,
+                records
+            };
+        },
+        /*
+     * `filter` is not read: the redirects page lists every rule and has no
+     * filter to export by. `scopeTokens` does not narrow either: rules are a
+     * site's, carry no `visibleTo`, and the export route admits a reader to
+     * a site's records only when they reach the site.
+     */ async count (ctx, options) {
+            const hostId = requireHost(ctx);
+            if (options.ids) return (await readByIds(hostId, options.ids)).size;
+            const [all, deleted] = await Promise.all([
+                rulesOf(hostId).count().get(),
+                rulesOf(hostId).where('deletedAt', '!=', null).count().get()
+            ]);
+            return Math.max(0, all.data().count - deleted.data().count);
+        },
+        async readPage (ctx, cursor, fieldIds, options = {}) {
+            var _options_pageSize;
+            const hostId = requireHost(ctx);
+            const size = Math.min(PAGE_SIZE_MAX, Math.max(1, Math.floor((_options_pageSize = options.pageSize) != null ? _options_pageSize : PAGE_SIZE_DEFAULT)));
+            const hits = fieldIds.includes(REDIRECT_FIELD.hits) ? await readHits(hostId) : null;
+            if (options.ids) {
+                // The selection, in the order it was made; the cursor is how far into it.
+                const start = Math.max(0, Number(cursor != null ? cursor : 0) || 0);
+                const ids = options.ids.slice(start, start + size);
+                const found = await readByIds(hostId, ids);
+                const rows = ids.flatMap((id)=>{
+                    const data = found.get(id);
+                    return data ? [
+                        exportRow(id, data, fieldIds, hits)
+                    ] : [];
+                });
+                return {
+                    rows,
+                    next: start + size < options.ids.length ? String(start + size) : null
+                };
+            }
+            // Ordered by document id, the one order every rule has: a rule with no
+            // `source` still exports (the page sorts by source, in the browser).
+            let query = rulesOf(hostId).orderBy(FieldPath.documentId()).limit(size);
+            if (cursor) query = query.startAfter(cursor);
+            const snapshot = await query.get();
+            const rows = snapshot.docs.flatMap((doc)=>{
+                const data = doc.data();
+                return isLive(data) ? [
+                    exportRow(doc.id, data, fieldIds, hits)
+                ] : [];
+            });
+            const last = snapshot.docs[snapshot.docs.length - 1];
+            return {
+                rows,
+                next: snapshot.docs.length === size && last ? last.id : null
+            };
+        },
+        /*
+     * By id, and by from-path: each value is read as the stored form of a
+     * path (normalized) and of a pattern (trimmed), and a rule answers for it
+     * under its own mode. The plan narrows a row's candidates to the row's
+     * mode; this answers every rule the value could mean.
+     */ async lookup (ctx, requests) {
+            const hostId = requireHost(ctx);
+            const lookup = new Map();
+            const records = new Map();
+            const file = (fieldId, value, id)=>{
+                var _lookup_get;
+                const key = matchLookupKey(fieldId, value);
+                const ids = (_lookup_get = lookup.get(key)) != null ? _lookup_get : [];
+                if (!ids.includes(id)) ids.push(id);
+                lookup.set(key, ids);
+            };
+            for (const request of requests){
+                if (request.fieldId === TRANSFER_ID_FIELD) {
+                    const found = await readByIds(hostId, request.values);
+                    for (const [id, data] of found){
+                        file(TRANSFER_ID_FIELD, id, id);
+                        records.set(id, redirectRuleValues(id, data));
+                    }
+                    continue;
+                }
+                if (request.fieldId !== REDIRECT_FIELD.source) continue;
+                const stored = new Set();
+                for (const value of request.values){
+                    for (const form of [
+                        normalizeRedirectSource(value),
+                        value.trim()
+                    ])if (form) stored.add(form);
+                }
+                for (const slice of slices([
+                    ...stored
+                ], IN_QUERY_MAX)){
+                    const snapshot = await rulesOf(hostId).where('source', 'in', slice).get();
+                    for (const doc of snapshot.docs){
+                        const data = doc.data();
+                        if (!isLive(data)) continue;
+                        const kind = typeof data['kind'] === 'string' && data['kind'] ? data['kind'] : 'exact';
+                        const held = storedSource(kind, text(data['source']));
+                        for (const value of request.values){
+                            if (held !== null && storedSource(kind, value) === held) {
+                                file(REDIRECT_FIELD.source, value, doc.id);
+                                records.set(doc.id, redirectRuleValues(doc.id, data));
+                            }
+                        }
+                    }
+                }
+            }
+            return {
+                lookup,
+                records
+            };
+        },
+        async plan (ctx, input) {
+            const site = await readSite(ctx);
+            const documents = await readAllRules(site.hostId);
+            const live = documents.filter((entry)=>isLive(entry.data));
+            const existing = new Map(input.existing);
+            for (const { id, data } of live)existing.set(id, redirectRuleValues(id, data));
+            // The resource's own matching (also the engine's `match` hook, so the
+            // Matching and Conflicts steps showed these outcomes): run again over
+            // the site as read here, which leaves outcomes it made unchanged.
+            const matches = redirectMatchOutcomes(input.rows.map((row)=>row.values), input.matches, existing, live);
+            // The row's values as the page would store them, so the review's
+            // before → after compares like with like, and a new rule shows the
+            // defaults it is created with.
+            const rows = input.rows.map((row, at)=>{
+                const match = matches[at];
+                const record = match.kind === 'matched' ? existing.get(match.recordId) : undefined;
+                const values = _extends({}, row.values);
+                const kind = canonicalRedirectKind(values['kind']);
+                if (kind) values['kind'] = kind;
+                const sourceKind = kind != null ? kind : isBlankTransferValue(values['kind']) ? text(record == null ? void 0 : record['kind']) || 'exact' : null;
+                if (typeof values['source'] === 'string' && sourceKind) {
+                    var _storedSource;
+                    values['source'] = (_storedSource = storedSource(sourceKind, values['source'])) != null ? _storedSource : values['source'].trim();
+                }
+                if (typeof values['destination'] === 'string') {
+                    var _normalizeRedirectDestination;
+                    values['destination'] = (_normalizeRedirectDestination = normalizeRedirectDestination(values['destination'])) != null ? _normalizeRedirectDestination : values['destination'].trim();
+                }
+                if (match.kind === 'new') {
+                    const defaults = {
+                        kind: 'exact',
+                        statusCode: 302,
+                        priority: REDIRECT_DEFAULT_PRIORITY,
+                        enabled: true
+                    };
+                    for (const [fieldId, value] of Object.entries(defaults)){
+                        if (isBlankTransferValue(values[fieldId])) values[fieldId] = value;
+                    }
+                }
+                return _extends({}, row, {
+                    values
+                });
+            });
+            const plan = buildTransferPlan(_extends({}, input, {
+                rows,
+                matches,
+                existing
+            }));
+            const findings = [];
+            const writing = plan.rows.filter((row)=>row.verdict === 'create' || row.verdict === 'update');
+            if (site.refusal) {
+                for (const row of writing)findings.push({
+                    row: row.index,
+                    detail: site.refusal,
+                    refuse: true
+                });
+                return withTransferResourceFindings(plan, findings);
+            }
+            // What the page refuses about a rule on its own.
+            const accepted = [];
+            for (const row of writing){
+                const rule = finalRule(row.recordId ? existing.get(row.recordId) : null, row.diff);
+                const problem = ruleProblem(rule, site.host);
+                if (problem) {
+                    findings.push(_extends({
+                        row: row.index
+                    }, problem, {
+                        refuse: true
+                    }));
+                    continue;
+                }
+                accepted.push({
+                    row,
+                    rule
+                });
+            }
+            // What the page refuses against the other rules, row by row in file
+            // order over the site as the rows above leave it.
+            const liveRows = new Map(live.map(({ id, data })=>[
+                    id,
+                    ruleRow(id, data)
+                ]));
+            const touched = new Set(accepted.flatMap(({ row })=>row.recordId ? [
+                    row.recordId
+                ] : []));
+            const ruleset = [
+                ...liveRows.values()
+            ].filter((rule)=>!touched.has(rule.$id));
+            const kept = [];
+            const keptByKey = new Map();
+            const keptByRecord = new Map();
+            for (const { row, rule } of accepted){
+                var _row_recordId, _keptByKey_get;
+                const candidate = {
+                    $id: (_row_recordId = row.recordId) != null ? _row_recordId : `row:${row.index}`,
+                    source: rule.source,
+                    destination: rule.destination,
+                    kind: rule.kind
+                };
+                const key = ruleKey(rule.kind, rule.source);
+                const repeated = (_keptByKey_get = keptByKey.get(key)) != null ? _keptByKey_get : row.recordId ? keptByRecord.get(row.recordId) : undefined;
+                let detail = null;
+                if (repeated !== undefined) detail = `Row ${repeated + 1} already redirects ${rule.source}`;
+                else if (findDuplicateRedirect(ruleset, candidate)) detail = `A rule for ${rule.source} already exists`;
+                else if (walkRedirectChain(ruleset, candidate).loop) {
+                    detail = 'That destination chains back to this rule — a redirect loop';
+                }
+                if (detail) {
+                    const fieldId = repeated !== undefined ? REDIRECT_FIELD.source : REDIRECT_FIELD.destination;
+                    findings.push({
+                        row: row.index,
+                        detail,
+                        fieldId,
+                        value: String(rule[fieldId]),
+                        refuse: true
+                    });
+                    // The rule it would have changed stays as it is.
+                    const current = row.recordId ? liveRows.get(row.recordId) : undefined;
+                    if (current) ruleset.push(current);
+                    continue;
+                }
+                ruleset.push(candidate);
+                kept.push({
+                    row,
+                    rule,
+                    candidate
+                });
+                keptByKey.set(key, row.index);
+                if (row.recordId) keptByRecord.set(row.recordId, row.index);
+            }
+            // What a person should know about the rules that will be written, read
+            // over the site as the whole import leaves it.
+            for (const { row, rule, candidate } of kept){
+                const walk = walkRedirectChain(ruleset, candidate);
+                const path = [
+                    rule.destination,
+                    ...walk.hops
+                ].join(' → ');
+                if (walk.loop || walk.cycle) {
+                    findings.push({
+                        row: row.index,
+                        detail: `Leads into a redirect loop: ${path}`,
+                        fieldId: REDIRECT_FIELD.destination,
+                        value: rule.destination
+                    });
+                } else if (walk.hops.length) {
+                    findings.push({
+                        row: row.index,
+                        detail: `Chains through another rule: ${path}`,
+                        fieldId: REDIRECT_FIELD.destination,
+                        value: rule.destination
+                    });
+                }
+                if (isExternalRedirectDestination(rule.destination)) {
+                    findings.push({
+                        row: row.index,
+                        detail: `Sends visitors to ${hostnameOf(rule.destination)}; importing approves it in your name`,
+                        fieldId: REDIRECT_FIELD.destination,
+                        value: rule.destination
+                    });
+                }
+                if (redirectSourceIsLivePage(site.host.screens, rule.source)) {
+                    findings.push({
+                        row: row.index,
+                        detail: `${rule.source} is a published page — the redirect takes precedence`,
+                        fieldId: REDIRECT_FIELD.source,
+                        value: rule.source
+                    });
+                }
+            }
+            // The plan's counter counts every rule document, soft-deleted ones
+            // included, as the create route counts them.
+            const remaining = Math.max(0, site.limit - documents.length);
+            return withCreateLimit(withTransferResourceFindings(plan, findings), remaining, site.limit);
+        },
+        async apply (ctx, chunk, writer) {
+            var _ref;
+            var _site_declared_externalDestination;
+            const site = await readSite(ctx);
+            const actor = ctx.actorUid;
+            const allowed = site.declared.fields;
+            const results = [];
+            const undo = [];
+            const paths = [];
+            const fail = (row, message, reason)=>({
+                    result: _extends({
+                        row: row.index,
+                        outcome: 'failed'
+                    }, row.recordId ? {
+                        recordId: row.recordId
+                    } : {}, reason ? {
+                        reason
+                    } : {}, {
+                        message
+                    }),
+                    entry: undefined
+                });
+            const approvalField = (_ref = (_site_declared_externalDestination = site.declared.externalDestination) == null ? void 0 : _site_declared_externalDestination.approvedByField) != null ? _ref : REDIRECT_FIELD.approvedBy;
+            const stampFor = (destination)=>site.declared.externalDestination && isExternalRedirectDestination(String(destination != null ? destination : '')) ? actor : null;
+            const create = async (row)=>{
+                const rule = finalRule(null, row.diff);
+                const problem = ruleProblem(rule, site.host);
+                if (problem) return fail(row, problem.detail, 'resourceRule');
+                const fields = storedFields(rule, allowed);
+                const stamp = stampFor(fields['destination']);
+                const ref = rulesOf(site.hostId).doc(importedRedirectId(ctx.jobId, row.index));
+                const at = Timestamp.fromMillis(now());
+                // Counted and created in one transaction, as the create route does,
+                // so two imports (or an import and the page) cannot both take the
+                // last slot.
+                const outcome = await firestore.runTransaction(async (tx)=>{
+                    if ((await tx.get(ref)).exists) return {
+                        existed: true
+                    };
+                    if (site.declared.quotaKey && Number.isFinite(site.limit)) {
+                        const used = (await tx.get(rulesOf(site.hostId).count())).data().count;
+                        const quota = checkQuota(site.org, site.declared.quotaKey, used);
+                        if (!quota.allowed) {
+                            return {
+                                refusal: `Your plan includes ${quota.limit} ${site.declared.label} — upgrade in Billing for more`
+                            };
+                        }
+                    }
+                    tx.create(ref, _extends({}, fields, stamp ? {
+                        [approvalField]: stamp
+                    } : {}, {
+                        createdAt: at,
+                        updatedAt: at,
+                        createdBy: actor
+                    }));
+                    return {};
+                });
+                if (outcome.refusal) return fail(row, outcome.refusal, 'planLimit');
+                const written = _extends({}, fields, stamp ? {
+                    [approvalField]: stamp
+                } : {});
+                if (!outcome.existed && deps.logCreated) {
+                    await deps.logCreated(site.hostId, actor, ref.id, site.declared).catch(()=>undefined);
+                }
+                const path = announcedPath(fields);
+                if (path) paths.push(path);
+                const result = {
+                    row: row.index,
+                    outcome: 'created',
+                    recordId: ref.id
+                };
+                const entry = {
+                    row: row.index,
+                    recordId: ref.id,
+                    action: 'created',
+                    written
+                };
+                return {
+                    result,
+                    entry
+                };
+            };
+            const update = async (row)=>{
+                const id = row.recordId;
+                const ref = rulesOf(site.hostId).doc(id);
+                const snapshot = await ref.get();
+                const data = snapshot.exists ? snapshot.data() : undefined;
+                if (!isLive(data)) return fail(row, 'This redirect was deleted after the dry run.', 'matchedRecordMissing');
+                const current = redirectRuleValues(id, data);
+                const rule = finalRule(current, row.diff);
+                const problem = ruleProblem(rule, site.host);
+                if (problem) return fail(row, problem.detail, 'resourceRule');
+                const fields = storedFields(rule, allowed);
+                const stamp = stampFor(fields['destination']);
+                const previous = {};
+                const written = {};
+                for (const fieldId of REDIRECT_WRITABLE_FIELDS){
+                    var _current_fieldId;
+                    if (!(fieldId in fields) || transferValuesEqual(current[fieldId], fields[fieldId])) continue;
+                    previous[fieldId] = (_current_fieldId = current[fieldId]) != null ? _current_fieldId : null;
+                    written[fieldId] = fields[fieldId];
+                }
+                if (!transferValuesEqual(current[approvalField], stamp)) {
+                    var _current_approvalField;
+                    previous[approvalField] = (_current_approvalField = current[approvalField]) != null ? _current_approvalField : null;
+                    written[approvalField] = stamp;
+                }
+                if (!Object.keys(written).length) {
+                    return {
+                        result: {
+                            row: row.index,
+                            outcome: 'unchanged',
+                            recordId: id
+                        },
+                        entry: undefined
+                    };
+                }
+                // The page's edit: every field the form owns, the stamp set or
+                // removed, `updatedAt`, merged so `lastHitAt` and `deletedAt` stay.
+                await ref.set(_extends({}, fields, {
+                    [approvalField]: stamp != null ? stamp : FieldValue.delete(),
+                    updatedAt: Timestamp.fromMillis(now())
+                }), {
+                    merge: true
+                });
+                for (const rulePath of [
+                    announcedPath(fields),
+                    announcedPath({
+                        kind: text(data['kind']),
+                        source: text(data['source'])
+                    })
+                ]){
+                    if (rulePath) paths.push(rulePath);
+                }
+                const result = {
+                    row: row.index,
+                    outcome: 'updated',
+                    recordId: id
+                };
+                const entry = {
+                    row: row.index,
+                    recordId: id,
+                    action: 'updated',
+                    previous,
+                    written
+                };
+                return {
+                    result,
+                    entry
+                };
+            };
+            for (const row of chunk.rows){
+                const before = await writer.alreadyApplied(row.index);
+                if (before) {
+                    results.push(before);
+                    continue;
+                }
+                if (writer.timeLeftMs() < ROW_RESERVE_MS) break;
+                const outcome = site.refusal ? fail(row, site.refusal, 'resourceRule') : row.verdict === 'create' ? await create(row) : await update(row);
+                await writer.markApplied(outcome.result, outcome.entry);
+                results.push(outcome.result);
+                if (outcome.entry) undo.push(outcome.entry);
+            }
+            if (paths.length) await announce(site.hostId, [
+                ...new Set(paths)
+            ]).catch(()=>undefined);
+            return {
+                results,
+                undo
+            };
+        },
+        async revert (ctx, snapshot, decisions) {
+            var _site_host_memberRoles, _ref;
+            var _site_declared_externalDestination;
+            const site = await readSite(ctx);
+            // Undo writes rules too, so it needs the same role; a lapsed plan does
+            // not stop it, since a rule the plan no longer covers is not served.
+            const role = ctx.actorUid ? ((_site_host_memberRoles = site.host['memberRoles']) != null ? _site_host_memberRoles : {})[ctx.actorUid] : undefined;
+            if (!hostRoleCanPublish(role)) {
+                throw new Error('Undoing a redirect import needs a publishing role on this site — ask an editor or admin');
+            }
+            const approvalField = (_ref = (_site_declared_externalDestination = site.declared.externalDestination) == null ? void 0 : _site_declared_externalDestination.approvedByField) != null ? _ref : REDIRECT_FIELD.approvedBy;
+            const done = [];
+            const conflicts = [];
+            const paths = [];
+            for (const entry of snapshot.entries){
+                const ref = rulesOf(site.hostId).doc(entry.recordId);
+                const stored = await ref.get();
+                const data = stored.exists ? stored.data() : undefined;
+                const current = isLive(data) ? redirectRuleValues(entry.recordId, data) : null;
+                const step = planTransferUndo(entry, current);
+                if (step.action === 'conflict' && (decisions == null ? void 0 : decisions[entry.recordId]) !== 'revert') {
+                    if ((decisions == null ? void 0 : decisions[entry.recordId]) === 'keep') {
+                        done.push({
+                            action: 'nothing',
+                            recordId: entry.recordId,
+                            why: 'alreadyReverted'
+                        });
+                    } else conflicts.push(step);
+                    continue;
+                }
+                const before = current ? announcedPath({
+                    kind: String(current['kind']),
+                    source: String(current['source'])
+                }) : null;
+                if (step.action === 'delete' || step.action === 'conflict' && entry.action === 'created') {
+                    await ref.delete();
+                    if (before) paths.push(before);
+                } else if ((step.action === 'restore' || step.action === 'conflict') && current) {
+                    const restored = _extends({}, current, step.values);
+                    const patch = {};
+                    for (const [fieldId, value] of Object.entries(step.values)){
+                        patch[fieldId] = value === null || value === undefined ? FieldValue.delete() : value;
+                    }
+                    // A destination on the site never keeps an approval.
+                    if (!isExternalRedirectDestination(text(restored['destination']))) patch[approvalField] = FieldValue.delete();
+                    patch['updatedAt'] = Timestamp.fromMillis(now());
+                    await ref.set(patch, {
+                        merge: true
+                    });
+                    const after = announcedPath({
+                        kind: String(restored['kind']),
+                        source: String(restored['source'])
+                    });
+                    for (const path of [
+                        before,
+                        after
+                    ])if (path) paths.push(path);
+                }
+                done.push(step);
+            }
+            if (paths.length) await announce(site.hostId, [
+                ...new Set(paths)
+            ]).catch(()=>undefined);
+            return {
+                done,
+                conflicts
+            };
+        }
+    };
+    return resource;
+}
+
+//# sourceMappingURL=redirects-transfer.js.map