@voyant-travel/inventory 0.1.0

package/dist/routes-configuration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes-configuration.d.ts","sourceRoot":"","sources":["../src/routes-configuration.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAA;AAIzC,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAobnC,CAAA"}

package/dist/routes-configuration.js

@@ -0,0 +1,364 @@
+import { parseJsonBody, parseQuery } from "@voyant-travel/hono";
+import { Hono } from "hono";
+import { appendProductMutationLedgerEntry, changedMutationFields } from "./action-ledger.js";
+import { productsService } from "./service.js";
+import * as validation from "./validation.js";
+export const productConfigurationRoutes = new Hono()
+    // ==========================================================================
+    // Product operating configuration
+    // ==========================================================================
+    .get("/activation-settings", async (c) => {
+    const query = parseQuery(c, validation.productActivationSettingListQuerySchema);
+    return c.json(await productsService.listActivationSettings(c.get("db"), query));
+})
+    .get("/activation-settings/:id", async (c) => {
+    const row = await productsService.getActivationSettingById(c.get("db"), c.req.param("id"));
+    if (!row) {
+        return c.json({ error: "Product activation setting not found" }, 404);
+    }
+    return c.json({ data: row });
+})
+    .post("/:id/activation-settings", async (c) => {
+    const productId = c.req.param("id");
+    const body = await parseJsonBody(c, validation.insertProductActivationSettingSchema);
+    const before = await productsService.getActivationSettingByProductId(c.get("db"), productId);
+    const row = await productsService.upsertActivationSetting(c.get("db"), productId, body);
+    if (!row) {
+        return c.json({ error: "Product not found" }, 404);
+    }
+    const action = before ? "update" : "create";
+    await appendProductMutationLedgerEntry(c, {
+        action,
+        productId,
+        changedFields: changedMutationFields(body, before, row),
+        subject: "product activation settings",
+        actionName: `product.activation_settings.${action}`,
+        routeOrToolName: `products.activation_settings.${action}`,
+    });
+    return c.json({ data: row }, 201);
+})
+    .patch("/activation-settings/:id", async (c) => {
+    const id = c.req.param("id");
+    const body = await parseJsonBody(c, validation.updateProductActivationSettingSchema);
+    const before = await productsService.getActivationSettingById(c.get("db"), id);
+    if (!before) {
+        return c.json({ error: "Product activation setting not found" }, 404);
+    }
+    const row = await productsService.updateActivationSetting(c.get("db"), id, body);
+    if (!row) {
+        return c.json({ error: "Product activation setting not found" }, 404);
+    }
+    await appendProductMutationLedgerEntry(c, {
+        action: "update",
+        productId: row.productId,
+        changedFields: changedMutationFields(body, before, row),
+        subject: "product activation settings",
+        actionName: "product.activation_settings.update",
+        routeOrToolName: "products.activation_settings.update",
+    });
+    return c.json({ data: row });
+})
+    .delete("/activation-settings/:id", async (c) => {
+    const id = c.req.param("id");
+    const before = await productsService.getActivationSettingById(c.get("db"), id);
+    if (!before) {
+        return c.json({ error: "Product activation setting not found" }, 404);
+    }
+    const row = await productsService.deleteActivationSetting(c.get("db"), id);
+    if (!row) {
+        return c.json({ error: "Product activation setting not found" }, 404);
+    }
+    await appendProductMutationLedgerEntry(c, {
+        action: "delete",
+        productId: before.productId,
+        changedFields: [],
+        subject: "product activation settings",
+        actionName: "product.activation_settings.delete",
+        routeOrToolName: "products.activation_settings.delete",
+    });
+    return c.json({ success: true }, 200);
+})
+    .get("/ticket-settings", async (c) => {
+    const query = parseQuery(c, validation.productTicketSettingListQuerySchema);
+    return c.json(await productsService.listTicketSettings(c.get("db"), query));
+})
+    .get("/ticket-settings/:id", async (c) => {
+    const row = await productsService.getTicketSettingById(c.get("db"), c.req.param("id"));
+    if (!row) {
+        return c.json({ error: "Product ticket setting not found" }, 404);
+    }
+    return c.json({ data: row });
+})
+    .post("/:id/ticket-settings", async (c) => {
+    const productId = c.req.param("id");
+    const body = await parseJsonBody(c, validation.insertProductTicketSettingSchema);
+    const before = await productsService.getTicketSettingByProductId(c.get("db"), productId);
+    const row = await productsService.upsertTicketSetting(c.get("db"), productId, body);
+    if (!row) {
+        return c.json({ error: "Product not found" }, 404);
+    }
+    const action = before ? "update" : "create";
+    await appendProductMutationLedgerEntry(c, {
+        action,
+        productId,
+        changedFields: changedMutationFields(body, before, row),
+        subject: "product ticket settings",
+        actionName: `product.ticket_settings.${action}`,
+        routeOrToolName: `products.ticket_settings.${action}`,
+    });
+    return c.json({ data: row }, 201);
+})
+    .patch("/ticket-settings/:id", async (c) => {
+    const id = c.req.param("id");
+    const body = await parseJsonBody(c, validation.updateProductTicketSettingSchema);
+    const before = await productsService.getTicketSettingById(c.get("db"), id);
+    if (!before) {
+        return c.json({ error: "Product ticket setting not found" }, 404);
+    }
+    const row = await productsService.updateTicketSetting(c.get("db"), id, body);
+    if (!row) {
+        return c.json({ error: "Product ticket setting not found" }, 404);
+    }
+    await appendProductMutationLedgerEntry(c, {
+        action: "update",
+        productId: row.productId,
+        changedFields: changedMutationFields(body, before, row),
+        subject: "product ticket settings",
+        actionName: "product.ticket_settings.update",
+        routeOrToolName: "products.ticket_settings.update",
+    });
+    return c.json({ data: row });
+})
+    .delete("/ticket-settings/:id", async (c) => {
+    const id = c.req.param("id");
+    const before = await productsService.getTicketSettingById(c.get("db"), id);
+    if (!before) {
+        return c.json({ error: "Product ticket setting not found" }, 404);
+    }
+    const row = await productsService.deleteTicketSetting(c.get("db"), id);
+    if (!row) {
+        return c.json({ error: "Product ticket setting not found" }, 404);
+    }
+    await appendProductMutationLedgerEntry(c, {
+        action: "delete",
+        productId: before.productId,
+        changedFields: [],
+        subject: "product ticket settings",
+        actionName: "product.ticket_settings.delete",
+        routeOrToolName: "products.ticket_settings.delete",
+    });
+    return c.json({ success: true }, 200);
+})
+    .get("/visibility-settings", async (c) => {
+    const query = parseQuery(c, validation.productVisibilitySettingListQuerySchema);
+    return c.json(await productsService.listVisibilitySettings(c.get("db"), query));
+})
+    .get("/visibility-settings/:id", async (c) => {
+    const row = await productsService.getVisibilitySettingById(c.get("db"), c.req.param("id"));
+    if (!row) {
+        return c.json({ error: "Product visibility setting not found" }, 404);
+    }
+    return c.json({ data: row });
+})
+    .post("/:id/visibility-settings", async (c) => {
+    const productId = c.req.param("id");
+    const body = await parseJsonBody(c, validation.insertProductVisibilitySettingSchema);
+    const before = await productsService.getVisibilitySettingByProductId(c.get("db"), productId);
+    const row = await productsService.upsertVisibilitySetting(c.get("db"), productId, body);
+    if (!row) {
+        return c.json({ error: "Product not found" }, 404);
+    }
+    const action = before ? "update" : "create";
+    await appendProductMutationLedgerEntry(c, {
+        action,
+        productId,
+        changedFields: changedMutationFields(body, before, row),
+        subject: "product visibility settings",
+        actionName: `product.visibility_settings.${action}`,
+        routeOrToolName: `products.visibility_settings.${action}`,
+    });
+    return c.json({ data: row }, 201);
+})
+    .patch("/visibility-settings/:id", async (c) => {
+    const id = c.req.param("id");
+    const body = await parseJsonBody(c, validation.updateProductVisibilitySettingSchema);
+    const before = await productsService.getVisibilitySettingById(c.get("db"), id);
+    if (!before) {
+        return c.json({ error: "Product visibility setting not found" }, 404);
+    }
+    const row = await productsService.updateVisibilitySetting(c.get("db"), id, body);
+    if (!row) {
+        return c.json({ error: "Product visibility setting not found" }, 404);
+    }
+    await appendProductMutationLedgerEntry(c, {
+        action: "update",
+        productId: row.productId,
+        changedFields: changedMutationFields(body, before, row),
+        subject: "product visibility settings",
+        actionName: "product.visibility_settings.update",
+        routeOrToolName: "products.visibility_settings.update",
+    });
+    return c.json({ data: row });
+})
+    .delete("/visibility-settings/:id", async (c) => {
+    const id = c.req.param("id");
+    const before = await productsService.getVisibilitySettingById(c.get("db"), id);
+    if (!before) {
+        return c.json({ error: "Product visibility setting not found" }, 404);
+    }
+    const row = await productsService.deleteVisibilitySetting(c.get("db"), id);
+    if (!row) {
+        return c.json({ error: "Product visibility setting not found" }, 404);
+    }
+    await appendProductMutationLedgerEntry(c, {
+        action: "delete",
+        productId: before.productId,
+        changedFields: [],
+        subject: "product visibility settings",
+        actionName: "product.visibility_settings.delete",
+        routeOrToolName: "products.visibility_settings.delete",
+    });
+    return c.json({ success: true }, 200);
+})
+    .get("/capabilities", async (c) => {
+    const query = parseQuery(c, validation.productCapabilityListQuerySchema);
+    return c.json(await productsService.listCapabilities(c.get("db"), query));
+})
+    .get("/capabilities/:id", async (c) => {
+    const row = await productsService.getCapabilityById(c.get("db"), c.req.param("id"));
+    if (!row) {
+        return c.json({ error: "Product capability not found" }, 404);
+    }
+    return c.json({ data: row });
+})
+    .post("/:id/capabilities", async (c) => {
+    const productId = c.req.param("id");
+    const body = await parseJsonBody(c, validation.insertProductCapabilitySchema);
+    const before = await productsService.getCapabilityByProductAndName(c.get("db"), productId, body.capability);
+    const row = await productsService.createCapability(c.get("db"), productId, body);
+    if (!row) {
+        return c.json({ error: "Product not found" }, 404);
+    }
+    const action = before ? "update" : "create";
+    await appendProductMutationLedgerEntry(c, {
+        action,
+        productId,
+        changedFields: changedMutationFields(body, before, row),
+        subject: "product capability",
+        actionName: `product.capability.${action}`,
+        routeOrToolName: `products.capability.${action}`,
+    });
+    return c.json({ data: row }, 201);
+})
+    .patch("/capabilities/:id", async (c) => {
+    const id = c.req.param("id");
+    const body = await parseJsonBody(c, validation.updateProductCapabilitySchema);
+    const before = await productsService.getCapabilityById(c.get("db"), id);
+    if (!before) {
+        return c.json({ error: "Product capability not found" }, 404);
+    }
+    const row = await productsService.updateCapability(c.get("db"), id, body);
+    if (!row) {
+        return c.json({ error: "Product capability not found" }, 404);
+    }
+    await appendProductMutationLedgerEntry(c, {
+        action: "update",
+        productId: row.productId,
+        changedFields: changedMutationFields(body, before, row),
+        subject: "product capability",
+        actionName: "product.capability.update",
+        routeOrToolName: "products.capability.update",
+    });
+    return c.json({ data: row });
+})
+    .delete("/capabilities/:id", async (c) => {
+    const id = c.req.param("id");
+    const before = await productsService.getCapabilityById(c.get("db"), id);
+    if (!before) {
+        return c.json({ error: "Product capability not found" }, 404);
+    }
+    const row = await productsService.deleteCapability(c.get("db"), id);
+    if (!row) {
+        return c.json({ error: "Product capability not found" }, 404);
+    }
+    await appendProductMutationLedgerEntry(c, {
+        action: "delete",
+        productId: before.productId,
+        changedFields: [],
+        subject: "product capability",
+        actionName: "product.capability.delete",
+        routeOrToolName: "products.capability.delete",
+    });
+    return c.json({ success: true }, 200);
+})
+    .get("/delivery-formats", async (c) => {
+    const query = parseQuery(c, validation.productDeliveryFormatListQuerySchema);
+    return c.json(await productsService.listDeliveryFormats(c.get("db"), query));
+})
+    .get("/delivery-formats/:id", async (c) => {
+    const row = await productsService.getDeliveryFormatById(c.get("db"), c.req.param("id"));
+    if (!row) {
+        return c.json({ error: "Product delivery format not found" }, 404);
+    }
+    return c.json({ data: row });
+})
+    .post("/:id/delivery-formats", async (c) => {
+    const productId = c.req.param("id");
+    const body = await parseJsonBody(c, validation.insertProductDeliveryFormatSchema);
+    const before = await productsService.getDeliveryFormatByProductAndFormat(c.get("db"), productId, body.format);
+    const row = await productsService.createDeliveryFormat(c.get("db"), productId, body);
+    if (!row) {
+        return c.json({ error: "Product not found" }, 404);
+    }
+    const action = before ? "update" : "create";
+    await appendProductMutationLedgerEntry(c, {
+        action,
+        productId,
+        changedFields: changedMutationFields(body, before, row),
+        subject: "product delivery format",
+        actionName: `product.delivery_format.${action}`,
+        routeOrToolName: `products.delivery_format.${action}`,
+    });
+    return c.json({ data: row }, 201);
+})
+    .patch("/delivery-formats/:id", async (c) => {
+    const id = c.req.param("id");
+    const body = await parseJsonBody(c, validation.updateProductDeliveryFormatSchema);
+    const before = await productsService.getDeliveryFormatById(c.get("db"), id);
+    if (!before) {
+        return c.json({ error: "Product delivery format not found" }, 404);
+    }
+    const row = await productsService.updateDeliveryFormat(c.get("db"), id, body);
+    if (!row) {
+        return c.json({ error: "Product delivery format not found" }, 404);
+    }
+    await appendProductMutationLedgerEntry(c, {
+        action: "update",
+        productId: row.productId,
+        changedFields: changedMutationFields(body, before, row),
+        subject: "product delivery format",
+        actionName: "product.delivery_format.update",
+        routeOrToolName: "products.delivery_format.update",
+    });
+    return c.json({ data: row });
+})
+    .delete("/delivery-formats/:id", async (c) => {
+    const id = c.req.param("id");
+    const before = await productsService.getDeliveryFormatById(c.get("db"), id);
+    if (!before) {
+        return c.json({ error: "Product delivery format not found" }, 404);
+    }
+    const row = await productsService.deleteDeliveryFormat(c.get("db"), id);
+    if (!row) {
+        return c.json({ error: "Product delivery format not found" }, 404);
+    }
+    await appendProductMutationLedgerEntry(c, {
+        action: "delete",
+        productId: before.productId,
+        changedFields: [],
+        subject: "product delivery format",
+        actionName: "product.delivery_format.delete",
+        routeOrToolName: "products.delivery_format.delete",
+    });
+    return c.json({ success: true }, 200);
+});

package/dist/routes-content.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Product content routes — unified owned + sourced detail endpoint.
+ *
+ *   GET /:id/content
+ *
+ * Returns the full `ProductContent` payload for ANY product:
+ *   - **Sourced**: cache hit → cached row + overlay merge; cache miss
+ *     with rich adapter → adapter fetch + write-through; cache miss
+ *     with thin adapter → synthesizer fallback (sourced-content §3.3,
+ *     §3.4, §3.6).
+ *   - **Owned**: read from the products module's own tables and
+ *     project to ProductContent. Overlay merge applies the same way.
+ *     Marked `source: "owned"` in the response.
+ *
+ * 404 only when the entity doesn't exist (no sourced-entry row AND
+ * no owned product row). The catalog detail sheet calls this on
+ * click to enrich the indexed projection with itinerary, media,
+ * options, and policies.
+ *
+ * Templates mount this router under their preferred prefix; the
+ * factory takes a `resolveRegistry` callback so the catalog
+ * `SourceAdapterRegistry` stays starter-owned (singleton lifetime,
+ * adapters carry HTTP clients).
+ *
+ * See `docs/architecture/catalog-sourced-content.md` §3.3.
+ */
+import type { SourceAdapterRegistry } from "@voyant-travel/catalog/booking-engine";
+import type { AnyDrizzleDb } from "@voyant-travel/db";
+import type { Context } from "hono";
+import { Hono } from "hono";
+export interface ProductContentRoutesEnv {
+    Variables: {
+        db: AnyDrizzleDb;
+    };
+}
+export interface CreateProductContentRoutesOptions {
+    /**
+     * Resolve the catalog `SourceAdapterRegistry` for the current
+     * request. Templates typically return a process-local singleton
+     * built lazily from env (mirroring the booking-engine registry
+     * pattern).
+     */
+    resolveRegistry: (c: Context) => SourceAdapterRegistry;
+    /**
+     * Optional sink for overlay-merge diagnostics. When set, called
+     * once per overlay that fails to apply. Defaults to silent (the
+     * read still succeeds; the bad overlay is skipped).
+     */
+    onOverlayError?: (event: {
+        field_path: string;
+        reason: string;
+    }) => void;
+    /**
+     * Optional override for `acceptMachineTranslated`. Defaults to
+     * `true` — storefront-friendly. Operator surfaces typically set
+     * `false` so ops sees authored content before deciding to override.
+     */
+    defaultAcceptMachineTranslated?: boolean;
+}
+/**
+ * Build the product content router. Returns a Hono instance that
+ * exposes a single `GET /:id/content` route. Templates mount it under
+ * `/v1/admin/products` or `/v1/public/products` as appropriate.
+ */
+export declare function createProductContentRoutes(options: CreateProductContentRoutesOptions): Hono<ProductContentRoutesEnv>;
+/**
+ * Parse an `Accept-Language` header into an ordered list of BCP 47
+ * tags. Quality factors are honored — higher-q first; ties keep
+ * insertion order. Lifted out of the route handler so it's testable
+ * in isolation.
+ */
+export declare function parseAcceptLanguage(header: string): string[];
+export type ProductContentRoutes = ReturnType<typeof createProductContentRoutes>;
+//# sourceMappingURL=routes-content.d.ts.map

package/dist/routes-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes-content.d.ts","sourceRoot":"","sources":["../src/routes-content.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAA;AAClF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAI3B,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE;QACT,EAAE,EAAE,YAAY,CAAA;KACjB,CAAA;CACF;AAED,MAAM,WAAW,iCAAiC;IAChD;;;;;OAKG;IACH,eAAe,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,qBAAqB,CAAA;IACtD;;;;OAIG;IACH,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAA;IACxE;;;;OAIG;IACH,8BAA8B,CAAC,EAAE,OAAO,CAAA;CACzC;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,iCAAiC,GACzC,IAAI,CAAC,uBAAuB,CAAC,CA+D/B;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAqB5D;AAED,MAAM,MAAM,oBAAoB,GAAG,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAA"}

package/dist/routes-content.js

@@ -0,0 +1,117 @@
+/**
+ * Product content routes — unified owned + sourced detail endpoint.
+ *
+ *   GET /:id/content
+ *
+ * Returns the full `ProductContent` payload for ANY product:
+ *   - **Sourced**: cache hit → cached row + overlay merge; cache miss
+ *     with rich adapter → adapter fetch + write-through; cache miss
+ *     with thin adapter → synthesizer fallback (sourced-content §3.3,
+ *     §3.4, §3.6).
+ *   - **Owned**: read from the products module's own tables and
+ *     project to ProductContent. Overlay merge applies the same way.
+ *     Marked `source: "owned"` in the response.
+ *
+ * 404 only when the entity doesn't exist (no sourced-entry row AND
+ * no owned product row). The catalog detail sheet calls this on
+ * click to enrich the indexed projection with itinerary, media,
+ * options, and policies.
+ *
+ * Templates mount this router under their preferred prefix; the
+ * factory takes a `resolveRegistry` callback so the catalog
+ * `SourceAdapterRegistry` stays starter-owned (singleton lifetime,
+ * adapters carry HTTP clients).
+ *
+ * See `docs/architecture/catalog-sourced-content.md` §3.3.
+ */
+import { Hono } from "hono";
+import { getProductContent } from "./service-content.js";
+/**
+ * Build the product content router. Returns a Hono instance that
+ * exposes a single `GET /:id/content` route. Templates mount it under
+ * `/v1/admin/products` or `/v1/public/products` as appropriate.
+ */
+export function createProductContentRoutes(options) {
+    return new Hono().get("/:id/content", async (c) => {
+        const entityId = c.req.param("id");
+        const scope = parseScope(c);
+        const registry = options.resolveRegistry(c);
+        const result = await getProductContent(c.var.db, entityId, scope, {
+            registry,
+            onOverlayError: options.onOverlayError,
+        });
+        if (!result) {
+            return c.json({
+                error: "not_found",
+                detail: `Product ${entityId} not found (no owned row + no sourced-entry row).`,
+            }, 404);
+        }
+        return c.json({
+            data: {
+                content: result.content,
+                served_locale: result.resolution.served_locale,
+                match_kind: result.resolution.match_kind,
+                source: result.source,
+                served_stale: result.served_stale,
+                synthesized: result.synthesized,
+                machine_translated: result.machine_translated,
+            },
+        });
+    });
+    function parseScope(c) {
+        // Locale priority: explicit query param > Accept-Language header
+        // > en-GB fallback. Multiple `?locale=` query params are joined
+        // into the preference chain.
+        const localeParams = c.req.queries("locale") ?? c.req.queries("locales") ?? [];
+        const headerLocale = c.req.header("accept-language");
+        const acceptLanguageList = headerLocale ? parseAcceptLanguage(headerLocale) : [];
+        const preferredLocales = localeParams.length > 0
+            ? localeParams
+            : acceptLanguageList.length > 0
+                ? acceptLanguageList
+                : ["en-GB"];
+        const market = c.req.query("market") ?? undefined;
+        const currency = c.req.query("currency") ?? undefined;
+        const acceptMTQuery = c.req.query("accept_mt");
+        const acceptMachineTranslated = acceptMTQuery != null
+            ? acceptMTQuery !== "false" && acceptMTQuery !== "0"
+            : (options.defaultAcceptMachineTranslated ?? true);
+        return {
+            preferredLocales,
+            market,
+            currency,
+            acceptMachineTranslated,
+        };
+    }
+}
+/**
+ * Parse an `Accept-Language` header into an ordered list of BCP 47
+ * tags. Quality factors are honored — higher-q first; ties keep
+ * insertion order. Lifted out of the route handler so it's testable
+ * in isolation.
+ */
+export function parseAcceptLanguage(header) {
+    const parts = header.split(",");
+    const ranked = [];
+    for (let i = 0; i < parts.length; i += 1) {
+        const part = parts[i].trim();
+        if (!part)
+            continue;
+        const [tagRaw, ...params] = part.split(";");
+        const tag = tagRaw.trim();
+        if (!tag || tag === "*")
+            continue;
+        let q = 1;
+        for (const p of params) {
+            const [k, v] = p.split("=").map((s) => s.trim());
+            if (k === "q" && v) {
+                const parsed = Number.parseFloat(v);
+                if (Number.isFinite(parsed))
+                    q = parsed;
+            }
+        }
+        ranked.push({ tag, q, idx: i });
+    }
+    ranked.sort((a, b) => b.q - a.q || a.idx - b.idx);
+    return ranked.map((r) => r.tag);
+}