@openlup/platform 0.27.0 → 0.29.0

package/dist/marketing/seo/jsonLd.js

@@ -0,0 +1,127 @@
+export function jsonLdGraph(...nodes) {
+    const seen = new Set();
+    const graph = nodes.flatMap(({ "@context": _context, ...node }) => {
+        if (node["@id"] && seen.has(node["@id"]))
+            return [];
+        if (node["@id"])
+            seen.add(node["@id"]);
+        return [node];
+    });
+    return { "@context": "https://schema.org", "@graph": graph };
+}
+export function entityIds(origin) {
+    const site = origin.replace(/\/$/, "");
+    return {
+        organization: `${site}/#organization`,
+        website: `${site}/#website`,
+        brand: `${site}/#brand`,
+    };
+}
+export function organizationLd(origin, type, facts) {
+    return {
+        "@context": "https://schema.org",
+        "@id": entityIds(origin).organization,
+        "@type": type,
+        name: facts.name,
+        legalName: facts.legalName,
+        url: facts.url,
+        logo: {
+            "@type": "ImageObject",
+            url: facts.logo.url,
+            contentUrl: facts.logo.contentUrl,
+            width: facts.logo.width,
+            height: facts.logo.height,
+        },
+        email: facts.email,
+        vatID: facts.vatID,
+        taxID: facts.taxID,
+        areaServed: facts.areaServed,
+        sameAs: facts.sameAs,
+        contactPoint: {
+            "@type": "ContactPoint",
+            email: facts.contactPoint.email,
+            contactType: facts.contactPoint.contactType,
+            availableLanguage: facts.contactPoint.availableLanguage,
+        },
+        address: {
+            "@type": "PostalAddress",
+            streetAddress: facts.address.streetAddress,
+            addressLocality: facts.address.addressLocality,
+            postalCode: facts.address.postalCode,
+            addressRegion: facts.address.addressRegion,
+            addressCountry: facts.address.addressCountry,
+        },
+    };
+}
+export function brandLd(origin, name, url) {
+    return { "@context": "https://schema.org", "@id": entityIds(origin).brand, "@type": "Brand", name, url };
+}
+export function websiteLd(origin, name, url, inLanguage) {
+    return {
+        "@context": "https://schema.org",
+        "@id": entityIds(origin).website,
+        "@type": "WebSite",
+        name,
+        url,
+        inLanguage,
+        publisher: { "@id": entityIds(origin).organization },
+    };
+}
+export function contactPageLd(origin, pageUrl) {
+    return {
+        "@context": "https://schema.org",
+        "@id": `${pageUrl.replace(/\/$/, "")}#webpage`,
+        "@type": "ContactPage",
+        url: pageUrl,
+        publisher: { "@id": entityIds(origin).organization },
+        mainEntity: { "@id": entityIds(origin).organization },
+    };
+}
+export function schemaWeight(netContent) {
+    const { unscaled, scale, unit } = netContent;
+    const unitCode = unit === "GRAM" || unit === "G" ? "GRM" : unit;
+    return { "@type": "QuantitativeValue", value: unscaled / 10 ** scale, unitCode };
+}
+export function productLd(origin, product) {
+    return {
+        "@context": "https://schema.org",
+        "@id": `${product.url.replace(/\/$/, "")}#product`,
+        "@type": "Product",
+        name: product.name,
+        inLanguage: product.inLanguage,
+        brand: { "@id": entityIds(origin).brand, "@type": "Brand", name: product.brandName },
+        manufacturer: { "@id": entityIds(origin).organization },
+        ...(product.category !== undefined ? { category: product.category } : {}),
+        image: product.images,
+        ...(product.sku !== undefined ? { sku: product.sku } : {}),
+        ...(product.gtin13 !== undefined ? { gtin13: product.gtin13 } : {}),
+        ...(product.netContent ? { weight: schemaWeight(product.netContent) } : {}),
+        url: product.url,
+    };
+}
+const pageEntityId = (pageUrl, fragment) => `${pageUrl.replace(/\/$/, "")}#${fragment}`;
+export function faqPageLd(faqs, pageUrl) {
+    return {
+        "@context": "https://schema.org",
+        "@id": pageEntityId(pageUrl, "faq"),
+        "@type": "FAQPage",
+        mainEntity: faqs.map((faq) => ({
+            "@type": "Question",
+            name: faq.question,
+            acceptedAnswer: { "@type": "Answer", text: faq.answer },
+        })),
+    };
+}
+export function breadcrumbLd(items, pageUrl) {
+    return {
+        "@context": "https://schema.org",
+        "@id": pageEntityId(pageUrl, "breadcrumb"),
+        "@type": "BreadcrumbList",
+        itemListElement: items.map((item, index) => ({
+            "@type": "ListItem",
+            position: index + 1,
+            name: item.name,
+            ...(item.url ? { item: item.url } : {}),
+        })),
+    };
+}

package/dist/marketing/seo/metadata.d.ts

@@ -0,0 +1,41 @@
+import { type JsonLdNode } from "./jsonLd.js";
+import { type SiteRoute } from "./urls.js";
+export type HeadTag = {
+    kind: "meta";
+    name: string;
+    content: string;
+} | {
+    kind: "meta";
+    property: string;
+    content: string;
+} | {
+    kind: "link";
+    rel: "canonical" | "alternate";
+    href: string;
+    hrefLang?: string;
+};
+export interface HeadFacts {
+    origin: string;
+    route: SiteRoute;
+    routes: readonly SiteRoute[];
+    xDefaultLocale: string;
+    htmlLang: string;
+    title: string;
+    description: string;
+    siteName: string;
+    ogImage: string;
+    ogImageWidth: number;
+    ogImageHeight: number;
+    ogLocale: string;
+    alternateOgLocale?: string;
+    twitterImage: string;
+    twitterHandle: string;
+    noindex?: boolean;
+    jsonLd?: JsonLdNode | JsonLdNode[];
+}
+export declare function buildHeadDescriptor(facts: HeadFacts): {
+    htmlLang: string;
+    title: string;
+    tags: HeadTag[];
+    jsonLd: string | null;
+};

package/dist/marketing/seo/metadata.js

@@ -0,0 +1,36 @@
+import { jsonLdGraph } from "./jsonLd.js";
+import { serializeJsonLd } from "./serializeJsonLd.js";
+import { canonicalUrlForRoute, hreflangLinksForRoute } from "./urls.js";
+export function buildHeadDescriptor(facts) {
+    const canonicalUrl = canonicalUrlForRoute(facts.origin, facts.route);
+    const nodes = facts.jsonLd ? (Array.isArray(facts.jsonLd) ? facts.jsonLd : [facts.jsonLd]) : [];
+    const tags = [
+        { kind: "meta", name: "description", content: facts.description },
+        { kind: "link", rel: "canonical", href: canonicalUrl },
+        ...(facts.noindex ? [{ kind: "meta", name: "robots", content: "noindex, nofollow" }] : []),
+        { kind: "meta", property: "og:title", content: facts.title },
+        { kind: "meta", property: "og:description", content: facts.description },
+        { kind: "meta", property: "og:image", content: facts.ogImage },
+        { kind: "meta", property: "og:image:width", content: String(facts.ogImageWidth) },
+        { kind: "meta", property: "og:image:height", content: String(facts.ogImageHeight) },
+        { kind: "meta", property: "og:type", content: "website" },
+        { kind: "meta", property: "og:site_name", content: facts.siteName },
+        { kind: "meta", property: "og:url", content: canonicalUrl },
+        { kind: "meta", property: "og:locale", content: facts.ogLocale },
+        ...(facts.alternateOgLocale ? [{ kind: "meta", property: "og:locale:alternate", content: facts.alternateOgLocale }] : []),
+        { kind: "meta", name: "twitter:card", content: "summary_large_image" },
+        { kind: "meta", name: "twitter:site", content: facts.twitterHandle },
+        { kind: "meta", name: "twitter:title", content: facts.title },
+        { kind: "meta", name: "twitter:description", content: facts.description },
+        { kind: "meta", name: "twitter:image", content: facts.twitterImage },
+        ...hreflangLinksForRoute(facts.origin, facts.route, facts.routes, facts.xDefaultLocale).map((link) => ({
+            kind: "link", rel: "alternate", hrefLang: link.hrefLang, href: link.href,
+        })),
+    ];
+    return {
+        htmlLang: facts.htmlLang,
+        title: facts.title,
+        tags,
+        jsonLd: nodes.length > 0 ? serializeJsonLd(jsonLdGraph(...nodes)) : null,
+    };
+}

package/dist/marketing/seo/serializeJsonLd.d.ts

@@ -0,0 +1 @@
+export declare function serializeJsonLd(value: object): string;

package/dist/marketing/seo/serializeJsonLd.js

@@ -0,0 +1,6 @@
+export function serializeJsonLd(value) {
+    return JSON.stringify(value)
+        .replace(/</g, "\\u003c")
+        .replace(/\u2028/g, "\\u2028")
+        .replace(/\u2029/g, "\\u2029");
+}

package/dist/marketing/seo/urls.d.ts

@@ -0,0 +1,14 @@
+export interface SiteRoute {
+    id: string;
+    locale: string;
+    canonicalPath: string;
+    alternateRouteId?: string;
+}
+export interface HreflangLink {
+    hrefLang: string;
+    href: string;
+}
+export declare function normalizeSitePath(pathname: string): string;
+export declare function absoluteSiteUrl(origin: string, pathname: string): string;
+export declare function canonicalUrlForRoute(origin: string, route: SiteRoute): string;
+export declare function hreflangLinksForRoute(origin: string, route: SiteRoute, routes: readonly SiteRoute[], xDefaultLocale: string): HreflangLink[];

package/dist/marketing/seo/urls.js

@@ -0,0 +1,23 @@
+export function normalizeSitePath(pathname) {
+    const path = pathname.startsWith("/") ? pathname : `/${pathname}`;
+    return path.length > 1 ? path.replace(/\/$/, "") : path;
+}
+export function absoluteSiteUrl(origin, pathname) {
+    const site = origin.replace(/\/$/, "");
+    const path = normalizeSitePath(pathname);
+    return path === "/" ? `${site}/` : `${site}${path}`;
+}
+export function canonicalUrlForRoute(origin, route) {
+    return absoluteSiteUrl(origin, route.canonicalPath);
+}
+export function hreflangLinksForRoute(origin, route, routes, xDefaultLocale) {
+    const alternate = route.alternateRouteId ? routes.find((candidate) => candidate.id === route.alternateRouteId) : undefined;
+    if (!alternate)
+        return [];
+    const pair = [route, alternate].sort((a, b) => a.locale.localeCompare(b.locale));
+    const preferred = pair.find((candidate) => candidate.locale === xDefaultLocale);
+    return [
+        ...pair.map((candidate) => ({ hrefLang: candidate.locale, href: canonicalUrlForRoute(origin, candidate) })),
+        { hrefLang: "x-default", href: canonicalUrlForRoute(origin, preferred ?? pair[0]) },
+    ];
+}

package/dist/marketing/server/acquisitionCaseDirect.d.ts

@@ -0,0 +1,4 @@
+import type { HttpRequest, HttpResponse } from "../../http/index.js";
+import type { AcquisitionCaseDirectDeps } from "./directPorts.js";
+export declare function createAcquisitionCaseListDirectHandler(options: AcquisitionCaseDirectDeps): (req: HttpRequest, res: HttpResponse) => Promise<void>;
+export declare function createAcquisitionCaseActiveCountDirectHandler(options: AcquisitionCaseDirectDeps): (req: HttpRequest, res: HttpResponse) => Promise<void>;

package/dist/marketing/server/acquisitionCaseDirect.js

@@ -0,0 +1,88 @@
+import { ACQUISITION_CASE_VIEW, acquisitionCaseActiveCountResponseSchema, acquisitionCaseListRequestSchema, acquisitionCaseListResponseSchema } from "../acquisitionCaseSchemas.js";
+export function createAcquisitionCaseListDirectHandler(options) {
+    const { respond, authorize, resolveBinding, isDirect } = options;
+    const { sendBffSuccess, sendMethodNotAllowed } = respond;
+    return async (req, res) => {
+        if (!isDirect() || first(req.query.view) !== ACQUISITION_CASE_VIEW)
+            return unavailable(res, respond);
+        if (req.method !== "GET")
+            return sendMethodNotAllowed(res, ["GET"]);
+        const actorRef = await authorize(req, res);
+        if (!actorRef)
+            return;
+        const request = acquisitionCaseListRequestSchema.safeParse({
+            view: first(req.query.view), cursor: first(req.query.cursor), limit: integer(first(req.query.limit), 25),
+        });
+        if (!request.success)
+            return badRequest(res, respond, request.error.flatten());
+        const binding = await bindingOrError(res, respond, resolveBinding);
+        if (!binding)
+            return;
+        const result = await operationOrError(res, respond, () => binding.handlers.list(actorRef, request.data));
+        if (!result)
+            return;
+        if (result.ok === false)
+            return failure(res, respond, result.error.kind);
+        const response = acquisitionCaseListResponseSchema.safeParse(result.value);
+        if (!response.success)
+            return invalidResponse(res, respond);
+        sendBffSuccess(res, response.data);
+    };
+}
+export function createAcquisitionCaseActiveCountDirectHandler(options) {
+    const { respond, resolveBinding, isDirect } = options;
+    const { sendBffSuccess, sendMethodNotAllowed } = respond;
+    return async (req, res) => {
+        if (!isDirect())
+            return unavailable(res, respond);
+        if (req.method !== "GET")
+            return sendMethodNotAllowed(res, ["GET"]);
+        const binding = await bindingOrError(res, respond, resolveBinding);
+        if (!binding)
+            return;
+        const result = await operationOrError(res, respond, () => binding.handlers.activeCount());
+        if (!result)
+            return;
+        if (result.ok === false)
+            return failure(res, respond, result.error.kind);
+        const response = acquisitionCaseActiveCountResponseSchema.safeParse(result.value);
+        if (!response.success)
+            return invalidResponse(res, respond);
+        sendBffSuccess(res, response.data);
+    };
+}
+async function bindingOrError(res, respond, resolve) {
+    try {
+        const binding = await resolve();
+        if (binding)
+            return binding;
+    }
+    catch { /* fail closed below */ }
+    respond.sendBffError(res, "UPSTREAM_UNAVAILABLE", "Acquisition case service unavailable");
+    return null;
+}
+async function operationOrError(res, respond, operation) {
+    try {
+        return await operation();
+    }
+    catch {
+        respond.sendBffError(res, "UPSTREAM_UNAVAILABLE", "Acquisition case service unavailable");
+        return null;
+    }
+}
+function first(value) { return Array.isArray(value) ? value[0] : value; }
+function integer(value, fallback) { return value === undefined ? fallback : Number(value); }
+function badRequest(res, respond, details) { respond.sendBffError(res, "BAD_REQUEST", "Invalid acquisition case request", { details }); }
+function unavailable(res, respond) { respond.sendBffError(res, "NOT_FOUND", "Acquisition case unavailable"); }
+function invalidResponse(res, respond) { respond.sendBffError(res, "INVALID_RESPONSE", "Acquisition case returned invalid response"); }
+function failure(res, respond, kind) {
+    if (kind === "invalid")
+        return badRequest(res, respond);
+    if (kind === "conflict")
+        return respond.sendBffError(res, "CONFLICT", "Acquisition case request conflicts with prior state");
+    if (kind === "rate_limited")
+        return respond.sendBffError(res, "RATE_LIMITED", "Acquisition submission rate limited");
+    if (kind === "not_found")
+        return unavailable(res, respond);
+    respond.sendBffError(res, "UPSTREAM_UNAVAILABLE", "Acquisition case service unavailable");
+}

package/dist/marketing/server/acquisitionCaseHandlers.d.ts

@@ -0,0 +1,28 @@
+import type { AcquisitionCaseListRequest } from "../contracts/index.js";
+import { type AcquisitionCaseSubmitRequest, type AcquisitionCaseTransitionRequest } from "./acquisitionCasePorts.js";
+import type { AcquisitionCasePort } from "./acquisitionCasePorts.js";
+export interface AcquisitionCaseHandlerOptions {
+    now?: () => string;
+}
+export declare function createAcquisitionCaseHandlers(port: AcquisitionCasePort, options?: AcquisitionCaseHandlerOptions): {
+    submit(request: AcquisitionCaseSubmitRequest, context: {
+        idempotencyKey: string;
+        requesterKey: string;
+    }): Promise<import("./acquisitionCasePorts.js").AcquisitionCaseResult<import("../contracts/acquisition.js").AcquisitionCaseProjection>>;
+    list(actorRef: string, request: AcquisitionCaseListRequest): Promise<import("./acquisitionCasePorts.js").AcquisitionCaseResult<import("../contracts/acquisition.js").AcquisitionCaseListResponse>>;
+    get(actorRef: string, caseRef: string): Promise<import("./acquisitionCasePorts.js").AcquisitionCaseResult<import("../contracts/acquisition.js").AcquisitionCaseProjection>>;
+    transition(actorRef: string, idempotencyKey: string, request: AcquisitionCaseTransitionRequest): Promise<import("./acquisitionCasePorts.js").AcquisitionCaseResult<import("../contracts/acquisition.js").AcquisitionCaseProjection>>;
+    activeCount(): Promise<{
+        ok: false;
+        error: {
+            kind: import("./acquisitionCasePorts.js").AcquisitionCaseFailureKind;
+        };
+    } | {
+        ok: true;
+        value: {
+            activeTesterCount: number;
+        };
+    }>;
+    contractVersion: "tester_application_v1";
+};
+export type AcquisitionCaseHandlers = ReturnType<typeof createAcquisitionCaseHandlers>;

package/dist/marketing/server/acquisitionCaseHandlers.js

@@ -0,0 +1,40 @@
+import { ACQUISITION_CASE_CONTRACT_VERSION, ACQUISITION_CASE_SOURCE } from "../acquisitionCaseSchemas.js";
+const SCOPE = "public_tester_application";
+export function createAcquisitionCaseHandlers(port, options = {}) {
+    const now = options.now ?? (() => new Date().toISOString());
+    return {
+        submit(request, context) {
+            return port.submit({
+                scope: SCOPE,
+                sourceKind: ACQUISITION_CASE_SOURCE,
+                idempotencyKey: context.idempotencyKey,
+                requesterKey: `${SCOPE}:${context.requesterKey}`,
+                acceptedAt: now(),
+                sourcePath: "/tester-application",
+                request,
+            });
+        },
+        list(actorRef, request) {
+            return port.list({
+                actorRef,
+                scope: SCOPE,
+                ...(request.cursor ? { cursor: request.cursor } : {}),
+                limit: request.limit,
+            });
+        },
+        get(actorRef, caseRef) {
+            return port.get({ actorRef, scope: SCOPE, caseRef });
+        },
+        transition(actorRef, idempotencyKey, request) {
+            return port.transition({ actorRef, scope: SCOPE, idempotencyKey, request });
+        },
+        async activeCount() {
+            const result = await port.activeCount(SCOPE);
+            return result.ok === false ? result : {
+                ok: true,
+                value: { activeTesterCount: result.value },
+            };
+        },
+        contractVersion: ACQUISITION_CASE_CONTRACT_VERSION,
+    };
+}

package/dist/marketing/server/acquisitionCasePorts.d.ts

@@ -0,0 +1,42 @@
+import type { AcquisitionCaseProjection, AcquisitionCaseResult, AcquisitionCasePort as PortableAcquisitionCasePort } from "../contracts/index.js";
+import type { AcquisitionAddressReference, AcquisitionCaseProjection as Projection } from "../contracts/index.js";
+/** Historical commands retained by the server adapter; public admission routes remain host-owned. */
+export interface AcquisitionCaseSubmitRequest {
+    contact: {
+        email: string;
+    };
+    consent: {
+        accepted: true;
+        consentVersion: string;
+        policyVersion: string;
+        locale: Projection["consent"]["locale"];
+    };
+    addressReference: AcquisitionAddressReference;
+}
+export interface AcquisitionCaseTransitionRequest {
+    view: "acquisition_case_v1";
+    caseRef: string;
+    expectedVersion: number;
+    transition: "approve" | "activate" | "reject" | "withdraw";
+    reason?: string | undefined;
+}
+export interface AcquisitionCaseSubmitCommand {
+    scope: "public_tester_application";
+    sourceKind: "tester_application";
+    idempotencyKey: string;
+    requesterKey: string;
+    acceptedAt: string;
+    sourcePath: "/tester-application";
+    request: AcquisitionCaseSubmitRequest;
+}
+export interface AcquisitionCaseTransitionCommand {
+    actorRef: string;
+    scope: "public_tester_application";
+    idempotencyKey: string;
+    request: AcquisitionCaseTransitionRequest;
+}
+export interface AcquisitionCasePort extends PortableAcquisitionCasePort {
+    submit(command: AcquisitionCaseSubmitCommand): Promise<AcquisitionCaseResult<AcquisitionCaseProjection>>;
+    transition(command: AcquisitionCaseTransitionCommand): Promise<AcquisitionCaseResult<AcquisitionCaseProjection>>;
+}
+export type { AcquisitionCaseFailureKind, AcquisitionCaseResult, AcquisitionCaseListQuery, AcquisitionCaseGetQuery, } from "../contracts/index.js";

package/dist/marketing/server/acquisitionCasePorts.js

@@ -0,0 +1 @@
+export {};

package/dist/marketing/server/acquisitionEvidenceDirect.d.ts

@@ -0,0 +1,5 @@
+import type { HttpRequest, HttpResponse } from "../../http/index.js";
+import type { AcquisitionEvidenceDirectDeps } from "./directPorts.js";
+export declare function createAcquisitionSurveySubmitDirectHandler(options: AcquisitionEvidenceDirectDeps): (req: HttpRequest, res: HttpResponse) => Promise<void>;
+export declare function createAcquisitionSurveyListDirectHandler(options: AcquisitionEvidenceDirectDeps): (req: HttpRequest, res: HttpResponse) => Promise<void>;
+export declare function createAcquisitionNewsletterConsentDirectHandler(options: AcquisitionEvidenceDirectDeps): (value: unknown, res: HttpResponse) => Promise<void>;

package/dist/marketing/server/acquisitionEvidenceDirect.js

@@ -0,0 +1,100 @@
+import { acquisitionNewsletterConsentEventSchema, acquisitionSurveyListQuerySchema, acquisitionSurveySubmitSchema } from "../acquisitionEvidenceSchemas.js";
+export function createAcquisitionSurveySubmitDirectHandler(options) {
+    const { respond, resolveBinding } = options;
+    const { sendBffSuccess, sendMethodNotAllowed } = respond;
+    return async (req, res) => {
+        if (req.method !== "POST")
+            return sendMethodNotAllowed(res, ["POST"]);
+        const request = acquisitionSurveySubmitSchema.safeParse(req.body);
+        const idempotencyKey = firstHeader(req.headers["idempotency-key"]);
+        if (!request.success || !idempotencyKey)
+            return badRequest(res, respond, request.success ? undefined : request.error.flatten());
+        const binding = await bindingOrError(res, respond, resolveBinding);
+        if (!binding)
+            return;
+        const result = await safeOperation(() => binding.submitSurvey({ ...request.data, idempotencyKey }));
+        if (!result)
+            return unavailable(res, respond);
+        if (result.ok === false)
+            return failure(res, respond, result.error.kind);
+        sendBffSuccess(res, result.value);
+    };
+}
+export function createAcquisitionSurveyListDirectHandler(options) {
+    const { respond, authorize, resolveBinding } = options;
+    const { sendBffSuccess, sendMethodNotAllowed } = respond;
+    return async (req, res) => {
+        if (req.method !== "GET")
+            return sendMethodNotAllowed(res, ["GET"]);
+        const actorReference = await authorize(req, res);
+        if (!actorReference)
+            return;
+        const request = acquisitionSurveyListQuerySchema.safeParse({
+            view: first(req.query.view), surveyType: first(req.query.surveyType), limit: first(req.query.limit) ?? "50",
+        });
+        if (!request.success)
+            return badRequest(res, respond, request.error.flatten());
+        const binding = await bindingOrError(res, respond, resolveBinding);
+        if (!binding)
+            return;
+        const result = await safeOperation(() => binding.listSurveys({ ...request.data, actorReference }));
+        if (!result)
+            return unavailable(res, respond);
+        if (result.ok === false)
+            return failure(res, respond, result.error.kind);
+        sendBffSuccess(res, result.value);
+    };
+}
+export function createAcquisitionNewsletterConsentDirectHandler(options) {
+    const { respond, resolveBinding } = options;
+    const { sendBffSuccess } = respond;
+    return async (value, res) => {
+        const request = acquisitionNewsletterConsentEventSchema.safeParse(value);
+        if (!request.success)
+            return badRequest(res, respond, request.error.flatten());
+        const binding = await bindingOrError(res, respond, resolveBinding);
+        if (!binding)
+            return;
+        const result = await safeOperation(() => binding.applyNewsletterConsent(request.data));
+        if (!result)
+            return unavailable(res, respond);
+        if (result.ok === false)
+            return failure(res, respond, result.error.kind);
+        sendBffSuccess(res, result.value);
+    };
+}
+async function bindingOrError(res, respond, resolve) {
+    try {
+        const binding = await resolve();
+        if (binding)
+            return binding;
+    }
+    catch { /* fail closed below */ }
+    unavailable(res, respond);
+    return null;
+}
+async function safeOperation(work) {
+    try {
+        return await work();
+    }
+    catch {
+        return null;
+    }
+}
+function failure(res, respond, kind) {
+    if (kind === "invalid")
+        return badRequest(res, respond);
+    if (kind === "not_found")
+        return respond.sendBffError(res, "NOT_FOUND", "Acquisition evidence subject not found");
+    if (kind === "conflict")
+        return respond.sendBffError(res, "CONFLICT", "Acquisition evidence request conflicts with prior state");
+    unavailable(res, respond);
+}
+function badRequest(res, respond, details) {
+    respond.sendBffError(res, "BAD_REQUEST", "Invalid acquisition evidence request", { details });
+}
+function unavailable(res, respond) {
+    respond.sendBffError(res, "UPSTREAM_UNAVAILABLE", "Acquisition evidence service unavailable");
+}
+function first(value) { return Array.isArray(value) ? value[0] : value; }
+function firstHeader(value) { return first(value); }

package/dist/marketing/server/analyticsContext.d.ts

@@ -0,0 +1,3 @@
+import type { HttpRequest, HttpResponse } from "../../http/index.js";
+import type { AnalyticsContextHandlerDeps } from "./analyticsContextPorts.js";
+export declare function createAnalyticsContextHandler(deps: AnalyticsContextHandlerDeps): (req: HttpRequest, res: HttpResponse) => Promise<void>;

package/dist/marketing/server/analyticsContext.js

@@ -0,0 +1,65 @@
+import { z } from "../validation.js";
+export function createAnalyticsContextHandler(deps) {
+    const { respond, isEnabled, resolveStore, readAccessToken, resolveTrustedSubject, capabilityCrypto, cookieName, clientIdField } = deps;
+    const { sendBffError, sendBffSuccess, sendMethodNotAllowed } = respond;
+    const requestSchema = z.object({
+        granted: z.boolean(),
+        [clientIdField]: z.string().regex(/^\d+\.\d+$/).max(64).optional(),
+        explicitGrant: z.boolean().default(false),
+    }).strict();
+    return async (req, res) => {
+        if (req.method !== "POST")
+            return sendMethodNotAllowed(res, ["POST"]);
+        if (!isEnabled())
+            return sendBffError(res, "NOT_FOUND", "Analytics context unavailable");
+        // No URL, IP, contact, session, form or account data is accepted or logged.
+        const origin = typeof req.headers.origin === "string" ? req.headers.origin : "";
+        if (!origin || origin !== `https://${req.headers.host}`)
+            return sendBffError(res, "FORBIDDEN", "Same-origin request required");
+        const parsed = requestSchema.safeParse(req.body);
+        const clientId = parsed.success ? parsed.data[clientIdField] : undefined;
+        if (!parsed.success || (parsed.data.granted && !clientId))
+            return sendBffError(res, "BAD_REQUEST", "Invalid analytics context");
+        const store = resolveStore();
+        if (!store)
+            return sendBffError(res, "UPSTREAM_UNAVAILABLE", "Analytics context unavailable");
+        // The computed shape key widens inference; the strict schema validates these fixed fields.
+        const data = parsed.data;
+        let hash = contextHash(typeof req.headers.cookie === "string" ? req.headers.cookie : undefined, cookieName, (value) => capabilityCrypto.hashToken(value));
+        // Explicit user re-consent gets a new capability; withdrawn old bindings stay withdrawn.
+        let token = null;
+        if (data.granted && !hash) {
+            token = capabilityCrypto.mintToken();
+            hash = capabilityCrypto.hashToken(token);
+        }
+        if (!hash) {
+            sendBffSuccess(res, { active: false });
+            return;
+        }
+        try {
+            const accessToken = readAccessToken(req);
+            const subject = data.granted && accessToken ? await resolveTrustedSubject(accessToken) : null;
+            if (accessToken && data.granted && !subject)
+                return sendBffError(res, "UNAUTHORIZED", "Customer session required");
+            let active = await store.syncContext({ tokenHash: hash, granted: data.granted, clientId: clientId ?? null });
+            if (active !== true && data.granted && data.explicitGrant && !token) {
+                token = capabilityCrypto.mintToken();
+                hash = capabilityCrypto.hashToken(token);
+                active = await store.syncContext({ tokenHash: hash, granted: true, clientId: clientId });
+            }
+            if (active === true && subject)
+                await store.enrollSubscriptions({ subject, contextHash: hash });
+            if (token && active === true)
+                res.setHeader("Set-Cookie", `${cookieName}=${token}; Path=/; Max-Age=31536000; HttpOnly; Secure; SameSite=Lax`);
+            res.setHeader("Cache-Control", "no-store");
+            sendBffSuccess(res, { active: active === true });
+        }
+        catch {
+            sendBffError(res, "UPSTREAM_UNAVAILABLE", "Analytics context unavailable");
+        }
+    };
+}
+function contextHash(cookie, cookieName, hashToken) {
+    const token = cookie?.split(";").map((part) => part.trim()).find((part) => part.startsWith(`${cookieName}=`))?.split("=")[1];
+    return token && /^[a-f0-9]{64}$/.test(token) ? hashToken(token) : null;
+}