@voyant-travel/operations-react 0.0.0

package/dist/availability/admin/index.d.ts

@@ -0,0 +1,70 @@
+import { type AdminExtension } from "@voyant-travel/admin";
+/**
+ * Semantic destinations the availability admin surfaces navigate to
+ * (packaged-admin RFC §4.7). Keys shared with other domains
+ * (`availabilitySlot.detail`, `booking.detail`, `product.detail`) come from
+ * the bookings-ui augmentation bound above; declared here are the
+ * availability-owned targets the packaged pages and breadcrumbs resolve
+ * through `useAdminHref`/`useAdminNavigate`.
+ */
+declare module "@voyant-travel/admin" {
+    interface AdminDestinations {
+        /** The availability landing page (slots list + calendar). */
+        "availabilitySlot.list": Record<string, never>;
+        /** An availability start time's detail page. */
+        "availabilityStartTime.detail": {
+            startTimeId: string;
+        };
+    }
+}
+export type { OptionResourceTemplatesPanelProps } from "./option-resource-templates-panel.js";
+export type { AvailabilityRuleDetailHostProps } from "./rule-detail-host.js";
+export type { AvailabilitySlotDetailHostProps } from "./slot-detail-host.js";
+export type { AvailabilityStartTimeDetailHostProps } from "./start-time-detail-host.js";
+export interface CreateAvailabilityAdminExtensionOptions {
+    /** Mount path of the availability pages inside the admin workspace. Default `/operations/availability`. */
+    basePath?: string;
+    /** Localized page titles. Defaults are the English operator nav labels. */
+    labels?: {
+        availability?: string;
+    };
+}
+/**
+ * The availability admin contribution (packaged-admin RFC Phase 3,
+ * `@voyant-travel/<domain>-ui/admin` convention).
+ *
+ * NAVIGATION: deliberately none. The Availability nav item is part of the
+ * BASE operator navigation — see `createOperatorAdminNavigation` in
+ * `@voyant-travel/admin` — so contributing a nav entry here would duplicate it.
+ * If the base nav ever drops the availability item, this extension is where
+ * the entry moves.
+ *
+ * ROUTES: contributions carry the FULL route implementation (packaged-admin
+ * RFC §4.2/§4.8) — lazy `page` module loaders, data loaders fed by the
+ * host-supplied {@link AdminRouteLoaderContext} (QueryClient + runtime +
+ * params), per-route SSR mode, and pending skeletons. Hosts bind them into
+ * their code-assembled admin route tree; no per-route host files needed.
+ * The pages stay code-split because each contribution's `page` dynamically
+ * imports the specific host/page module — never the admin barrel — so the
+ * heavy page chunks load on navigation, not with workspace chrome.
+ * {@link AvailabilityIndexHost} (the slots list + calendar landing page,
+ * with bulk update/delete running through the typed batch mutation hooks in
+ * `@voyant-travel/operations-react/availability`) mounts as a zero-prop page; the detail
+ * hosts {@link AvailabilitySlotDetailHost},
+ * {@link AvailabilityRuleDetailHost} and
+ * {@link AvailabilityStartTimeDetailHost} read their record id from
+ * `AdminRoutePageProps` via the default-exported wrappers in `./pages/`.
+ * The index host's SSR loader binding is no longer app-side:
+ * {@link ensureAvailabilityPageData} runs in the contribution's own loader
+ * against the host runtime's cookie-forwarding fetcher. The pages keep
+ * their filter state component-local, so there are no URL search contracts,
+ * and every cross-route link resolves through the semantic destinations
+ * declared above.
+ *
+ * WIDGETS: none. {@link OptionResourceTemplatesPanel} (the per-option
+ * resource templates editor the product editor embeds) ships from this
+ * entry as a directly importable component — the products admin host owns
+ * where it mounts.
+ */
+export declare function createAvailabilityAdminExtension(options?: CreateAvailabilityAdminExtensionOptions): AdminExtension;
+//# sourceMappingURL=index.d.ts.map

package/dist/availability/admin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/availability/admin/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAKpB,MAAM,sBAAsB,CAAA;AAsB7B;;;;;;;GAOG;AACH,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,iBAAiB;QACzB,6DAA6D;QAC7D,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;QAC9C,gDAAgD;QAChD,8BAA8B,EAAE;YAAE,WAAW,EAAE,MAAM,CAAA;SAAE,CAAA;KACxD;CACF;AAYD,YAAY,EAAE,iCAAiC,EAAE,MAAM,sCAAsC,CAAA;AAC7F,YAAY,EAAE,+BAA+B,EAAE,MAAM,uBAAuB,CAAA;AAC5E,YAAY,EAAE,+BAA+B,EAAE,MAAM,uBAAuB,CAAA;AAC5E,YAAY,EAAE,oCAAoC,EAAE,MAAM,6BAA6B,CAAA;AAEvF,MAAM,WAAW,uCAAuC;IACtD,2GAA2G;IAC3G,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,2EAA2E;IAC3E,MAAM,CAAC,EAAE;QACP,YAAY,CAAC,EAAE,MAAM,CAAA;KACtB,CAAA;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,gCAAgC,CAC9C,OAAO,GAAE,uCAA4C,GACpD,cAAc,CA0FhB"}

package/dist/availability/admin/index.js

@@ -0,0 +1,140 @@
+import { adminRoutePageModule, defineAdminExtension, } from "@voyant-travel/admin";
+// Lean static only: the client module (fetcher). The page-data helper pulls
+// the availability query options (client + response schemas), so the index
+// loader resolves it via dynamic import instead of pinning it into the
+// workspace-chrome chunk that evaluates this factory.
+import { defaultFetcher } from "../client.js";
+import { AvailabilityPageSkeleton, AvailabilityRuleDetailSkeleton, AvailabilitySlotDetailSkeleton, AvailabilityStartTimeDetailSkeleton, } from "../components/availability-skeletons.js";
+/**
+ * The availability admin contribution (packaged-admin RFC Phase 3,
+ * `@voyant-travel/<domain>-ui/admin` convention).
+ *
+ * NAVIGATION: deliberately none. The Availability nav item is part of the
+ * BASE operator navigation — see `createOperatorAdminNavigation` in
+ * `@voyant-travel/admin` — so contributing a nav entry here would duplicate it.
+ * If the base nav ever drops the availability item, this extension is where
+ * the entry moves.
+ *
+ * ROUTES: contributions carry the FULL route implementation (packaged-admin
+ * RFC §4.2/§4.8) — lazy `page` module loaders, data loaders fed by the
+ * host-supplied {@link AdminRouteLoaderContext} (QueryClient + runtime +
+ * params), per-route SSR mode, and pending skeletons. Hosts bind them into
+ * their code-assembled admin route tree; no per-route host files needed.
+ * The pages stay code-split because each contribution's `page` dynamically
+ * imports the specific host/page module — never the admin barrel — so the
+ * heavy page chunks load on navigation, not with workspace chrome.
+ * {@link AvailabilityIndexHost} (the slots list + calendar landing page,
+ * with bulk update/delete running through the typed batch mutation hooks in
+ * `@voyant-travel/operations-react/availability`) mounts as a zero-prop page; the detail
+ * hosts {@link AvailabilitySlotDetailHost},
+ * {@link AvailabilityRuleDetailHost} and
+ * {@link AvailabilityStartTimeDetailHost} read their record id from
+ * `AdminRoutePageProps` via the default-exported wrappers in `./pages/`.
+ * The index host's SSR loader binding is no longer app-side:
+ * {@link ensureAvailabilityPageData} runs in the contribution's own loader
+ * against the host runtime's cookie-forwarding fetcher. The pages keep
+ * their filter state component-local, so there are no URL search contracts,
+ * and every cross-route link resolves through the semantic destinations
+ * declared above.
+ *
+ * WIDGETS: none. {@link OptionResourceTemplatesPanel} (the per-option
+ * resource templates editor the product editor embeds) ships from this
+ * entry as a directly importable component — the products admin host owns
+ * where it mounts.
+ */
+export function createAvailabilityAdminExtension(options = {}) {
+    const { basePath = "/operations/availability", labels = {} } = options;
+    const { availability = "Availability" } = labels;
+    return defineAdminExtension({
+        id: "availability",
+        routes: [
+            {
+                id: "availability-index",
+                path: basePath,
+                title: availability,
+                // Route-backed destination (RFC §4.7 endgame): the key resolves by
+                // pure path interpolation of this route, so the host's resolver is
+                // generated (`voyant admin generate --destinations`).
+                destination: "availabilitySlot.list",
+                ssr: "data-only",
+                page: () => import("./availability-index-host.js").then((module) => adminRoutePageModule(module.AvailabilityIndexHost)),
+                // Awaits only what the slots tab + the products picker need for
+                // first paint; the slot dialog's rules/start-times dimensions
+                // prefetch in the background. Dynamic import on purpose: the helper
+                // pulls the availability query options, and a static import here
+                // would pin them into the workspace-chrome chunk.
+                loader: async ({ queryClient, runtime }) => {
+                    const { ensureAvailabilityPageData } = await import("./availability-page-data.js");
+                    return ensureAvailabilityPageData(queryClient, loaderClient(runtime));
+                },
+                pendingComponent: AvailabilityPageSkeleton,
+            },
+            {
+                id: "availability-slot-detail",
+                path: `${basePath}/$id`,
+                title: availability,
+                // Key declared by @voyant-travel/bookings-react/admin (bound type-only above).
+                destination: "availabilitySlot.detail",
+                destinationParams: { id: "slotId" },
+                page: () => import("./pages/availability-slot-detail-page.js"),
+                loader: async ({ queryClient, runtime, params }) => {
+                    const id = params.id;
+                    if (!id)
+                        return;
+                    // Dynamic import on purpose: the loader helper lives in the slot
+                    // detail page module, and a static import here would pin that
+                    // module into the host's workspace-chrome chunk, defeating the
+                    // route's code-split. The loader and the page resolve the same
+                    // chunk, fetched once.
+                    const { loadAvailabilitySlotDetailPage } = await import("../components/availability-slot-detail-page.js");
+                    return loadAvailabilitySlotDetailPage(queryClient, loaderClient(runtime), id);
+                },
+                pendingComponent: AvailabilitySlotDetailSkeleton,
+            },
+            {
+                id: "availability-rule-detail",
+                path: `${basePath}/rules/$id`,
+                title: availability,
+                page: () => import("./pages/availability-rule-detail-page.js"),
+                loader: async ({ queryClient, runtime, params }) => {
+                    const id = params.id;
+                    if (!id)
+                        return;
+                    // Dynamic import on purpose — see the slot detail loader above.
+                    const { loadAvailabilityRuleDetailPage } = await import("../components/availability-rule-detail-page.js");
+                    return loadAvailabilityRuleDetailPage(queryClient, loaderClient(runtime), id);
+                },
+                pendingComponent: AvailabilityRuleDetailSkeleton,
+            },
+            {
+                id: "availability-start-time-detail",
+                path: `${basePath}/start-times/$id`,
+                title: availability,
+                destination: "availabilityStartTime.detail",
+                destinationParams: { id: "startTimeId" },
+                page: () => import("./pages/availability-start-time-detail-page.js"),
+                loader: async ({ queryClient, runtime, params }) => {
+                    const id = params.id;
+                    if (!id)
+                        return;
+                    // Dynamic import on purpose — see the slot detail loader above.
+                    const { loadAvailabilityStartTimeDetailPage } = await import("../components/availability-start-time-detail-page.js");
+                    return loadAvailabilityStartTimeDetailPage(queryClient, loaderClient(runtime), id);
+                },
+                pendingComponent: AvailabilityStartTimeDetailSkeleton,
+            },
+        ],
+    });
+}
+/**
+ * Bridge the host-supplied {@link AdminRouteRuntime} (optional fetcher) to
+ * the required-fetcher client contract the availability loaders take.
+ *
+ * Note: the operator's detail route files built this client with the
+ * package `defaultFetcher` (a plain `credentials: "include"` fetch); the
+ * contribution uses the host runtime's cookie-forwarding fetcher instead,
+ * so detail SSR prefetches authenticate — an intentional improvement.
+ */
+function loaderClient(runtime) {
+    return { baseUrl: runtime.baseUrl, fetcher: runtime.fetcher ?? defaultFetcher };
+}

package/dist/availability/admin/option-resource-template-seat-map.d.ts

@@ -0,0 +1,10 @@
+import { type SeatLayoutSpec } from "../index.js";
+export declare function SeatMapSummaryBadge({ flags, messages, }: {
+    flags: Record<string, unknown>;
+    messages: {
+        seatMapSummary: string;
+    };
+}): import("react/jsx-runtime").JSX.Element | null;
+export declare function extractLayoutSpec(flags: Record<string, unknown> | null | undefined): SeatLayoutSpec | null;
+export declare function countSeats(spec: SeatLayoutSpec | null): number;
+//# sourceMappingURL=option-resource-template-seat-map.d.ts.map

package/dist/availability/admin/option-resource-template-seat-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"option-resource-template-seat-map.d.ts","sourceRoot":"","sources":["../../../src/availability/admin/option-resource-template-seat-map.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,cAAc,EAAwB,MAAM,aAAa,CAAA;AAEvE,wBAAgB,mBAAmB,CAAC,EAClC,KAAK,EACL,QAAQ,GACT,EAAE;IACD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,QAAQ,EAAE;QAAE,cAAc,EAAE,MAAM,CAAA;KAAE,CAAA;CACrC,kDAWA;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,GAChD,cAAc,GAAG,IAAI,CAQvB;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,GAAG,MAAM,CAS9D"}

package/dist/availability/admin/option-resource-template-seat-map.js

@@ -0,0 +1,36 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { formatMessage } from "@voyant-travel/i18n";
+import { Badge } from "@voyant-travel/ui/components";
+import { seatLayoutSpecSchema } from "../index.js";
+export function SeatMapSummaryBadge({ flags, messages, }) {
+    const spec = extractLayoutSpec(flags);
+    if (!spec)
+        return null;
+    return (_jsx(Badge, { variant: "outline", className: "text-[10px]", children: formatMessage(messages.seatMapSummary, {
+            rows: spec.rows.length,
+            count: countSeats(spec),
+        }) }));
+}
+export function extractLayoutSpec(flags) {
+    const raw = flags?.layoutSpec;
+    if (!raw)
+        return null;
+    // Validate against the schema rather than trust the shape — the server
+    // stores flags as opaque JSON, so a malformed value (e.g. a row missing
+    // `cells`) could otherwise reach `countSeats` and throw at runtime.
+    const parsed = seatLayoutSpecSchema.safeParse(raw);
+    return parsed.success ? parsed.data : null;
+}
+export function countSeats(spec) {
+    if (!spec)
+        return 0;
+    let count = 0;
+    for (const row of spec.rows) {
+        for (const cell of row.cells) {
+            if (cell === "seat")
+                count += 1;
+        }
+    }
+    return count;
+}

package/dist/availability/admin/option-resource-templates-panel.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Per-option Resource templates editor. Templates drive the Allocation
+ * tab's "Generate resources" automation — without a template configured
+ * for an option, no rooms/seats/etc. are materialized when bookings hit
+ * a slot.
+ *
+ * Each template is identified by `(optionId, kind, refId)` — an option can
+ * hold several templates of the same kind, one per `option_unit` (e.g. a
+ * "room" template per room type), distinguished by `refId`. Common kinds:
+ *   - `room` — accommodation rooms (default capacity 2)
+ *   - `vehicle_seat` — coach/van seats (capacity 1)
+ *   - `cabin` — cruise cabins
+ *
+ * The kind field is a free-form string on the server; we constrain the
+ * picker to the known set for UX, but operators can extend by typing.
+ */
+export interface OptionResourceTemplatesPanelProps {
+    productId: string;
+    optionId: string;
+}
+export declare function OptionResourceTemplatesPanel({ productId, optionId, }: OptionResourceTemplatesPanelProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=option-resource-templates-panel.d.ts.map

package/dist/availability/admin/option-resource-templates-panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"option-resource-templates-panel.d.ts","sourceRoot":"","sources":["../../../src/availability/admin/option-resource-templates-panel.tsx"],"names":[],"mappings":"AAmDA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,iCAAiC;IAChD,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAiBD,wBAAgB,4BAA4B,CAAC,EAC3C,SAAS,EACT,QAAQ,GACT,EAAE,iCAAiC,2CAqenC"}

package/dist/availability/admin/option-resource-templates-panel.js

@@ -0,0 +1,221 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useOperatorAdminMessages } from "@voyant-travel/admin";
+import { formatMessage } from "@voyant-travel/i18n";
+import { useOptionUnits } from "@voyant-travel/inventory-react";
+import { Badge, Button, Collapsible, CollapsibleContent, CollapsibleTrigger, Dialog, DialogBody, DialogContent, DialogFooter, DialogHeader, DialogTitle, Input, Label, Select, SelectContent, SelectItem, SelectTrigger, SelectValue, } from "@voyant-travel/ui/components";
+import { Armchair, Bed, CalendarCheck, ChevronDown, ChevronRight, Loader2, Pencil, Plus, Sparkles, Trash2, } from "lucide-react";
+import { useMemo, useState } from "react";
+import { SeatMapBuilder } from "../allocation/index.js";
+import { useMaterializeOpenSlotsMutation, useProductResourceTemplates, useResourceTemplateMutation, } from "../index.js";
+import { countSeats, extractLayoutSpec, SeatMapSummaryBadge, } from "./option-resource-template-seat-map.js";
+// Defaults populate the namePattern field when the operator picks a kind. They
+// are starting points the operator edits before saving, not display labels —
+// the localized prompt copy lives in the dialog's namePatternPlaceholder.
+const COMMON_KINDS = [
+    // i18n-literal-ok
+    { value: "room", defaultPattern: "Room {sequence}" },
+    // i18n-literal-ok
+    { value: "vehicle_seat", defaultPattern: "Seat {sequence}" },
+    // i18n-literal-ok
+    { value: "cabin", defaultPattern: "Cabin {sequence}" },
+    // i18n-literal-ok
+    { value: "flight_seat", defaultPattern: "Seat {sequence}" },
+];
+export function OptionResourceTemplatesPanel({ productId, optionId, }) {
+    const adminMessages = useOperatorAdminMessages();
+    const t = adminMessages.availability.details.resourceTemplates;
+    const { data, isPending, isError } = useProductResourceTemplates({ productId });
+    const { upsert, remove } = useResourceTemplateMutation(productId);
+    const materializeOpenSlots = useMaterializeOpenSlotsMutation(productId);
+    const templates = useMemo(() => {
+        const option = (data?.data ?? []).find((entry) => entry.id === optionId);
+        return option?.templates ?? [];
+    }, [data?.data, optionId]);
+    const totalPerDeparture = useMemo(() => templates.reduce((sum, template) => sum + (template.defaultCount ?? 0), 0), [templates]);
+    // The option's room units already carry quantity (maxQuantity) and occupancy
+    // — generate departure inventory straight from them instead of re-typing it.
+    const { data: unitsData } = useOptionUnits({ optionId, limit: 100 });
+    const roomUnits = useMemo(() => (unitsData?.data ?? []).filter((unit) => unit.unitType === "room"), [unitsData?.data]);
+    const [open, setOpen] = useState(false);
+    const [dialogOpen, setDialogOpen] = useState(false);
+    const [seatMapOpen, setSeatMapOpen] = useState(false);
+    const [editingKind, setEditingKind] = useState(null);
+    // The ref of the template being edited, so submit updates that exact
+    // (option, kind, refId) row rather than colliding with siblings of the same
+    // kind. Null for ref-less templates (the manual "Add" path).
+    const [editingRefType, setEditingRefType] = useState(null);
+    const [editingRefId, setEditingRefId] = useState(null);
+    const [kindValue, setKindValue] = useState("room");
+    const [capacityValue, setCapacityValue] = useState(2);
+    const [defaultCountValue, setDefaultCountValue] = useState(1);
+    const [namePatternValue, setNamePatternValue] = useState("Room {sequence}");
+    const [layoutSpec, setLayoutSpec] = useState(null);
+    const [error, setError] = useState(null);
+    const [applyResult, setApplyResult] = useState(null);
+    const derivedSeatCount = useMemo(() => countSeats(layoutSpec), [layoutSpec]);
+    const usingSeatMap = kindValue === "vehicle_seat" && layoutSpec !== null;
+    function openCreate() {
+        setEditingKind(null);
+        setEditingRefType(null);
+        setEditingRefId(null);
+        setKindValue("room");
+        setCapacityValue(2);
+        setDefaultCountValue(1);
+        setNamePatternValue("Room {sequence}");
+        setLayoutSpec(null);
+        setError(null);
+        setDialogOpen(true);
+    }
+    function openEdit(template) {
+        setEditingKind(template.kind);
+        setEditingRefType(template.refType);
+        setEditingRefId(template.refId);
+        setKindValue(template.kind);
+        setCapacityValue(template.capacity);
+        setDefaultCountValue(template.defaultCount ?? 0);
+        setNamePatternValue(template.namePattern);
+        setLayoutSpec(extractLayoutSpec(template.flags));
+        setError(null);
+        setDialogOpen(true);
+    }
+    async function submit(event) {
+        event.preventDefault();
+        setError(null);
+        const trimmedKind = kindValue.trim();
+        const trimmedPattern = namePatternValue.trim();
+        const effectiveCapacity = usingSeatMap ? derivedSeatCount : capacityValue;
+        if (!trimmedKind || !trimmedPattern || effectiveCapacity < 1) {
+            setError(t.validation);
+            return;
+        }
+        const flags = {};
+        if (trimmedKind === "vehicle_seat" && layoutSpec) {
+            flags.layoutSpec = layoutSpec;
+        }
+        try {
+            await upsert.mutateAsync({
+                optionId,
+                kind: trimmedKind,
+                input: {
+                    capacity: effectiveCapacity,
+                    defaultCount: defaultCountValue > 0 ? defaultCountValue : null,
+                    namePattern: trimmedPattern,
+                    // Preserve the edited template's ref so the upsert targets its exact
+                    // (option, kind, refId) row instead of clobbering a sibling.
+                    refType: editingRefType,
+                    refId: editingRefId,
+                    flags,
+                },
+            });
+            setDialogOpen(false);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : t.saveFailed);
+        }
+    }
+    async function handleRemove(kind, refId, label) {
+        if (!globalThis.confirm?.(formatMessage(t.deleteConfirm, { kind: label })))
+            return;
+        try {
+            await remove.mutateAsync({ optionId, kind, refId });
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : t.deleteFailed);
+        }
+    }
+    async function generateFromRooms() {
+        setError(null);
+        try {
+            for (const unit of roomUnits) {
+                await upsert.mutateAsync({
+                    optionId,
+                    // All room types share kind "room"; they're distinguished — and
+                    // travelers are constrained to their booked type — by the option_unit
+                    // ref (allocator's groupUnitMatchScore: refType "option_unit" + refId
+                    // === bookedOptionUnitId). The widened (option, kind, ref) unique
+                    // index lets one option carry a "room" template per unit.
+                    kind: "room",
+                    input: {
+                        capacity: unit.occupancyMax ?? unit.occupancyMin ?? 1,
+                        defaultCount: unit.maxQuantity ?? null,
+                        // {index} numbers each room type from 1 (Double 1…20), not the
+                        // global {sequence}, so the shared "room" pool reads cleanly.
+                        namePattern: `${unit.name} {index}`,
+                        refType: "option_unit",
+                        refId: unit.id,
+                        flags: {},
+                    },
+                });
+            }
+            setOpen(true);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : t.saveFailed);
+        }
+    }
+    async function applyToOpenDepartures() {
+        if (!globalThis.confirm?.(t.applyToOpenConfirm))
+            return;
+        setError(null);
+        setApplyResult(null);
+        try {
+            const result = await materializeOpenSlots.mutateAsync({ optionId });
+            setApplyResult(result.slots === 0
+                ? t.applyToOpenEmpty
+                : formatMessage(t.applyToOpenResult, {
+                    created: result.created,
+                    slots: result.slots,
+                }));
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : t.applyToOpenFailed);
+        }
+    }
+    const matchingCommon = COMMON_KINDS.find((entry) => entry.value === kindValue);
+    const isExtendedKind = !matchingCommon && kindValue.trim().length > 0;
+    return (_jsxs(Collapsible, { open: open, onOpenChange: setOpen, children: [_jsxs("div", { className: "rounded-md border bg-background/60", children: [_jsxs(CollapsibleTrigger, { className: "flex w-full items-center gap-2 px-3 py-2.5 text-left", children: [_jsx(Bed, { className: "size-4 shrink-0 text-muted-foreground", "aria-hidden": "true" }), _jsx("span", { className: "font-medium text-sm", children: t.title }), _jsx(Badge, { variant: "secondary", className: "font-normal", children: templates.length === 0
+                                    ? t.collapsedEmpty
+                                    : formatMessage(t.collapsedSummary, {
+                                        count: templates.length,
+                                        total: totalPerDeparture,
+                                    }) }), _jsx("span", { className: "flex-1" }), open ? (_jsx(ChevronDown, { className: "size-4 shrink-0 text-muted-foreground", "aria-hidden": "true" })) : (_jsx(ChevronRight, { className: "size-4 shrink-0 text-muted-foreground", "aria-hidden": "true" }))] }), _jsx(CollapsibleContent, { children: _jsxs("div", { className: "flex flex-col gap-3 border-t p-3", children: [_jsxs("div", { className: "flex items-start justify-between gap-3", children: [_jsx("p", { className: "text-muted-foreground text-xs", children: t.description }), _jsxs("div", { className: "flex shrink-0 flex-wrap items-center justify-end gap-2", children: [templates.length > 0 ? (_jsxs(Button, { size: "sm", variant: "outline", onClick: () => void applyToOpenDepartures(), disabled: materializeOpenSlots.isPending, children: [_jsx(CalendarCheck, { className: "mr-1 size-4", "aria-hidden": "true" }), t.applyToOpenButton] })) : null, roomUnits.length > 0 ? (_jsxs(Button, { size: "sm", variant: "outline", onClick: () => void generateFromRooms(), disabled: upsert.isPending, children: [_jsx(Sparkles, { className: "mr-1 size-4", "aria-hidden": "true" }), t.generateFromRooms] })) : null, _jsxs(Button, { size: "sm", variant: "outline", onClick: openCreate, children: [_jsx(Plus, { className: "mr-1 size-4", "aria-hidden": "true" }), t.addButton] })] })] }), applyResult ? (_jsx("p", { className: "rounded-md bg-muted/50 px-3 py-2 text-muted-foreground text-xs", children: applyResult })) : null, error ? _jsx("p", { className: "text-destructive text-xs", children: error }) : null, isPending ? (_jsx("p", { className: "flex items-center justify-center gap-2 py-4 text-muted-foreground text-sm", children: _jsx(Loader2, { className: "size-3.5 animate-spin" }) })) : isError ? (_jsx("p", { className: "py-4 text-center text-destructive text-sm", children: t.loadFailed })) : templates.length === 0 ? (_jsx("p", { className: "rounded-md border border-dashed px-3 py-4 text-center text-muted-foreground text-xs", children: roomUnits.length > 0 ? t.generateFromRoomsHint : t.emptyMessage })) : (_jsx("ul", { className: "divide-y overflow-hidden rounded-md border", children: templates.map((template) => {
+                                        const kindLabel = t.kinds[template.kind] ?? template.kind;
+                                        // Several "room" templates share a kind but map to different
+                                        // option_units — surface the unit name so the operator can
+                                        // tell Single / Double / Triple rows apart.
+                                        const unit = template.refId
+                                            ? roomUnits.find((entry) => entry.id === template.refId)
+                                            : undefined;
+                                        const displayLabel = unit?.name ?? kindLabel;
+                                        return (_jsxs("li", { className: "flex items-center justify-between gap-3 px-3 py-2.5", children: [_jsx("div", { className: "min-w-0 flex-1", children: _jsxs("div", { className: "flex items-center gap-2", children: [_jsx(Badge, { variant: "outline", className: "text-[10px]", children: displayLabel }), _jsx("span", { className: "text-sm", children: formatMessage(t.capacitySummary, {
+                                                                    capacity: template.capacity,
+                                                                    count: template.defaultCount ?? 0,
+                                                                    pattern: template.namePattern,
+                                                                }) }), template.kind === "vehicle_seat" ? (_jsx(SeatMapSummaryBadge, { flags: template.flags, messages: t })) : null] }) }), _jsxs("div", { className: "flex items-center gap-1", children: [_jsx(Button, { size: "sm", variant: "ghost", className: "h-7 px-2", onClick: () => openEdit({
+                                                                kind: template.kind,
+                                                                refType: template.refType,
+                                                                refId: template.refId,
+                                                                capacity: template.capacity,
+                                                                defaultCount: template.defaultCount,
+                                                                namePattern: template.namePattern,
+                                                                flags: template.flags,
+                                                            }), children: _jsx(Pencil, { className: "size-3.5", "aria-hidden": "true" }) }), _jsx(Button, { size: "sm", variant: "ghost", className: "h-7 px-2 text-destructive hover:text-destructive", onClick: () => void handleRemove(template.kind, template.refId, displayLabel), disabled: remove.isPending, children: _jsx(Trash2, { className: "size-3.5", "aria-hidden": "true" }) })] })] }, template.id));
+                                    }) }))] }) })] }), _jsx(Dialog, { open: dialogOpen, onOpenChange: setDialogOpen, children: _jsxs(DialogContent, { children: [_jsx(DialogHeader, { children: _jsx(DialogTitle, { children: editingKind ? formatMessage(t.editTitle, { kind: editingKind }) : t.newTitle }) }), _jsxs("form", { onSubmit: submit, children: [_jsxs(DialogBody, { className: "grid gap-4", children: [_jsxs("div", { className: "grid gap-1.5", children: [_jsx(Label, { htmlFor: "resource-template-kind", children: t.kindLabel }), _jsxs(Select, { value: isExtendedKind ? "__custom__" : kindValue, onValueChange: (value) => {
+                                                        if (!value || value === "__custom__") {
+                                                            setKindValue("");
+                                                            return;
+                                                        }
+                                                        setKindValue(value);
+                                                        const found = COMMON_KINDS.find((entry) => entry.value === value);
+                                                        if (found && namePatternValue === "Room {sequence}") {
+                                                            setNamePatternValue(found.defaultPattern);
+                                                        }
+                                                    }, disabled: editingKind !== null, children: [_jsx(SelectTrigger, { id: "resource-template-kind", className: "w-full", children: _jsx(SelectValue, { placeholder: t.kindPlaceholder }) }), _jsxs(SelectContent, { children: [COMMON_KINDS.map((entry) => (_jsx(SelectItem, { value: entry.value, children: t.kinds[entry.value] }, entry.value))), _jsx(SelectItem, { value: "__custom__", children: t.kindCustomOption })] })] }), isExtendedKind || editingKind ? (_jsx(Input, { value: kindValue, onChange: (event) => setKindValue(event.target.value), placeholder: t.kindCustomInputPlaceholder, disabled: editingKind !== null })) : null] }), kindValue === "vehicle_seat" ? (_jsxs("div", { className: "grid gap-1.5", children: [_jsx(Label, { children: t.seatMapLabel }), layoutSpec ? (_jsxs("div", { className: "flex items-center gap-2 rounded-md border p-3", children: [_jsx(Armchair, { className: "size-4 text-muted-foreground", "aria-hidden": "true" }), _jsx("div", { className: "min-w-0 flex-1 text-sm", children: formatMessage(t.seatMapSummary, {
+                                                                rows: layoutSpec.rows.length,
+                                                                count: derivedSeatCount,
+                                                            }) }), _jsxs(Button, { type: "button", size: "sm", variant: "ghost", onClick: () => setSeatMapOpen(true), children: [_jsx(Pencil, { className: "mr-1 size-3.5", "aria-hidden": "true" }), t.seatMapEditButton] })] })) : (_jsxs("div", { className: "flex flex-col gap-2 rounded-md border border-dashed p-3 text-sm", children: [_jsx("p", { className: "text-muted-foreground", children: t.seatMapEmpty }), _jsxs(Button, { type: "button", size: "sm", variant: "outline", onClick: () => setSeatMapOpen(true), children: [_jsx(Armchair, { className: "mr-1 size-3.5", "aria-hidden": "true" }), t.seatMapEditButton] })] }))] })) : null, _jsxs("div", { className: "grid gap-1.5", children: [_jsx(Label, { htmlFor: "resource-template-capacity", children: t.capacityLabel }), _jsx(Input, { id: "resource-template-capacity", type: "number", min: 1, value: usingSeatMap ? derivedSeatCount : capacityValue, onChange: (event) => setCapacityValue(Number(event.target.value) || 1), disabled: usingSeatMap }), usingSeatMap ? (_jsx("p", { className: "text-muted-foreground text-xs", children: formatMessage(t.capacityDerivedHint, { count: derivedSeatCount }) })) : null] }), _jsxs("div", { className: "grid gap-1.5", children: [_jsx(Label, { htmlFor: "resource-template-count", children: t.defaultCountLabel }), _jsx(Input, { id: "resource-template-count", type: "number", min: 0, value: defaultCountValue, onChange: (event) => setDefaultCountValue(Number(event.target.value) || 0) }), _jsx("p", { className: "text-muted-foreground text-xs", children: t.defaultCountHint })] }), _jsxs("div", { className: "grid gap-1.5", children: [_jsx(Label, { htmlFor: "resource-template-pattern", children: t.namePatternLabel }), _jsx(Input, { id: "resource-template-pattern", value: namePatternValue, onChange: (event) => setNamePatternValue(event.target.value), placeholder: t.namePatternPlaceholder }), _jsx("p", { className: "text-muted-foreground text-xs", children: (() => {
+                                                        const [before, after] = t.namePatternHint.split("{placeholder}");
+                                                        return (_jsxs(_Fragment, { children: [before, _jsx("code", { children: "{sequence}" }), after] }));
+                                                    })() })] }), error ? _jsx("p", { className: "text-destructive text-xs", children: error }) : null] }), _jsxs(DialogFooter, { children: [_jsx(Button, { type: "button", variant: "ghost", onClick: () => setDialogOpen(false), children: t.cancel }), _jsxs(Button, { type: "submit", disabled: upsert.isPending, children: [upsert.isPending ? (_jsx(Loader2, { className: "mr-1 size-3.5 animate-spin", "aria-hidden": "true" })) : null, editingKind ? t.save : t.createButton] })] })] })] }) }), _jsx(Dialog, { open: seatMapOpen, onOpenChange: setSeatMapOpen, children: _jsxs(DialogContent, { className: "max-w-3xl", children: [_jsx(DialogHeader, { children: _jsx(DialogTitle, { children: t.seatMapDialogTitle }) }), _jsx(DialogBody, { children: _jsx(SeatMapBuilder, { value: layoutSpec, onChange: setLayoutSpec }) }), _jsx(DialogFooter, { children: _jsx(Button, { type: "button", onClick: () => setSeatMapOpen(false), children: t.seatMapDialogDone }) })] }) })] }));
+}

package/dist/availability/admin/pages/availability-rule-detail-page.d.ts

@@ -0,0 +1,9 @@
+import type { AdminRoutePageProps } from "@voyant-travel/admin";
+/**
+ * Param-taking page for the `availability-rule-detail` contribution: reads
+ * the rule id off {@link AdminRoutePageProps} and binds it onto the packaged
+ * host. Resolved lazily through the contribution's `page` loader so the
+ * detail page lands in its own chunk.
+ */
+export default function AvailabilityRuleDetailRoutePage({ params }: AdminRoutePageProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=availability-rule-detail-page.d.ts.map

package/dist/availability/admin/pages/availability-rule-detail-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"availability-rule-detail-page.d.ts","sourceRoot":"","sources":["../../../../src/availability/admin/pages/availability-rule-detail-page.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAI/D;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,+BAA+B,CAAC,EAAE,MAAM,EAAE,EAAE,mBAAmB,2CAEtF"}

package/dist/availability/admin/pages/availability-rule-detail-page.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { AvailabilityRuleDetailHost } from "../rule-detail-host.js";
+/**
+ * Param-taking page for the `availability-rule-detail` contribution: reads
+ * the rule id off {@link AdminRoutePageProps} and binds it onto the packaged
+ * host. Resolved lazily through the contribution's `page` loader so the
+ * detail page lands in its own chunk.
+ */
+export default function AvailabilityRuleDetailRoutePage({ params }) {
+    return _jsx(AvailabilityRuleDetailHost, { ruleId: params.id ?? "" });
+}

package/dist/availability/admin/pages/availability-slot-detail-page.d.ts

@@ -0,0 +1,9 @@
+import type { AdminRoutePageProps } from "@voyant-travel/admin";
+/**
+ * Param-taking page for the `availability-slot-detail` contribution: reads
+ * the slot id off {@link AdminRoutePageProps} and binds it onto the packaged
+ * host. Resolved lazily through the contribution's `page` loader so the
+ * detail page lands in its own chunk.
+ */
+export default function AvailabilitySlotDetailRoutePage({ params }: AdminRoutePageProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=availability-slot-detail-page.d.ts.map

package/dist/availability/admin/pages/availability-slot-detail-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"availability-slot-detail-page.d.ts","sourceRoot":"","sources":["../../../../src/availability/admin/pages/availability-slot-detail-page.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAI/D;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,+BAA+B,CAAC,EAAE,MAAM,EAAE,EAAE,mBAAmB,2CAEtF"}

package/dist/availability/admin/pages/availability-slot-detail-page.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { AvailabilitySlotDetailHost } from "../slot-detail-host.js";
+/**
+ * Param-taking page for the `availability-slot-detail` contribution: reads
+ * the slot id off {@link AdminRoutePageProps} and binds it onto the packaged
+ * host. Resolved lazily through the contribution's `page` loader so the
+ * detail page lands in its own chunk.
+ */
+export default function AvailabilitySlotDetailRoutePage({ params }) {
+    return _jsx(AvailabilitySlotDetailHost, { slotId: params.id ?? "" });
+}

package/dist/availability/admin/pages/availability-start-time-detail-page.d.ts

@@ -0,0 +1,9 @@
+import type { AdminRoutePageProps } from "@voyant-travel/admin";
+/**
+ * Param-taking page for the `availability-start-time-detail` contribution:
+ * reads the start time id off {@link AdminRoutePageProps} and binds it onto
+ * the packaged host. Resolved lazily through the contribution's `page`
+ * loader so the detail page lands in its own chunk.
+ */
+export default function AvailabilityStartTimeDetailRoutePage({ params }: AdminRoutePageProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=availability-start-time-detail-page.d.ts.map

package/dist/availability/admin/pages/availability-start-time-detail-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"availability-start-time-detail-page.d.ts","sourceRoot":"","sources":["../../../../src/availability/admin/pages/availability-start-time-detail-page.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAI/D;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,oCAAoC,CAAC,EAAE,MAAM,EAAE,EAAE,mBAAmB,2CAE3F"}

package/dist/availability/admin/pages/availability-start-time-detail-page.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { AvailabilityStartTimeDetailHost } from "../start-time-detail-host.js";
+/**
+ * Param-taking page for the `availability-start-time-detail` contribution:
+ * reads the start time id off {@link AdminRoutePageProps} and binds it onto
+ * the packaged host. Resolved lazily through the contribution's `page`
+ * loader so the detail page lands in its own chunk.
+ */
+export default function AvailabilityStartTimeDetailRoutePage({ params }) {
+    return _jsx(AvailabilityStartTimeDetailHost, { startTimeId: params.id ?? "" });
+}

package/dist/availability/admin/rule-detail-host.d.ts

@@ -0,0 +1,14 @@
+export interface AvailabilityRuleDetailHostProps {
+    /** The availability rule id (route param, bound by the host route file). */
+    ruleId: string;
+}
+/**
+ * Packaged admin host for the availability rule detail page (packaged-admin
+ * RFC Phase 3). Data wiring runs through the shared availability provider
+ * context; breadcrumbs through the admin chrome; cross-route links through
+ * the semantic destinations `availabilitySlot.list`, `availabilitySlot.detail`
+ * and `product.detail` (RFC §4.7). The SSR prefetch loader stays in the host
+ * route file with the app's cookie-forwarding fetcher.
+ */
+export declare function AvailabilityRuleDetailHost({ ruleId }: AvailabilityRuleDetailHostProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=rule-detail-host.d.ts.map

package/dist/availability/admin/rule-detail-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-detail-host.d.ts","sourceRoot":"","sources":["../../../src/availability/admin/rule-detail-host.tsx"],"names":[],"mappings":"AAeA,MAAM,WAAW,+BAA+B;IAC9C,4EAA4E;IAC5E,MAAM,EAAE,MAAM,CAAA;CACf;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,EAAE,MAAM,EAAE,EAAE,+BAA+B,2CAsBrF"}