@openlup/platform 0.28.0 → 0.29.0

package/dist/marketing/acquisitionCaseSchemas.js

@@ -0,0 +1,53 @@
+import { z } from "./validation.js";
+export const ACQUISITION_CASE_CONTRACT_VERSION = "tester_application_v1";
+export const ACQUISITION_CASE_VIEW = "acquisition_case_v1";
+export const ACQUISITION_CASE_SOURCE = "tester_application";
+export const acquisitionOpaqueReferenceSchema = z.string().trim().min(8).max(160)
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/);
+const dateTimeSchema = z.string().datetime({ offset: true });
+export const acquisitionAddressReferenceSchema = z.object({
+    source: z.string().trim().min(1).max(48).regex(/^[a-z][a-z0-9_-]*$/),
+    reference: acquisitionOpaqueReferenceSchema,
+    revision: z.string().trim().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/),
+    provenance: z.string().trim().min(1).max(64).regex(/^[a-z][a-z0-9_-]*$/),
+}).strict();
+export const acquisitionCaseStateSchema = z.enum([
+    "submitted", "approved", "active", "rejected", "withdrawn",
+]);
+export const acquisitionCaseProjectionSchema = z.object({
+    contractVersion: z.literal(ACQUISITION_CASE_CONTRACT_VERSION),
+    caseRef: acquisitionOpaqueReferenceSchema,
+    contactRef: acquisitionOpaqueReferenceSchema,
+    sourceKind: z.literal(ACQUISITION_CASE_SOURCE),
+    consent: z.object({
+        consentVersion: z.string().min(1).max(64),
+        policyVersion: z.string().min(1).max(64),
+        recordedAt: dateTimeSchema,
+        locale: z.enum(["en", "pl"]),
+        sourcePath: z.literal("/tester-application"),
+    }).strict(),
+    addressReference: acquisitionAddressReferenceSchema.nullable(),
+    state: acquisitionCaseStateSchema,
+    version: z.number().int().positive(),
+    createdAt: dateTimeSchema,
+    updatedAt: dateTimeSchema,
+}).strict().superRefine((value, context) => {
+    if (value.state !== "withdrawn" && value.addressReference === null) {
+        context.addIssue({ code: z.ZodIssueCode.custom, path: ["addressReference"], message: "active case requires address reference" });
+    }
+});
+export const acquisitionCaseListRequestSchema = z.object({
+    view: z.literal(ACQUISITION_CASE_VIEW),
+    cursor: acquisitionOpaqueReferenceSchema.optional(),
+    limit: z.number().int().min(1).max(100).default(25),
+}).strict();
+export const acquisitionCaseListResponseSchema = z.object({
+    contractVersion: z.literal(ACQUISITION_CASE_CONTRACT_VERSION),
+    cases: z.array(acquisitionCaseProjectionSchema).max(100),
+    nextCursor: acquisitionOpaqueReferenceSchema.nullable(),
+}).strict();
+export const acquisitionCaseActiveCountResponseSchema = z.object({
+    activeTesterCount: z.number().int().nonnegative(),
+}).strict();
+export const acquisitionIdempotencyKeySchema = z.string().trim().min(8).max(200)
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/);

package/dist/marketing/acquisitionEvidenceSchemas.d.ts

@@ -0,0 +1,105 @@
+import { z } from "./validation.js";
+export declare const ACQUISITION_SURVEY_VERSION: "acquisition_survey_v1";
+export declare const ACQUISITION_NEWSLETTER_VERSION: "acquisition_newsletter_consent_v1";
+export declare const acquisitionSurveySubmitSchema: z.ZodObject<{
+    view: z.ZodLiteral<"acquisition_survey_v1">;
+    caseReference: z.ZodString;
+    surveyType: z.ZodEnum<{
+        producer: "producer";
+        consumer: "consumer";
+    }>;
+    responseData: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const acquisitionSurveyEvidenceSchema: z.ZodObject<{
+    evidenceReference: z.ZodString;
+    caseReference: z.ZodString;
+    contactReference: z.ZodString;
+    surveyType: z.ZodEnum<{
+        producer: "producer";
+        consumer: "consumer";
+    }>;
+    responseDigest: z.ZodString;
+    answerCount: z.ZodNumber;
+    recordedAt: z.ZodString;
+}, z.core.$strip>;
+export declare const acquisitionSurveySubmitResponseSchema: z.ZodObject<{
+    contractVersion: z.ZodLiteral<"acquisition_survey_v1">;
+    evidence: z.ZodObject<{
+        evidenceReference: z.ZodString;
+        caseReference: z.ZodString;
+        contactReference: z.ZodString;
+        surveyType: z.ZodEnum<{
+            producer: "producer";
+            consumer: "consumer";
+        }>;
+        responseDigest: z.ZodString;
+        answerCount: z.ZodNumber;
+        recordedAt: z.ZodString;
+    }, z.core.$strip>;
+    replayed: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const acquisitionSurveyListQuerySchema: z.ZodObject<{
+    view: z.ZodLiteral<"acquisition_survey_v1">;
+    surveyType: z.ZodOptional<z.ZodEnum<{
+        producer: "producer";
+        consumer: "consumer";
+    }>>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export declare const acquisitionSurveyListResponseSchema: z.ZodObject<{
+    contractVersion: z.ZodLiteral<"acquisition_survey_v1">;
+    rows: z.ZodArray<z.ZodObject<{
+        evidenceReference: z.ZodString;
+        caseReference: z.ZodString;
+        contactReference: z.ZodString;
+        surveyType: z.ZodEnum<{
+            producer: "producer";
+            consumer: "consumer";
+        }>;
+        responseDigest: z.ZodString;
+        answerCount: z.ZodNumber;
+        recordedAt: z.ZodString;
+    }, z.core.$strip>>;
+    totalCount: z.ZodNumber;
+}, z.core.$strip>;
+export declare const acquisitionNewsletterConsentEventSchema: z.ZodObject<{
+    contractVersion: z.ZodLiteral<"acquisition_newsletter_consent_v1">;
+    caseReference: z.ZodString;
+    contactReference: z.ZodString;
+    eventReference: z.ZodString;
+    eventType: z.ZodEnum<{
+        suppress: "suppress";
+        update: "update";
+        subscribe: "subscribe";
+        unsubscribe: "unsubscribe";
+        complaint: "complaint";
+    }>;
+    purpose: z.ZodEnum<{
+        marketing_launch_offer: "marketing_launch_offer";
+        marketing_newsletter: "marketing_newsletter";
+    }>;
+    explicitOptInEvidence: z.ZodDefault<z.ZodBoolean>;
+    occurredAt: z.ZodString;
+}, z.core.$strict>;
+export declare const acquisitionNewsletterConsentResponseSchema: z.ZodObject<{
+    contractVersion: z.ZodLiteral<"acquisition_newsletter_consent_v1">;
+    eventReference: z.ZodString;
+    outcome: z.ZodEnum<{
+        applied: "applied";
+        ignored: "ignored";
+        stale: "stale";
+    }>;
+    consentState: z.ZodNullable<z.ZodEnum<{
+        suppressed: "suppressed";
+        granted: "granted";
+    }>>;
+    auditReference: z.ZodString;
+    replayed: z.ZodBoolean;
+}, z.core.$strip>;
+export type AcquisitionSurveySubmit = z.infer<typeof acquisitionSurveySubmitSchema>;
+export type AcquisitionSurveyEvidence = z.infer<typeof acquisitionSurveyEvidenceSchema>;
+export type AcquisitionSurveySubmitResponse = z.infer<typeof acquisitionSurveySubmitResponseSchema>;
+export type AcquisitionSurveyListQuery = z.infer<typeof acquisitionSurveyListQuerySchema>;
+export type AcquisitionSurveyListResponse = z.infer<typeof acquisitionSurveyListResponseSchema>;
+export type AcquisitionNewsletterConsentEvent = z.infer<typeof acquisitionNewsletterConsentEventSchema>;
+export type AcquisitionNewsletterConsentResponse = z.infer<typeof acquisitionNewsletterConsentResponseSchema>;

package/dist/marketing/acquisitionEvidenceSchemas.js

@@ -0,0 +1,55 @@
+import { z } from "./validation.js";
+export const ACQUISITION_SURVEY_VERSION = "acquisition_survey_v1";
+export const ACQUISITION_NEWSLETTER_VERSION = "acquisition_newsletter_consent_v1";
+const caseReference = z.string().regex(/^acquisition-case:[0-9a-f-]{36}$/);
+const contactReference = z.string().regex(/^acquisition-contact:[0-9a-f-]{36}$/);
+const commandKey = z.string().min(8).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]+$/);
+const digest = z.string().regex(/^[0-9a-f]{64}$/);
+export const acquisitionSurveySubmitSchema = z.object({
+    view: z.literal(ACQUISITION_SURVEY_VERSION),
+    caseReference,
+    surveyType: z.enum(["producer", "consumer"]),
+    responseData: z.record(z.string(), z.unknown()),
+});
+export const acquisitionSurveyEvidenceSchema = z.object({
+    evidenceReference: z.string().regex(/^acquisition-survey:[0-9a-f-]{36}$/),
+    caseReference,
+    contactReference,
+    surveyType: z.enum(["producer", "consumer"]),
+    responseDigest: digest,
+    answerCount: z.number().int().min(1).max(100),
+    recordedAt: z.string().datetime({ offset: true }),
+});
+export const acquisitionSurveySubmitResponseSchema = z.object({
+    contractVersion: z.literal(ACQUISITION_SURVEY_VERSION),
+    evidence: acquisitionSurveyEvidenceSchema,
+    replayed: z.boolean(),
+});
+export const acquisitionSurveyListQuerySchema = z.object({
+    view: z.literal(ACQUISITION_SURVEY_VERSION),
+    surveyType: z.enum(["producer", "consumer"]).optional(),
+    limit: z.coerce.number().int().min(1).max(100).default(50),
+});
+export const acquisitionSurveyListResponseSchema = z.object({
+    contractVersion: z.literal(ACQUISITION_SURVEY_VERSION),
+    rows: z.array(acquisitionSurveyEvidenceSchema),
+    totalCount: z.number().int().min(0),
+});
+export const acquisitionNewsletterConsentEventSchema = z.object({
+    contractVersion: z.literal(ACQUISITION_NEWSLETTER_VERSION),
+    caseReference,
+    contactReference,
+    eventReference: commandKey,
+    eventType: z.enum(["subscribe", "unsubscribe", "suppress", "complaint", "update"]),
+    purpose: z.enum(["marketing_launch_offer", "marketing_newsletter"]),
+    explicitOptInEvidence: z.boolean().default(false),
+    occurredAt: z.string().datetime({ offset: true }),
+}).strict();
+export const acquisitionNewsletterConsentResponseSchema = z.object({
+    contractVersion: z.literal(ACQUISITION_NEWSLETTER_VERSION),
+    eventReference: commandKey,
+    outcome: z.enum(["applied", "ignored", "stale"]),
+    consentState: z.enum(["granted", "suppressed"]).nullable(),
+    auditReference: z.string().regex(/^acquisition-consent:[0-9a-f-]{36}$/),
+    replayed: z.boolean(),
+});

package/dist/marketing/analytics/dataLayer.d.ts

@@ -0,0 +1,18 @@
+import type { AnalyticsSinkAttemptMask, AnalyticsSinkAdmission, AnalyticsCookieConsent, AnalyticsDataLayerOptions } from "../contracts/analytics.js";
+export type { AnalyticsSinkAttemptMask, AnalyticsSinkAdmission, AnalyticsCookieConsent, AnalyticsBrowserWindow, AnalyticsDataLayerOptions } from "../contracts/analytics.js";
+import type { AnalyticsEventMap, AnalyticsEventName } from "./noop.js";
+/** Each instance owns loader state; the host supplies browser and deployment policy. */
+export declare function createAnalyticsDataLayer<StepName extends string = string>(options?: AnalyticsDataLayerOptions<StepName>): {
+    readCookieConsent: () => AnalyticsCookieConsent | null;
+    hasAnalyticsConsent: (consent?: AnalyticsCookieConsent | null) => boolean;
+    configuredContainerId: () => string | null;
+    subscribeToAnalyticsConsent: (listener: () => void) => () => void;
+    isAnalyticsLoaderReady: () => boolean;
+    subscribeToAnalyticsLoaderReadiness: (listener: () => void) => () => void;
+    markAnalyticsLoaderReady: () => void;
+    resetAnalyticsLoaderReadiness: () => void;
+    pushAnalyticsConsentDefault: () => void;
+    pushAnalyticsConsentUpdate: (granted: boolean) => void;
+    pushAnalyticsEvent: <K extends AnalyticsEventName>(event: K, properties: AnalyticsEventMap<StepName>[K]) => boolean;
+    emitAnalyticsEvent: <K extends AnalyticsEventName>(event: K, properties: AnalyticsEventMap<StepName>[K], attempts?: AnalyticsSinkAttemptMask) => AnalyticsSinkAdmission;
+};

package/dist/marketing/analytics/dataLayer.js

@@ -0,0 +1,111 @@
+import { trackDeploymentEvent } from "./noop.js";
+/** Each instance owns loader state; the host supplies browser and deployment policy. */
+export function createAnalyticsDataLayer(options = {}) {
+    const { consentStorageKey = "", consentChangeEvent = "", consentSignalNames, eventPrefix = "", readContainerId = () => null, getWindow = () => undefined } = options;
+    const deploymentSink = options.trackDeploymentEvent ?? trackDeploymentEvent;
+    let analyticsLoaderReady = false;
+    const readinessListeners = new Set();
+    function readCookieConsent() {
+        const browser = getWindow();
+        if (!browser)
+            return null;
+        try {
+            const parsed = JSON.parse(browser.localStorage.getItem(consentStorageKey) ?? "");
+            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+                return null;
+            const value = parsed;
+            if (typeof value.necessary !== "boolean" || typeof value.functional !== "boolean"
+                || typeof value.analytics !== "boolean" || typeof value.marketing !== "boolean")
+                return null;
+            return { necessary: value.necessary, functional: value.functional,
+                analytics: value.analytics, marketing: value.marketing };
+        }
+        catch {
+            return null;
+        }
+    }
+    function hasAnalyticsConsent(consent = readCookieConsent()) { return consent?.analytics === true; }
+    function configuredContainerId() { return readContainerId(); }
+    function subscribeToAnalyticsConsent(listener) {
+        const browser = getWindow();
+        if (!browser)
+            return () => undefined;
+        const onStorage = (event) => { if (event.key === consentStorageKey)
+            listener(); };
+        browser.addEventListener("storage", onStorage);
+        browser.addEventListener(consentChangeEvent, listener);
+        return () => {
+            browser.removeEventListener("storage", onStorage);
+            browser.removeEventListener(consentChangeEvent, listener);
+        };
+    }
+    function isAnalyticsLoaderReady() { return analyticsLoaderReady; }
+    function subscribeToAnalyticsLoaderReadiness(listener) {
+        readinessListeners.add(listener);
+        return () => readinessListeners.delete(listener);
+    }
+    function markAnalyticsLoaderReady() {
+        if (analyticsLoaderReady)
+            return;
+        analyticsLoaderReady = true;
+        for (const listener of readinessListeners)
+            listener();
+    }
+    function resetAnalyticsLoaderReadiness() { analyticsLoaderReady = false; }
+    function pushAnalyticsConsentDefault() {
+        pushConsentCommand("default", "denied", "denied");
+    }
+    function pushAnalyticsConsentUpdate(granted) {
+        const analyticsState = granted ? "granted" : "denied";
+        // Read the separate advertising grant at push time; revocation denies all signals.
+        const adState = granted && readCookieConsent()?.marketing === true ? "granted" : "denied";
+        pushConsentCommand("update", analyticsState, adState);
+    }
+    function pushAnalyticsEvent(event, properties) {
+        const browser = getWindow();
+        if (!consentSignalNames || !browser || !configuredContainerId() || !hasAnalyticsConsent())
+            return false;
+        if (!browser.dataLayer) {
+            browser.dataLayer = [];
+            pushAnalyticsConsentDefault();
+            pushAnalyticsConsentUpdate(true);
+        }
+        browser.dataLayer.push({ event: `${eventPrefix}${event}`, ...properties });
+        return true;
+    }
+    function emitAnalyticsEvent(event, properties, attempts = { deployment: true, optional: true }) {
+        let deployment = false;
+        let optional = false;
+        if (attempts.deployment) {
+            try {
+                deployment = deploymentSink(event, properties);
+            }
+            catch { /* Sink failure never gates the product. */ }
+        }
+        if (attempts.optional) {
+            try {
+                optional = pushAnalyticsEvent(event, properties);
+            }
+            catch { /* Independent best-effort admission. */ }
+        }
+        return { deployment, optional };
+    }
+    function pushConsentCommand(action, analyticsState, adState) {
+        const browser = getWindow();
+        if (!consentSignalNames || !browser?.dataLayer)
+            return;
+        const settings = { [consentSignalNames.analytics]: analyticsState };
+        for (const name of consentSignalNames.advertising)
+            settings[name] = adState;
+        function consentCommand(..._args) {
+            // Consent commands use the array-like arguments object, not an event object.
+            // eslint-disable-next-line prefer-rest-params
+            browser?.dataLayer?.push(arguments);
+        }
+        consentCommand("consent", action, settings);
+    }
+    return { readCookieConsent, hasAnalyticsConsent, configuredContainerId, subscribeToAnalyticsConsent,
+        isAnalyticsLoaderReady, subscribeToAnalyticsLoaderReadiness, markAnalyticsLoaderReady,
+        resetAnalyticsLoaderReadiness, pushAnalyticsConsentDefault, pushAnalyticsConsentUpdate,
+        pushAnalyticsEvent, emitAnalyticsEvent };
+}

package/dist/marketing/analytics/noop.d.ts

@@ -0,0 +1,9 @@
+import type { AnalyticsEventMap, AnalyticsEventName } from "../contracts/analytics.js";
+export type { AnalyticsStepName, AnalyticsCheckoutItem, AnalyticsPurchaseItem, AnalyticsCheckoutMode, AnalyticsPaymentWaitOutcome, AnalyticsEventMap, AnalyticsEventName } from "../contracts/analytics.js";
+import type { AnalyticsPort } from "@openlup/core/platform-runtime";
+export declare function initializeDeploymentAnalytics(): void;
+export declare function trackDeploymentEvent<K extends AnalyticsEventName>(_event: K, _properties: AnalyticsEventMap[K]): boolean;
+export declare function syncAdvertisingConsent(): void;
+export declare function trackAdvertisingPurchase(_payload: AnalyticsEventMap["purchase"]): boolean;
+/** Inert composition satisfies the existing platform runtime port. */
+export declare function createNoopAnalytics(): AnalyticsPort;

package/dist/marketing/analytics/noop.js

@@ -0,0 +1,8 @@
+export function initializeDeploymentAnalytics() { }
+export function trackDeploymentEvent(_event, _properties) { return false; }
+export function syncAdvertisingConsent() { }
+export function trackAdvertisingPurchase(_payload) { return false; }
+/** Inert composition satisfies the existing platform runtime port. */
+export function createNoopAnalytics() {
+    return { trackPageView() { }, trackEvent() { } };
+}

package/dist/marketing/analytics/purchaseFacts.d.ts

@@ -0,0 +1,4 @@
+import type { PurchaseOrder, PurchaseSuppressionReason } from "../contracts/analytics.js";
+export type { PurchaseOrder, PurchaseSuppressionReason } from "../contracts/analytics.js";
+import type { AnalyticsEventMap } from "./noop.js";
+export declare function projectPaidPurchase(recap: PurchaseOrder, suppressPurchase?: (reason: PurchaseSuppressionReason) => null): AnalyticsEventMap["purchase"] | null;

package/dist/marketing/analytics/purchaseFacts.js

@@ -0,0 +1,69 @@
+const MAX_ITEMS = 200;
+export function projectPaidPurchase(recap, suppressPurchase = () => null) {
+    if (recap.status !== "paid")
+        return suppressPurchase("order_not_paid");
+    if (recap.paymentStatus !== "succeeded")
+        return suppressPurchase("payment_not_succeeded");
+    if (recap.checkoutKind !== "one_time" && recap.checkoutKind !== "subscription_initial"
+        && recap.checkoutKind !== "subscription_renewal")
+        return suppressPurchase("checkout_kind_unsupported");
+    if (!recap.moneyReconciled)
+        return suppressPurchase("money_unreconciled");
+    if (recap.items.length === 0)
+        return suppressPurchase("items_empty");
+    let effectiveNet = 0;
+    const items = [];
+    for (const item of recap.items) {
+        if (!item.sku)
+            return suppressPurchase("sku_missing");
+        if (!Number.isSafeInteger(item.quantity) || item.quantity <= 0)
+            return suppressPurchase("quantity_invalid");
+        if (item.quantity > MAX_ITEMS)
+            return suppressPurchase("item_limit_exceeded");
+        if (!isNonNegativeSafeInteger(item.catalogTotalGross) || !isNonNegativeSafeInteger(item.effectiveNet)
+            || !isNonNegativeSafeInteger(item.vatRateBps) || item.vatRateBps > 10_000)
+            return suppressPurchase("line_money_invalid");
+        const catalogNet = netFromGross(item.catalogTotalGross, item.vatRateBps);
+        const netDiscount = catalogNet - item.effectiveNet;
+        if (netDiscount < 0)
+            return suppressPurchase("net_discount_invalid");
+        const projected = allocateLineItems({ sku: item.sku, variantCode: item.variantCode,
+            quantity: item.quantity, effectiveNet: item.effectiveNet, netDiscount });
+        if (items.length + projected.length > MAX_ITEMS)
+            return suppressPurchase("item_limit_exceeded");
+        items.push(...projected);
+        effectiveNet += item.effectiveNet;
+    }
+    const tax = recap.totals.tax.amountMinor;
+    const total = recap.totals.total.amountMinor;
+    const effectiveShippingNet = total - tax - effectiveNet;
+    if (!isNonNegativeSafeInteger(effectiveShippingNet))
+        return suppressPurchase("shipping_net_invalid");
+    return { transaction_id: recap.orderId, currency: recap.totals.total.currency, value: effectiveNet / 100,
+        shipping: effectiveShippingNet / 100, tax: tax / 100,
+        checkout_mode: recap.checkoutKind === "one_time" ? "one_time" : "subscription", items };
+}
+function allocateLineItems(input) {
+    const priceBase = Math.floor(input.effectiveNet / input.quantity);
+    const priceRemainder = input.effectiveNet % input.quantity;
+    const discountBase = Math.floor(input.netDiscount / input.quantity);
+    const discountRemainder = input.netDiscount % input.quantity;
+    const grouped = new Map();
+    for (let position = 0; position < input.quantity; position += 1) {
+        const priceMinor = priceBase + (position < priceRemainder ? 1 : 0);
+        const discountMinor = discountBase + (position < discountRemainder ? 1 : 0);
+        const key = `${priceMinor}:${discountMinor}`;
+        const current = grouped.get(key);
+        if (current)
+            current.quantity += 1;
+        else
+            grouped.set(key, { priceMinor, discountMinor, quantity: 1 });
+    }
+    return [...grouped.values()].map(group => ({ item_id: input.sku,
+        ...(input.variantCode ? { item_variant: input.variantCode } : {}), price: group.priceMinor / 100,
+        discount: group.discountMinor / 100, quantity: group.quantity }));
+}
+function netFromGross(grossMinor, vatRateBps) {
+    return Math.round(grossMinor * 10_000 / (10_000 + vatRateBps));
+}
+function isNonNegativeSafeInteger(value) { return Number.isSafeInteger(value) && value >= 0; }

package/dist/marketing/analytics/routePolicy.d.ts

@@ -0,0 +1,10 @@
+import type { AnalyticsRoutePolicyInput } from "../contracts/analytics.js";
+export type { AnalyticsRoutePolicyInput } from "../contracts/analytics.js";
+export declare function normalizeAnalyticsPathname(pathname: string): string;
+/** Route manifests and sensitive paths are explicit host policy. */
+export declare function createAnalyticsRoutePolicy(input: AnalyticsRoutePolicyInput): {
+    isSensitiveAnalyticsPath: (pathname: string) => boolean;
+    isOptionalAnalyticsRouteEligible: (pathname: string) => boolean;
+    isDeploymentAnalyticsRouteEligible: (pathname: string, additionalPublicPaths?: ReadonlySet<string>) => boolean;
+    sanitizeDeploymentAnalyticsUrl: (rawUrl: string, currentOrigin: string, additionalPublicPaths?: ReadonlySet<string>) => string | null;
+};

package/dist/marketing/analytics/routePolicy.js

@@ -0,0 +1,59 @@
+const CAMPAIGN_KEYS = ["utm_source", "utm_medium", "utm_campaign", "utm_content", "utm_term"];
+const CAMPAIGN_VALUE = /^[A-Za-z0-9_-]{1,100}$/;
+const NO_ADDITIONAL_PATHS = new Set();
+export function normalizeAnalyticsPathname(pathname) {
+    const withLeadingSlash = pathname.startsWith("/") ? pathname : `/${pathname}`;
+    const withoutTrailingSlash = withLeadingSlash.length > 1
+        ? withLeadingSlash.replace(/\/+$/, "") : withLeadingSlash;
+    return withoutTrailingSlash.toLowerCase();
+}
+/** Route manifests and sensitive paths are explicit host policy. */
+export function createAnalyticsRoutePolicy(input) {
+    const manifestPaths = new Set(input.publicPaths.map(normalizeAnalyticsPathname));
+    const redirectPaths = new Set(input.redirectSources.filter(source => !source.includes(":"))
+        .map(normalizeAnalyticsPathname));
+    function isSensitiveAnalyticsPath(pathname) {
+        const capabilityPath = pathname.toLowerCase();
+        return input.privatePathPrefixes.some(prefix => pathname === prefix || pathname.startsWith(`${prefix}/`))
+            || input.privateAuthPaths.includes(pathname)
+            || input.capabilityPathPrefixes.some(prefix => capabilityPath === prefix || capabilityPath.startsWith(`${prefix}/`));
+    }
+    function isOptionalAnalyticsRouteEligible(pathname) {
+        return !isSensitiveAnalyticsPath(pathname);
+    }
+    function isDeploymentAnalyticsRouteEligible(pathname, additionalPublicPaths = NO_ADDITIONAL_PATHS) {
+        const path = normalizeAnalyticsPathname(pathname);
+        if (isSensitiveAnalyticsPath(path))
+            return false;
+        return manifestPaths.has(path) || redirectPaths.has(path) || additionalPublicPaths.has(path);
+    }
+    function sanitizeDeploymentAnalyticsUrl(rawUrl, currentOrigin, additionalPublicPaths) {
+        let base;
+        let url;
+        try {
+            base = new URL(currentOrigin);
+            url = new URL(rawUrl, base);
+        }
+        catch {
+            return null;
+        }
+        if ((url.protocol !== "http:" && url.protocol !== "https:") || url.username || url.password
+            || url.origin !== base.origin)
+            return null;
+        const pathname = normalizeAnalyticsPathname(url.pathname);
+        if (!isDeploymentAnalyticsRouteEligible(pathname, additionalPublicPaths))
+            return null;
+        const campaign = new URLSearchParams();
+        for (const key of CAMPAIGN_KEYS) {
+            const values = url.searchParams.getAll(key);
+            if (values.length === 1 && CAMPAIGN_VALUE.test(values[0]))
+                campaign.set(key, values[0]);
+        }
+        url.pathname = pathname;
+        url.search = campaign.toString();
+        url.hash = "";
+        return url.href;
+    }
+    return { isSensitiveAnalyticsPath, isOptionalAnalyticsRouteEligible,
+        isDeploymentAnalyticsRouteEligible, sanitizeDeploymentAnalyticsUrl };
+}

package/dist/marketing/consentEvidence.d.ts

@@ -0,0 +1,8 @@
+import type { MarketingHistoricalConsentCommand, MarketingHistoricalConsentState, MarketingHistoricalConsentResult } from "./contracts/analytics.js";
+export type { MarketingHistoricalConsentCommand, MarketingHistoricalConsentState, MarketingHistoricalConsentResult } from "./contracts/analytics.js";
+/** Transport chronology after authorization; never changes the local consent grant. */
+export declare function selectMarketingHistoricalConsentTime(input: {
+    command: MarketingHistoricalConsentCommand;
+    state: MarketingHistoricalConsentState;
+    now: Date;
+}): MarketingHistoricalConsentResult;

package/dist/marketing/consentEvidence.js

@@ -0,0 +1,32 @@
+import { z } from "./validation.js";
+const historicalTimestamp = z.string().max(80).datetime({ offset: true });
+const HISTORICAL_MIN_AGE_MS = 5 * 60 * 1000;
+/** Transport chronology after authorization; never changes the local consent grant. */
+export function selectMarketingHistoricalConsentTime(input) {
+    const { command, state, now } = input;
+    if (!Number.isFinite(now.getTime()))
+        return { kind: "hold", reason: "consent_time_invalid" };
+    let selected = command.consentedAt;
+    if (state.consent === "SUBSCRIBED") {
+        const native = historicalTimestamp.safeParse(state.nativeConsentAt);
+        if (!native.success || !Number.isFinite(Date.parse(native.data)) || Date.parse(native.data) >= now.getTime()) {
+            return { kind: "hold", reason: "provider_state_unknown" };
+        }
+        const overriding = state.suppressions.some(item => item.reason === "UNSUBSCRIBE"
+            && (item.listId === null || item.listId === command.listId));
+        if (!overriding)
+            selected = native.data;
+        else if (Date.parse(command.consentedAt ?? "") > Date.parse(native.data)) {
+            return { kind: "hold", reason: "provider_state_unknown" };
+        }
+    }
+    const parsed = historicalTimestamp.safeParse(selected);
+    if (!parsed.success || !Number.isFinite(Date.parse(parsed.data)) || Date.parse(parsed.data) >= now.getTime()) {
+        return { kind: "hold", reason: "consent_time_invalid" };
+    }
+    // Parsing truncates fractional milliseconds; round only the age boundary up.
+    const discarded = /\.\d{3}(\d+)(?:Z|[+-]\d{2}:\d{2})$/.exec(parsed.data)?.[1];
+    const matureAt = Date.parse(parsed.data) + (discarded && /[1-9]/.test(discarded) ? 1 : 0) + HISTORICAL_MIN_AGE_MS;
+    return now.getTime() < matureAt ? { kind: "defer", retryAt: new Date(matureAt).toISOString() }
+        : { kind: "ready", providerConsentedAt: parsed.data };
+}

package/dist/marketing/contactLegal.d.ts

@@ -0,0 +1,14 @@
+import type { ContactContent, LegalDocumentContent } from "./contracts/contactLegal.js";
+export declare function contactContent(facts: ContactContent): {
+    supportEmail: string;
+    companyLines: string[];
+};
+export declare function legalDocumentContent(content: LegalDocumentContent): {
+    lastUpdated?: string | undefined;
+    title: string;
+    intro: string;
+    sections: {
+        title: string;
+        body: string;
+    }[];
+};

package/dist/marketing/contactLegal.js

@@ -0,0 +1,19 @@
+export function contactContent(facts) {
+    return {
+        supportEmail: facts.supportEmail,
+        companyLines: [
+            facts.organization.legalName,
+            facts.addressLine,
+            facts.registrationIdentifiers.map(({ label, value }) => `${label} ${value}`).join(" · "),
+            ...(facts.registrationAuthority !== undefined ? [facts.registrationAuthority] : []),
+        ],
+    };
+}
+export function legalDocumentContent(content) {
+    return {
+        title: content.title,
+        intro: content.intro,
+        sections: content.sections.map(({ title, body }) => ({ title, body })),
+        ...(content.lastUpdated !== undefined ? { lastUpdated: content.lastUpdated } : {}),
+    };
+}