@aglyn/aglyn 1.0.0-beta.196 → 1.0.0-beta.197

package/src/lib/app-utils/consent-group-change.js

@@ -0,0 +1,671 @@
+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.
+ */ /**
+ * CHANGING WHICH SITES ARE ONE SENDER (AGL-3320) — the pure half.
+ *
+ * `consent-groups.ts` reads a declaration; this is what a change to one
+ * means. It validates the next declaration an admin submits, decides what has
+ * to move for the sites to stop or start being one sender, and words the
+ * result — and it does all of that without a read, so the console's review
+ * step, the route's refusal and the executor's plan are one computation.
+ *
+ * ## Why a change is a plan and not a write
+ *
+ * A declaration is read at send time, so flipping it is instant — and that is
+ * exactly the problem. Two facts are stored per SITE and read across the
+ * CURRENT group: a refusal (a suppression row, a topic opt-out, a pace, a
+ * declined consent) and a holder's business record (the CRM facet keyed by
+ * the group). When sites stop being one sender, each stops reading the
+ * other's refusals; when they become one, the records they kept apart must
+ * become one. The flip itself moves neither, so every change is:
+ *
+ *  1. CARRY the refusals onto the sites that are about to stop reading them,
+ *     in BOTH directions — the person who left one site of a sender was told
+ *     the opt-out covers all of them, so the site leaving keeps what it
+ *     honored and the sites staying keep what the leaver honored;
+ *  2. FLIP the declaration;
+ *  3. RE-HOME the holder records keyed by the old group ids.
+ *
+ * {@link planConsentGroupChange} says which pairs carry and which holder keys
+ * move or split; the executor in `libs/tenant/data/admin` performs it.
+ *
+ * ## What the planner never touches
+ *
+ * Grants. A grant is written forward, one entry per disclosed site, and is
+ * evidence of what a person was told, so a change never copies, re-keys or
+ * revokes one — see `consent-groups.ts`, "Pooling applies FORWARD only".
+ */ import { consentGroupDisclosure, CONSENT_GROUPS_FIELD, MAX_CONSENT_GROUP_HOSTS, readConsentGroups } from "./consent-groups.js";
+/**
+ * The org field that marks a change in flight:
+ * {@link ConsentGroupsChangeMarker}. Authoritative — the job document holds
+ * the detail, and this says whether there is a job at all.
+ *
+ * On the org document, beside the declaration it guards, so the transaction
+ * that starts a change and the one that flips the declaration read one
+ * document. Server-owned: denied to every client by the rules.
+ */ export const CONSENT_GROUPS_CHANGE_FIELD = 'consentGroupsChange';
+/** `orgs/{orgId}/consentGroupChanges/{changeId}` — one job per change. */ export const CONSENT_GROUP_CHANGES_COLLECTION = 'consentGroupChanges';
+/**
+ * The longest group name a declaration may carry.
+ *
+ * The name is rendered on every signup form of the group, inside a sentence,
+ * so it is a brand and not a description.
+ */ export const CONSENT_GROUP_NAME_MAX = 80;
+/**
+ * How long after the flip the sweep waits before its final pass.
+ *
+ * A long job — a campaign batch, a dynamic list, an outreach tick — resolves
+ * the group once per batch and runs for at most five minutes, so a write it
+ * made against the OLD declaration can land after the flip. Six minutes is
+ * past the longest of them.
+ */ export const CONSENT_GROUP_SWEEP_DELAY_MS = 6 * 60000;
+/**
+ * What every minted group id starts with.
+ *
+ * A group id is a holder key beside the site ids a solo site is keyed by, so
+ * the two must never meet. Firestore's automatic ids — which every site id is
+ * — are alphanumeric, and an underscore cannot occur in one.
+ */ export const CONSENT_GROUP_ID_PREFIX = 'cg_';
+/**
+ * The sites an organization owns, from its `hosts` map, sorted.
+ *
+ * The map is `{ [hostId]: true }`; an array is read too, so a hand-built
+ * fixture and the stored shape agree.
+ */ export function orgSiteIds(org) {
+    const hosts = (org != null ? org : {})['hosts'];
+    const ids = Array.isArray(hosts) ? hosts.map((id)=>String(id != null ? id : '')) : hosts && typeof hosts === 'object' ? Object.entries(hosts).filter(([, value])=>value !== false && value != null).map(([id])=>id) : [];
+    return [
+        ...new Set(ids.map((id)=>id.trim()).filter(Boolean))
+    ].sort();
+}
+/** The raw declaration's ids that `readConsentGroups` drops, sorted. */ export function discardedConsentGroupIds(org) {
+    const raw = (org != null ? org : {})[CONSENT_GROUPS_FIELD];
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return [];
+    const usable = readConsentGroups(org);
+    return Object.keys(raw).filter((id)=>!(id in usable)).sort();
+}
+const BASE36 = '0123456789abcdefghijklmnopqrstuvwxyz';
+/** Uniform in [0, 1), from the platform's CSPRNG where there is one. */ function defaultRandom() {
+    const crypto = globalThis.crypto;
+    if (crypto == null ? void 0 : crypto.getRandomValues) {
+        const word = crypto.getRandomValues(new Uint32Array(1))[0];
+        return word / 2 ** 32;
+    }
+    return Math.random();
+}
+/**
+ * A fresh group id: {@link CONSENT_GROUP_ID_PREFIX} and sixteen base-36
+ * characters, never one in `taken`.
+ *
+ * `taken` holds every id the id must not equal — the current groups', the
+ * raw declaration's, every site's and every id already minted for the same
+ * declaration. Eighty bits make a collision a formality, and the loop makes it
+ * impossible.
+ */ export function mintConsentGroupId(taken, random = defaultRandom) {
+    for(;;){
+        let id = CONSENT_GROUP_ID_PREFIX;
+        for(let index = 0; index < 16; index += 1){
+            id += BASE36[Math.min(35, Math.floor(random() * 36))];
+        }
+        if (!taken.has(id)) return id;
+    }
+}
+/** A group's canonical form: its name trimmed, its sites unique and sorted. */ function canonicalGroup(group) {
+    const value = group && typeof group === 'object' ? group : {};
+    const name = typeof value['name'] === 'string' ? value['name'].trim() : '';
+    const hostIds = Array.isArray(value['hostIds']) ? [
+        ...new Set(value['hostIds'].map((id)=>String(id != null ? id : '').trim()).filter(Boolean))
+    ].sort() : [];
+    return {
+        name,
+        hostIds
+    };
+}
+/**
+ * Whether two declarations say the same thing: the same ids, each with the
+ * same trimmed name and the same set of sites. Order never matters.
+ */ export function consentGroupsEqual(a, b) {
+    return consentGroupsFingerprint(a) === consentGroupsFingerprint(b);
+}
+/**
+ * A declaration as one canonical string: what "the value the editor
+ * rendered" and "the value stored now" are compared by.
+ *
+ * Every entry is kept, usable or not, because the question is whether the
+ * stored value CHANGED, and an edit to an entry `readConsentGroups` drops is
+ * still somebody else's edit. Absent, `null` and `{}` are one value — an
+ * organization with no groups.
+ */ export function consentGroupsFingerprint(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return 'null';
+    const entries = Object.entries(raw).map(([id, group])=>[
+            id,
+            canonicalGroup(group)
+        ]).sort(([a], [b])=>a < b ? -1 : a > b ? 1 : 0);
+    return entries.length ? JSON.stringify(entries) : 'null';
+}
+/**
+ * The next declaration, checked against the organization's sites and the
+ * declaration in force, with an id minted for every new group.
+ *
+ * Refuses everything in the list on {@link ConsentGroupValidationCode}, and
+ * reports every problem it finds rather than the first, so the editor can
+ * mark each draft at once.
+ */ export function validateConsentGroupDeclaration(input) {
+    var _input_reserved;
+    const { before } = input;
+    if (!Array.isArray(input.groups)) {
+        return {
+            ok: false,
+            errors: [
+                {
+                    code: 'malformed'
+                }
+            ]
+        };
+    }
+    const sites = new Set(input.siteIds);
+    const errors = [];
+    const names = new Set();
+    const ids = new Set();
+    const claimed = new Set();
+    const drafts = [];
+    input.groups.forEach((value, groupIndex)=>{
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            errors.push({
+                code: 'malformed',
+                groupIndex
+            });
+            return;
+        }
+        const entry = value;
+        if (typeof entry['name'] !== 'string' || !Array.isArray(entry['hostIds'])) {
+            errors.push({
+                code: 'malformed',
+                groupIndex
+            });
+            return;
+        }
+        const { name, hostIds } = canonicalGroup(entry);
+        if (!name) errors.push({
+            code: 'name-empty',
+            groupIndex
+        });
+        else if (name.length > CONSENT_GROUP_NAME_MAX) {
+            errors.push({
+                code: 'name-too-long',
+                groupIndex
+            });
+        } else if (names.has(name.toLowerCase())) {
+            errors.push({
+                code: 'name-duplicate',
+                groupIndex
+            });
+        }
+        if (name) names.add(name.toLowerCase());
+        for (const hostId of hostIds){
+            if (!sites.has(hostId)) {
+                errors.push({
+                    code: 'unknown-site',
+                    groupIndex,
+                    hostId
+                });
+            } else if (claimed.has(hostId)) {
+                errors.push({
+                    code: 'site-in-two-groups',
+                    groupIndex,
+                    hostId
+                });
+            }
+            claimed.add(hostId);
+        }
+        if (hostIds.length < 2) errors.push({
+            code: 'too-few-sites',
+            groupIndex
+        });
+        else if (hostIds.length > MAX_CONSENT_GROUP_HOSTS) {
+            errors.push({
+                code: 'too-many-sites',
+                groupIndex
+            });
+        }
+        const rawId = entry['id'];
+        const id = typeof rawId === 'string' && rawId.trim() ? rawId.trim() : null;
+        if (id !== null) {
+            if (ids.has(id)) errors.push({
+                code: 'duplicate-group',
+                groupIndex
+            });
+            else if (!(id in before)) errors.push({
+                code: 'unknown-group',
+                groupIndex
+            });
+            else if (!before[id].hostIds.some((hostId)=>hostIds.includes(hostId))) {
+                errors.push({
+                    code: 'group-replaced',
+                    groupIndex
+                });
+            }
+            ids.add(id);
+        }
+        drafts.push({
+            id,
+            name,
+            hostIds
+        });
+    });
+    if (errors.length) return {
+        ok: false,
+        errors
+    };
+    const taken = new Set([
+        ...Object.keys(before),
+        ...input.siteIds,
+        ...(_input_reserved = input.reserved) != null ? _input_reserved : [],
+        ...ids
+    ]);
+    const after = {};
+    for (const draft of drafts){
+        var _draft_id;
+        const id = (_draft_id = draft.id) != null ? _draft_id : mintConsentGroupId(taken, input.random);
+        taken.add(id);
+        after[id] = {
+            name: draft.name,
+            hostIds: draft.hostIds
+        };
+    }
+    if (consentGroupsEqual(before, after)) {
+        return {
+            ok: false,
+            errors: [
+                {
+                    code: 'no-change'
+                }
+            ]
+        };
+    }
+    return {
+        ok: true,
+        after
+    };
+}
+function groupOf(declaration) {
+    const map = new Map();
+    for (const [id, group] of Object.entries(declaration)){
+        for (const hostId of group.hostIds)map.set(hostId, {
+            id,
+            hostIds: group.hostIds
+        });
+    }
+    return map;
+}
+const byString = (a, b)=>a < b ? -1 : a > b ? 1 : 0;
+/** `declaration` without the sites `keep` does not name. */ function withSitesOnly(declaration, keep) {
+    const out = {};
+    for (const [id, group] of Object.entries(declaration)){
+        const hostIds = group.hostIds.filter((hostId)=>keep.has(hostId));
+        if (hostIds.length) out[id] = {
+            name: group.name,
+            hostIds
+        };
+    }
+    return out;
+}
+/**
+ * What moving from `before` to `after` requires.
+ *
+ * `key(s)` is the holder key of site `s` — its group's id, or `s` itself when
+ * it is alone — and `members(s)` the sites of that group, or `[s]`.
+ *
+ *  - **Carries.** For every pair a ≠ b that are one sender now and will not
+ *    be, `b`'s refusals are copied onto `a`. Pairs that stay together, and
+ *    pairs that come together, need nothing: a joined site reads its new
+ *    siblings' refusals the moment the declaration names it.
+ *  - **Holder flows.** For each key `k` in force, the sites it covers map to
+ *    a set `T` of keys afterwards. `T = {k}` needs nothing; one other key is
+ *    a MOVE; anything else is a SPLIT, which `k` survives when it is in `T`.
+ *
+ * `siteIds`, when given, are the sites the organization still owns: a site
+ * named by `before` that is gone neither receives a carry nor takes a copy of
+ * a record, because there is nothing left to hold either.
+ */ export function planConsentGroupChange(before, after, options = {}) {
+    const owned = options.siteIds ? new Set(options.siteIds) : null;
+    const moving = owned ? withSitesOnly(before, owned) : before;
+    const beforeOf = groupOf(moving);
+    const afterOf = groupOf(after);
+    const keyBefore = (hostId)=>{
+        var _ref;
+        var _beforeOf_get;
+        return (_ref = (_beforeOf_get = beforeOf.get(hostId)) == null ? void 0 : _beforeOf_get.id) != null ? _ref : hostId;
+    };
+    const keyAfter = (hostId)=>{
+        var _ref;
+        var _afterOf_get;
+        return (_ref = (_afterOf_get = afterOf.get(hostId)) == null ? void 0 : _afterOf_get.id) != null ? _ref : hostId;
+    };
+    const membersBefore = (hostId)=>{
+        var _ref;
+        var _beforeOf_get;
+        return (_ref = (_beforeOf_get = beforeOf.get(hostId)) == null ? void 0 : _beforeOf_get.hostIds) != null ? _ref : [
+            hostId
+        ];
+    };
+    const membersAfter = (hostId)=>{
+        var _ref;
+        var _afterOf_get;
+        return (_ref = (_afterOf_get = afterOf.get(hostId)) == null ? void 0 : _afterOf_get.hostIds) != null ? _ref : [
+            hostId
+        ];
+    };
+    const sites = [
+        ...new Set([
+            ...Object.values(moving).flatMap((group)=>group.hostIds),
+            ...Object.values(after).flatMap((group)=>group.hostIds)
+        ])
+    ].sort(byString);
+    const carries = [];
+    for (const a of sites){
+        const stays = new Set(membersAfter(a));
+        for (const b of membersBefore(a)){
+            if (b !== a && !stays.has(b)) carries.push({
+                toHostId: a,
+                fromHostId: b
+            });
+        }
+    }
+    const flows = [];
+    const keys = [
+        ...new Set(sites.map(keyBefore))
+    ].sort(byString);
+    for (const key of keys){
+        const covered = sites.filter((hostId)=>keyBefore(hostId) === key);
+        const targets = [
+            ...new Set(covered.map(keyAfter))
+        ].sort(byString);
+        if (targets.length === 1 && targets[0] === key) continue;
+        if (targets.length === 1) {
+            flows.push({
+                kind: 'move',
+                from: key,
+                fromHostIds: covered,
+                to: targets[0],
+                toHostIds: [
+                    ...membersAfter(covered[0])
+                ]
+            });
+            continue;
+        }
+        flows.push({
+            kind: 'split',
+            from: key,
+            fromHostIds: covered,
+            survives: targets.includes(key),
+            stayHostIds: covered.filter((hostId)=>keyAfter(hostId) === key),
+            successors: targets.filter((target)=>target !== key).map((target)=>({
+                    key: target,
+                    hostIds: covered.filter((hostId)=>keyAfter(hostId) === target)
+                }))
+        });
+    }
+    const lines = planLines(before, after);
+    const touched = new Set();
+    const beforeAll = groupOf(before);
+    for (const hostId of new Set([
+        ...beforeAll.keys(),
+        ...afterOf.keys()
+    ])){
+        var _ref, _ref1;
+        var _before_was_id, _after_now_id;
+        const was = beforeAll.get(hostId);
+        const now = afterOf.get(hostId);
+        const sameMembers = ((_ref = was == null ? void 0 : was.hostIds) != null ? _ref : [
+            hostId
+        ]).join('\n') === ((_ref1 = now == null ? void 0 : now.hostIds) != null ? _ref1 : [
+            hostId
+        ]).join('\n');
+        const sameName = !was || !now || ((_before_was_id = before[was.id]) == null ? void 0 : _before_was_id.name) === ((_after_now_id = after[now.id]) == null ? void 0 : _after_now_id.name);
+        if ((was == null ? void 0 : was.id) !== (now == null ? void 0 : now.id) || !sameMembers || !sameName) touched.add(hostId);
+    }
+    return {
+        before,
+        after,
+        carries,
+        flows,
+        lines,
+        hostIds: [
+            ...touched
+        ].sort(byString),
+        renameOnly: !carries.length && !flows.length && lines.length > 0 && lines.every((line)=>line.kind === 'renamed')
+    };
+}
+/** The declaration-level changes, in the order the activity log lists them. */ function planLines(before, after) {
+    const beforeOf = groupOf(before);
+    const afterOf = groupOf(after);
+    const created = [];
+    const renamed = [];
+    const added = [];
+    const removed = [];
+    const moved = [];
+    const dissolved = [];
+    const moveInto = (hostId, toGroupId)=>{
+        const from = beforeOf.get(hostId);
+        if (!from || from.id === toGroupId) return false;
+        moved.push({
+            kind: 'moved',
+            hostId,
+            fromGroupId: from.id,
+            fromName: before[from.id].name,
+            toGroupId,
+            toName: after[toGroupId].name
+        });
+        return true;
+    };
+    for (const id of Object.keys(after).sort(byString)){
+        const next = after[id];
+        const previous = before[id];
+        if (!previous) {
+            created.push({
+                kind: 'created',
+                groupId: id,
+                name: next.name,
+                hostIds: [
+                    ...next.hostIds
+                ]
+            });
+            for (const hostId of next.hostIds)moveInto(hostId, id);
+            continue;
+        }
+        if (previous.name !== next.name) {
+            renamed.push({
+                kind: 'renamed',
+                groupId: id,
+                from: previous.name,
+                to: next.name
+            });
+        }
+        for (const hostId of next.hostIds){
+            if (previous.hostIds.includes(hostId)) continue;
+            if (!moveInto(hostId, id)) {
+                added.push({
+                    kind: 'added',
+                    groupId: id,
+                    name: next.name,
+                    hostId
+                });
+            }
+        }
+        for (const hostId of previous.hostIds){
+            if (next.hostIds.includes(hostId)) continue;
+            // A site that went to another group is that group's `moved` line.
+            if (!afterOf.has(hostId)) {
+                removed.push({
+                    kind: 'removed',
+                    groupId: id,
+                    name: next.name,
+                    hostId
+                });
+            }
+        }
+    }
+    for (const id of Object.keys(before).sort(byString)){
+        if (!(id in after)) dissolved.push({
+            kind: 'dissolved',
+            groupId: id,
+            name: before[id].name
+        });
+    }
+    return [
+        ...created,
+        ...renamed,
+        ...added,
+        ...removed,
+        ...moved,
+        ...dissolved
+    ];
+}
+/**
+ * The sites in a sentence: "A", "A and B", "A, B and C".
+ */ export function listSiteNames(names) {
+    var _names_;
+    if (names.length <= 1) return (_names_ = names[0]) != null ? _names_ : '';
+    return `${names.slice(0, -1).join(', ')} and ${names[names.length - 1]}`;
+}
+/**
+ * One line of the plan as the organization's activity log says it.
+ *
+ * `siteName` turns a site id into what the console shows for it; the id
+ * itself is the fallback, so a line is never blank.
+ */ export function describeConsentGroupChangeLine(line, siteName = (hostId)=>hostId) {
+    const site = (hostId)=>siteName(hostId) || hostId;
+    switch(line.kind){
+        case 'created':
+            return `Created consent group "${line.name}" with ${listSiteNames(line.hostIds.map(site))}`;
+        case 'renamed':
+            return `Renamed consent group "${line.from}" to "${line.to}"`;
+        case 'added':
+            return `Added ${site(line.hostId)} to consent group "${line.name}"`;
+        case 'removed':
+            return `Removed ${site(line.hostId)} from consent group "${line.name}"`;
+        case 'moved':
+            return `Moved ${site(line.hostId)} from consent group "${line.fromName}" to "${line.toName}"`;
+        case 'dissolved':
+            return `Dissolved consent group "${line.name}"`;
+    }
+}
+const PHASES = [
+    'carry',
+    'rehome',
+    'sweep'
+];
+/** The marker off an org document, or `null` when no change is in flight. */ export function readConsentGroupsChange(org) {
+    const raw = (org != null ? org : {})[CONSENT_GROUPS_CHANGE_FIELD];
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+    const value = raw;
+    const changeId = typeof value['changeId'] === 'string' ? value['changeId'] : '';
+    const phase = PHASES.find((candidate)=>candidate === value['phase']);
+    if (!changeId || !phase) return null;
+    const declaredAtMs = Number(value['declaredAtMs']);
+    return _extends({
+        changeId,
+        phase,
+        hostIds: Array.isArray(value['hostIds']) ? value['hostIds'].filter((id)=>typeof id === 'string' && id !== '') : [],
+        startedAtMs: Number(value['startedAtMs']) || 0
+    }, Number.isFinite(declaredAtMs) && declaredAtMs > 0 ? {
+        declaredAtMs
+    } : {});
+}
+/**
+ * Whether the holder records `hostId` reads may be mid-move: a change in
+ * flight has flipped the declaration and names this site.
+ *
+ * A reader that decides something by a record's ABSENCE — a dynamic list
+ * that removes whoever no longer matches — must not decide it while this
+ * holds, because a record that has not moved yet reads as missing.
+ */ export function consentGroupHoldersInMotion(org, hostId) {
+    const marker = readConsentGroupsChange(org);
+    return Boolean(marker && marker.phase !== 'carry' && marker.hostIds.includes(hostId));
+}
+/**
+ * The executor's steps, in order.
+ *
+ *  - `carry` — every carry, then every participant's carry phase.
+ *  - `catch-up-pre` — the refusals filed since the carry began.
+ *  - `declare` — the flip, in one transaction.
+ *  - `catch-up-post` — the same catch-up, for what raced the flip.
+ *  - `rehome` — every participant's holder records.
+ *  - `sweep-wait` — until {@link CONSENT_GROUP_SWEEP_DELAY_MS} has passed.
+ *  - `sweep` — every carry again in full, and every participant's sweep.
+ *  - `finish` — the marker cleared.
+ *
+ * A rename-only change runs `declare` and `finish` alone.
+ */ export const CONSENT_GROUP_CHANGE_STEPS = [
+    'carry',
+    'catch-up-pre',
+    'declare',
+    'catch-up-post',
+    'rehome',
+    'sweep-wait',
+    'sweep',
+    'finish'
+];
+/** The steps a rename-only change runs. */ export const CONSENT_GROUP_RENAME_STEPS = [
+    'declare',
+    'finish'
+];
+/** The marker phase a step runs under. */ export function consentGroupChangePhaseOf(step) {
+    if (step === 'carry' || step === 'catch-up-pre' || step === 'declare') return 'carry';
+    if (step === 'catch-up-post' || step === 'rehome') return 'rehome';
+    return 'sweep';
+}
+/** The work bands behind {@link ConsentGroupChangeEstimate}. */ export function estimateConsentGroupChange(plan, documents) {
+    if (plan.renameOnly) return 'instant';
+    if (documents < 5000) return 'under-a-minute';
+    if (documents < 100000) return 'minutes';
+    return 'long';
+}
+/** The groups whose disclosure sentence differs between the declarations. */ export function consentGroupDisclosureChanges(before, after) {
+    const sentence = (id, group)=>group ? consentGroupDisclosure({
+            hostId: group.hostIds[0],
+            groupId: id,
+            name: group.name,
+            hostIds: group.hostIds,
+            declared: true,
+            awaitsConfirmation: false
+        }) : null;
+    const out = [];
+    for (const id of [
+        ...new Set([
+            ...Object.keys(before),
+            ...Object.keys(after)
+        ])
+    ].sort(byString)){
+        var _after_id;
+        const was = sentence(id, before[id]);
+        const now = sentence(id, after[id]);
+        if (was === now) continue;
+        out.push({
+            groupId: id,
+            hostIds: [
+                ...((_after_id = after[id]) != null ? _after_id : before[id]).hostIds
+            ],
+            before: was,
+            after: now
+        });
+    }
+    return out;
+}
+
+//# sourceMappingURL=consent-group-change.js.map