@oxygen-agent/cli 1.1011.1091 → 1.1012.2

package/node_modules/@oxygen/shared/dist/external-effect-arming.js

@@ -0,0 +1,90 @@
+import { OxygenError } from "./cli-result.js";
+import { isProductionData, resolveDeployEnv } from "./deploy-env.js";
+/**
+ * Which background EXTERNAL EFFECTS each deployment is armed to dispatch, declared
+ * here per environment rather than implied by whichever credentials a box holds.
+ *
+ * OXP-1.6.190 (classify-A P-05). Three background families write outside OXYGEN with
+ * no human in the loop: the off-session Stripe writes of `inbox_billing_reconcile`,
+ * the Zapmail writes of `mailbox_connection_repair`, and the dedicated-egress vendor
+ * release (IPRoyal `toggle-auto-extend`) of the egress order reconcile and lifecycle.
+ * Before this table their arming was implicit: present credentials meant armed.
+ *
+ * Chosen design (coordinator, 2026-10-07, "option 2"): every CURRENT default is kept, so
+ * dev billing reconcile, Zapmail repair and egress releases keep working for dev flows,
+ * but the state is now explicit, reviewable and read back, and two mismatches fail
+ * closed outside production-data environments: a LIVE Stripe key, and a vendor release
+ * whose family is not armed here. Production stays armed; nothing here changes a
+ * production default or touches a secret. A default-off posture outside production
+ * was considered and not chosen, because other dev workflows depend on these effects.
+ *
+ * Changing an entry is a reviewed code change. `OXYGEN_WORKER_MAILBOX_CONNECTION_REPAIR`
+ * remains the existing runtime kill switch for the repair family (`false` disarms it).
+ */
+export const EXTERNAL_EFFECT_FAMILIES = [
+    "inbox_billing_stripe",
+    "mailbox_connection_repair",
+    "egress_vendor_release",
+];
+/** The checked-in declaration, per deploy tier (see `resolveDeployEnv`). */
+export const EXTERNAL_EFFECT_ARMING = {
+    inbox_billing_stripe: { prod: "armed", shadow: "armed", dev: "armed", local: "armed" },
+    mailbox_connection_repair: { prod: "armed", shadow: "armed", dev: "armed", local: "armed" },
+    egress_vendor_release: { prod: "armed", shadow: "armed", dev: "armed", local: "armed" },
+};
+/** Per-family runtime kill switch: an explicit false disarms, nothing arms beyond the declaration. */
+const KILL_SWITCH_ENV = {
+    mailbox_connection_repair: "OXYGEN_WORKER_MAILBOX_CONNECTION_REPAIR",
+};
+function killSwitchDisarms(family, env) {
+    const name = KILL_SWITCH_ENV[family];
+    const raw = name ? env[name]?.trim().toLowerCase() : undefined;
+    // Exactly the worker's readBooleanEnv falsy set, so the readback and the gate agree.
+    return raw === "false" || raw === "0" || raw === "no";
+}
+export function resolveExternalEffectArming(family, env = process.env) {
+    const deploy = resolveDeployEnv(env);
+    const declared = EXTERNAL_EFFECT_ARMING[family][deploy.tier];
+    const disarmedByEnv = declared === "armed" && killSwitchDisarms(family, env);
+    return {
+        family,
+        armed: declared === "armed" && !disarmedByEnv,
+        declared,
+        source: disarmedByEnv ? "env" : "declaration",
+        tier: deploy.tier,
+        deploy_env: deploy.label,
+        production_data: isProductionData(env),
+    };
+}
+/** The readback: every family's effective gate for this process. */
+export function describeExternalEffectArming(env = process.env) {
+    return EXTERNAL_EFFECT_FAMILIES.map((family) => resolveExternalEffectArming(family, env));
+}
+/**
+ * Throw before an effect is dispatched when this process is not armed for it.
+ * Production-data environments keep their declared state; the refusal names the
+ * family and environment so a skipped effect is never silent.
+ */
+export function assertExternalEffectArmed(family, env = process.env) {
+    const arming = resolveExternalEffectArming(family, env);
+    if (!arming.armed) {
+        throw new OxygenError("external_effect_not_armed", `${family} is not armed in ${arming.deploy_env} (${arming.source === "env" ? "disarmed by its kill switch" : "declared disarmed"}), so this external effect was not dispatched.`, { details: { family, deploy_env: arming.deploy_env, source: arming.source }, exitCode: 1 });
+    }
+    return arming;
+}
+/** Live-mode Stripe secret or restricted key. Test keys (`sk_test_`/`rk_test_`) never match. */
+export function isLiveStripeKey(key) {
+    const value = key?.trim() ?? "";
+    return value.startsWith("sk_live_") || value.startsWith("rk_live_");
+}
+/**
+ * Fail closed when a process that does NOT hold production data is about to write to
+ * Stripe with a LIVE key: that is a dev or local box pointed at real money. The key is
+ * never echoed; only its mode is named.
+ */
+export function assertStripeKeyMatchesEnvironment(key, env = process.env) {
+    if (!isLiveStripeKey(key) || isProductionData(env))
+        return;
+    const deploy = resolveDeployEnv(env);
+    throw new OxygenError("external_effect_environment_mismatch", `A live-mode Stripe key is configured in ${deploy.label}, which does not hold production data; refusing the Stripe write. Use a test-mode key outside production.`, { details: { family: "inbox_billing_stripe", deploy_env: deploy.label, key_mode: "live" }, exitCode: 1 });
+}

package/node_modules/@oxygen/shared/dist/geo.d.ts

@@ -0,0 +1,247 @@
+export declare const GEO_ENGINES: readonly ["chatgpt", "gemini", "google-ai-mode", "google-ai-overview", "perplexity", "copilot", "claude"];
+export type GeoEngine = (typeof GEO_ENGINES)[number];
+export type GeoMarket = {
+    country: string;
+    language: string;
+};
+export type GeoCompetitor = {
+    name: string;
+    aliases: string[];
+    domains: string[];
+};
+export type GeoProject = GeoCompetitor & {
+    id: string;
+    icp: string;
+    engines: GeoEngine[];
+    markets: GeoMarket[];
+    repetitions: number;
+    schedule: "paused" | "daily" | "weekly";
+    next_run_at: string | null;
+    archived: boolean;
+};
+export type GeoPrompt = {
+    id: string;
+    text: string;
+    topic: string;
+    persona: string;
+    stage: string;
+    source: "hypothesis" | "research" | "customer";
+    evidence_id?: string;
+    enabled: boolean;
+    revision: number;
+};
+export type GeoCitation = {
+    url: string;
+    domain: string;
+    position: number;
+    category: "owned" | "competitor" | "community" | "review" | "editorial" | "other";
+};
+export type GeoMention = {
+    brand: string;
+    present: boolean;
+    evidence: string | null;
+    recommendation_rank: number | null;
+};
+export type GeoMeasurement = {
+    brand: GeoCompetitor;
+    competitors: GeoCompetitor[];
+};
+export type GeoAnswer = {
+    id: string;
+    run_id: string | null;
+    prompt_id: string | null;
+    prompt: string;
+    engine: GeoEngine;
+    provider: string;
+    collection: "consumer" | "import";
+    market: GeoMarket | null;
+    reported_market: GeoMarket | null;
+    captured_at: string;
+    text: string;
+    citations: GeoCitation[];
+    mentions: GeoMention[];
+    fan_out: string[];
+    outcome: "answer" | "no_overview";
+    cost_micros: number;
+    raw: unknown;
+    extraction_version: number;
+    measurement?: GeoMeasurement;
+    cost_basis?: "reported" | "reserved_estimate";
+    prompt_revision?: number;
+    topic?: string;
+};
+export type GeoDocumentKind = "prompt" | "competitor" | "answer" | "evidence" | "opportunity" | "experiment" | "audit";
+export type GeoDocument = {
+    id: string;
+    project_id: string;
+    kind: GeoDocumentKind;
+    data: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+};
+export type GeoRunItem = {
+    id: string;
+    run_id: string;
+    project_id: string;
+    prompt: GeoPrompt;
+    brand: GeoCompetitor;
+    competitors: GeoCompetitor[];
+    engine: GeoEngine;
+    market: GeoMarket;
+    state: "queued" | "submitting" | "collecting" | "succeeded" | "failed" | "uncertain" | "cancelled";
+    provider_task_id: string | null;
+    provider: string;
+    reserved_micros: number;
+    cost_micros: number;
+    error: string | null;
+    attempt: number;
+    terminal_before_dispatch?: boolean;
+    submission_cost_micros?: number | null;
+};
+export declare const GEO_PILOT_CAP_MICROS = 10000000;
+/** The initial release gate is independent of NODE_ENV and protects shadow data. */
+export declare function isGeoEnabled(env?: NodeJS.ProcessEnv): boolean;
+export declare function assertGeoEnabled(env?: NodeJS.ProcessEnv): void;
+export declare function geoDomain(value: string): string | null;
+export declare function analyzeGeoAnswer(text: string, brand: GeoCompetitor, competitors: GeoCompetitor[], urls: string[]): {
+    mentions: GeoMention[];
+    citations: GeoCitation[];
+    measurement: GeoMeasurement;
+};
+/** Exact capture-time configuration, canonicalized for matched comparisons. */
+export declare function geoMeasurementKey(answer: Pick<GeoAnswer, "measurement">): string;
+export declare function summarizeGeoAnswers(answers: GeoAnswer[], brand: string, failedSamples?: number): {
+    successful_samples: number;
+    measurement_contexts: number;
+    failed_samples: number;
+    imported_samples: number;
+    no_overview_samples: number;
+    mentioned_samples: number;
+    visibility: number | null;
+    cited_samples: number;
+    citation_coverage: number | null;
+    share_of_voice: number | null;
+    competitors: {
+        name: string;
+        mentioned_samples: number;
+        share_of_voice: number | null;
+    }[];
+    sources: {
+        domain: string;
+        count: number;
+        category: string;
+        urls: string[];
+    }[];
+};
+/** No fetching or execution: customer wording and citations are evidence only. */
+export declare function parseGeoTranscript(input: string, redactions?: string[]): {
+    messages: {
+        role: "user" | "assistant";
+        text: string;
+    }[];
+    prompts: string[];
+    sources: string[];
+    redacted_text: string;
+};
+/** Compare only common collection cohorts; imports and missing AIOs are excluded. */
+export declare function compareGeoExperiment(before: GeoAnswer[], after: GeoAnswer[], brand: string): {
+    before: {
+        successful_samples: number;
+        measurement_contexts: number;
+        failed_samples: number;
+        imported_samples: number;
+        no_overview_samples: number;
+        mentioned_samples: number;
+        visibility: number | null;
+        cited_samples: number;
+        citation_coverage: number | null;
+        share_of_voice: number | null;
+        competitors: {
+            name: string;
+            mentioned_samples: number;
+            share_of_voice: number | null;
+        }[];
+        sources: {
+            domain: string;
+            count: number;
+            category: string;
+            urls: string[];
+        }[];
+    };
+    after: {
+        successful_samples: number;
+        measurement_contexts: number;
+        failed_samples: number;
+        imported_samples: number;
+        no_overview_samples: number;
+        mentioned_samples: number;
+        visibility: number | null;
+        cited_samples: number;
+        citation_coverage: number | null;
+        share_of_voice: number | null;
+        competitors: {
+            name: string;
+            mentioned_samples: number;
+            share_of_voice: number | null;
+        }[];
+        sources: {
+            domain: string;
+            count: number;
+            category: string;
+            urls: string[];
+        }[];
+    };
+    comparable_cohorts: number;
+    excluded_before: number;
+    excluded_after: number;
+    cohorts: {
+        cohort: any;
+        before: {
+            successful_samples: number;
+            measurement_contexts: number;
+            failed_samples: number;
+            imported_samples: number;
+            no_overview_samples: number;
+            mentioned_samples: number;
+            visibility: number | null;
+            cited_samples: number;
+            citation_coverage: number | null;
+            share_of_voice: number | null;
+            competitors: {
+                name: string;
+                mentioned_samples: number;
+                share_of_voice: number | null;
+            }[];
+            sources: {
+                domain: string;
+                count: number;
+                category: string;
+                urls: string[];
+            }[];
+        };
+        after: {
+            successful_samples: number;
+            measurement_contexts: number;
+            failed_samples: number;
+            imported_samples: number;
+            no_overview_samples: number;
+            mentioned_samples: number;
+            visibility: number | null;
+            cited_samples: number;
+            citation_coverage: number | null;
+            share_of_voice: number | null;
+            competitors: {
+                name: string;
+                mentioned_samples: number;
+                share_of_voice: number | null;
+            }[];
+            sources: {
+                domain: string;
+                count: number;
+                category: string;
+                urls: string[];
+            }[];
+        };
+    }[];
+    interpretation: string;
+};

package/node_modules/@oxygen/shared/dist/geo.js

@@ -0,0 +1,314 @@
+import { OxygenError } from "./cli-result.js";
+import { resolveDeployEnv } from "./deploy-env.js";
+export const GEO_ENGINES = [
+    "chatgpt",
+    "gemini",
+    "google-ai-mode",
+    "google-ai-overview",
+    "perplexity",
+    "copilot",
+    "claude",
+];
+export const GEO_PILOT_CAP_MICROS = 10_000_000;
+/** The initial release gate is independent of NODE_ENV and protects shadow data. */
+export function isGeoEnabled(env = process.env) {
+    return resolveDeployEnv(env).tier === "dev";
+}
+export function assertGeoEnabled(env = process.env) {
+    if (!isGeoEnabled(env))
+        throw new OxygenError("geo_unavailable", "GEO / AEO is available to staff on dev while it is being tested.", { exitCode: 1 });
+}
+export function geoDomain(value) {
+    try {
+        const url = new URL(value.includes("://") ? value : `https://${value}`);
+        if (!["http:", "https:"].includes(url.protocol) ||
+            url.username ||
+            url.password)
+            return null;
+        return url.hostname
+            .toLowerCase()
+            .replace(/^www\./, "")
+            .replace(/\.$/, "");
+    }
+    catch {
+        return null;
+    }
+}
+function matchedTerm(text, term) {
+    const escaped = term.trim().replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    if (!escaped)
+        return -1;
+    const match = new RegExp(`(^|[^\\p{L}\\p{N}])(${escaped})(?=$|[^\\p{L}\\p{N}])`, "iu").exec(text);
+    return match ? match.index + (match[1]?.length ?? 0) : -1;
+}
+export function analyzeGeoAnswer(text, brand, competitors, urls) {
+    const prose = text.replace(/\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/g, (_link, label, url) => {
+        // A domain-only citation label is source attribution, not a recommendation.
+        return label.trim().includes(".") &&
+            geoDomain(label.trim()) === geoDomain(url)
+            ? ""
+            : label;
+    });
+    const subjects = [brand, ...competitors];
+    const mentions = subjects.map((subject) => {
+        const indices = [subject.name, ...subject.aliases, ...subject.domains]
+            .map((term) => matchedTerm(prose, term))
+            .filter((index) => index >= 0);
+        const first = indices.length ? Math.min(...indices) : -1;
+        let rank = null;
+        for (const line of prose.split("\n")) {
+            const list = /^\s*(\d{1,2})[.)]\s+(.+)$/.exec(line);
+            if (list &&
+                [subject.name, ...subject.aliases].some((term) => matchedTerm(list[2] ?? "", term) >= 0)) {
+                rank = Number(list[1]);
+                break;
+            }
+        }
+        return {
+            brand: subject.name,
+            present: first >= 0,
+            evidence: first >= 0 ? prose.slice(Math.max(0, first - 60), first + 180) : null,
+            recommendation_rank: rank,
+        };
+    });
+    const citations = [];
+    const seen = new Set();
+    for (const raw of urls) {
+        try {
+            const url = new URL(raw);
+            const domain = geoDomain(raw);
+            if (!domain)
+                continue;
+            url.hash = "";
+            for (const key of [...url.searchParams.keys()])
+                if (/^(utm_|fbclid|gclid)/i.test(key))
+                    url.searchParams.delete(key);
+            const normalized = url.href;
+            if (seen.has(normalized))
+                continue;
+            seen.add(normalized);
+            const belongs = (subject) => subject.domains.some((d) => {
+                const owned = geoDomain(d);
+                return owned && (domain === owned || domain.endsWith(`.${owned}`));
+            });
+            const category = belongs(brand)
+                ? "owned"
+                : competitors.some(belongs)
+                    ? "competitor"
+                    : /(^|\.)(reddit\.com|linkedin\.com|youtube\.com|quora\.com)$/.test(domain)
+                        ? "community"
+                        : /(^|\.)(g2\.com|capterra\.com|trustpilot\.com)$/.test(domain)
+                            ? "review"
+                            : "other";
+            citations.push({
+                url: normalized,
+                domain,
+                position: citations.length + 1,
+                category,
+            });
+        }
+        catch {
+            /* An invalid provider URL is retained in raw evidence, not made clickable. */
+        }
+    }
+    return {
+        mentions,
+        citations,
+        measurement: structuredClone({ brand, competitors }),
+    };
+}
+/** Exact capture-time configuration, canonicalized for matched comparisons. */
+export function geoMeasurementKey(answer) {
+    if (!answer.measurement)
+        return "unknown";
+    const subject = (value) => ({
+        name: value.name.trim().toLowerCase(),
+        aliases: [
+            ...new Set(value.aliases.map((a) => a.trim().toLowerCase())),
+        ].sort(),
+        domains: [
+            ...new Set(value.domains.map((d) => geoDomain(d) ?? d.toLowerCase())),
+        ].sort(),
+    });
+    return JSON.stringify({
+        brand: subject(answer.measurement.brand),
+        competitors: answer.measurement.competitors
+            .map(subject)
+            .sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b))),
+    });
+}
+export function summarizeGeoAnswers(answers, brand, failedSamples = 0) {
+    const samples = answers.filter((a) => a.collection === "consumer" && a.outcome === "answer");
+    const measurementContexts = new Set(samples.map(geoMeasurementKey)).size;
+    const comparable = measurementContexts <= 1;
+    const brands = new Map();
+    for (const sample of samples) {
+        const presentBrands = new Set(sample.mentions
+            .filter((m) => m.present)
+            .map((m) => m.brand === sample.measurement?.brand.name ? brand : m.brand));
+        for (const name of presentBrands)
+            brands.set(name, (brands.get(name) ?? 0) + 1);
+    }
+    const totalMentions = [...brands.values()].reduce((a, b) => a + b, 0);
+    const present = brands.get(brand) ?? 0;
+    const cited = samples.filter((a) => a.citations.some((c) => c.category === "owned")).length;
+    const sources = new Map();
+    for (const answer of samples)
+        for (const citation of answer.citations) {
+            const source = sources.get(citation.domain) ?? {
+                domain: citation.domain,
+                count: 0,
+                category: citation.category,
+                urls: [],
+            };
+            source.count++;
+            if (!source.urls.includes(citation.url))
+                source.urls.push(citation.url);
+            sources.set(citation.domain, source);
+        }
+    return {
+        successful_samples: samples.length,
+        measurement_contexts: measurementContexts,
+        failed_samples: failedSamples,
+        imported_samples: answers.filter((a) => a.collection === "import").length,
+        no_overview_samples: answers.filter((a) => a.outcome === "no_overview")
+            .length,
+        mentioned_samples: present,
+        visibility: comparable && samples.length ? present / samples.length : null,
+        cited_samples: cited,
+        citation_coverage: comparable && samples.length ? cited / samples.length : null,
+        share_of_voice: comparable && totalMentions ? present / totalMentions : null,
+        competitors: [...brands].map(([name, count]) => ({
+            name,
+            mentioned_samples: count,
+            share_of_voice: comparable && totalMentions ? count / totalMentions : null,
+        })),
+        sources: [...sources.values()].sort((a, b) => b.count - a.count),
+    };
+}
+/** No fetching or execution: customer wording and citations are evidence only. */
+export function parseGeoTranscript(input, redactions = []) {
+    if (new TextEncoder().encode(input).byteLength > 1_000_000)
+        throw new OxygenError("geo_import_too_large", "Import one conversation of at most 1 MB.", { exitCode: 2 });
+    const redact = (value) => redactions.reduce((text, term) => term.trim() ? text.split(term).join("[redacted]") : text, value);
+    const messages = [];
+    let parsed;
+    try {
+        parsed = JSON.parse(input);
+    }
+    catch {
+        parsed = null;
+    }
+    if (Array.isArray(parsed) && parsed.length > 1)
+        throw new OxygenError("geo_conversation_required", "Import one selected conversation instead of a full account export.", { exitCode: 2 });
+    const root = Array.isArray(parsed) ? parsed[0] : parsed;
+    if (root && typeof root === "object") {
+        const data = root;
+        if (data.mapping && typeof data.mapping === "object") {
+            const mapping = data.mapping;
+            const branch = [];
+            let node = typeof data.current_node === "string" ? data.current_node : null;
+            if (!node || !Object.hasOwn(mapping, node))
+                throw new OxygenError("geo_conversation_branch_required", "Import a conversation export with a valid selected branch.", { exitCode: 2 });
+            const visited = new Set();
+            while (node) {
+                if (!Object.hasOwn(mapping, node) || visited.has(node) || !mapping[node] || typeof mapping[node] !== "object")
+                    throw new OxygenError("geo_conversation_branch_invalid", "The selected conversation branch is incomplete or invalid.", { exitCode: 2 });
+                visited.add(node);
+                const entry = mapping[node];
+                branch.unshift(entry);
+                node = entry.parent ?? null;
+            }
+            for (const entry of branch) {
+                const role = entry.message?.author?.role;
+                if (role === "user" || role === "assistant")
+                    messages.push({
+                        role,
+                        text: (entry.message?.content?.parts ?? [])
+                            .filter((x) => typeof x === "string")
+                            .join("\n"),
+                    });
+            }
+            if (!messages.length)
+                throw new OxygenError("geo_conversation_branch_invalid", "The selected conversation branch contains no readable messages.", { exitCode: 2 });
+        }
+        else {
+            const rows = data.chat_messages ?? data.messages;
+            if (Array.isArray(rows))
+                for (const row of rows) {
+                    if (!row || typeof row !== "object")
+                        continue;
+                    const role = row.sender === "human" || row.role === "user"
+                        ? "user"
+                        : row.sender === "assistant" || row.role === "assistant"
+                            ? "assistant"
+                            : null;
+                    if (role)
+                        messages.push({
+                            role,
+                            text: typeof row.text === "string"
+                                ? row.text
+                                : typeof row.content === "string"
+                                    ? row.content
+                                    : Array.isArray(row.content)
+                                        ? row.content
+                                            .map((c) => c.text ?? "")
+                                            .join("\n")
+                                        : "",
+                        });
+                }
+        }
+    }
+    if (!messages.length)
+        messages.push({ role: "user", text: input });
+    for (const message of messages)
+        message.text = redact(message.text);
+    // Retain only the selected conversation branch and reviewed text. Hidden JSON
+    // metadata, sibling chats, attachments and discarded branches are never saved.
+    return {
+        messages,
+        prompts: messages
+            .filter((m) => m.role === "user")
+            .map((m) => m.text)
+            .filter(Boolean),
+        sources: [
+            ...new Set(messages.flatMap((m) => m.text.match(/https?:\/\/[^\s<>"\])]+/g) ?? [])),
+        ],
+        redacted_text: messages.map((m) => `${m.role}: ${m.text}`).join("\n\n"),
+    };
+}
+/** Compare only common collection cohorts; imports and missing AIOs are excluded. */
+export function compareGeoExperiment(before, after, brand) {
+    const eligible = (answers) => answers.filter((a) => a.collection === "consumer" &&
+        a.outcome === "answer" &&
+        a.measurement !== undefined);
+    const key = (a) => JSON.stringify([
+        a.prompt_id,
+        a.prompt_revision ?? null,
+        a.engine,
+        a.provider,
+        a.market?.country,
+        a.market?.language,
+        geoMeasurementKey(a),
+    ]);
+    const baseline = eligible(before);
+    const followup = eligible(after);
+    const baselineKeys = new Set(baseline.map(key));
+    const followupKeys = new Set(followup.map(key));
+    const common = [...baselineKeys].filter((k) => followupKeys.has(k));
+    const matchedBefore = baseline.filter((a) => common.includes(key(a)));
+    const matchedAfter = followup.filter((a) => common.includes(key(a)));
+    return {
+        before: summarizeGeoAnswers(matchedBefore, brand),
+        after: summarizeGeoAnswers(matchedAfter, brand),
+        comparable_cohorts: common.length,
+        excluded_before: before.length - matchedBefore.length,
+        excluded_after: after.length - matchedAfter.length,
+        cohorts: common.map((k) => ({
+            cohort: JSON.parse(k),
+            before: summarizeGeoAnswers(baseline.filter((a) => key(a) === k), brand),
+            after: summarizeGeoAnswers(followup.filter((a) => key(a) === k), brand),
+        })),
+        interpretation: "Observed association within matching prompt revision, engine, provider, locale and capture-time brand definitions. Unknown definitions are excluded. Compare individual cohorts; changing their sample mix can change aggregate rates. This does not establish causation.",
+    };
+}

package/node_modules/@oxygen/shared/dist/linkedin-countries.d.ts

@@ -20,6 +20,15 @@
  */
 /** Canonical LinkedIn country name for each ISO 3166-1 alpha-2 code, A→Z by name. */
 export declare const LINKEDIN_COUNTRIES: ReadonlyArray<readonly [code: string, name: string]>;
+/**
+ * Spellings a provider may return that are not the canonical name. Lowercased
+ * keys; the resolver lowercases its input before the lookup. Kept deliberately
+ * short — it covers the CLDR spellings this table overrides (so a payload
+ * carrying the un-overridden name still resolves), the common colloquial forms,
+ * and the alpha-3 codes, because Up2Data's `hq.country` is not contractually
+ * alpha-2 and has been observed carrying a display name.
+ */
+export declare const COUNTRY_ALIASES: Readonly<Record<string, string>>;
 /**
  * Resolve a provider value — an alpha-2 code, a canonical name, or a known
  * alias — to its canonical LinkedIn country name.

package/node_modules/@oxygen/shared/dist/linkedin-countries.js

@@ -279,7 +279,7 @@ export const LINKEDIN_COUNTRIES = [
  * and the alpha-3 codes, because Up2Data's `hq.country` is not contractually
  * alpha-2 and has been observed carrying a display name.
  */
-const COUNTRY_ALIASES = {
+export const COUNTRY_ALIASES = {
     // CLDR spellings this table overrides.
     "hong kong sar china": "HK",
     "macao sar china": "MO",