@openlup/platform 0.27.0 → 0.29.0

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

@@ -0,0 +1,31 @@
+import type { HttpRequest } from "../../http/index.js";
+import type { BffResponder } from "../../bff/index.js";
+/** Host persistence rejects on failure; only literal true means an active context. */
+export interface AnalyticsContextPersistencePort {
+    syncContext(input: {
+        tokenHash: string;
+        granted: boolean;
+        clientId: string | null;
+    }): Promise<unknown>;
+    enrollSubscriptions(input: {
+        subject: string;
+        contextHash: string;
+    }): Promise<unknown>;
+}
+export type AnalyticsContextStoreResolver = () => AnalyticsContextPersistencePort | null;
+/** The host supplies opaque 32-byte hexadecimal tokens and their cryptographic hash. */
+export interface AnalyticsContextCapabilityCrypto {
+    mintToken(): string;
+    hashToken(token: string): string;
+}
+export interface AnalyticsContextHandlerDeps {
+    respond: BffResponder;
+    isEnabled: () => boolean;
+    resolveStore: AnalyticsContextStoreResolver;
+    readAccessToken: (req: HttpRequest) => string | null;
+    resolveTrustedSubject: (accessToken: string) => Promise<string | null>;
+    capabilityCrypto: AnalyticsContextCapabilityCrypto;
+    cookieName: string;
+    /** Historical request field name supplied by the host. */
+    clientIdField: string;
+}

package/dist/marketing/server/analyticsContextPorts.js

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

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

@@ -0,0 +1,14 @@
+import type { ReadinessIssue } from "@openlup/core/readiness";
+import { type MarketingPrivacyContributor, type MarketingPrivacyDependencies } from "./privacyContributor.js";
+/** Select one fully bound privacy contributor; absent activation leaves the host registry unchanged. */
+export declare function createMarketingPrivacyBindings<Context>(input: MarketingPrivacyDependencies<Context> & {
+    enabled?: boolean;
+}): {
+    contributor: MarketingPrivacyContributor<Context> | null;
+    issues: ReadinessIssue[];
+    callables: Readonly<{
+        exportPersonalData: MarketingPrivacyContributor<Context>["export"] | null;
+        assessErasure: MarketingPrivacyContributor<Context>["assessErasure"] | null;
+        eraseOrRetain: MarketingPrivacyContributor<Context>["eraseOrRetain"] | null;
+    }>;
+};

package/dist/marketing/server/bindings.js

@@ -0,0 +1,18 @@
+import { createMarketingPrivacyContributor } from "./privacyContributor.js";
+/** Select one fully bound privacy contributor; absent activation leaves the host registry unchanged. */
+export function createMarketingPrivacyBindings(input) {
+    const acquisition = input.acquisition && [input.acquisition.export, input.acquisition.assessErasure, input.acquisition.eraseOrRetain].every(fn => typeof fn === "function") ? input.acquisition : null;
+    const remoteErasure = input.remoteErasure && [input.remoteErasure.read, input.remoteErasure.openAndFence].every(fn => typeof fn === "function") ? input.remoteErasure : null;
+    const issues = [];
+    for (const [name, port] of [["acquisition", acquisition], ["remoteErasure", remoteErasure]]) {
+        if (!port)
+            issues.push({ code: "OPENLUP_E_PORT_MISSING", package: "@openlup/platform", module: "marketing", subject: name, fix: `Bind the marketing ${name} owner port.` });
+    }
+    const selected = input.enabled === true && issues.length === 0
+        ? createMarketingPrivacyContributor({ ...input, acquisition, remoteErasure }) : null;
+    return { contributor: selected, issues, callables: Object.freeze({
+            exportPersonalData: selected ? selected.export : null,
+            assessErasure: selected ? selected.assessErasure : null,
+            eraseOrRetain: selected ? selected.eraseOrRetain : null,
+        }) };
+}

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

@@ -0,0 +1,26 @@
+import type { HttpRequest, HttpResponse } from "../../http/index.js";
+import type { BffResponder } from "../../bff/index.js";
+import type { AcquisitionCaseHandlers } from "./acquisitionCaseHandlers.js";
+import type { AcquisitionEvidencePort } from "../contracts/index.js";
+export interface AcquisitionCaseReadBinding {
+    handlers: Pick<AcquisitionCaseHandlers, "list" | "get" | "activeCount">;
+}
+export type AcquisitionCaseBindingResolver = () => Promise<AcquisitionCaseReadBinding | null>;
+export type AcquisitionEvidenceBindingResolver = () => Promise<AcquisitionEvidencePort | null>;
+export type AcquisitionAuthorize = (req: HttpRequest, res: HttpResponse) => Promise<string | null>;
+export interface AcquisitionCaseDirectDeps {
+    respond: BffResponder;
+    authorize: AcquisitionAuthorize;
+    resolveBinding: AcquisitionCaseBindingResolver;
+    isDirect: () => boolean;
+}
+export interface PrelaunchAcquisitionDirectDeps {
+    respond: BffResponder;
+    authorize: AcquisitionAuthorize;
+    resolveBinding: AcquisitionCaseBindingResolver;
+}
+export interface AcquisitionEvidenceDirectDeps {
+    respond: BffResponder;
+    authorize: AcquisitionAuthorize;
+    resolveBinding: AcquisitionEvidenceBindingResolver;
+}

package/dist/marketing/server/directPorts.js

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

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

@@ -0,0 +1,14 @@
+/** Node-only acquisition and research algorithms. Hosts own routing, authorization and presentation. */
+export * from "./acquisitionCaseHandlers.js";
+export type * from "./acquisitionCasePorts.js";
+export type * from "./directPorts.js";
+export * from "./acquisitionCaseDirect.js";
+export * from "./prelaunchAcquisitionDirect.js";
+export * from "./acquisitionEvidenceDirect.js";
+export * from "./research/surveyResponseSubmitHandler.js";
+export * from "./research/adminSurveyResponsesHandler.js";
+export * from "./research/managedSurveyResponseSubmit.js";
+export { createAnalyticsContextHandler } from "./analyticsContext.js";
+export type * from "./analyticsContextPorts.js";
+export * from "./privacyContributor.js";
+export * from "./bindings.js";

package/dist/marketing/server/index.js

@@ -0,0 +1,11 @@
+/** Node-only acquisition and research algorithms. Hosts own routing, authorization and presentation. */
+export * from "./acquisitionCaseHandlers.js";
+export * from "./acquisitionCaseDirect.js";
+export * from "./prelaunchAcquisitionDirect.js";
+export * from "./acquisitionEvidenceDirect.js";
+export * from "./research/surveyResponseSubmitHandler.js";
+export * from "./research/adminSurveyResponsesHandler.js";
+export * from "./research/managedSurveyResponseSubmit.js";
+export { createAnalyticsContextHandler } from "./analyticsContext.js";
+export * from "./privacyContributor.js";
+export * from "./bindings.js";

package/dist/marketing/server/postgres/acquisitionCaseRoutines.d.ts

@@ -0,0 +1,10 @@
+import { Pool } from "pg";
+import type { AcquisitionCasePort } from "../acquisitionCasePorts.js";
+type Env = {
+    connectionString: string;
+};
+type Options = {
+    poolFactory?: (env: Env) => Pool | Promise<Pool>;
+};
+export declare function createPostgresAcquisitionCasePort(env: Env, options?: Options): AcquisitionCasePort;
+export {};

package/dist/marketing/server/postgres/acquisitionCaseRoutines.js

@@ -0,0 +1,204 @@
+import { Buffer } from "node:buffer";
+import { Pool } from "pg";
+import { ACQUISITION_CASE_CONTRACT_VERSION, acquisitionCaseListResponseSchema, acquisitionCaseProjectionSchema } from "../../acquisitionCaseSchemas.js";
+const ROLE = "SET LOCAL ROLE platform_acquisition_runtime";
+const SUBMIT = `SELECT public.acquisition_case_submit_v1(
+  $1::text,$2::text,$3::text,$4::text,$5::boolean,$6::text,$7::text,
+  $8::text,$9::text,$10::text,$11::text,$12::text,$13::text,$14::timestamptz
+) AS response`;
+const LIST = "SELECT public.acquisition_case_operator_list_v1($1::uuid,$2::timestamptz,$3::uuid,$4::integer) AS response";
+const GET = "SELECT public.acquisition_case_operator_get_v1($1::uuid,$2::text) AS response";
+const TRANSITION = `SELECT public.acquisition_case_transition_v1(
+  $1::uuid,$2::text,$3::bigint,$4::text,$5::text,$6::text,$7::timestamptz
+) AS response`;
+const ACTIVE_COUNT = "SELECT public.acquisition_case_active_count_v1() AS response";
+export function createPostgresAcquisitionCasePort(env, options = {}) {
+    if (!env.connectionString.trim())
+        throw new Error("acquisition_case_database_url_required");
+    let poolPromise = null;
+    const pool = () => poolPromise ??= Promise.resolve(options.poolFactory ? options.poolFactory(env) : new Pool({ connectionString: env.connectionString }));
+    const call = async (sql, values) => withRole(await pool(), async (client) => {
+        const result = await client.query(sql, values);
+        return object(result.rows[0])?.response ?? null;
+    });
+    return {
+        async submit(command) {
+            if (command.scope !== "public_tester_application" || command.sourceKind !== "tester_application") {
+                return failure("invalid");
+            }
+            try {
+                const request = command.request;
+                const response = object(await call(SUBMIT, [
+                    command.idempotencyKey,
+                    command.requesterKey,
+                    request.contact.email.trim().toLowerCase(),
+                    null,
+                    request.consent.accepted,
+                    request.consent.consentVersion,
+                    request.consent.policyVersion,
+                    request.consent.locale,
+                    command.sourcePath,
+                    request.addressReference.source,
+                    request.addressReference.reference,
+                    request.addressReference.revision,
+                    request.addressReference.provenance,
+                    command.acceptedAt,
+                ]));
+                return projectionResult(response);
+            }
+            catch (error) {
+                return databaseFailure(error);
+            }
+        },
+        async list(query) {
+            if (query.scope !== "public_tester_application")
+                return failure("invalid");
+            const cursor = decodeCursor(query.cursor);
+            if (cursor === undefined)
+                return failure("invalid");
+            try {
+                const response = object(await call(LIST, [
+                    query.actorRef,
+                    cursor?.createdAt ?? null,
+                    cursor?.id ?? null,
+                    query.limit,
+                ]));
+                if (!response || !Array.isArray(response.cases))
+                    return failure("unavailable");
+                const parsed = acquisitionCaseListResponseSchema.safeParse({
+                    contractVersion: response.contractVersion ?? ACQUISITION_CASE_CONTRACT_VERSION,
+                    cases: response.cases,
+                    nextCursor: response.nextCursor === null ? null : encodeCursor(response.nextCursor),
+                });
+                return parsed.success ? { ok: true, value: parsed.data } : failure("unavailable");
+            }
+            catch (error) {
+                return databaseFailure(error);
+            }
+        },
+        async get(query) {
+            if (query.scope !== "public_tester_application")
+                return failure("invalid");
+            try {
+                const response = object(await call(GET, [query.actorRef, query.caseRef]));
+                if (response?.outcome === "not_found")
+                    return failure("not_found");
+                return projectionResult(response);
+            }
+            catch (error) {
+                return databaseFailure(error);
+            }
+        },
+        async transition(command) {
+            if (command.scope !== "public_tester_application")
+                return failure("invalid");
+            const target = transitionTarget(command);
+            try {
+                const response = object(await call(TRANSITION, [
+                    command.actorRef,
+                    command.request.caseRef,
+                    command.request.expectedVersion,
+                    target,
+                    command.request.reason ?? null,
+                    command.idempotencyKey,
+                    new Date().toISOString(),
+                ]));
+                return projectionResult(response);
+            }
+            catch (error) {
+                return databaseFailure(error);
+            }
+        },
+        async activeCount(scope) {
+            if (scope !== "public_tester_application")
+                return failure("invalid");
+            try {
+                const raw = await call(ACTIVE_COUNT, []);
+                const count = typeof raw === "number" ? raw : Number(raw);
+                return Number.isSafeInteger(count) && count >= 0
+                    ? { ok: true, value: count }
+                    : failure("unavailable");
+            }
+            catch (error) {
+                return databaseFailure(error);
+            }
+        },
+        async close() {
+            if (poolPromise)
+                await (await poolPromise).end();
+        },
+    };
+}
+async function withRole(pool, work) {
+    const client = await pool.connect();
+    try {
+        await client.query("BEGIN");
+        await client.query(ROLE);
+        const value = await work(client);
+        await client.query("COMMIT");
+        return value;
+    }
+    catch (error) {
+        await client.query("ROLLBACK").catch(() => { });
+        throw error;
+    }
+    finally {
+        client.release();
+    }
+}
+function projectionResult(response) {
+    if (!response)
+        return failure("unavailable");
+    const outcome = response.outcome;
+    if (outcome === "created" || outcome === "replayed" || outcome === "transitioned" || outcome === "found") {
+        const parsed = acquisitionCaseProjectionSchema.safeParse(response.acquisitionCase);
+        return parsed.success
+            ? { ok: true, value: parsed.data, replayed: response.replayed === true }
+            : failure("unavailable");
+    }
+    return failure(outcomeFailure(outcome));
+}
+function outcomeFailure(outcome) {
+    if (outcome === "invalid_address")
+        return "invalid";
+    if (outcome === "rate_limited")
+        return "rate_limited";
+    if (outcome === "not_found")
+        return "not_found";
+    if (outcome === "idempotency_conflict" || outcome === "contact_conflict"
+        || outcome === "version_conflict" || outcome === "transition_conflict")
+        return "conflict";
+    return "unavailable";
+}
+function databaseFailure(error) {
+    return failure(object(error)?.code === "22023" ? "invalid" : "unavailable");
+}
+function failure(kind) {
+    return { ok: false, error: { kind } };
+}
+function transitionTarget(command) {
+    return { approve: "approved", activate: "active", reject: "rejected", withdraw: "withdrawn" }[command.request.transition];
+}
+function encodeCursor(value) {
+    const cursor = object(value);
+    if (!cursor || typeof cursor.createdAt !== "string" || typeof cursor.id !== "string") {
+        throw new Error("acquisition_case_cursor_invalid");
+    }
+    return Buffer.from(JSON.stringify({ createdAt: cursor.createdAt, id: cursor.id }), "utf8").toString("base64url");
+}
+function decodeCursor(value) {
+    if (value === undefined)
+        return null;
+    try {
+        const parsed = object(JSON.parse(Buffer.from(value, "base64url").toString("utf8")));
+        return parsed && typeof parsed.createdAt === "string" && typeof parsed.id === "string"
+            ? { createdAt: parsed.createdAt, id: parsed.id }
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function object(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}

package/dist/marketing/server/postgres/acquisitionEvidenceRoutines.d.ts

@@ -0,0 +1,10 @@
+import { Pool } from "pg";
+import type { AcquisitionEvidencePort } from "../../contracts/index.js";
+type Env = {
+    connectionString: string;
+};
+type Options = {
+    poolFactory?: (env: Env) => Pool | Promise<Pool>;
+};
+export declare function createPostgresAcquisitionEvidencePort(env: Env, options?: Options): AcquisitionEvidencePort;
+export {};

package/dist/marketing/server/postgres/acquisitionEvidenceRoutines.js

@@ -0,0 +1,107 @@
+import { Pool } from "pg";
+import { ACQUISITION_NEWSLETTER_VERSION, ACQUISITION_SURVEY_VERSION, acquisitionNewsletterConsentResponseSchema, acquisitionSurveyListResponseSchema, acquisitionSurveySubmitResponseSchema } from "../../acquisitionEvidenceSchemas.js";
+const ROLE = "SET LOCAL ROLE platform_acquisition_runtime";
+const SUBMIT = "SELECT public.acquisition_survey_submit_v1($1::text,$2::text,$3::text,$4::jsonb,$5::timestamptz) AS response";
+const LIST = "SELECT public.acquisition_survey_operator_list_v1($1::uuid,$2::text,$3::integer) AS response";
+const CONSENT = "SELECT public.acquisition_newsletter_consent_v1($1::text,$2::text,$3::text,$4::text,$5::text,$6::boolean,$7::timestamptz,$8::timestamptz) AS response";
+export function createPostgresAcquisitionEvidencePort(env, options = {}) {
+    if (!env.connectionString.trim())
+        throw new Error("acquisition_evidence_database_url_required");
+    let poolPromise = null;
+    const pool = () => poolPromise ??= Promise.resolve(options.poolFactory ? options.poolFactory(env) : new Pool({ connectionString: env.connectionString }));
+    const call = async (sql, values) => withRole(await pool(), async (client) => object(object((await client.query(sql, values)).rows[0])?.response));
+    return {
+        async submitSurvey(input) {
+            try {
+                const response = await call(SUBMIT, [input.idempotencyKey, input.caseReference,
+                    input.surveyType, JSON.stringify(input.responseData), new Date().toISOString()]);
+                const failure = outcomeFailure(response?.outcome);
+                if (failure)
+                    return fail(failure);
+                const parsed = acquisitionSurveySubmitResponseSchema.safeParse({
+                    contractVersion: ACQUISITION_SURVEY_VERSION,
+                    evidence: response?.evidence,
+                    replayed: response?.replayed === true,
+                });
+                return parsed.success ? { ok: true, value: parsed.data } : fail("unavailable");
+            }
+            catch (error) {
+                return databaseFailure(error);
+            }
+        },
+        async listSurveys(input) {
+            try {
+                const response = await call(LIST, [input.actorReference, input.surveyType ?? null, input.limit]);
+                const parsed = acquisitionSurveyListResponseSchema.safeParse({
+                    contractVersion: ACQUISITION_SURVEY_VERSION,
+                    rows: response?.rows,
+                    totalCount: number(response?.totalCount),
+                });
+                return parsed.success ? { ok: true, value: parsed.data } : fail("unavailable");
+            }
+            catch (error) {
+                return databaseFailure(error);
+            }
+        },
+        async applyNewsletterConsent(input) {
+            try {
+                const response = await call(CONSENT, [input.caseReference, input.contactReference,
+                    input.eventReference, input.eventType, input.purpose, input.explicitOptInEvidence,
+                    input.occurredAt, new Date().toISOString()]);
+                const failure = outcomeFailure(response?.outcome);
+                if (failure)
+                    return fail(failure);
+                const parsed = acquisitionNewsletterConsentResponseSchema.safeParse({
+                    contractVersion: ACQUISITION_NEWSLETTER_VERSION,
+                    eventReference: response?.eventReference,
+                    outcome: response?.outcome,
+                    consentState: response?.consentState ?? null,
+                    auditReference: response?.auditReference,
+                    replayed: response?.replayed === true,
+                });
+                return parsed.success ? { ok: true, value: parsed.data } : fail("unavailable");
+            }
+            catch (error) {
+                return databaseFailure(error);
+            }
+        },
+        async close() { if (poolPromise)
+            await (await poolPromise).end(); },
+    };
+}
+async function withRole(pool, work) {
+    const client = await pool.connect();
+    try {
+        await client.query("BEGIN");
+        await client.query(ROLE);
+        const value = await work(client);
+        await client.query("COMMIT");
+        return value;
+    }
+    catch (error) {
+        await client.query("ROLLBACK").catch(() => { });
+        throw error;
+    }
+    finally {
+        client.release();
+    }
+}
+function outcomeFailure(outcome) {
+    if (outcome === "not_found")
+        return "not_found";
+    if (outcome === "idempotency_conflict")
+        return "conflict";
+    if (["recorded", "replayed", "applied", "ignored", "stale"].includes(String(outcome)))
+        return null;
+    return "unavailable";
+}
+function databaseFailure(error) {
+    return fail(object(error)?.code === "22023" ? "invalid" : "unavailable");
+}
+function fail(kind) {
+    return { ok: false, error: { kind } };
+}
+function object(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function number(value) { return typeof value === "number" ? value : Number(value); }

package/dist/marketing/server/postgres/index.d.ts

@@ -0,0 +1,3 @@
+/** PostgreSQL acquisition ports; select with the optional pg peer. */
+export { createPostgresAcquisitionCasePort } from "./acquisitionCaseRoutines.js";
+export { createPostgresAcquisitionEvidencePort } from "./acquisitionEvidenceRoutines.js";

package/dist/marketing/server/postgres/index.js

@@ -0,0 +1,3 @@
+/** PostgreSQL acquisition ports; select with the optional pg peer. */
+export { createPostgresAcquisitionCasePort } from "./acquisitionCaseRoutines.js";
+export { createPostgresAcquisitionEvidencePort } from "./acquisitionEvidenceRoutines.js";

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

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

package/dist/marketing/server/prelaunchAcquisitionDirect.js

@@ -0,0 +1,122 @@
+import { PRELAUNCH_ACQUISITION_CONTRACT_VERSION, prelaunchAcquisitionDetailRequestSchema, prelaunchAcquisitionDetailResponseSchema, prelaunchAcquisitionListRequestSchema, prelaunchAcquisitionListResponseSchema, } from "../prelaunchAcquisitionSchemas.js";
+export function createPrelaunchAcquisitionListHandler(options) {
+    const { respond, authorize, resolveBinding } = options;
+    const { sendBffSuccess, sendMethodNotAllowed } = respond;
+    return async (req, res) => {
+        if (req.method !== "GET")
+            return sendMethodNotAllowed(res, ["GET"]);
+        const actorRef = await authorize(req, res);
+        if (!actorRef)
+            return;
+        const request = prelaunchAcquisitionListRequestSchema.safeParse({
+            view: first(req.query.view),
+            cursor: first(req.query.cursor),
+            limit: 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, {
+            view: "acquisition_case_v1",
+            ...(request.data.cursor ? { cursor: request.data.cursor } : {}),
+            limit: request.data.limit,
+        }));
+        if (!result)
+            return;
+        if (result.ok === false)
+            return failure(res, respond, result.error.kind);
+        const response = prelaunchAcquisitionListResponseSchema.safeParse({
+            contractVersion: PRELAUNCH_ACQUISITION_CONTRACT_VERSION,
+            leads: result.value.cases.map(toLead),
+            nextCursor: result.value.nextCursor,
+        });
+        if (!response.success)
+            return invalidResponse(res, respond);
+        sendBffSuccess(res, response.data);
+    };
+}
+export function createPrelaunchAcquisitionDetailHandler(options) {
+    const { respond, authorize, resolveBinding } = options;
+    const { sendBffSuccess, sendMethodNotAllowed } = respond;
+    return async (req, res) => {
+        if (req.method !== "GET")
+            return sendMethodNotAllowed(res, ["GET"]);
+        const actorRef = await authorize(req, res);
+        if (!actorRef)
+            return;
+        const request = prelaunchAcquisitionDetailRequestSchema.safeParse({
+            sourceRef: first(req.query.sourceRef),
+        });
+        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.get(actorRef, request.data.sourceRef));
+        if (!result)
+            return;
+        if (result.ok === false)
+            return failure(res, respond, result.error.kind);
+        const response = prelaunchAcquisitionDetailResponseSchema.safeParse({
+            contractVersion: PRELAUNCH_ACQUISITION_CONTRACT_VERSION,
+            lead: toLead(result.value),
+        });
+        if (!response.success)
+            return invalidResponse(res, respond);
+        sendBffSuccess(res, response.data);
+    };
+}
+function toLead(value) {
+    return {
+        sourceRef: value.caseRef,
+        contactRef: value.contactRef,
+        sourceKind: value.sourceKind,
+        consent: value.consent,
+        addressReference: value.addressReference,
+        state: value.state,
+        version: value.version,
+        createdAt: value.createdAt,
+        updatedAt: value.updatedAt,
+    };
+}
+async function bindingOrError(res, respond, resolve) {
+    try {
+        const binding = await resolve();
+        if (binding)
+            return binding;
+    }
+    catch { /* fail closed below */ }
+    respond.sendBffError(res, "UPSTREAM_UNAVAILABLE", "Prelaunch acquisition service unavailable");
+    return null;
+}
+async function operationOrError(res, respond, operation) {
+    try {
+        return await operation();
+    }
+    catch {
+        respond.sendBffError(res, "UPSTREAM_UNAVAILABLE", "Prelaunch acquisition service unavailable");
+        return null;
+    }
+}
+function first(value) {
+    return Array.isArray(value) ? value[0] : value;
+}
+function badRequest(res, respond, details) {
+    respond.sendBffError(res, "BAD_REQUEST", "Invalid prelaunch acquisition request", { details });
+}
+function invalidResponse(res, respond) {
+    respond.sendBffError(res, "INVALID_RESPONSE", "Prelaunch acquisition returned invalid response");
+}
+function failure(res, respond, kind) {
+    if (kind === "invalid")
+        return badRequest(res, respond);
+    if (kind === "not_found")
+        return respond.sendBffError(res, "NOT_FOUND", "Prelaunch acquisition case not found");
+    if (kind === "conflict")
+        return respond.sendBffError(res, "CONFLICT", "Prelaunch acquisition request conflicts with prior state");
+    if (kind === "rate_limited")
+        return respond.sendBffError(res, "RATE_LIMITED", "Prelaunch acquisition request rate limited");
+    respond.sendBffError(res, "UPSTREAM_UNAVAILABLE", "Prelaunch acquisition service unavailable");
+}