@mohasinac/appkit 4.31.1 → 4.32.1

package/dist/features/admin/schemas/admin-ops-forms.d.ts

@@ -173,3 +173,84 @@ export declare const adminAdFormSchema: z.ZodEffects<z.ZodObject<{
     thirdPartyUrl?: string | undefined;
 }>;
 export type AdminAdFormValues = z.infer<typeof adminAdFormSchema>;
+/**
+ * Ad SETTINGS — the provider credentials and the global consent switch.
+ *
+ * Distinct from `adminAdFormSchema`, which is one ad record. This is the
+ * platform-level configuration every ad renders under, and it was validated by
+ * a hand-written `localCredentialIssues` array that computed the same two rules
+ * on every keystroke and rendered them as a banner headed "Fix settings before
+ * saving" — never on the field that was wrong.
+ *
+ * Both credentials are optional and BLANK MEANS UNCHANGED: the route stores
+ * them encrypted and returns only a masked form, so the input starts empty on
+ * every load and an empty submit must leave the stored value alone. That is why
+ * neither field has a `.min()` — an empty string here is not an omission.
+ */
+export declare const adsConfigSchema: z.ZodEffects<z.ZodObject<{
+    consentRequired: z.ZodBoolean;
+    adsenseClientId: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    thirdPartyScriptUrl: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+}, "strip", z.ZodTypeAny, {
+    consentRequired: boolean;
+    adsenseClientId?: string | undefined;
+    thirdPartyScriptUrl?: string | undefined;
+}, {
+    consentRequired: boolean;
+    adsenseClientId?: string | undefined;
+    thirdPartyScriptUrl?: string | undefined;
+}>, {
+    consentRequired: boolean;
+    adsenseClientId?: string | undefined;
+    thirdPartyScriptUrl?: string | undefined;
+}, {
+    consentRequired: boolean;
+    adsenseClientId?: string | undefined;
+    thirdPartyScriptUrl?: string | undefined;
+}>;
+export type AdsConfigValues = z.infer<typeof adsConfigSchema>;
+/**
+ * The support-ticket triage form — what an admin CHANGES about a ticket, as
+ * distinct from what they SAY on it (the reply box, which is its own write to
+ * a different endpoint and carries the ticket's new status with it).
+ *
+ * The five linked-party ids are FLAT here and reassembled into
+ * `relatedParties` at the payload boundary, the same call the ad creative and
+ * the user's public profile make: the stored shape is one nested object, and
+ * the form has always offered five discrete inputs.
+ */
+export declare const supportTicketUpdateSchema: z.ZodObject<{
+    status: z.ZodEnum<["open", "in_progress", "waiting_on_user", "resolved", "closed"]>;
+    priority: z.ZodEnum<["low", "normal", "high", "urgent"]>;
+    internalNotes: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    userId: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    storeId: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    orderId: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    productId: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    bidId: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+}, "strip", z.ZodTypeAny, {
+    status: "closed" | "open" | "resolved" | "in_progress" | "waiting_on_user";
+    priority: "normal" | "high" | "low" | "urgent";
+    storeId?: string | undefined;
+    userId?: string | undefined;
+    orderId?: string | undefined;
+    productId?: string | undefined;
+    bidId?: string | undefined;
+    internalNotes?: string | undefined;
+}, {
+    status: "closed" | "open" | "resolved" | "in_progress" | "waiting_on_user";
+    priority: "normal" | "high" | "low" | "urgent";
+    storeId?: string | undefined;
+    userId?: string | undefined;
+    orderId?: string | undefined;
+    productId?: string | undefined;
+    bidId?: string | undefined;
+    internalNotes?: string | undefined;
+}>;
+export type SupportTicketUpdateValues = z.infer<typeof supportTicketUpdateSchema>;
+/**
+ * The five flat id fields, back into the nested `relatedParties` the ticket
+ * stores. Blank fields are dropped, and an entirely empty set returns
+ * `undefined` so the key is omitted rather than written as `{}`.
+ */
+export declare function toRelatedPartiesPayload(v: SupportTicketUpdateValues): Record<string, string> | undefined;

package/dist/features/admin/schemas/admin-ops-forms.js

@@ -40,7 +40,11 @@ export const adminOrderUpdateSchema = z.object({
         section: "shipping", sectionLabel: "Shipping", order: 1, row: "pair",
     }),
     carrier: annotate(z.string().trim().max(80).optional(), {
-        section: "shipping", order: 2, row: "pair",
+        // `kind: "select"` is explicit because the field is a free string in the
+        // schema — the route accepts any carrier name — while the ADMIN form offers
+        // a fixed list. Without it the inferred control is a text input and the
+        // `options` passed by the view would be ignored.
+        section: "shipping", order: 2, row: "pair", kind: "select",
     }),
     /*
      * 🛑 Bounded. This was `parseFloat` + `> 0` with no ceiling, so a slipped
@@ -229,3 +233,121 @@ export const adminAdFormSchema = z
         }
     }
 });
+/**
+ * Ad SETTINGS — the provider credentials and the global consent switch.
+ *
+ * Distinct from `adminAdFormSchema`, which is one ad record. This is the
+ * platform-level configuration every ad renders under, and it was validated by
+ * a hand-written `localCredentialIssues` array that computed the same two rules
+ * on every keystroke and rendered them as a banner headed "Fix settings before
+ * saving" — never on the field that was wrong.
+ *
+ * Both credentials are optional and BLANK MEANS UNCHANGED: the route stores
+ * them encrypted and returns only a masked form, so the input starts empty on
+ * every load and an empty submit must leave the stored value alone. That is why
+ * neither field has a `.min()` — an empty string here is not an omission.
+ */
+export const adsConfigSchema = z.object({
+    consentRequired: annotate(z.boolean(), {
+        section: "consent", sectionLabel: "Consent", sectionRequired: true,
+        quick: true, order: 1, row: "full",
+        label: "Require consent globally for ad rendering",
+    }),
+    adsenseClientId: annotate(z
+        .string()
+        .trim()
+        .regex(/^ca-pub-[0-9]{10,20}$/, "An AdSense client id looks like ca-pub-XXXXXXXXXX.")
+        .optional()
+        .or(z.literal("")), {
+        section: "credentials", sectionLabel: "Provider credentials",
+        order: 1, row: "pair", label: "AdSense client id",
+        help: "Leave blank to keep the stored value.",
+    }),
+    thirdPartyScriptUrl: annotate(z.string().trim().max(2000).optional().or(z.literal("")), {
+        section: "credentials", order: 2, row: "pair",
+        label: "Third-party script URL", inputType: "url",
+        help: "Must be https. Leave blank to keep the stored value.",
+    }),
+})
+    .superRefine((v, ctx) => {
+    const url = v.thirdPartyScriptUrl?.trim();
+    if (!url)
+        return;
+    let parsed = null;
+    try {
+        parsed = new URL(url);
+    }
+    catch (err) {
+        void normalizeError(err);
+        parsed = null;
+    }
+    if (!parsed) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom, path: ["thirdPartyScriptUrl"],
+            message: "That is not a valid URL.",
+        });
+    }
+    else if (parsed.protocol !== "https:") {
+        // A third-party ad script runs in the page's own origin; http would let
+        // any network hop rewrite it.
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom, path: ["thirdPartyScriptUrl"],
+            message: "A third-party script URL must use https.",
+        });
+    }
+});
+/**
+ * The support-ticket triage form — what an admin CHANGES about a ticket, as
+ * distinct from what they SAY on it (the reply box, which is its own write to
+ * a different endpoint and carries the ticket's new status with it).
+ *
+ * The five linked-party ids are FLAT here and reassembled into
+ * `relatedParties` at the payload boundary, the same call the ad creative and
+ * the user's public profile make: the stored shape is one nested object, and
+ * the form has always offered five discrete inputs.
+ */
+export const supportTicketUpdateSchema = z.object({
+    status: annotate(z.enum(["open", "in_progress", "waiting_on_user", "resolved", "closed"]), {
+        section: "triage", sectionLabel: "Triage", sectionRequired: true,
+        quick: true, order: 1, row: "pair", kind: "select",
+    }),
+    priority: annotate(z.enum(["low", "normal", "high", "urgent"]), {
+        section: "triage", quick: true, order: 2, row: "pair", kind: "select",
+    }),
+    internalNotes: annotate(z.string().trim().max(4000).optional().or(z.literal("")), {
+        section: "triage", order: 3, row: "full", kind: "textarea",
+        label: "Internal notes (staff only)",
+        help: "Visible only to admins and employees.",
+    }),
+    userId: annotate(z.string().trim().max(200).optional().or(z.literal("")), {
+        section: "parties", sectionLabel: "Linked parties", order: 1, row: "pair",
+        label: "User slug",
+        help: "Tag the buyer, store, order, product or bid this ticket concerns.",
+    }),
+    storeId: annotate(z.string().trim().max(200).optional().or(z.literal("")), {
+        section: "parties", order: 2, row: "pair", label: "Store slug",
+    }),
+    orderId: annotate(z.string().trim().max(200).optional().or(z.literal("")), {
+        section: "parties", order: 3, row: "pair", label: "Order ID",
+    }),
+    productId: annotate(z.string().trim().max(200).optional().or(z.literal("")), {
+        section: "parties", order: 4, row: "pair", label: "Product slug",
+    }),
+    bidId: annotate(z.string().trim().max(200).optional().or(z.literal("")), {
+        section: "parties", order: 5, row: "pair", label: "Bid ID",
+    }),
+});
+/**
+ * The five flat id fields, back into the nested `relatedParties` the ticket
+ * stores. Blank fields are dropped, and an entirely empty set returns
+ * `undefined` so the key is omitted rather than written as `{}`.
+ */
+export function toRelatedPartiesPayload(v) {
+    const out = {};
+    for (const key of ["userId", "storeId", "orderId", "productId", "bidId"]) {
+        const value = v[key]?.trim();
+        if (value)
+            out[key] = value;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}

package/dist/features/admin/schemas/admin-user-form.d.ts

@@ -1,26 +1,69 @@
 import { z } from "zod";
+import type { JsonValue } from "../../../schemas/types";
 export declare const adminUserUpdateSchema: z.ZodObject<{
+    role: z.ZodOptional<z.ZodEnum<["user", "seller", "admin", "moderator"]>>;
+    emailVerified: z.ZodOptional<z.ZodBoolean>;
     displayName: z.ZodOptional<z.ZodString>;
     phoneNumber: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
     isTester: z.ZodOptional<z.ZodBoolean>;
     canTestAdmin: z.ZodOptional<z.ZodBoolean>;
     adminNotes: z.ZodOptional<z.ZodString>;
-    publicProfile: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("../../..").FirestoreValue, z.ZodTypeDef, import("../../..").FirestoreValue>>>;
+    bio: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    location: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    website: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    twitter: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    instagram: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    facebook: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    linkedin: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
 }, "strip", z.ZodTypeAny, {
+    role?: "user" | "seller" | "admin" | "moderator" | undefined;
     displayName?: string | undefined;
+    location?: string | undefined;
     adminNotes?: string | undefined;
+    bio?: string | undefined;
     phoneNumber?: string | undefined;
+    emailVerified?: boolean | undefined;
+    website?: string | undefined;
     isTester?: boolean | undefined;
     canTestAdmin?: boolean | undefined;
-    publicProfile?: Record<string, import("../../..").FirestoreValue> | undefined;
+    instagram?: string | undefined;
+    facebook?: string | undefined;
+    twitter?: string | undefined;
+    linkedin?: string | undefined;
 }, {
+    role?: "user" | "seller" | "admin" | "moderator" | undefined;
     displayName?: string | undefined;
+    location?: string | undefined;
     adminNotes?: string | undefined;
+    bio?: string | undefined;
     phoneNumber?: string | undefined;
+    emailVerified?: boolean | undefined;
+    website?: string | undefined;
     isTester?: boolean | undefined;
     canTestAdmin?: boolean | undefined;
-    publicProfile?: Record<string, import("../../..").FirestoreValue> | undefined;
+    instagram?: string | undefined;
+    facebook?: string | undefined;
+    twitter?: string | undefined;
+    linkedin?: string | undefined;
 }>;
+/**
+ * The flat social/profile fields, reassembled into the nested shape the PATCH
+ * route stores.
+ *
+ * Empty strings are dropped rather than written: the drawer sends a partial
+ * PATCH so an untouched field must leave the stored subkey alone, and writing
+ * `""` would erase it. Returns `undefined` when nothing was filled in, so the
+ * key is omitted from the payload entirely.
+ */
+export declare function toPublicProfilePayload(v: {
+    bio?: string;
+    location?: string;
+    website?: string;
+    twitter?: string;
+    instagram?: string;
+    facebook?: string;
+    linkedin?: string;
+}): Record<string, JsonValue> | undefined;
 export type AdminUserUpdateValues = z.infer<typeof adminUserUpdateSchema>;
 /**
  * A store's WhatsApp Business connection.
@@ -51,6 +94,38 @@ export declare const whatsappSettingsSchema: z.ZodObject<{
     catalogId?: string | undefined;
 }>;
 export type WhatsappSettingsValues = z.infer<typeof whatsappSettingsSchema>;
+/**
+ * The CONNECTION form's fields — credentials only.
+ *
+ * `catalogSyncEnabled` is deliberately absent. Its toggle lives in a different
+ * card and owns its own write (`syncToggleMutation`), because the credentials
+ * form used to send it unconditionally from two cards away: a seller flipped
+ * the switch, saw it move, and nothing persisted it. A field in this schema is
+ * a field this form's Save button owns.
+ *
+ * 🛑 `.omit()` rather than a second literal, so the two cannot drift — it
+ * carries the SAME field instances into the new shape, which is what keeps the
+ * `annotate()` WeakMap entries alive. (A wrapper such as `.superRefine()` is
+ * transparent for the same reason; a field-level re-wrap is not.)
+ */
+export declare const whatsappConnectionSchema: z.ZodObject<Omit<{
+    catalogSyncEnabled: z.ZodBoolean;
+    phoneNumber: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    wabaId: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    catalogId: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    accessToken: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+}, "catalogSyncEnabled">, "strip", z.ZodTypeAny, {
+    phoneNumber?: string | undefined;
+    accessToken?: string | undefined;
+    wabaId?: string | undefined;
+    catalogId?: string | undefined;
+}, {
+    phoneNumber?: string | undefined;
+    accessToken?: string | undefined;
+    wabaId?: string | undefined;
+    catalogId?: string | undefined;
+}>;
+export type WhatsappConnectionValues = z.infer<typeof whatsappConnectionSchema>;
 /**
  * A buyer's lottery entry.
  *

package/dist/features/admin/schemas/admin-user-form.js

@@ -30,13 +30,26 @@
  */
 import { z } from "zod";
 import { annotate } from "../../shell/field-ui-meta";
-import { firestoreValueSchema } from "../../../schemas/firestore-value";
 const PHONE_RE = /^(\+?91[-\s]?)?[6-9]\d{9}$/;
 export const adminUserUpdateSchema = z.object({
+    /*
+     * Role and email-verification lead, because they are what an admin opens this
+     * drawer for. They were controls with no schema entry at all — the form
+     * declared a schema covering six of its twelve fields, so `Role` and
+     * `Email verified` were validated by nothing.
+     */
+    role: annotate(z.enum(["user", "seller", "admin", "moderator"]).optional(), {
+        section: "profile", sectionLabel: "Profile", sectionRequired: true, quick: true,
+        order: 1, row: "pair", kind: "select",
+    }),
+    emailVerified: annotate(z.boolean().optional(), {
+        section: "profile", quick: true, order: 2, row: "quarter",
+        label: "Email verified",
+    }),
     displayName: annotate(z.string().trim().min(1).max(120).optional(), {
-        section: "profile", sectionLabel: "Profile", sectionRequired: true, quick: true, order: 1, row: "pair",
+        section: "profile", quick: true, order: 3, row: "pair",
     }),
-    phoneNumber: annotate(z.string().trim().regex(PHONE_RE, "Enter a 10-digit Indian mobile number.").optional().or(z.literal("")), { section: "profile", order: 2, row: "pair" }),
+    phoneNumber: annotate(z.string().trim().regex(PHONE_RE, "Enter a 10-digit Indian mobile number.").optional().or(z.literal("")), { section: "profile", order: 4, row: "pair" }),
     /*
      * The tester flags. Kept OPTIONAL rather than defaulted, deliberately: a
      * PATCH that omits them must leave them alone. Defaulting either to `false`
@@ -48,17 +61,76 @@ export const adminUserUpdateSchema = z.object({
     }),
     canTestAdmin: annotate(z.boolean().optional(), {
         section: "access", order: 2, row: "quarter",
+        // The drawer already hid this behind `isTester`; stating it here is what
+        // makes `visibleValues()` drop a stale `true` when the flag is switched off.
+        when: (v) => Boolean(v.isTester),
     }),
     adminNotes: annotate(z.string().trim().max(2000).optional(), {
         section: "access", order: 3, row: "full", kind: "textarea",
         help: "Internal only — never shown to the user.",
     }),
-    // Open: the public profile carries per-user social links and bio fields that
-    // are added over time, and a closed shape would strip a newly-added one.
-    publicProfile: annotate(z.record(firestoreValueSchema).optional(), {
-        section: "access", order: 4, row: "full", kind: "list",
+    /*
+     * The public profile, FLAT — the same call the ad form makes.
+     *
+     * The STORED shape is an open record (`publicProfileSchema` on the route),
+     * because per-user profile keys are added over time and a closed shape would
+     * strip a newly-added one. That was the right conclusion for the document and
+     * the wrong one for the FORM: as one `kind: "list"` field it renders as a
+     * disabled placeholder, while the drawer has always offered seven discrete
+     * inputs — bio, location, website and four social handles — validated by
+     * nothing. The nested shape is reassembled at the payload boundary, where the
+     * API wants it, by `toPublicProfilePayload()` below.
+     */
+    bio: annotate(z.string().trim().max(1000).optional().or(z.literal("")), {
+        section: "public", sectionLabel: "Public profile", order: 1, row: "full",
+        kind: "textarea", help: "Shown on the user's public profile page.",
+    }),
+    location: annotate(z.string().trim().max(120).optional().or(z.literal("")), {
+        section: "public", order: 2, row: "pair",
+    }),
+    website: annotate(z.string().trim().max(2000).optional().or(z.literal("")), {
+        section: "public", order: 3, row: "pair", inputType: "url",
+    }),
+    twitter: annotate(z.string().trim().max(200).optional().or(z.literal("")), {
+        section: "social", sectionLabel: "Social links", order: 1, row: "pair",
+        label: "Twitter / X",
+    }),
+    instagram: annotate(z.string().trim().max(200).optional().or(z.literal("")), {
+        section: "social", order: 2, row: "pair",
+    }),
+    facebook: annotate(z.string().trim().max(200).optional().or(z.literal("")), {
+        section: "social", order: 3, row: "pair",
+    }),
+    linkedin: annotate(z.string().trim().max(200).optional().or(z.literal("")), {
+        section: "social", order: 4, row: "pair", label: "LinkedIn",
     }),
 });
+/**
+ * The flat social/profile fields, reassembled into the nested shape the PATCH
+ * route stores.
+ *
+ * Empty strings are dropped rather than written: the drawer sends a partial
+ * PATCH so an untouched field must leave the stored subkey alone, and writing
+ * `""` would erase it. Returns `undefined` when nothing was filled in, so the
+ * key is omitted from the payload entirely.
+ */
+export function toPublicProfilePayload(v) {
+    const socialLinks = {};
+    for (const key of ["twitter", "instagram", "facebook", "linkedin"]) {
+        const value = v[key]?.trim();
+        if (value)
+            socialLinks[key] = value;
+    }
+    const publicProfile = {};
+    for (const key of ["bio", "location", "website"]) {
+        const value = v[key]?.trim();
+        if (value)
+            publicProfile[key] = value;
+    }
+    if (Object.keys(socialLinks).length > 0)
+        publicProfile.socialLinks = socialLinks;
+    return Object.keys(publicProfile).length > 0 ? publicProfile : undefined;
+}
 /**
  * A store's WhatsApp Business connection.
  *
@@ -79,6 +151,23 @@ export const whatsappSettingsSchema = z.object({
     catalogId: annotate(z.string().trim().regex(/^\d{5,32}$/, "A catalog ID is a numeric id, not a URL.").optional().or(z.literal("")), { section: "connection", order: 3, row: "pair" }),
     accessToken: annotate(z.string().trim().min(20, "That access token looks truncated.").optional().or(z.literal("")), { section: "connection", order: 4, row: "full", help: "Leave blank to keep the current token." }),
 });
+/**
+ * The CONNECTION form's fields — credentials only.
+ *
+ * `catalogSyncEnabled` is deliberately absent. Its toggle lives in a different
+ * card and owns its own write (`syncToggleMutation`), because the credentials
+ * form used to send it unconditionally from two cards away: a seller flipped
+ * the switch, saw it move, and nothing persisted it. A field in this schema is
+ * a field this form's Save button owns.
+ *
+ * 🛑 `.omit()` rather than a second literal, so the two cannot drift — it
+ * carries the SAME field instances into the new shape, which is what keeps the
+ * `annotate()` WeakMap entries alive. (A wrapper such as `.superRefine()` is
+ * transparent for the same reason; a field-level re-wrap is not.)
+ */
+export const whatsappConnectionSchema = whatsappSettingsSchema.omit({
+    catalogSyncEnabled: true,
+});
 /**
  * A buyer's lottery entry.
  *

package/dist/features/admin/schemas/homepage-section-form.d.ts

@@ -20,3 +20,12 @@ export declare const homepageSectionFormSchema: z.ZodObject<{
     order?: number | undefined;
 }>;
 export type HomepageSectionFormValues = z.infer<typeof homepageSectionFormSchema>;
+/**
+ * What the FORM holds, as distinct from what the schema produces.
+ *
+ * `order` is a `z.coerce.number()`, so the parsed value is a number while the
+ * control that feeds it is a text input holding a string — including the empty
+ * string, which means "auto-place". The draft is the INPUT side; only the save
+ * path sees the output.
+ */
+export type HomepageSectionFormInput = z.input<typeof homepageSectionFormSchema>;

package/dist/features/layout/PageTabs.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+export interface PageTabDef {
+    id: string;
+    label: string;
+}
+export interface PageTabsProps {
+    /** The tabs, in order. The first is the default when `?tab=` is absent or unknown. */
+    tabs: readonly PageTabDef[];
+    /** One node per tab id. A missing entry renders an empty panel, not a crash. */
+    panels: Record<string, React.ReactNode>;
+    /**
+     * Override the default tab. Omit to use the first — which is right whenever
+     * the host page's own content is the first tab, as it is on all six.
+     */
+    defaultTabId?: string;
+}
+export declare function PageTabs({ tabs, panels, defaultTabId }: PageTabsProps): React.JSX.Element;

package/dist/features/layout/PageTabs.js

@@ -0,0 +1,45 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/*
+ * WHY: W8's C2 folds sibling pages that are one task into one tabbed page, and
+ *      four of the six hosts are SERVER components that fetch their panels'
+ *      data. Tabs need client state, so something has to sit between.
+ *
+ * WHAT: The tab strip and the panel switch, URL-synced via `?tab=`.
+ *
+ * ## 🛑 Why the tab list is DATA and the guard is derived
+ *
+ * A Server Component cannot hand a function to a Client Component — it is not
+ * serialisable, and the failure is a build error at best and a React #441 at
+ * worst (Root Cause #76). So this takes the tab ARRAY and derives the
+ * "is this a real tab id" test from it, rather than taking an `isValid`
+ * predicate the way `useTabParam` does for callers that are already clients.
+ *
+ * Panels are passed as a record of nodes, which IS serialisable: a Server
+ * Component renders both panels and hands over the results.
+ *
+ * ## Every panel is rendered, always
+ *
+ * `TabsContent` mounts all of them and shows one. That is deliberate for these
+ * six pages: the absorbed panels are small, their data was already fetched
+ * server-side by the same request, and mounting on first view would make a tab
+ * click cost a spinner for content that is already in the payload.
+ *
+ * EXPORTS: PageTabs, type PageTabDef
+ *
+ * @tag domain:layout
+ * @tag layer:component
+ * @tag pattern:none
+ * @tag access:client
+ * @tag consumers:store payouts/shipping/fulfillment/storefront,admin roles/settings
+ * @tag sideEffects:router
+ */
+import React from "react";
+import { Tabs, TabsList, TabsTrigger, TabsContent } from "../../ui";
+import { useTabParam } from "../../react/hooks/useTabParam";
+export function PageTabs({ tabs, panels, defaultTabId }) {
+    const ids = React.useMemo(() => tabs.map((t) => t.id), [tabs]);
+    const isValid = React.useCallback((value) => !!value && ids.includes(value), [ids]);
+    const [activeTab, setActiveTab] = useTabParam(isValid, defaultTabId ?? tabs[0]?.id ?? "");
+    return (_jsxs(Tabs, { value: activeTab, onChange: setActiveTab, children: [_jsx(TabsList, { children: tabs.map((tab) => (_jsx(TabsTrigger, { value: tab.id, children: tab.label }, tab.id))) }), tabs.map((tab) => (_jsx(TabsContent, { value: tab.id, children: panels[tab.id] ?? null }, tab.id)))] }));
+}