@withpotter/lib 0.13.0-next.101

package/dist/api/types/waitlist.d.ts

@@ -0,0 +1,324 @@
+/**
+ * WAITLIST API — as the API sends it.
+ *
+ * One slice of what was a 4,164-line `types.ts`. The sections were already
+ * here as comment fences; they are files now, so a type is found by the
+ * endpoint it belongs to rather than by scrolling.
+ */
+/**
+ * One person waiting for a slot, as `WaitlistMapper.toResponse` sends it.
+ *
+ * Typed against the mapper rather than the entity, which is where this drifted:
+ * it used to declare `tenantId`, `contentId`, `resourceId`, `customerNote`,
+ * `metadata` and `updatedAt` — six fields no waitlist endpoint has ever
+ * returned — while omitting the four that make an offer legible. So the board
+ * could not show what slot was offered or when the offer runs out, which is the
+ * only thing on a waitlist that is urgent.
+ */
+export interface WaitlistItem {
+    id: string;
+    /** Human reference: WL + the first eight of the id. */
+    inquiryNumber?: string;
+    customerName?: string;
+    customerEmail: string;
+    customerPhone?: string;
+    /**
+     * What they are waiting FOR, and optionally on whom.
+     *
+     * The API's table has carried `contentId` and `resourceId` since it was
+     * created; `WaitlistMapper.toResponse` dropped both, so this type was an
+     * accurate description of a response that had thrown the answer away. Fixed
+     * on the API side — the list eager-loads the content, so `contentTitle` is
+     * the thing's own name rather than a uuid.
+     *
+     * Optional because an entry may genuinely name nothing: a walk-in queue for
+     * "a table, any table" has no content behind it.
+     */
+    contentId?: string | null;
+    contentTitle?: string | null;
+    resourceId?: string | null;
+    requestedDate: string;
+    requestedStartTime?: string;
+    requestedEndTime?: string;
+    status: 'waiting' | 'notified' | 'converted' | 'expired' | 'cancelled' | 'declined';
+    position?: number;
+    priority: 'normal' | 'high' | 'urgent';
+    partySize?: number;
+    /** The slot that was offered, once one has been. */
+    offeredDate?: string;
+    offeredStartTime?: string;
+    offeredEndTime?: string;
+    /** When the offer lapses and the engine moves to the next person. */
+    offerExpiresAt?: string;
+    createdAt: string;
+}
+export interface WaitlistListResponse {
+    data: WaitlistItem[];
+    meta: {
+        pagination: {
+            total: number;
+            page: number;
+            pageSize: number;
+            pageCount: number;
+        };
+    };
+}
+export interface BehaviorFieldDefinition {
+    name: string;
+    type: string;
+    label?: string;
+    required?: boolean;
+    showIf?: string;
+}
+export interface BehaviorDefinition {
+    id: string;
+    name: string;
+    description: string;
+    icon: string;
+    tags: string[];
+    formFields: BehaviorFieldDefinition[];
+    tableColumns: {
+        key: string;
+        label: string;
+        format?: string;
+    }[];
+    actions: {
+        id: string;
+        label: string;
+        icon: string;
+    }[];
+    filters: {
+        key: string;
+        label: string;
+        query: Record<string, unknown>;
+    }[];
+}
+export interface Transaction {
+    id: string;
+    /**
+     * The nine the API's own enum declares, verified against
+     * `entities/transaction/transaction.entity.ts`. This listed seven and was
+     * missing `invoice` and `subscription` — both of which the ledger has always
+     * offered as filters, so the type said those filters could not match while
+     * the API happily served them.
+     */
+    type: 'order' | 'invoice' | 'booking' | 'membership' | 'subscription' | 'deposit' | 'tip' | 'refund' | 'payout';
+    /**
+     * The nine states the ledger can hold, in the order money travels.
+     *
+     * `authorized`, `settled`, `expired` and `reversed` were added when the
+     * ledger stopped describing only an online card charge that either works or
+     * does not. Money held and not yet taken, money confirmed in the bank, a
+     * payment nobody ever came back for, and the provider taking it back all had
+     * to be called one of the other five before.
+     */
+    status: 'pending' | 'authorized' | 'success' | 'settled' | 'failed' | 'expired' | 'reversed' | 'refunded' | 'partially_refunded';
+    reference: string;
+    description: string | null;
+    amount: number;
+    fee: number;
+    netAmount: number;
+    currency: string;
+    channel: string | null;
+    customer: {
+        id: string | null;
+        email: string | null;
+        phone: string | null;
+        name: string | null;
+    };
+    paymentDetails: {
+        cardLast4: string | null;
+        cardBrand: string | null;
+        bankName: string | null;
+        accountNumber?: string | null;
+    };
+    relatedRecords: {
+        orderId: string | null;
+        bookingId: string | null;
+        invoiceId: string | null;
+        membershipSubscriptionId: string | null;
+    };
+    /**
+     * Whether `fee` is the provider's figure or our arithmetic. Only `provider`
+     * figures tie to a statement.
+     */
+    feeSource?: 'provider' | 'estimated';
+    /** Terminal, gate or counter that took it. Null for the online storefront. */
+    deviceId?: string | null;
+    /** Taken while the device could not reach us, and replayed later. */
+    capturedOffline?: boolean;
+    /** When the device took it, which for an offline capture is not when we heard. */
+    capturedAt?: string | null;
+    /**
+     * THE ROAD THE MONEY TOOK, and the DTO sends it now.
+     *
+     * The entity has carried these since the transaction spine landed and the
+     * finance DTO serialised none of them, so three of these were declared here
+     * against a payload that never contained them — and the detail screen's
+     * timeline fell back to created / paid / refunded and could not show a
+     * decline, a retry, or the day a payment reached the bank.
+     *
+     * `settledAt` is the one merchants ask for: "Paid" means the customer's side
+     * finished, and only this means the money reached the bank. Deliberately a
+     * FACT rather than a forecast — Shopify shows an "available on" date because
+     * their model can promise one; ours knows when settlement happened and should
+     * not invent when it will.
+     *
+     * Null means "has not happened", never "we did not record it". Optional
+     * because an older API sends none of them, and `undefined` there has to stay
+     * distinguishable from a genuine null.
+     */
+    authorizedAt?: string | null;
+    settledAt?: string | null;
+    reversedAt?: string | null;
+    paidAt: string | null;
+    refundedAt: string | null;
+    refundedAmount: number;
+    /**
+     * On a refund row: the payment it takes money back from. Optional because an
+     * API deployed before it shipped omits it.
+     */
+    originalTransactionId?: string | null;
+    /** Why the merchant gave the refund, when they said. Optional on an older API. */
+    refundReason?: string | null;
+    /**
+     * Why a failed payment failed, in the provider's own words.
+     *
+     * Null on anything that did not fail, and null on failures recorded before
+     * api#448 started keeping it — so absence means "we do not know" rather than
+     * a reason worth printing a placeholder for. Optional, because a dashboard
+     * can be talking to an API that predates the field.
+     */
+    failureReason?: string | null;
+    createdAt: string;
+}
+export interface FinanceAnalytics {
+    summary: {
+        totalRevenue: number;
+        /**
+         * Given back to customers, out of the takings above.
+         *
+         * Optional because an API deployed before this shipped omits it, and a
+         * missing refunds figure has to read as "not known" rather than as zero.
+         */
+        totalRefunded?: number;
+        /** Money customers tried to pay and could not. Optional on an older API. */
+        totalFailed?: number;
+        /**
+         * Asked for and not yet taken. Optional because an API deployed before it
+         * shipped omits it, and a missing figure must read as "not known", not zero.
+         */
+        totalPending?: number;
+        totalFees: number;
+        netRevenue: number;
+        transactionCount: number;
+        successfulCount: number;
+        failedCount: number;
+        pendingCount: number;
+        refundedCount: number;
+        averageTransactionValue: number;
+        currency: string;
+    };
+    recentTransactions: Transaction[];
+    revenueByType: {
+        breakdown: Array<{
+            type: string;
+            total: number;
+            count: number;
+            percentage: number;
+        }>;
+        total: number;
+    };
+    /**
+     * Takings split by how the money arrived, and the one number the Payments
+     * hub turns on: how much of it the provider actually holds. Cash and
+     * hand-recorded transfers are income but can never be withdrawn.
+     *
+     * Optional because an API deployed before this shipped simply omits it. The
+     * surface hides the split rather than guessing at it.
+     */
+    revenueByChannel?: {
+        breakdown: Array<{
+            channel: string;
+            total: number;
+            count: number;
+            percentage: number;
+        }>;
+        settleable: number;
+        offPlatform: number;
+        total: number;
+    };
+    chart: {
+        data: Array<{
+            date: string;
+            total: number;
+            count: number;
+            /**
+             * Given back to customers that day, out of the takings beside it.
+             *
+             * Optional because an API deployed before this shipped omits it, and a
+             * missing outflow has to read as "not known" rather than as zero — a
+             * cash-flow chart drawing a flat zero line for refunds would report every
+             * business as keeping everything it took.
+             */
+            refunds?: number;
+        }>;
+        period: string;
+        totalRevenue: number;
+        /** Refunded across the window, so a strip and the series cannot disagree. */
+        totalRefunded?: number;
+        totalTransactions: number;
+    };
+}
+/**
+ * One thing that happened to a transaction.
+ *
+ * `source` is which road it came in by — the provider's webhook, a customer
+ * reloading the return page, an operator, a device, the sweep. Recorded rather
+ * than inferred, because when two of them disagree the only way to see it is to
+ * know which wrote what.
+ */
+export interface TransactionTimelineEntry {
+    id: string;
+    type: 'initiated' | 'authorized' | 'captured' | 'failed' | 'settled' | 'reversed' | 'refunded' | 'expired' | 'reconciled' | 'replayed' | 'note';
+    summary: string;
+    source: 'webhook' | 'verify' | 'dashboard' | 'device' | 'sweeper' | 'system';
+    fromValue: string | null;
+    toValue: string | null;
+    actorName: string | null;
+    deviceId: string | null;
+    /** Minor units, when the event moved money. */
+    amount: number | null;
+    occurredAt: string;
+}
+export interface TransactionTimeline {
+    transactionId: string;
+    reference: string;
+    status: string;
+    entries: TransactionTimelineEntry[];
+}
+/** One kind of thing going wrong, with a sentence saying why it matters. */
+export interface PaymentExceptionGroup {
+    key: string;
+    /**
+     * Whether there is something a person can DO about this group.
+     *
+     * Comes from the API rather than being worked out here: a group that names a
+     * problem and offers nothing is the defect this surface exists to remove, and
+     * letting the screen guess which ones have actions is how the next one gets
+     * added without its own.
+     */
+    action?: 'offline_captures' | 'webhook_failures' | 'discrepancies' | 'stuck_refunds' | 'overdrawn_balances';
+    label: string;
+    detail: string;
+    count: number;
+    /** Minor units. Null where a total would be meaningless. */
+    amount: number | null;
+    severity: 'critical' | 'warning' | 'info';
+}
+export interface PaymentExceptions {
+    groups: PaymentExceptionGroup[];
+    /** True when nothing needs a human. The screen says so rather than drawing nothing. */
+    clear: boolean;
+    checkedAt: string;
+}

package/dist/api/types/waitlist.js

@@ -0,0 +1 @@
+//# sourceMappingURL=waitlist.js.map

package/dist/api/types/waitlist.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/api/types.d.ts

@@ -0,0 +1 @@
+export * from './types/index';

package/dist/api/types.js

@@ -0,0 +1 @@
+export * from './types/index.js';

package/dist/api/unserved-routes.d.ts

@@ -0,0 +1,4 @@
+/** Whether `endpoint` (as passed to `apiFetch`, query string allowed) is one this box does not serve. */
+export declare function isUnservedRoute(endpoint: string): boolean;
+/** The router's own sentence for a route it does not have, as the engine would say it. */
+export declare function unservedMessage(method: string, endpoint: string): string;

package/dist/api/unserved-routes.js

@@ -0,0 +1,15 @@
+const unservedPrefixes = () => (process.env.NEXT_PUBLIC_BOX_UNSERVED_ROUTES ?? "").split(",").map((entry) => entry.trim().replace(/^\/+|\/+$/g, "")).filter(Boolean);
+function isUnservedRoute(endpoint) {
+  const path = endpoint.split(/[?#]/)[0].replace(/^\/+/, "");
+  return unservedPrefixes().some(
+    (prefix) => path === prefix || path.startsWith(`${prefix}/`)
+  );
+}
+function unservedMessage(method, endpoint) {
+  return `Cannot ${method.toUpperCase()} ${endpoint.split(/[?#]/)[0]}`;
+}
+export {
+  isUnservedRoute,
+  unservedMessage
+};
+//# sourceMappingURL=unserved-routes.js.map

package/dist/api/unserved-routes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/api/unserved-routes.ts"],"sourcesContent":["/**\n * Box switch for the API routes this box's engine does not serve.\n *\n * `NEXT_PUBLIC_BOX_UNSERVED_ROUTES=billing,analytics/stock-cover`: a comma list\n * of path prefixes. A call to one of them (the prefix itself or anything below\n * it, never `/billing-export` for `billing`) is answered here with the same 404\n * the engine would give, \"Cannot GET /billing/plans\", without asking the\n * engine. Pages already treat that answer as a service the box does not have\n * (`isServiceMissing`), so they look exactly as they did; the only change is\n * that the browser stops sending a request that can only fail.\n *\n * Off unless set, so other boxes call every route. Read when called, so a test\n * can set it. NEXT_PUBLIC_* is inlined at build.\n */\nconst unservedPrefixes = () =>\n  (process.env.NEXT_PUBLIC_BOX_UNSERVED_ROUTES ?? '')\n    .split(',')\n    .map((entry) => entry.trim().replace(/^\\/+|\\/+$/g, ''))\n    .filter(Boolean);\n\n/** Whether `endpoint` (as passed to `apiFetch`, query string allowed) is one this box does not serve. */\nexport function isUnservedRoute(endpoint: string): boolean {\n  const path = endpoint.split(/[?#]/)[0].replace(/^\\/+/, '');\n  return unservedPrefixes().some(\n    (prefix) => path === prefix || path.startsWith(`${prefix}/`),\n  );\n}\n\n/** The router's own sentence for a route it does not have, as the engine would say it. */\nexport function unservedMessage(method: string, endpoint: string): string {\n  return `Cannot ${method.toUpperCase()} ${endpoint.split(/[?#]/)[0]}`;\n}\n"],"mappings":"AAcA,MAAM,mBAAmB,OACtB,QAAQ,IAAI,mCAAmC,IAC7C,MAAM,GAAG,EACT,IAAI,CAAC,UAAU,MAAM,KAAK,EAAE,QAAQ,cAAc,EAAE,CAAC,EACrD,OAAO,OAAO;AAGZ,SAAS,gBAAgB,UAA2B;AACzD,QAAM,OAAO,SAAS,MAAM,MAAM,EAAE,CAAC,EAAE,QAAQ,QAAQ,EAAE;AACzD,SAAO,iBAAiB,EAAE;AAAA,IACxB,CAAC,WAAW,SAAS,UAAU,KAAK,WAAW,GAAG,MAAM,GAAG;AAAA,EAC7D;AACF;AAGO,SAAS,gBAAgB,QAAgB,UAA0B;AACxE,SAAO,UAAU,OAAO,YAAY,CAAC,IAAI,SAAS,MAAM,MAAM,EAAE,CAAC,CAAC;AACpE;","names":[]}

package/dist/api/waitlist.d.ts

@@ -0,0 +1,80 @@
+import type { WaitlistItem, WaitlistListResponse } from './types';
+export declare const waitlistApi: {
+    /**
+     * List all waitlist entries
+     */
+    list: (tenantSlug: string, params?: {
+        status?: string;
+        page?: number;
+        limit?: number;
+    }) => Promise<WaitlistListResponse>;
+    /**
+     * Put someone on the list from the desk.
+     *
+     * The list could only ever be joined from the storefront, which is not how
+     * anybody joins a waitlist here: they ring up, or they are standing at the
+     * counter being told tonight is full. Backed by POST /waitlist, the same
+     * endpoint the storefront uses.
+     */
+    add: (tenantSlug: string, data: {
+        customerEmail: string;
+        customerName?: string;
+        customerPhone?: string;
+        requestedDate: string;
+        requestedStartTime?: string;
+        requestedEndTime?: string;
+        partySize?: number;
+        priority?: "normal" | "high" | "urgent";
+        contentId?: string;
+        resourceId?: string;
+    }) => Promise<{
+        data: WaitlistItem;
+    }>;
+    /**
+     * Offer an open slot to a waiting entry (notifies the customer).
+     */
+    offer: (tenantSlug: string, id: string, data: {
+        date: string;
+        startTime: string;
+        endTime: string;
+        expiresInHours?: number;
+    }) => Promise<{
+        data: WaitlistItem;
+    }>;
+    /**
+     * Accept an outstanding offer.
+     *
+     * This creates a real booking and hands back its id and number — the
+     * endpoint's whole point. It was typed as returning the waitlist entry,
+     * which is not what the API sends and not what the caller needs, so the
+     * booking came into existence and nothing on screen ever mentioned it.
+     */
+    accept: (tenantSlug: string, id: string) => Promise<{
+        bookingId: string;
+        bookingNumber: string;
+    }>;
+    /** Decline an outstanding offer; optionally keep the entry waiting. */
+    decline: (tenantSlug: string, id: string, stayOnWaitlist?: boolean) => Promise<{
+        data: WaitlistItem;
+    }>;
+    /** Remove an entry from the waitlist. */
+    cancel: (tenantSlug: string, id: string) => Promise<{
+        success: boolean;
+    }>;
+    /** Aggregate counts for the board header. */
+    stats: (tenantSlug: string, dateFrom?: string, dateTo?: string) => Promise<{
+        total: number;
+        byStatus: Record<string, number>;
+    }>;
+    /**
+     * Who is waiting for a given day, in the order the engine will offer to.
+     *
+     * This is what makes the cancellation loop visible: potter-api already
+     * listens for `booking.cancelled` and offers the freed slot to the next
+     * person here, with a two-hour window — but the dashboard never showed it, so
+     * staff cancelled into silence.
+     */
+    queue: (tenantSlug: string, date: string, resourceId?: string) => Promise<WaitlistItem[] | {
+        data: WaitlistItem[];
+    }>;
+};

package/dist/api/waitlist.js

@@ -0,0 +1,85 @@
+import { apiFetch } from "./core";
+const waitlistApi = {
+  /**
+   * List all waitlist entries
+   */
+  list: (tenantSlug, params) => {
+    const searchParams = new URLSearchParams();
+    if (params?.status) searchParams.set("status", params.status);
+    if (params?.page) searchParams.set("page", String(params.page));
+    if (params?.limit) searchParams.set("limit", String(params.limit));
+    const query = searchParams.toString() ? `?${searchParams.toString()}` : "";
+    return apiFetch(`/waitlist${query}`, { tenantSlug });
+  },
+  /**
+   * Put someone on the list from the desk.
+   *
+   * The list could only ever be joined from the storefront, which is not how
+   * anybody joins a waitlist here: they ring up, or they are standing at the
+   * counter being told tonight is full. Backed by POST /waitlist, the same
+   * endpoint the storefront uses.
+   */
+  add: (tenantSlug, data) => apiFetch("/waitlist", {
+    method: "POST",
+    tenantSlug,
+    body: JSON.stringify(data)
+  }),
+  /**
+   * Offer an open slot to a waiting entry (notifies the customer).
+   */
+  offer: (tenantSlug, id, data) => apiFetch(`/waitlist/${id}/offer`, {
+    method: "POST",
+    tenantSlug,
+    body: JSON.stringify(data)
+  }),
+  /**
+   * Accept an outstanding offer.
+   *
+   * This creates a real booking and hands back its id and number — the
+   * endpoint's whole point. It was typed as returning the waitlist entry,
+   * which is not what the API sends and not what the caller needs, so the
+   * booking came into existence and nothing on screen ever mentioned it.
+   */
+  accept: (tenantSlug, id) => apiFetch(
+    `/waitlist/${id}/accept`,
+    { method: "POST", tenantSlug }
+  ),
+  /** Decline an outstanding offer; optionally keep the entry waiting. */
+  decline: (tenantSlug, id, stayOnWaitlist = false) => apiFetch(
+    `/waitlist/${id}/decline?stayOnWaitlist=${stayOnWaitlist}`,
+    { method: "POST", tenantSlug }
+  ),
+  /** Remove an entry from the waitlist. */
+  cancel: (tenantSlug, id) => apiFetch(`/waitlist/${id}`, {
+    method: "DELETE",
+    tenantSlug
+  }),
+  /** Aggregate counts for the board header. */
+  stats: (tenantSlug, dateFrom, dateTo) => {
+    const searchParams = new URLSearchParams();
+    if (dateFrom) searchParams.set("dateFrom", dateFrom);
+    if (dateTo) searchParams.set("dateTo", dateTo);
+    const query = searchParams.toString() ? `?${searchParams.toString()}` : "";
+    return apiFetch(`/waitlist/stats${query}`, { tenantSlug });
+  },
+  /**
+   * Who is waiting for a given day, in the order the engine will offer to.
+   *
+   * This is what makes the cancellation loop visible: potter-api already
+   * listens for `booking.cancelled` and offers the freed slot to the next
+   * person here, with a two-hour window — but the dashboard never showed it, so
+   * staff cancelled into silence.
+   */
+  queue: (tenantSlug, date, resourceId) => {
+    const params = new URLSearchParams({ date });
+    if (resourceId) params.set("resourceId", resourceId);
+    return apiFetch(
+      `/waitlist/queue?${params.toString()}`,
+      { tenantSlug }
+    );
+  }
+};
+export {
+  waitlistApi
+};
+//# sourceMappingURL=waitlist.js.map

package/dist/api/waitlist.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/api/waitlist.ts"],"sourcesContent":["import { apiFetch } from './core';\nimport type { WaitlistItem, WaitlistListResponse } from './types';\n\nexport const waitlistApi = {\n  /**\n   * List all waitlist entries\n   */\n  list: (\n    tenantSlug: string,\n    params?: {\n      status?: string;\n      page?: number;\n      limit?: number;\n    },\n  ) => {\n    const searchParams = new URLSearchParams();\n    if (params?.status) searchParams.set('status', params.status);\n    if (params?.page) searchParams.set('page', String(params.page));\n    if (params?.limit) searchParams.set('limit', String(params.limit));\n    const query = searchParams.toString() ? `?${searchParams.toString()}` : '';\n    return apiFetch<WaitlistListResponse>(`/waitlist${query}`, { tenantSlug });\n  },\n\n  /**\n   * Put someone on the list from the desk.\n   *\n   * The list could only ever be joined from the storefront, which is not how\n   * anybody joins a waitlist here: they ring up, or they are standing at the\n   * counter being told tonight is full. Backed by POST /waitlist, the same\n   * endpoint the storefront uses.\n   */\n  add: (\n    tenantSlug: string,\n    data: {\n      customerEmail: string;\n      customerName?: string;\n      customerPhone?: string;\n      requestedDate: string;\n      requestedStartTime?: string;\n      requestedEndTime?: string;\n      partySize?: number;\n      priority?: 'normal' | 'high' | 'urgent';\n      contentId?: string;\n      resourceId?: string;\n    },\n  ) =>\n    apiFetch<{ data: WaitlistItem }>('/waitlist', {\n      method: 'POST',\n      tenantSlug,\n      body: JSON.stringify(data),\n    }),\n\n  /**\n   * Offer an open slot to a waiting entry (notifies the customer).\n   */\n  offer: (\n    tenantSlug: string,\n    id: string,\n    data: {\n      date: string;\n      startTime: string;\n      endTime: string;\n      expiresInHours?: number;\n    },\n  ) =>\n    apiFetch<{ data: WaitlistItem }>(`/waitlist/${id}/offer`, {\n      method: 'POST',\n      tenantSlug,\n      body: JSON.stringify(data),\n    }),\n\n  /**\n   * Accept an outstanding offer.\n   *\n   * This creates a real booking and hands back its id and number — the\n   * endpoint's whole point. It was typed as returning the waitlist entry,\n   * which is not what the API sends and not what the caller needs, so the\n   * booking came into existence and nothing on screen ever mentioned it.\n   */\n  accept: (tenantSlug: string, id: string) =>\n    apiFetch<{ bookingId: string; bookingNumber: string }>(\n      `/waitlist/${id}/accept`,\n      { method: 'POST', tenantSlug },\n    ),\n\n  /** Decline an outstanding offer; optionally keep the entry waiting. */\n  decline: (tenantSlug: string, id: string, stayOnWaitlist = false) =>\n    apiFetch<{ data: WaitlistItem }>(\n      `/waitlist/${id}/decline?stayOnWaitlist=${stayOnWaitlist}`,\n      { method: 'POST', tenantSlug },\n    ),\n\n  /** Remove an entry from the waitlist. */\n  cancel: (tenantSlug: string, id: string) =>\n    apiFetch<{ success: boolean }>(`/waitlist/${id}`, {\n      method: 'DELETE',\n      tenantSlug,\n    }),\n\n  /** Aggregate counts for the board header. */\n  stats: (tenantSlug: string, dateFrom?: string, dateTo?: string) => {\n    const searchParams = new URLSearchParams();\n    if (dateFrom) searchParams.set('dateFrom', dateFrom);\n    if (dateTo) searchParams.set('dateTo', dateTo);\n    const query = searchParams.toString() ? `?${searchParams.toString()}` : '';\n    return apiFetch<{\n      total: number;\n      byStatus: Record<string, number>;\n    }>(`/waitlist/stats${query}`, { tenantSlug });\n  },\n\n  /**\n   * Who is waiting for a given day, in the order the engine will offer to.\n   *\n   * This is what makes the cancellation loop visible: potter-api already\n   * listens for `booking.cancelled` and offers the freed slot to the next\n   * person here, with a two-hour window — but the dashboard never showed it, so\n   * staff cancelled into silence.\n   */\n  queue: (tenantSlug: string, date: string, resourceId?: string) => {\n    const params = new URLSearchParams({ date });\n    if (resourceId) params.set('resourceId', resourceId);\n    return apiFetch<{ data: WaitlistItem[] } | WaitlistItem[]>(\n      `/waitlist/queue?${params.toString()}`,\n      { tenantSlug },\n    );\n  },\n};\n\n// ============================================\n// BEHAVIORS API\n// ============================================\n"],"mappings":"AAAA,SAAS,gBAAgB;AAGlB,MAAM,cAAc;AAAA;AAAA;AAAA;AAAA,EAIzB,MAAM,CACJ,YACA,WAKG;AACH,UAAM,eAAe,IAAI,gBAAgB;AACzC,QAAI,QAAQ,OAAQ,cAAa,IAAI,UAAU,OAAO,MAAM;AAC5D,QAAI,QAAQ,KAAM,cAAa,IAAI,QAAQ,OAAO,OAAO,IAAI,CAAC;AAC9D,QAAI,QAAQ,MAAO,cAAa,IAAI,SAAS,OAAO,OAAO,KAAK,CAAC;AACjE,UAAM,QAAQ,aAAa,SAAS,IAAI,IAAI,aAAa,SAAS,CAAC,KAAK;AACxE,WAAO,SAA+B,YAAY,KAAK,IAAI,EAAE,WAAW,CAAC;AAAA,EAC3E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,KAAK,CACH,YACA,SAaA,SAAiC,aAAa;AAAA,IAC5C,QAAQ;AAAA,IACR;AAAA,IACA,MAAM,KAAK,UAAU,IAAI;AAAA,EAC3B,CAAC;AAAA;AAAA;AAAA;AAAA,EAKH,OAAO,CACL,YACA,IACA,SAOA,SAAiC,aAAa,EAAE,UAAU;AAAA,IACxD,QAAQ;AAAA,IACR;AAAA,IACA,MAAM,KAAK,UAAU,IAAI;AAAA,EAC3B,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUH,QAAQ,CAAC,YAAoB,OAC3B;AAAA,IACE,aAAa,EAAE;AAAA,IACf,EAAE,QAAQ,QAAQ,WAAW;AAAA,EAC/B;AAAA;AAAA,EAGF,SAAS,CAAC,YAAoB,IAAY,iBAAiB,UACzD;AAAA,IACE,aAAa,EAAE,2BAA2B,cAAc;AAAA,IACxD,EAAE,QAAQ,QAAQ,WAAW;AAAA,EAC/B;AAAA;AAAA,EAGF,QAAQ,CAAC,YAAoB,OAC3B,SAA+B,aAAa,EAAE,IAAI;AAAA,IAChD,QAAQ;AAAA,IACR;AAAA,EACF,CAAC;AAAA;AAAA,EAGH,OAAO,CAAC,YAAoB,UAAmB,WAAoB;AACjE,UAAM,eAAe,IAAI,gBAAgB;AACzC,QAAI,SAAU,cAAa,IAAI,YAAY,QAAQ;AACnD,QAAI,OAAQ,cAAa,IAAI,UAAU,MAAM;AAC7C,UAAM,QAAQ,aAAa,SAAS,IAAI,IAAI,aAAa,SAAS,CAAC,KAAK;AACxE,WAAO,SAGJ,kBAAkB,KAAK,IAAI,EAAE,WAAW,CAAC;AAAA,EAC9C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,OAAO,CAAC,YAAoB,MAAc,eAAwB;AAChE,UAAM,SAAS,IAAI,gBAAgB,EAAE,KAAK,CAAC;AAC3C,QAAI,WAAY,QAAO,IAAI,cAAc,UAAU;AACnD,WAAO;AAAA,MACL,mBAAmB,OAAO,SAAS,CAAC;AAAA,MACpC,EAAE,WAAW;AAAA,IACf;AAAA,EACF;AACF;","names":[]}

package/dist/api.d.ts

@@ -0,0 +1 @@
+export * from './api/index';

package/dist/api.js

@@ -0,0 +1 @@
+export * from './api/index.js';

package/dist/app-name.d.ts

@@ -0,0 +1,29 @@
+/**
+ * What the app calls itself in a browser tab, on a home screen, and in a
+ * share card.
+ *
+ * Not "Box Dashboard". A dashboard is a read-only view of numbers, and
+ * analytics is one tab inside this rather than the whole of it — what actually
+ * lives here is the catalogue, orders, fulfilment, payments, domains and the
+ * editor. Not "Box Merchant" either: `merchant` is our internal word for the
+ * customer and reaches no shipped UI string, and it is a retail noun in a
+ * product that also runs clubs, halls and short-lets, which is the same trap
+ * `useEntityLabel` exists to avoid one level up.
+ *
+ * So the suffix only has to say whose app this is. The screen name carries the
+ * rest, the way Linear and Vercel do it.
+ */
+export declare const APP_NAME = "Box";
+/**
+ * "Orders · Ada's Kitchen", falling back to "Orders · Box".
+ *
+ * The suffix is the business, not the app, whenever you are inside one. Box
+ * runs several workspaces per person, so naming every tab after Box leaves
+ * three tabs on three different businesses reading the same thing — the app
+ * name is the one word they already share. The plated favicon carries the
+ * brand at 16px; the words can belong to whoever the tab is for.
+ *
+ * `owner` is absent before a workspace is picked (sign-in, onboarding), and
+ * there the app name is all there is to say.
+ */
+export declare function tabTitle(name?: string, owner?: string): string;

package/dist/app-name.js

@@ -0,0 +1,11 @@
+const APP_NAME = "Box";
+function tabTitle(name, owner) {
+  const screen = name?.trim();
+  const suffix = owner?.trim() || APP_NAME;
+  return screen ? `${screen} \xB7 ${suffix}` : suffix;
+}
+export {
+  APP_NAME,
+  tabTitle
+};
+//# sourceMappingURL=app-name.js.map

package/dist/app-name.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/app-name.ts"],"sourcesContent":["/**\n * What the app calls itself in a browser tab, on a home screen, and in a\n * share card.\n *\n * Not \"Box Dashboard\". A dashboard is a read-only view of numbers, and\n * analytics is one tab inside this rather than the whole of it — what actually\n * lives here is the catalogue, orders, fulfilment, payments, domains and the\n * editor. Not \"Box Merchant\" either: `merchant` is our internal word for the\n * customer and reaches no shipped UI string, and it is a retail noun in a\n * product that also runs clubs, halls and short-lets, which is the same trap\n * `useEntityLabel` exists to avoid one level up.\n *\n * So the suffix only has to say whose app this is. The screen name carries the\n * rest, the way Linear and Vercel do it.\n */\nexport const APP_NAME = 'Box';\n\n/**\n * \"Orders · Ada's Kitchen\", falling back to \"Orders · Box\".\n *\n * The suffix is the business, not the app, whenever you are inside one. Box\n * runs several workspaces per person, so naming every tab after Box leaves\n * three tabs on three different businesses reading the same thing — the app\n * name is the one word they already share. The plated favicon carries the\n * brand at 16px; the words can belong to whoever the tab is for.\n *\n * `owner` is absent before a workspace is picked (sign-in, onboarding), and\n * there the app name is all there is to say.\n */\nexport function tabTitle(name?: string, owner?: string): string {\n  const screen = name?.trim();\n  const suffix = owner?.trim() || APP_NAME;\n  return screen ? `${screen} · ${suffix}` : suffix;\n}\n"],"mappings":"AAeO,MAAM,WAAW;AAcjB,SAAS,SAAS,MAAe,OAAwB;AAC9D,QAAM,SAAS,MAAM,KAAK;AAC1B,QAAM,SAAS,OAAO,KAAK,KAAK;AAChC,SAAO,SAAS,GAAG,MAAM,SAAM,MAAM,KAAK;AAC5C;","names":[]}

package/dist/arrival.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Saying something once, to somebody who has just arrived.
+ *
+ * Extracted from `staff-arrival`, which had solved this properly for one case
+ * and was about to be copy-pasted for a second. The traps it documents are not
+ * about staff — they are about one-shot messages on this app's dashboard, and
+ * a second copy would carry the same three paragraphs of reasoning and drift
+ * from them.
+ *
+ * ── THE THREE THINGS THAT ARE NOT OBVIOUS ──
+ *
+ * STORED, NOT DERIVED. `joinedAt` or `createdAt` looks like the obvious source
+ * and would greet somebody on every sign-in on their first day — and on a
+ * shared counter phone, greet whoever opened it next. A flag written by the
+ * screen that caused the arrival fires exactly once, for the person who was
+ * actually there.
+ *
+ * CLEARED ON READ, NOT ON DISMISS. A welcome that survives a refresh greets
+ * somebody twice, and the second time reads as a bug.
+ *
+ * LATCHED FOR THE PAGE LOAD. The dashboard layout renders a phone tree OR a
+ * desktop tree, and which one is only known after hydration — the server has no
+ * viewport, so a phone paints the desktop tree first and swaps. That swap
+ * unmounts one welcome and mounts another, and with the flag cleared on read
+ * the second one asked an empty cupboard: anyone arriving on a phone, which is
+ * most of them, got nothing at all. `decided` lives in module scope, so it
+ * lasts exactly as long as the page.
+ *
+ * sessionStorage, not local: a welcome should not survive into a new tab
+ * opened tomorrow.
+ */
+export interface Arrival {
+    /** Write the flag. Called by whatever caused the arrival, before it routes. */
+    flag: () => void;
+    /** Read and clear in one breath, latched for the rest of this page load. */
+    take: () => boolean;
+    /** Said. Anything mounting after this gets nothing. */
+    end: () => void;
+    /**
+     * Was this page load an arrival?
+     *
+     * For anything that must NOT interrupt while the arrival's own message is on
+     * screen. Read-only — it never consumes the flag, so asking cannot change
+     * who gets greeted.
+     */
+    taken: () => boolean;
+}
+export declare function makeArrival(key: string): Arrival;