restaurant-kit 0.1.0

package/dist/types/config/useOrdering.d.ts

@@ -0,0 +1,16 @@
+export type ResolvedOrdering = {
+    /** False = browse-only menu: no add-to-cart, no cart drawer. */
+    readonly cartEnabled: boolean;
+    readonly isWhatsApp: boolean;
+    /** Where the header / hero / item-sheet order buttons go. Empty when there is nowhere to send people. */
+    readonly href: string;
+    readonly label: string;
+    readonly shortLabel: string;
+    /** External mode only: the ordering app's logo. */
+    readonly iconSrc?: string;
+};
+/**
+ * Resolves `config.ordering`. Reads the context directly instead of `useSiteConfig()` so the
+ * menu components stay renderable without a provider (they fall back to the WhatsApp cart).
+ */
+export declare function useOrdering(): ResolvedOrdering;

package/dist/types/index.d.ts

@@ -0,0 +1,38 @@
+import "./styles/global.css";
+export { RestaurantSite } from "./RestaurantSiteRoutes";
+export { RestaurantKitProvider } from "./config/RestaurantKitProvider";
+export { useMenuApi, useRestaurantKit, useSeedMenu, useSiteConfig, type RestaurantKitApiOptions, type RestaurantKitValue } from "./config/siteConfigContext";
+export type { OrderingConfig, RestaurantSiteConfig } from "./config/siteTypes";
+export { useOrdering, type ResolvedOrdering } from "./config/useOrdering";
+export { MenuSite } from "./pages/MenuSite";
+export { AdminMenuEditor } from "./pages/AdminMenuEditor";
+export { AdminPreview } from "./pages/AdminPreview";
+export { Brand } from "./components/Brand";
+export { Footer } from "./components/Footer";
+export { Header } from "./components/Header";
+export { Hero } from "./components/Hero";
+export { LocationsSection } from "./components/LocationsSection";
+export { Marquee } from "./components/Marquee";
+export { RatingSection } from "./components/RatingSection";
+export { TestimonialsSection } from "./components/TestimonialsSection";
+export { InstagramIcon } from "./components/InstagramIcon";
+export { WhatsAppIcon } from "./components/WhatsAppIcon";
+export { MenuBrowser } from "./menu-browser/MenuBrowser";
+export { MenuSection } from "./menu-browser/MenuSection";
+export { MenuCartDrawer } from "./menu-browser/MenuCartDrawer";
+export { CartProvider } from "./cart/CartProvider";
+export { useCart } from "./cart/useCart";
+export { buildWhatsAppMessage, buildWhatsAppOrderUrl, cartSelectionKey, formatVariationName, type CartOrderConfig } from "./cart/cartOrder";
+export type { CartItem, CartSelection, CartState, CartContextValue } from "./cart/cartTypes";
+export { MenuDataProvider, useMenuData, type MenuDataStatus, type MenuDataValue } from "./menu/useMenuData";
+export { createMenuApiClient, MenuApiError, type AdminAuthStrategy, type AdminSession, type MenuApiClient, type MenuBackup, type RestoreDraftSource, type MenuApiClientOptions, type MenuImageUpload, type PublishResult, } from "./menu/menuApi";
+export { createLocalMenuApiClient, shouldUseLocalMenuApi } from "./menu/localMenuApi";
+export { clearMenuDraft, menuDraftStorageKey, readMenuDraft, writeMenuDraft } from "./menu/menuDraftStorage";
+export { menuIcons, menuIconOptions } from "./menu/menuIcons";
+export { formatPrice, formatPriceTotal, priceFromInput, priceInputValue, type PriceCurrency } from "./menu/priceFormat";
+export { menuIconIds, type DynamicMenu, type MenuCategory, type MenuGroup, type MenuIcon, type MenuItem, type MenuSize, type Testimonial } from "./menu/menuSchema";
+export { assertValidMenu, validateMenu, type MenuValidationIssue } from "./menu/validateMenu";
+export { useAdminMenuDraft, type AdminMenuDraft, type UseAdminMenuDraftOptions } from "./admin/useAdminMenuDraft";
+export { AdminDraftProvider } from "./admin/AdminDraftProvider";
+export { useAdminDraft, useAdminDraftContext } from "./admin/useAdminDraft";
+export { applyAdminMenuCommand, getAdminMenuCommandRejection, type AdminMenuCommand, type AdminMenuCommandRejection } from "./admin/adminMenuCommands";

package/dist/types/menu/localMenuApi.d.ts

@@ -0,0 +1,9 @@
+import type { MenuApiClient } from "./menuApi";
+import type { DynamicMenu } from "./menuSchema";
+/** Browser-only adapter for localhost: drafts persist to localStorage under `storageKey`. */
+export declare function createLocalMenuApiClient(initialMenu: DynamicMenu, storageKey: string): MenuApiClient;
+/**
+ * localhost / 127.0.0.1 → browser-local adapter (no Worker needed), unless an API base URL is
+ * configured, which opts the dev server into a real Worker (e.g. `wrangler dev` on :8787).
+ */
+export declare function shouldUseLocalMenuApi(apiBaseUrl?: string): boolean;

package/dist/types/menu/menuApi.d.ts

@@ -0,0 +1,68 @@
+import type { DynamicMenu } from "./menuSchema";
+type Fetcher = typeof fetch;
+export type MenuImageUpload = {
+    readonly key: string;
+    readonly url: string;
+};
+export type PublishResult = {
+    readonly ok: true;
+    readonly backupKey: string | null;
+};
+/** "local" is the browser-only dev client; the Worker reports password | access | none. */
+export type AdminAuthStrategy = "password" | "access" | "none" | "local";
+export type AdminSession = {
+    readonly authenticated: boolean;
+    readonly strategy: AdminAuthStrategy;
+    readonly user: string | null;
+};
+export type DraftMenuRecord = {
+    readonly menu: DynamicMenu;
+    /** Server etag of the draft, or null when unknown (local adapter, published fallback). */
+    readonly etag: string | null;
+};
+export type SaveDraftOptions = {
+    /** Send the etag from the last load/save; the server answers 412 if the draft changed meanwhile. */
+    readonly ifMatch?: string | null;
+};
+export type MenuBackup = {
+    readonly key: string;
+    readonly publishedAt: string;
+    readonly size: number;
+};
+export type RestoreDraftSource = {
+    readonly kind: "published";
+} | {
+    readonly kind: "backup";
+    readonly key: string;
+};
+export type MenuApiClient = {
+    readonly getPublishedMenu: () => Promise<DynamicMenu>;
+    readonly getDraftMenu: () => Promise<DynamicMenu>;
+    readonly getDraft: () => Promise<DraftMenuRecord>;
+    readonly getAdminSignInUrl: (returnTo?: string) => string;
+    readonly getAdminSession: () => Promise<AdminSession>;
+    readonly signInWithPassword: (password: string) => Promise<AdminSession>;
+    readonly signOut: () => Promise<void>;
+    readonly saveDraftMenu: (menu: DynamicMenu, options?: SaveDraftOptions) => Promise<{
+        readonly etag: string | null;
+    }>;
+    readonly publishDraftMenu: () => Promise<PublishResult>;
+    readonly listMenuBackups: () => Promise<readonly MenuBackup[]>;
+    /** Replaces the remote draft with the published menu or a backup. Reload the draft afterwards. */
+    readonly restoreDraft: (source: RestoreDraftSource) => Promise<{
+        readonly etag: string | null;
+    }>;
+    readonly uploadMenuImage: (file: File) => Promise<MenuImageUpload>;
+    readonly deleteMenuImage: (key: string) => Promise<void>;
+};
+export type MenuApiClientOptions = {
+    readonly apiBaseUrl?: string;
+    readonly publicMenuUrl?: string;
+    readonly fetcher?: Fetcher;
+};
+export declare class MenuApiError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+export declare function createMenuApiClient(options?: MenuApiClientOptions): MenuApiClient;
+export {};

package/dist/types/menu/menuDraftStorage.d.ts

@@ -0,0 +1,5 @@
+import type { DynamicMenu } from "./menuSchema";
+export declare function menuDraftStorageKey(restaurantId: string): string;
+export declare function readMenuDraft(storageKey: string): DynamicMenu | null;
+export declare function writeMenuDraft(menu: DynamicMenu, storageKey: string): void;
+export declare function clearMenuDraft(storageKey: string): void;

package/dist/types/menu/menuIcons.d.ts

@@ -0,0 +1,7 @@
+import { Utensils } from "lucide-react";
+import type { MenuIcon } from "./menuSchema";
+export declare const menuIcons: Record<MenuIcon, typeof Utensils>;
+export declare const menuIconOptions: readonly {
+    readonly id: MenuIcon;
+    readonly label: string;
+}[];

package/dist/types/menu/menuMutations.d.ts

@@ -0,0 +1,13 @@
+import type { DynamicMenu, MenuCategory, MenuGroup, MenuItem, MenuSize } from "./menuSchema";
+export declare function addMenuGroup(menu: DynamicMenu, group: MenuGroup): DynamicMenu;
+export declare function updateMenuGroup(menu: DynamicMenu, groupId: string, patch: Partial<MenuGroup>): DynamicMenu;
+export declare function deleteMenuGroup(menu: DynamicMenu, groupId: string): DynamicMenu;
+export declare function addMenuCategory(menu: DynamicMenu, category: MenuCategory): DynamicMenu;
+export declare function updateMenuCategory(menu: DynamicMenu, categoryId: string, patch: Partial<MenuCategory>): DynamicMenu;
+export declare function deleteMenuCategory(menu: DynamicMenu, categoryId: string): DynamicMenu;
+export declare function addMenuItem(menu: DynamicMenu, item: MenuItem): DynamicMenu;
+export declare function updateMenuItem(menu: DynamicMenu, itemId: string, patch: Partial<MenuItem>): DynamicMenu;
+export declare function deleteMenuItem(menu: DynamicMenu, itemId: string): DynamicMenu;
+export declare function addMenuSize(menu: DynamicMenu, itemId: string, size: MenuSize): DynamicMenu;
+export declare function updateMenuSize(menu: DynamicMenu, itemId: string, sizeId: string, patch: Partial<MenuSize>): DynamicMenu;
+export declare function deleteMenuSize(menu: DynamicMenu, itemId: string, sizeId: string): DynamicMenu;

package/dist/types/menu/menuOrdering.d.ts

@@ -0,0 +1,38 @@
+import type { DynamicMenu, MenuCategory, MenuGroup, MenuItem } from "./menuSchema";
+type OrderedEntity = {
+    readonly order: number;
+};
+export type OrderedMenuSection = {
+    readonly section: MenuCategory;
+    readonly items: readonly MenuItem[];
+};
+export type OrderedMenuGroup = {
+    readonly group: MenuGroup;
+    readonly sections: readonly OrderedMenuSection[];
+};
+export type OrderedMenu = {
+    readonly groups: readonly OrderedMenuGroup[];
+    readonly sections: readonly OrderedMenuSection[];
+};
+type OrderedMenuOptions = {
+    readonly includeHidden?: boolean;
+    readonly includeEmptySections?: boolean;
+};
+export declare function sortByOrder<T extends OrderedEntity>(items: readonly T[]): T[];
+export declare function normalizeOrder<T extends OrderedEntity>(items: readonly T[]): (T & {
+    order: number;
+})[];
+/**
+ * Re-numbers categories in render order (group order, then section order). Categories whose
+ * group no longer resolves are kept at the end untouched, so a dangling `groupId` in seed or
+ * remote data is never silently deleted by an unrelated edit.
+ */
+export declare function renumberSections(menu: DynamicMenu): DynamicMenu;
+export declare function getOrderedMenu(menu: DynamicMenu, options?: OrderedMenuOptions): OrderedMenu;
+export declare function moveGroup(menu: DynamicMenu, groupId: string, direction: -1 | 1): DynamicMenu;
+export declare function moveGroupBefore(menu: DynamicMenu, groupId: string, targetGroupId: string): DynamicMenu;
+export declare function setGroupOrder(menu: DynamicMenu, orderedGroupIds: readonly string[]): DynamicMenu;
+export declare function moveSection(menu: DynamicMenu, sectionId: string, direction: -1 | 1): DynamicMenu;
+export declare function moveSectionBefore(menu: DynamicMenu, sectionId: string, targetSectionId: string): DynamicMenu;
+export declare function moveItemBefore(menu: DynamicMenu, itemId: string, targetItemId: string): DynamicMenu;
+export {};

package/dist/types/menu/menuSchema.d.ts

@@ -0,0 +1,68 @@
+export declare const menuIconIds: readonly ["plate", "burger", "wrap", "chicken", "platter", "fries", "kids", "drink"];
+export type MenuIcon = (typeof menuIconIds)[number];
+export type MenuGroup = {
+    readonly id: string;
+    readonly label: string;
+    readonly icon: MenuIcon;
+    readonly order: number;
+    readonly isVisible: boolean;
+};
+export type MenuCategory = {
+    readonly id: string;
+    readonly groupId: string;
+    readonly title: string;
+    readonly order: number;
+    readonly isVisible: boolean;
+};
+export type MenuSize = {
+    readonly id: string;
+    readonly label: string;
+    readonly price: string;
+    readonly order: number;
+};
+export type MenuItem = {
+    readonly id: string;
+    readonly categoryId: string;
+    readonly title: string;
+    readonly description: string;
+    readonly image: string;
+    readonly imageKey?: string;
+    readonly order: number;
+    readonly isVisible: boolean;
+    readonly pricingMode: "single" | "sizes";
+    readonly price: string;
+    readonly sizes: readonly MenuSize[];
+    readonly removableIngredients?: readonly string[];
+};
+/** A customer review the owner copied in (typically from Google Maps), optionally with the customer's photo. */
+export type Testimonial = {
+    readonly id: string;
+    readonly author: string;
+    /** Whole stars, 1–5. */
+    readonly rating: number;
+    readonly text: string;
+    /** Static path, URL, or an uploaded image URL (then `imageKey` is its R2 key). */
+    readonly image?: string;
+    readonly imageKey?: string;
+    /** Link to the original review. */
+    readonly sourceUrl?: string;
+    readonly order: number;
+    readonly isVisible: boolean;
+};
+export type DynamicMenu = {
+    readonly schemaVersion: 1;
+    readonly updatedAt: string;
+    readonly restaurant: {
+        readonly id: string;
+        readonly name: string;
+        readonly tagline: string;
+        readonly phone: string;
+        readonly whatsapp: string;
+        readonly address: string;
+    };
+    readonly groups: readonly MenuGroup[];
+    readonly categories: readonly MenuCategory[];
+    readonly items: readonly MenuItem[];
+    /** Optional. The public Testimonials section only renders when at least one is visible. */
+    readonly testimonials?: readonly Testimonial[];
+};

package/dist/types/menu/priceFormat.d.ts

@@ -0,0 +1,8 @@
+export type PriceCurrency = "USD" | "LBP";
+export declare function priceInputValue(price: string, fallbackCurrency?: PriceCurrency): {
+    readonly amount: string;
+    readonly currency: PriceCurrency;
+};
+export declare function priceFromInput(amount: string, currency: PriceCurrency): string;
+export declare function formatPrice(price: string): string;
+export declare function formatPriceTotal(price: string, quantity: number): string;

package/dist/types/menu/useMenuData.d.ts

@@ -0,0 +1,12 @@
+import { type ReactNode } from "react";
+import type { DynamicMenu } from "./menuSchema";
+export type MenuDataStatus = "local" | "loading" | "remote" | "fallback" | "draft";
+export type MenuDataValue = {
+    readonly menu: DynamicMenu;
+    readonly status: MenuDataStatus;
+};
+export declare function MenuDataProvider({ children, value }: {
+    readonly children: ReactNode;
+    readonly value: MenuDataValue;
+}): import("react").FunctionComponentElement<import("react").ProviderProps<MenuDataValue | null>>;
+export declare function useMenuData(): MenuDataValue;

package/dist/types/menu/validateMenu.d.ts

@@ -0,0 +1,16 @@
+import { type DynamicMenu } from "./menuSchema";
+export type MenuValidationIssue = {
+    /** Dotted path to the offending value, e.g. `items[3].categoryId`. */
+    readonly path: string;
+    readonly message: string;
+};
+/**
+ * Checks a menu's shape and cross-references. The runtime tolerates orphans (a category whose
+ * group is gone is kept at the end, an item whose category is gone is hidden); call this on seed
+ * data in a test or build step so those mistakes fail loudly instead.
+ *
+ * Returns every issue found; an empty array means the menu is valid.
+ */
+export declare function validateMenu(value: unknown): MenuValidationIssue[];
+/** Throws with every issue listed when the menu is invalid; narrows `value` otherwise. */
+export declare function assertValidMenu(value: unknown): asserts value is DynamicMenu;

package/dist/types/menu-browser/MenuBrowser.d.ts

@@ -0,0 +1,6 @@
+import type { DynamicMenu } from "../menu/menuSchema";
+type MenuBrowserProps = {
+    menu: DynamicMenu;
+};
+export declare function MenuBrowser({ menu }: MenuBrowserProps): import("react").JSX.Element;
+export {};

package/dist/types/menu-browser/MenuCard.d.ts

@@ -0,0 +1,7 @@
+import type { MenuItem } from "../menu/menuSchema";
+type MenuCardProps = {
+    item: MenuItem;
+    onOpen?: () => void;
+};
+export declare function MenuCard({ item, onOpen }: MenuCardProps): import("react").JSX.Element;
+export {};

package/dist/types/menu-browser/MenuCartDrawer.d.ts

@@ -0,0 +1,5 @@
+/**
+ * CartDrawer wired to the menu: each cart line gets an Edit action that
+ * opens the item sheet prefilled with the line and replaces it on save.
+ */
+export declare function MenuCartDrawer(): import("react").JSX.Element;

package/dist/types/menu-browser/MenuCategoryBlock.d.ts

@@ -0,0 +1,11 @@
+import type { MenuCategory, MenuItem } from "../menu/menuSchema";
+type MenuCategoryBlockProps = {
+    category: MenuCategory;
+    groupId: string;
+    groupLabel: string;
+    isOpen: boolean;
+    items: readonly MenuItem[];
+    onToggle: () => void;
+};
+export declare function MenuCategoryBlock({ category, groupId, groupLabel, isOpen, items, onToggle }: MenuCategoryBlockProps): import("react").JSX.Element;
+export {};

package/dist/types/menu-browser/MenuItemSheet.d.ts

@@ -0,0 +1,10 @@
+import type { CartItem } from "../cart/cartTypes";
+import type { MenuItem } from "../menu/menuSchema";
+type MenuItemSheetProps = {
+    item: MenuItem;
+    /** Cart line to edit: prefills the form and replaces the line on save instead of adding. */
+    editLine?: CartItem;
+    onClose: () => void;
+};
+export declare function MenuItemSheet({ item, editLine, onClose }: MenuItemSheetProps): import("react").JSX.Element;
+export {};

package/dist/types/menu-browser/MenuLightbox.d.ts

@@ -0,0 +1,9 @@
+type MenuLightboxProps = {
+    addLabel?: string;
+    alt: string;
+    imageSrc: string;
+    onAdd?: () => void;
+    onClose: () => void;
+};
+export declare function MenuLightbox({ addLabel, alt, imageSrc, onAdd, onClose }: MenuLightboxProps): import("react").JSX.Element;
+export {};

package/dist/types/menu-browser/MenuRow.d.ts

@@ -0,0 +1,7 @@
+import type { MenuItem } from "../menu/menuSchema";
+type MenuRowProps = {
+    item: MenuItem;
+    onOpen: () => void;
+};
+export declare function MenuRow({ item, onOpen }: MenuRowProps): import("react").JSX.Element;
+export {};

package/dist/types/menu-browser/MenuSection.d.ts

@@ -0,0 +1 @@
+export declare function MenuSection(): import("react").JSX.Element;

package/dist/types/menu-browser/menuItemDisplay.d.ts

@@ -0,0 +1,5 @@
+import type { MenuItem, MenuSize } from "../menu/menuSchema";
+export { formatPrice } from "../menu/priceFormat";
+export declare function variationLabel(size: MenuSize): string;
+export declare function sortedSizes(item: MenuItem): MenuSize[];
+export declare function imageSrc(image: string): string;

package/dist/types/menu-browser/useMediaQuery.d.ts

@@ -0,0 +1 @@
+export declare function useMediaQuery(query: string): boolean;

package/dist/types/menu-browser/useMenuBrowserState.d.ts

@@ -0,0 +1,17 @@
+import type { DynamicMenu } from "../menu/menuSchema";
+export declare function useMenuBrowserState(menu: DynamicMenu): {
+    activeGroup: string;
+    catalogRef: import("react").RefObject<HTMLDivElement | null>;
+    controlStripRef: import("react").RefObject<HTMLDivElement | null>;
+    groupLabels: Map<string, string>;
+    handleGroupClick: (groupId: string) => void;
+    isTabsStuck: boolean;
+    openCategories: readonly string[];
+    tabsRef: import("react").RefObject<HTMLDivElement | null>;
+    toggleCategory: (categoryId: string) => void;
+    visibleCategories: {
+        category: import("..").MenuCategory;
+        items: readonly import("..").MenuItem[];
+    }[];
+    visibleGroups: import("..").MenuGroup[];
+};

package/dist/types/menu-browser/useParkedSheet.d.ts

@@ -0,0 +1,13 @@
+/**
+ * State for a sheet/dialog that the browser back button should close.
+ * Opening parks a history entry; every close routes through history.back()
+ * so popping the entry is the single close path (pushing from the open
+ * handler, never an effect, keeps StrictMode's double effects harmless).
+ * Each parked entry is tagged with a token so only this hook's own entry is
+ * ever popped, and unmounting while open pops it instead of leaving it behind.
+ */
+export declare function useParkedSheet<T>(onClosed?: () => void): {
+    value: T | null;
+    open: (next: T) => void;
+    close: () => void;
+};

package/dist/types/pages/AdminMenuEditor.d.ts

@@ -0,0 +1 @@
+export declare function AdminMenuEditor(): import("react").JSX.Element;

package/dist/types/pages/AdminPreview.d.ts

@@ -0,0 +1 @@
+export declare function AdminPreview(): import("react").JSX.Element;

package/dist/types/pages/MenuSite.d.ts

@@ -0,0 +1,6 @@
+import { type MenuDataValue } from "../menu/useMenuData";
+type MenuSiteProps = {
+    readonly menuData?: MenuDataValue;
+};
+export declare function MenuSite({ menuData }: MenuSiteProps): import("react").JSX.Element;
+export {};

package/dist/types/testimonials/downscaleImage.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Customer photos come straight off a phone. Shrink them to a web-sized JPEG before upload so they
+ * stay far below the Worker's 5 MB limit (and fit localStorage in local-dev mode).
+ * Falls back to the original file when the browser cannot decode it.
+ */
+export declare function downscaleImage(file: File): Promise<File>;

package/dist/types/testimonials/testimonialMutations.d.ts

@@ -0,0 +1,9 @@
+import type { DynamicMenu, Testimonial } from "../menu/menuSchema";
+export declare function clampRating(rating: number): number;
+export declare function sortedTestimonials(menu: DynamicMenu): readonly Testimonial[];
+export declare function visibleTestimonials(menu: DynamicMenu): readonly Testimonial[];
+export declare function createTestimonialDraft(): Testimonial;
+export declare function addTestimonial(menu: DynamicMenu, testimonial: Testimonial): DynamicMenu;
+export declare function updateTestimonial(menu: DynamicMenu, testimonialId: string, patch: Partial<Testimonial>): DynamicMenu;
+export declare function deleteTestimonial(menu: DynamicMenu, testimonialId: string): DynamicMenu;
+export declare function moveTestimonial(menu: DynamicMenu, testimonialId: string, direction: -1 | 1): DynamicMenu;

package/dist/types/utils.d.ts

@@ -0,0 +1 @@
+export declare function cx(...classes: Array<string | false | null | undefined>): string;

package/dist/types/worker/auth.d.ts

@@ -0,0 +1,97 @@
+import { type HttpEnv } from "./http";
+/**
+ * Admin authentication for the menu API.
+ *
+ * Two strategies:
+ *  - "password": a single owner password (PBKDF2 hash in ADMIN_PASSWORD_HASH) exchanged for
+ *    an HMAC-signed, HttpOnly session cookie. No Cloudflare Access / Zero Trust required.
+ *  - "access":   legacy Cloudflare Access; trusts the cf-access-authenticated-user-email header
+ *    against ADMIN_EMAILS. Only safe when Access fronts every route to this Worker.
+ *
+ * The strategy is picked from env: ADMIN_AUTH wins when set, otherwise ADMIN_PASSWORD_HASH
+ * implies "password", otherwise a non-empty ADMIN_EMAILS implies "access", otherwise "none"
+ * (every admin request is denied).
+ */
+export type AdminAuthStrategy = "password" | "access" | "none";
+export type RateLimiter = {
+    limit(options: {
+        readonly key: string;
+    }): Promise<{
+        readonly success: boolean;
+    }>;
+};
+export type AuthEnv = HttpEnv & {
+    readonly ADMIN_AUTH?: string;
+    readonly ADMIN_PASSWORD_HASH?: string;
+    readonly ADMIN_SESSION_SECRET?: string;
+    readonly ADMIN_SESSION_TTL_HOURS?: string;
+    readonly LOGIN_RATE_LIMITER?: RateLimiter;
+};
+export type AdminIdentity = {
+    readonly user: string;
+    readonly strategy: AdminAuthStrategy;
+};
+export type AdminSessionInfo = {
+    readonly authenticated: boolean;
+    readonly strategy: AdminAuthStrategy;
+    readonly user: string | null;
+};
+export declare const SESSION_COOKIE_NAME = "rk_admin_session";
+export declare const PASSWORD_HASH_ALGORITHM = "pbkdf2-sha256";
+/** Workers Free plan caps PBKDF2 at 100k iterations; keep the default there so login fits the CPU budget. */
+export declare const DEFAULT_PBKDF2_ITERATIONS = 100000;
+export declare function resolveAdminAuthStrategy(env: AuthEnv): AdminAuthStrategy;
+export declare function getAllowedAdminEmails(env: HttpEnv): string[];
+export declare function base64UrlEncode(bytes: Uint8Array): string;
+export declare function base64UrlDecode(value: string): Uint8Array<ArrayBuffer>;
+export declare function timingSafeEqual(left: Uint8Array, right: Uint8Array): boolean;
+/** Produces `pbkdf2-sha256$<iterations>$<salt>$<hash>` for ADMIN_PASSWORD_HASH. */
+export declare function hashPassword(password: string, iterations?: number): Promise<string>;
+export declare function parsePasswordHash(encoded: string): {
+    iterations: number;
+    salt: Uint8Array<ArrayBuffer>;
+    hash: Uint8Array<ArrayBuffer>;
+} | null;
+export declare function verifyPassword(password: string, encodedHash: string): Promise<boolean>;
+type SessionPayload = {
+    readonly sub: string;
+    readonly iat: number;
+    readonly exp: number;
+};
+export declare function createSessionToken(secret: string, subject: string, ttlSeconds: number, now?: number): Promise<string>;
+export declare function verifySessionToken(secret: string, token: string, now?: number): Promise<SessionPayload | null>;
+export declare function readCookie(request: Request, name: string): string | null;
+export declare function buildSessionCookie(request: Request, token: string, maxAgeSeconds: number): string;
+export declare function buildClearedSessionCookie(request: Request): string;
+/**
+ * Browsers always attach an Origin header to POST/PUT/DELETE, so a present Origin that is
+ * neither the request's own origin nor an allowed one is a cross-site request. Non-browser
+ * clients (no Origin) carry no ambient cookie, so they are not a CSRF vector.
+ */
+export declare function isTrustedOrigin(request: Request, env: HttpEnv): boolean;
+export declare function getAccessIdentity(request: Request, env: HttpEnv): AdminIdentity | null;
+/**
+ * Session signing key = session secret + current password hash. Rotating either one
+ * invalidates every outstanding session, so a password change is also a global sign-out.
+ */
+export declare function getSessionSigningKey(env: AuthEnv): string | null;
+export declare function getPasswordSessionIdentity(request: Request, env: AuthEnv): Promise<AdminIdentity | null>;
+export declare function getAdminIdentity(request: Request, env: AuthEnv): Promise<AdminIdentity | null>;
+export declare function getAdminSessionInfo(request: Request, env: AuthEnv): Promise<AdminSessionInfo>;
+export type LoginResult = {
+    readonly status: "ok";
+    readonly user: string;
+    readonly setCookie: string;
+} | {
+    readonly status: "wrong-password";
+} | {
+    readonly status: "rate-limited";
+} | {
+    readonly status: "bad-request";
+    readonly message: string;
+} | {
+    readonly status: "misconfigured";
+    readonly message: string;
+};
+export declare function loginWithPassword(request: Request, env: AuthEnv): Promise<LoginResult>;
+export {};

package/dist/types/worker/http.d.ts

@@ -0,0 +1,17 @@
+export type HttpEnv = {
+    /** Comma-separated Cloudflare Access emails. Only used by the "access" auth strategy. */
+    readonly ADMIN_EMAILS?: string;
+    readonly ALLOWED_ORIGINS: string;
+};
+/** Error carrying an HTTP status so the top-level handler can answer 4xx instead of 500. */
+export declare class RequestError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+export declare function getAllowedOrigins(env: HttpEnv): string[];
+export declare function getCorsHeaders(request: Request, env: HttpEnv): Record<string, string>;
+export declare function getSafeReturnTo(request: Request, env: HttpEnv): string;
+export declare function redirectResponse(location: string, corsHeaders: Record<string, string>): Response;
+export declare function jsonResponse(body: unknown, init?: ResponseInit, corsHeaders?: Record<string, string>): Response;
+/** Cloudflare Access header check. Kept for the "access" strategy; see auth.ts for the full picture. */
+export declare function isAdminRequest(request: Request, env: HttpEnv): boolean;

package/dist/types/worker/index.d.ts

@@ -0,0 +1,16 @@
+import { type AuthEnv } from "./auth";
+import { type R2Bucket } from "./menuStorage";
+type AssetsBinding = {
+    fetch(request: Request): Promise<Response>;
+};
+export type Env = AuthEnv & {
+    readonly MENU_BUCKET: R2Bucket;
+    readonly RESTAURANT_ID: string;
+    /** Present when the site is deployed as one Worker with static assets (`[assets]` in wrangler.toml). */
+    readonly ASSETS?: AssetsBinding;
+};
+declare const _default: {
+    fetch(request: Request, env: Env): Promise<Response>;
+};
+export default _default;
+export { hashPassword, verifyPassword, resolveAdminAuthStrategy, type AdminAuthStrategy, type AuthEnv } from "./auth";