@openlup/platform 0.28.0 → 0.30.0

package/dist/marketing/prelaunchAcquisitionSchemas.d.ts

@@ -0,0 +1,116 @@
+import { z } from "./validation.js";
+export declare const PRELAUNCH_ACQUISITION_VIEW: "prelaunch_acquisition_v1";
+export declare const PRELAUNCH_ACQUISITION_CONTRACT_VERSION: "prelaunch_acquisition_v1";
+export declare const prelaunchAcquisitionListRequestSchema: z.ZodObject<{
+    view: z.ZodLiteral<"prelaunch_acquisition_v1">;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export declare const prelaunchAcquisitionDetailRequestSchema: z.ZodObject<{
+    sourceRef: z.ZodString;
+}, z.core.$strict>;
+export declare const prelaunchAcquisitionLeadSchema: z.ZodObject<{
+    sourceRef: z.ZodString;
+    contactRef: z.ZodString;
+    sourceKind: z.ZodLiteral<"tester_application">;
+    consent: z.ZodObject<{
+        consentVersion: z.ZodString;
+        policyVersion: z.ZodString;
+        recordedAt: z.ZodString;
+        locale: z.ZodEnum<{
+            en: "en";
+            pl: "pl";
+        }>;
+        sourcePath: z.ZodLiteral<"/tester-application">;
+    }, z.core.$strict>;
+    addressReference: z.ZodNullable<z.ZodObject<{
+        source: z.ZodString;
+        reference: z.ZodString;
+        revision: z.ZodString;
+        provenance: z.ZodString;
+    }, z.core.$strict>>;
+    state: z.ZodEnum<{
+        rejected: "rejected";
+        active: "active";
+        submitted: "submitted";
+        withdrawn: "withdrawn";
+        approved: "approved";
+    }>;
+    version: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strict>;
+export declare const prelaunchAcquisitionListResponseSchema: z.ZodObject<{
+    contractVersion: z.ZodLiteral<"prelaunch_acquisition_v1">;
+    leads: z.ZodArray<z.ZodObject<{
+        sourceRef: z.ZodString;
+        contactRef: z.ZodString;
+        sourceKind: z.ZodLiteral<"tester_application">;
+        consent: z.ZodObject<{
+            consentVersion: z.ZodString;
+            policyVersion: z.ZodString;
+            recordedAt: z.ZodString;
+            locale: z.ZodEnum<{
+                en: "en";
+                pl: "pl";
+            }>;
+            sourcePath: z.ZodLiteral<"/tester-application">;
+        }, z.core.$strict>;
+        addressReference: z.ZodNullable<z.ZodObject<{
+            source: z.ZodString;
+            reference: z.ZodString;
+            revision: z.ZodString;
+            provenance: z.ZodString;
+        }, z.core.$strict>>;
+        state: z.ZodEnum<{
+            rejected: "rejected";
+            active: "active";
+            submitted: "submitted";
+            withdrawn: "withdrawn";
+            approved: "approved";
+        }>;
+        version: z.ZodNumber;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const prelaunchAcquisitionDetailResponseSchema: z.ZodObject<{
+    contractVersion: z.ZodLiteral<"prelaunch_acquisition_v1">;
+    lead: z.ZodObject<{
+        sourceRef: z.ZodString;
+        contactRef: z.ZodString;
+        sourceKind: z.ZodLiteral<"tester_application">;
+        consent: z.ZodObject<{
+            consentVersion: z.ZodString;
+            policyVersion: z.ZodString;
+            recordedAt: z.ZodString;
+            locale: z.ZodEnum<{
+                en: "en";
+                pl: "pl";
+            }>;
+            sourcePath: z.ZodLiteral<"/tester-application">;
+        }, z.core.$strict>;
+        addressReference: z.ZodNullable<z.ZodObject<{
+            source: z.ZodString;
+            reference: z.ZodString;
+            revision: z.ZodString;
+            provenance: z.ZodString;
+        }, z.core.$strict>>;
+        state: z.ZodEnum<{
+            rejected: "rejected";
+            active: "active";
+            submitted: "submitted";
+            withdrawn: "withdrawn";
+            approved: "approved";
+        }>;
+        version: z.ZodNumber;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type PrelaunchAcquisitionListRequest = z.infer<typeof prelaunchAcquisitionListRequestSchema>;
+export type PrelaunchAcquisitionDetailRequest = z.infer<typeof prelaunchAcquisitionDetailRequestSchema>;
+export type PrelaunchAcquisitionLead = z.infer<typeof prelaunchAcquisitionLeadSchema>;
+export type PrelaunchAcquisitionListResponse = z.infer<typeof prelaunchAcquisitionListResponseSchema>;
+export type PrelaunchAcquisitionDetailResponse = z.infer<typeof prelaunchAcquisitionDetailResponseSchema>;

package/dist/marketing/prelaunchAcquisitionSchemas.js

@@ -0,0 +1,51 @@
+import { z } from "./validation.js";
+export const PRELAUNCH_ACQUISITION_VIEW = "prelaunch_acquisition_v1";
+export const PRELAUNCH_ACQUISITION_CONTRACT_VERSION = "prelaunch_acquisition_v1";
+const acquisitionCaseRefSchema = z.string().regex(/^acquisition-case:[0-9a-f-]{36}$/);
+const acquisitionContactRefSchema = z.string().regex(/^acquisition-contact:[0-9a-f-]{36}$/);
+const acquisitionOpaqueRefSchema = z.string().trim().min(8).max(160)
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/);
+const acquisitionDateTimeSchema = z.string().datetime({ offset: true });
+export const prelaunchAcquisitionListRequestSchema = z.object({
+    view: z.literal(PRELAUNCH_ACQUISITION_VIEW),
+    cursor: acquisitionOpaqueRefSchema.optional(),
+    limit: z.coerce.number().int().min(1).max(100).default(25),
+}).strict();
+export const prelaunchAcquisitionDetailRequestSchema = z.object({
+    sourceRef: acquisitionCaseRefSchema,
+}).strict();
+export const prelaunchAcquisitionLeadSchema = z.object({
+    sourceRef: acquisitionCaseRefSchema,
+    contactRef: acquisitionContactRefSchema,
+    sourceKind: z.literal("tester_application"),
+    consent: z.object({
+        consentVersion: z.string().min(1).max(64),
+        policyVersion: z.string().min(1).max(64),
+        recordedAt: acquisitionDateTimeSchema,
+        locale: z.enum(["en", "pl"]),
+        sourcePath: z.literal("/tester-application"),
+    }).strict(),
+    addressReference: z.object({
+        source: z.string().trim().min(1).max(48).regex(/^[a-z][a-z0-9_-]*$/),
+        reference: acquisitionOpaqueRefSchema,
+        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().nullable(),
+    state: z.enum(["submitted", "approved", "active", "rejected", "withdrawn"]),
+    version: z.number().int().positive(),
+    createdAt: acquisitionDateTimeSchema,
+    updatedAt: acquisitionDateTimeSchema,
+}).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 prelaunchAcquisitionListResponseSchema = z.object({
+    contractVersion: z.literal(PRELAUNCH_ACQUISITION_CONTRACT_VERSION),
+    leads: z.array(prelaunchAcquisitionLeadSchema).max(100),
+    nextCursor: acquisitionOpaqueRefSchema.nullable(),
+}).strict();
+export const prelaunchAcquisitionDetailResponseSchema = z.object({
+    contractVersion: z.literal(PRELAUNCH_ACQUISITION_CONTRACT_VERSION),
+    lead: prelaunchAcquisitionLeadSchema,
+}).strict();

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

@@ -0,0 +1,157 @@
+import type { OrganizationFacts } from "../contracts/contactLegal.js";
+export type JsonLdNode = Record<string, unknown> & {
+    "@context"?: string;
+    "@id"?: string;
+};
+export declare function jsonLdGraph(...nodes: JsonLdNode[]): {
+    "@context": string;
+    "@graph": {
+        [x: string]: unknown;
+        "@id"?: string;
+    }[];
+};
+export declare function entityIds(origin: string): {
+    organization: string;
+    website: string;
+    brand: string;
+};
+export declare function organizationLd(origin: string, type: "Organization" | "OnlineStore", facts: OrganizationFacts): {
+    "@context": string;
+    "@id": string;
+    "@type": "Organization" | "OnlineStore";
+    name: string;
+    legalName: string;
+    url: string;
+    logo: {
+        "@type": string;
+        url: string;
+        contentUrl: string;
+        width: number;
+        height: number;
+    };
+    email: string;
+    vatID: string;
+    taxID: string;
+    areaServed: string;
+    sameAs: string[];
+    contactPoint: {
+        "@type": string;
+        email: string;
+        contactType: string;
+        availableLanguage: string[];
+    };
+    address: {
+        "@type": string;
+        streetAddress: string;
+        addressLocality: string;
+        postalCode: string;
+        addressRegion: string;
+        addressCountry: string;
+    };
+};
+export declare function brandLd(origin: string, name: string, url: string): {
+    "@context": string;
+    "@id": string;
+    "@type": string;
+    name: string;
+    url: string;
+};
+export declare function websiteLd(origin: string, name: string, url: string, inLanguage: string[]): {
+    "@context": string;
+    "@id": string;
+    "@type": string;
+    name: string;
+    url: string;
+    inLanguage: string[];
+    publisher: {
+        "@id": string;
+    };
+};
+export declare function contactPageLd(origin: string, pageUrl: string): {
+    "@context": string;
+    "@id": string;
+    "@type": string;
+    url: string;
+    publisher: {
+        "@id": string;
+    };
+    mainEntity: {
+        "@id": string;
+    };
+};
+export interface NetContent {
+    unscaled: number;
+    scale: number;
+    unit: string;
+}
+export declare function schemaWeight(netContent: NetContent): {
+    "@type": string;
+    value: number;
+    unitCode: string;
+};
+export interface ProductFacts {
+    url: string;
+    name: string;
+    inLanguage: string;
+    brandName: string;
+    category?: string;
+    images: string[];
+    sku?: string;
+    gtin13?: string;
+    netContent?: NetContent;
+}
+export declare function productLd(origin: string, product: ProductFacts): {
+    url: string;
+    weight?: {
+        "@type": string;
+        value: number;
+        unitCode: string;
+    } | undefined;
+    gtin13?: string | undefined;
+    sku?: string | undefined;
+    image: string[];
+    category?: string | undefined;
+    "@context": string;
+    "@id": string;
+    "@type": string;
+    name: string;
+    inLanguage: string;
+    brand: {
+        "@id": string;
+        "@type": string;
+        name: string;
+    };
+    manufacturer: {
+        "@id": string;
+    };
+};
+export declare function faqPageLd(faqs: {
+    question: string;
+    answer: string;
+}[], pageUrl: string): {
+    "@context": string;
+    "@id": string;
+    "@type": string;
+    mainEntity: {
+        "@type": string;
+        name: string;
+        acceptedAnswer: {
+            "@type": string;
+            text: string;
+        };
+    }[];
+};
+export declare function breadcrumbLd(items: {
+    name: string;
+    url?: string;
+}[], pageUrl: string): {
+    "@context": string;
+    "@id": string;
+    "@type": string;
+    itemListElement: {
+        item?: string | undefined;
+        "@type": string;
+        position: number;
+        name: string;
+    }[];
+};

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");
+}