@dreamtree-org/landing-kit 0.8.0 → 0.10.0

package/dist/schema.js

@@ -267,8 +267,8 @@ var MAX_SECTIONS = 20;
 function sectionDefaults(type) {
   const def = SECTION_TYPES[type];
   if (!def) throw new Error(`Unknown section type "${type}"`);
-  const fill = (fields2) => Object.fromEntries(fields2.map((f) => [f.key, f.kind === "list" ? (f.default || []).map((item) => ({ ...fill(f.of), ...item })) : f.default]));
-  return fill(def.fields);
+  const fill2 = (fields2) => Object.fromEntries(fields2.map((f) => [f.key, f.kind === "list" ? (f.default || []).map((item) => ({ ...fill2(f.of), ...item })) : f.default]));
+  return fill2(def.fields);
 }
 var seq = 0;
 function newSectionId(type) {
@@ -298,7 +298,7 @@ var decode = (s) => s.replace(/&(amp|quot|#39|lt|gt|#x[0-9a-f]+|#\d+);/gi, (m, e
 });
 function safeHref(raw) {
   const v = decode(String(raw || "")).replace(/[\u0000- \u007f-\u009f]/g, "");
-  if (!v) return null;
+  if (!v || v.includes("\\")) return null;
   if (/^(https?:\/\/|mailto:|tel:)/i.test(v)) return v;
   if (/^\/(?!\/)/.test(v) || v.startsWith("#")) return v;
   return null;
@@ -422,6 +422,9 @@ function field(f, value, path, errors) {
       throw new Error(`Unknown field kind "${f.kind}" (${path})`);
   }
 }
+function validateFields(defs, obj, path, errors) {
+  return fields(defs, obj, path, errors);
+}
 function fields(defs, obj, path, errors) {
   const src = obj && typeof obj === "object" && !Array.isArray(obj) ? obj : {};
   if (obj != null && src !== obj) errors.push({ path, message: "must be an object" });
@@ -645,24 +648,318 @@ function themeVars(input) {
     }
   };
 }
+
+// src/schema/store.js
+var STORE_VERSION = 2;
+var MAX_BLOCKS = 12;
+var ID_RE2 = /^[a-z0-9][a-z0-9-]{0,39}$/;
+var opt = (...pairs) => pairs.map(([value, label]) => ({ value, label }));
+var sel = (key, label, options, d) => ({ key, kind: "select", label, options, default: d });
+var bool = (key, label, d) => ({ key, kind: "bool", label, default: d });
+var heading = (d, max = 90) => ({ key: "title", kind: "text", label: "Heading", max, default: d });
+var CONTENT_BLOCKS = ["promo_banner", "usp_strip", "trust_badges", "cta_cards", "faq", "rich_text", "testimonials", "brand_strip", "gallery"];
+var LISTING_SLOTS = {
+  collection_header: { label: "Collection header", description: "Title, description and quick links for the category or search.", fields: [bool("show_description", "Show the description", true), bool("show_quick_links", "Show quick links", true)] },
+  toolbar: { label: "Toolbar and sort", description: "Result count, sort and the filters in use.", fields: [] },
+  filters: { label: "Filters", description: "Price, brand and spec filters.", required: true, fields: [] },
+  results: { label: "Results grid", description: "The products, with paging.", required: true, fields: [] }
+};
+var PRODUCT_SLOTS = {
+  gallery: { label: "Gallery", description: "Photos of the product.", required: true, fields: [] },
+  buy_box: { label: "Buy box", description: "Title, price, key specs and the buy buttons.", required: true, fields: [bool("show_compare", "Show Add to compare", true), bool("show_quote", "Show bulk quote link", true)] },
+  highlights: { label: "Highlights", description: "The product's headline numbers and selling points.", fields: [heading("Highlights")] },
+  delivery: { label: "Delivery check", description: "PIN code delivery estimate.", fields: [] },
+  seller: { label: "Seller", description: "Who sells and services the product.", fields: [] },
+  inspection: { label: "Inspection report", description: "Checks, grade and condition notes.", fields: [heading("Inspection report"), bool("expanded", "Open by default", false)] },
+  battery: { label: "Battery", description: "Battery health, where the product has one.", fields: [] },
+  included: { label: "In the box", description: "What ships with the product.", fields: [] },
+  specs: { label: "Specifications", description: "The full specification table.", fields: [heading("Specifications")] },
+  policies: { label: "Warranty and returns", description: "The store's warranty and return terms.", fields: [heading("Warranty and returns")] },
+  similar: { label: "Similar products", description: "More products like this one.", fields: [heading("Similar products"), sel("limit", "How many", opt(["3", "3"], ["4", "4"], ["6", "6"], ["8", "8"]), "4")] }
+};
+var SORTS = opt(["relevance", "Recommended"], ["newest", "Newest first"], ["price_asc", "Price: low to high"], ["price_desc", "Price: high to low"], ["discount", "Biggest discount"]);
+var STORE_PAGES = {
+  listing: {
+    label: "Listing page",
+    slots: LISTING_SLOTS,
+    settings: [
+      sel("columns", "Columns on desktop", opt(["3", "3"], ["4", "4"]), "3"),
+      sel("columns_mobile", "Columns on phones", opt(["1", "1"], ["2", "2"]), "2"),
+      sel("page_size", "Products per page", opt(["12", "12"], ["24", "24"], ["36", "36"]), "12"),
+      sel("default_sort", "Default sort", SORTS, "relevance"),
+      sel("filters", "Filters show as", opt(["sidebar", "Sidebar"], ["topbar", "Bar above the results"], ["drawer", "Button that opens a panel"]), "sidebar"),
+      bool("active_chips", "Show the filters in use as chips", true),
+      sel("paging", "Paging", opt(["pages", "Page numbers"], ["load_more", "Load more button"]), "pages")
+    ],
+    templates: {
+      classic: { label: "Classic", description: "Filters in a sidebar beside a product grid.", settings: {}, blocks: ["collection_header", "toolbar", "filters", "results"] },
+      topbar: { label: "Top bar", description: "Filter chips above a wide grid, more room for products.", settings: { columns: "4", filters: "topbar", paging: "load_more" }, blocks: ["collection_header", "filters", "toolbar", "results"] },
+      editorial: { label: "Editorial", description: "A story-led collection header, then the grid behind a filter button.", settings: { columns: "4", filters: "drawer", active_chips: false }, blocks: ["collection_header", "rich_text", "toolbar", "filters", "results"] }
+    },
+    default: "classic"
+  },
+  product: {
+    label: "Product page",
+    slots: PRODUCT_SLOTS,
+    settings: [
+      sel("gallery", "Gallery", opt(["thumbs_side", "Thumbnails beside the photo"], ["thumbs_below", "Thumbnails below the photo"], ["mosaic", "Full-width mosaic"]), "thumbs_side"),
+      bool("sticky_buy_bar", "Sticky buy bar on phones", true),
+      sel("spec_tiles", "Key spec tiles", opt(["0", "None"], ["4", "4"], ["6", "6"]), "4"),
+      bool("breadcrumbs", "Show breadcrumbs", true)
+    ],
+    templates: {
+      classic: { label: "Classic", description: "Photos beside the buy box, details below.", settings: { gallery: "thumbs_side" }, blocks: ["gallery", "buy_box", "delivery", "seller", "inspection", "battery", "included", "specs", "policies", "similar"] },
+      immersive: { label: "Immersive", description: "A full-width photo mosaic first, a floating buy panel, the story below.", settings: { gallery: "mosaic" }, blocks: ["gallery", "buy_box", "highlights", "inspection", "specs", "policies", "similar"] },
+      compact: { label: "Compact", description: "One column, phone first, with a sticky buy bar.", settings: { gallery: "thumbs_below", spec_tiles: "0", breadcrumbs: false }, blocks: ["gallery", "buy_box", "delivery", "inspection", "specs", "policies", "similar"] }
+    },
+    default: "classic"
+  }
+};
+var STORE_PAGE_KEYS = Object.keys(STORE_PAGES);
+var link = [
+  { key: "label", kind: "text", label: "Label", max: 30, required: true, default: "" },
+  { key: "href", kind: "url", label: "Link", required: true, default: "" }
+];
+var CHROME_FIELDS = [
+  {
+    key: "announcement",
+    kind: "group",
+    label: "Announcement bar",
+    fields: [
+      bool("enabled", "Show the announcement bar", false),
+      { key: "text", kind: "text", label: "Message", max: 120, default: "" },
+      { key: "href", kind: "url", label: "Link", default: "" },
+      sel("tone", "Colour", opt(["brand", "Brand"], ["accent", "Accent"], ["dark", "Dark"]), "brand")
+    ]
+  },
+  {
+    key: "header",
+    kind: "group",
+    label: "Header",
+    fields: [
+      { key: "utility_text", kind: "text", label: "Strip above the header", max: 80, default: "" },
+      bool("show_search", "Search box", true),
+      bool("category_nav", "Menu of the categories you sell", true),
+      { key: "nav_links", kind: "list", label: "Extra menu links", max: 8, itemLabel: "label", of: link, default: [] },
+      bool("sticky", "Keep the header on screen while scrolling", true)
+    ]
+  },
+  {
+    key: "footer",
+    kind: "group",
+    label: "Footer",
+    fields: [
+      { key: "about", kind: "textarea", label: "About the store", max: 240, default: "" },
+      {
+        key: "columns",
+        kind: "list",
+        label: "Link columns",
+        max: 4,
+        itemLabel: "title",
+        of: [{ key: "title", kind: "text", label: "Column heading", max: 40, required: true, default: "" }, { key: "links", kind: "list", label: "Links", max: 8, itemLabel: "label", of: link, default: [] }],
+        default: []
+      },
+      {
+        key: "socials",
+        kind: "list",
+        label: "Social profiles",
+        max: 6,
+        itemLabel: "network",
+        of: [sel("network", "Network", opt(["instagram", "Instagram"], ["facebook", "Facebook"], ["youtube", "YouTube"], ["x", "X"], ["linkedin", "LinkedIn"], ["whatsapp", "WhatsApp"]), "instagram"), { key: "href", kind: "url", label: "Profile link", required: true, default: "" }],
+        default: []
+      },
+      { key: "note", kind: "text", label: "Small print (GSTIN, address)", max: 160, default: "" }
+    ]
+  }
+];
+var CARD_FIELDS = [
+  sel("image_ratio", "Photo shape", opt(["4:3", "Landscape 4:3"], ["1:1", "Square"], ["3:4", "Portrait 3:4"]), "4:3"),
+  bool("badges", "Condition and discount badges", true),
+  bool("spec_line", "Key specs line", true),
+  bool("compare", "Compare checkbox", true),
+  bool("quick_add", "Add to cart button", true),
+  bool("mrp", "Show the MRP struck through", true),
+  sel("hover", "On hover", opt(["none", "Nothing"], ["zoom", "Zoom the photo"], ["second_image", "Show the second photo"]), "zoom")
+];
+function validateGroups(defs, obj, path, errors) {
+  const src = obj && typeof obj === "object" && !Array.isArray(obj) ? obj : {};
+  if (obj != null && src !== obj) errors.push({ path, message: "must be an object" });
+  return Object.fromEntries(defs.map((g) => [g.key, g.kind === "group" ? validateFields(g.fields, src[g.key], `${path}.${g.key}`, errors) : validateFields([g], src, path, errors)[g.key]]));
+}
+var fill = (defs) => Object.fromEntries(defs.map((f) => [f.key, f.kind === "group" ? fill(f.fields) : f.kind === "list" ? [...f.default || []] : f.default]));
+var defaultChrome = () => fill(CHROME_FIELDS);
+var defaultCard = () => fill(CARD_FIELDS);
+function blockDef(pageKey, type) {
+  const page = own(STORE_PAGES, pageKey) ? STORE_PAGES[pageKey] : null;
+  if (!page) return null;
+  if (own(page.slots, type)) return { ...page.slots[type], slot: true };
+  if (CONTENT_BLOCKS.includes(type) && own(SECTION_TYPES, type)) return { ...SECTION_TYPES[type], slot: false };
+  return null;
+}
+var own = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+var blockId = (type) => type.replace(/_/g, "-");
+var blockDefaults = (pageKey, type) => {
+  const def = blockDef(pageKey, type);
+  return def.slot ? fill(def.fields) : sectionDefaults(type);
+};
+function newBlock(pageKey, type) {
+  const def = blockDef(pageKey, type);
+  if (!def) throw new Error(`Unknown block "${type}" on the ${pageKey} page`);
+  return { id: def.slot ? blockId(type) : newSectionId(type), type, enabled: true, props: blockDefaults(pageKey, type) };
+}
+function templatePage(pageKey, template) {
+  const page = STORE_PAGES[pageKey];
+  const key = own(page.templates, template) ? template : page.default;
+  const tpl = page.templates[key];
+  const settings = { ...fill(page.settings), ...tpl.settings };
+  const blocks = tpl.blocks.map((type) => ({ id: blockId(type), type, enabled: true, props: blockDefaults(pageKey, type) }));
+  return { template: key, settings, blocks };
+}
+function validateTemplatePage(pageKey, input, path, errors) {
+  var _a, _b;
+  const page = STORE_PAGES[pageKey];
+  const src = input && typeof input === "object" && !Array.isArray(input) ? input : {};
+  let template = (_a = src.template) != null ? _a : page.default;
+  if (!own(page.templates, template)) {
+    errors.push({ path: `${path}.template`, message: `must be one of ${Object.keys(page.templates).join(", ")}` });
+    template = page.default;
+  }
+  const tpl = page.templates[template];
+  const settingDefs = page.settings.map((f) => tpl.settings[f.key] === void 0 ? f : { ...f, default: tpl.settings[f.key] });
+  const settings = validateFields(settingDefs, (_b = src.settings) != null ? _b : {}, `${path}.settings`, errors);
+  const list = Array.isArray(src.blocks) ? src.blocks : null;
+  if (src.blocks != null && !list) errors.push({ path: `${path}.blocks`, message: "must be a list" });
+  const raw = list != null ? list : templatePage(pageKey, template).blocks;
+  if (raw.length > MAX_BLOCKS) errors.push({ path: `${path}.blocks`, message: `can have at most ${MAX_BLOCKS}` });
+  const ids = /* @__PURE__ */ new Set();
+  const slotsSeen = /* @__PURE__ */ new Set();
+  const blocks = [];
+  raw.slice(0, MAX_BLOCKS).forEach((b, i) => {
+    var _a2, _b2;
+    const at = `${path}.blocks[${i}]`;
+    if (!b || typeof b !== "object") {
+      errors.push({ path: at, message: "must be an object" });
+      return;
+    }
+    const def = blockDef(pageKey, b.type);
+    if (!def) {
+      errors.push({ path: `${at}.type`, message: `unknown block "${b.type}" on the ${page.label.toLowerCase()}` });
+      return;
+    }
+    const id = String((_a2 = b.id) != null ? _a2 : "");
+    if (!ID_RE2.test(id)) errors.push({ path: `${at}.id`, message: "must be 1\u201340 lowercase letters, digits or dashes" });
+    else if (ids.has(id)) errors.push({ path: `${at}.id`, message: `duplicate id "${id}"` });
+    ids.add(id);
+    if (def.slot) {
+      if (slotsSeen.has(b.type)) {
+        errors.push({ path: `${at}.type`, message: `"${def.label}" can appear only once` });
+        return;
+      }
+      slotsSeen.add(b.type);
+    }
+    let enabled = b.enabled === void 0 ? true : b.enabled;
+    if (typeof enabled !== "boolean") {
+      errors.push({ path: `${at}.enabled`, message: "must be true or false" });
+      enabled = true;
+    }
+    if (def.required && !enabled) {
+      errors.push({ path: `${at}.enabled`, message: `"${def.label}" is required and cannot be hidden` });
+      enabled = true;
+    }
+    blocks.push({ id, type: b.type, enabled, props: validateFields(def.fields, (_b2 = b.props) != null ? _b2 : {}, `${at}.props`, errors) });
+  });
+  for (const [type, def] of Object.entries(page.slots)) {
+    if (def.required && !slotsSeen.has(type)) {
+      errors.push({ path: `${path}.blocks`, message: `"${def.label}" is required` });
+      blocks.push({ id: ids.has(blockId(type)) ? `${blockId(type)}-1` : blockId(type), type, enabled: true, props: blockDefaults(pageKey, type) });
+    }
+  }
+  return { template, settings, blocks };
+}
+function migrateStore(input) {
+  const home = input && typeof input === "object" && Array.isArray(input.sections) ? input : null;
+  return {
+    version: STORE_VERSION,
+    pages: { home: home ? { version: 1, sections: home.sections } : defaultPage(), listing: templatePage("listing"), product: templatePage("product") },
+    chrome: defaultChrome(),
+    card: defaultCard()
+  };
+}
+var isLegacyPage = (doc) => !!doc && typeof doc === "object" && doc.version !== STORE_VERSION && Array.isArray(doc.sections);
+function validateStore(input) {
+  var _a, _b, _c;
+  const errors = [];
+  const src0 = isLegacyPage(input) ? migrateStore(input) : input;
+  const src = src0 && typeof src0 === "object" && !Array.isArray(src0) ? src0 : null;
+  if (!src) {
+    const doc2 = migrateStore(null);
+    return { ok: false, errors: [{ path: "doc", message: "must be an object" }], doc: doc2 };
+  }
+  if (src.version != null && src.version !== STORE_VERSION) errors.push({ path: "version", message: `must be ${STORE_VERSION}` });
+  const pages = src.pages && typeof src.pages === "object" ? src.pages : {};
+  const home = validatePage((_a = pages.home) != null ? _a : defaultPage());
+  home.errors.forEach((e) => errors.push({ path: `pages.home.${e.path}`, message: e.message }));
+  const doc = {
+    version: STORE_VERSION,
+    pages: {
+      home: home.page,
+      ...Object.fromEntries(STORE_PAGE_KEYS.map((k) => [k, validateTemplatePage(k, pages[k], `pages.${k}`, errors)]))
+    },
+    chrome: validateGroups(CHROME_FIELDS, (_b = src.chrome) != null ? _b : {}, "chrome", errors),
+    card: validateFields(CARD_FIELDS, (_c = src.card) != null ? _c : {}, "card", errors)
+  };
+  if (doc.chrome.announcement.enabled && !doc.chrome.announcement.text) errors.push({ path: "chrome.announcement.text", message: "is required when the bar is shown" });
+  return { ok: errors.length === 0, errors, doc };
+}
+function defaultStore({ name, tagline } = {}) {
+  return { ...migrateStore(defaultPage({ name, tagline })) };
+}
+function storeMediaRefs(doc) {
+  const out = [];
+  const walk = (v) => {
+    if (Array.isArray(v)) v.forEach(walk);
+    else if (v && typeof v === "object") {
+      if (v.media_id != null && Object.keys(v).every((k) => k === "media_id" || k === "alt")) out.push(v);
+      else Object.values(v).forEach(walk);
+    }
+  };
+  walk(doc);
+  return out;
+}
 export {
+  CARD_FIELDS,
+  CHROME_FIELDS,
+  CONTENT_BLOCKS,
   DEFAULT_THEME,
   FONT_PAIRS,
   ICON_NAMES,
+  LISTING_SLOTS,
+  MAX_BLOCKS,
   MAX_SECTIONS,
   MODES,
   PAGE_VERSION,
   PALETTE_STEPS,
+  PRODUCT_SLOTS,
   RADII,
   SECTION_TYPES,
   SECTION_TYPE_KEYS,
+  STORE_PAGES,
+  STORE_PAGE_KEYS,
+  STORE_VERSION,
   THEME_PRESETS,
+  blockDef,
   brandPalette,
   contrastRatio,
+  defaultCard,
+  defaultChrome,
   defaultPage,
+  defaultStore,
   hexToOklch,
   isHex,
+  isLegacyPage,
   luminance,
+  migrateStore,
+  newBlock,
   newSection,
   newSectionId,
   oklchToHex,
@@ -670,7 +967,11 @@ export {
   safeHref,
   sanitizeRichText,
   sectionDefaults,
+  storeMediaRefs,
+  templatePage,
   themeVars,
+  validateFields,
   validatePage,
+  validateStore,
   validateTheme
 };

package/index.d.ts

@@ -299,7 +299,7 @@ export declare function createDemoIsland(props: Omit<DemoDialogProps, 'onClose'>
 // ---------------------------------------------------------------------------
 // Tenant pages: a store's own landing page as data. Validate and build pages
 // with `@dreamtree-org/landing-kit/schema`; render them with TenantPage.
-import type { PageDoc, Theme, MediaRef, SectionType, ValidationError, Palette, FontPair } from './schema';
+import type { PageDoc, Theme, MediaRef, SectionType, ValidationError, Palette, FontPair, StoreDoc, TemplateBlock } from './schema';
 
 export interface TenantPageProps {
   /** A page document (validated again here; invalid sections are dropped). */
@@ -321,6 +321,20 @@ export function TenantPage(props: TenantPageProps): JSX.Element;
 export const TENANT_BLOCKS: Record<SectionType, (props: any) => JSX.Element | null>;
 export function HeroSlider(props: Record<string, unknown>): JSX.Element | null;
 export function NamedIcon(props: { name: string; size?: number; className?: string }): JSX.Element | null;
+export interface TemplateRegionProps {
+  /** The blocks of a template page (StoreDoc.pages.listing/product.blocks), in order; hidden ones are skipped. */
+  blocks: TemplateBlock[];
+  /** App components for commerce slots, by block type; return null to place a slot yourself. */
+  slots?: Record<string, ComponentType<{ block: TemplateBlock; props: Record<string, unknown> }>>;
+  theme?: Partial<Theme> | null;
+  resolveMedia?: (ref: MediaRef, variant: string) => string | null;
+  linkComponent?: ComponentType<any> | null;
+  storeName?: string;
+  className?: string;
+}
+/** A listing or product page's blocks: app slots plus content sections rendered like TenantPage. */
+export function TemplateRegion(props: TemplateRegionProps): JSX.Element;
+export function validateStore(doc: unknown): { ok: boolean; errors: ValidationError[]; doc: StoreDoc };
 export function validatePage(doc: unknown): { ok: boolean; errors: ValidationError[]; page: PageDoc };
 export function validateTheme(theme: unknown): { ok: boolean; errors: ValidationError[]; warnings: ValidationError[]; theme: Theme };
 export function themeVars(theme: unknown): { theme: Theme; font: FontPair; palette: { primary: Palette; accent: Palette }; style: Record<string, string> };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dreamtree-org/landing-kit",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "The shared marketing site, auth frame (AuthShell + brands) and Platform admin console for every Dreamtree product: content-driven landing pages, login/signup shell, platform console client, Express routes, prerender and SEO files.",
   "author": {
     "name": "Partha Preetham Krishna",

package/platform.d.ts

@@ -5,7 +5,7 @@ export const PLATFORM_API_BASE: '/api/platform';
 export const PLATFORM_LOGIN_PATH: '/platform/login';
 export const STEP_UP_REQUIRED: 'STEP_UP_REQUIRED';
 
-export type PlatformFeature = 'overview' | 'companies' | 'jobs' | 'plans' | 'audit' | 'support' | 'settings' | 'admins';
+export type PlatformFeature = 'overview' | 'companies' | 'jobs' | 'plans' | 'audit' | 'support' | 'settings' | 'domains' | 'admins';
 /** Every console feature, in nav order. */
 export const PLATFORM_FEATURES: readonly PlatformFeature[];
 /** Features a server without `GET /me` serves. */
@@ -91,7 +91,7 @@ export interface PlatformMe {
   permissions: string[];
   /** `console` false = enrollment-only session (enroll an authenticator first). */
   access?: { console: boolean; stepUpFresh: boolean };
-  features: Partial<Record<PlatformFeature | 'domains', boolean>>;
+  features: Partial<Record<PlatformFeature, boolean>>;
   app: { key: string; name: string; companyLoginPath?: string };
 }
 
@@ -187,28 +187,35 @@ export interface Plan {
   seats?: number | null;
   limits?: Record<string, number | null>;
   features?: string[];
+  sort?: number;
 }
 
 export interface Subscription {
   id: string;
   companyId: string;
   planId: string;
+  planCode?: string | null;
+  planName?: string | null;
   status: 'trial' | 'active' | 'past_due' | 'cancelled' | 'expired';
   startsAt: Iso;
   endsAt: Iso | null;
   seats?: number | null;
   notes?: string | null;
+  createdBy?: string | null;
+  createdAt?: Iso;
 }
 
 export interface SettingsField {
   key: string;
   label: string;
   type: 'text' | 'number' | 'boolean' | 'select' | 'secret' | 'email' | 'url';
-  options?: string[];
+  options?: Array<{ value: string; label: string }>;
   /** Secret values come back masked (`set: true`), never in clear. */
   value?: unknown;
   set?: boolean;
   help?: string;
+  /** Where the value comes from. */
+  source?: 'branch' | 'company' | 'default' | null;
 }
 export interface SettingsFamily {
   family: string;
@@ -216,24 +223,37 @@ export interface SettingsFamily {
   scope: 'platform' | 'company';
   fields: SettingsField[];
 }
+/** GET settings?company= */
+export interface SettingsResponse {
+  families: SettingsFamily[];
+  /** Send back with PUT settings/:family; a stale version answers 409. */
+  version: number;
+}
 
 export interface SupportGrant {
   id: string;
   companyId: string;
   companyName?: string;
   requestedBy: string;
+  requestedById?: string;
   approvedBy?: string | null;
   reason: string;
+  /** Length of the access window, counted from approval. */
+  minutes?: number | null;
   status: 'requested' | 'active' | 'expired' | 'revoked';
   expiresAt: Iso | null;
+  approvedAt?: Iso | null;
+  revokedAt?: Iso | null;
   createdAt: Iso;
 }
 
 export interface CompanyDomain {
   id: string;
   host: string;
+  status?: 'pending' | 'verified';
   primary: boolean;
   verifiedAt: Iso | null;
+  createdAt?: Iso;
   verification?: { type: 'TXT'; name: string; value: string };
 }
 
@@ -327,6 +347,8 @@ export function usePlatform(): {
   href(rel?: string): string;
   navigate(href: string): void;
   can(permission: string): boolean;
+  /** Features this console shows (requested ∩ advertised by GET /me). */
+  features: PlatformFeature[];
   companyLoginPath(slug: string): string;
   companyLoginUrl(slug: string): string;
 };
@@ -340,3 +362,15 @@ export const CopyButton: ComponentType<{ value: string; label?: string }>;
 export const OneTimeSecret: ComponentType<{ title?: string; loginUrl?: string; email: string; password: string; onDone?: () => void }>;
 export const InspectResult: ComponentType<{ report: Record<string, any> }>;
 export function describeAction(action: string): string;
+/** "₹999.00 / month" from minor units. */
+export function formatPrice(priceMinor: number, currency?: string, interval?: Plan['interval']): string;
+
+/** Built-in v1.1 views, exported for products that compose their own console. They render inside <PlatformConsole>. */
+export const PlansView: ComponentType;
+export const SupportAccessView: ComponentType;
+export const SupportGrants: ComponentType<{ companyId?: string; companyName?: string }>;
+type CompanyTabProps = { company: { id: string; displayName?: string } & Record<string, any>; setFlash(flash: { kind: 'success' | 'error' | 'warning' | 'info'; msg: string } | null): void };
+export const SubscriptionTab: ComponentType<CompanyTabProps>;
+export const DomainsTab: ComponentType<CompanyTabProps>;
+export const SettingsTab: ComponentType<CompanyTabProps>;
+export const SupportTab: ComponentType<CompanyTabProps>;

package/schema.d.ts

@@ -94,3 +94,53 @@ export function hexToOklch(hex: string): { l: number; c: number; h: number };
 export function oklchToHex(c: { l: number; c: number; h: number }): string;
 export function isHex(v: unknown): boolean;
 export const PALETTE_STEPS: number[];
+
+// ---------------------------------------------------------------------------
+// Store documents (version 2): the landing page plus listing and product
+// template pages, the header/footer and the product card.
+
+export type StorePageKey = 'listing' | 'product';
+export type ListingSlot = 'collection_header' | 'toolbar' | 'filters' | 'results';
+export type ProductSlot = 'gallery' | 'buy_box' | 'highlights' | 'delivery' | 'seller' | 'inspection' | 'battery' | 'included' | 'specs' | 'policies' | 'similar';
+export type ContentBlock = 'promo_banner' | 'usp_strip' | 'trust_badges' | 'cta_cards' | 'faq' | 'rich_text' | 'testimonials' | 'brand_strip' | 'gallery';
+export interface SlotDef { label: string; description: string; required?: boolean; fields: FieldDef[] }
+export interface TemplateDef { label: string; description: string; /** Setting values that differ from the page's defaults. */ settings: Record<string, unknown>; /** Default block order. */ blocks: string[] }
+export interface StorePageDef { label: string; slots: Record<string, SlotDef>; settings: FieldDef[]; templates: Record<string, TemplateDef>; default: string }
+export interface TemplateBlock { id: string; type: string; enabled: boolean; props: Record<string, unknown> }
+export interface TemplatePage { template: string; settings: Record<string, unknown>; blocks: TemplateBlock[] }
+export interface GroupDef { key: string; kind: 'group'; label: string; fields: FieldDef[] }
+export interface StoreLink { label: string; href: string }
+export interface StoreChrome {
+  announcement: { enabled: boolean; text: string; href: string; tone: 'brand' | 'accent' | 'dark' };
+  header: { utility_text: string; show_search: boolean; category_nav: boolean; nav_links: StoreLink[]; sticky: boolean };
+  footer: { about: string; columns: { title: string; links: StoreLink[] }[]; socials: { network: string; href: string }[]; note: string };
+}
+export interface StoreCard { image_ratio: '4:3' | '1:1' | '3:4'; badges: boolean; spec_line: boolean; compare: boolean; quick_add: boolean; mrp: boolean; hover: 'none' | 'zoom' | 'second_image' }
+export interface StoreDoc { version: 2; pages: { home: PageDoc; listing: TemplatePage; product: TemplatePage }; chrome: StoreChrome; card: StoreCard }
+
+export const STORE_VERSION: 2;
+export const MAX_BLOCKS: number;
+export const STORE_PAGES: Record<StorePageKey, StorePageDef>;
+export const STORE_PAGE_KEYS: StorePageKey[];
+export const LISTING_SLOTS: Record<ListingSlot, SlotDef>;
+export const PRODUCT_SLOTS: Record<ProductSlot, SlotDef>;
+export const CONTENT_BLOCKS: ContentBlock[];
+export const CHROME_FIELDS: GroupDef[];
+export const CARD_FIELDS: FieldDef[];
+/** Normalise a store document (a version-1 landing page is migrated first) and report every problem by path. Required slots cannot be hidden or removed. */
+export function validateStore(doc: unknown): { ok: boolean; errors: ValidationError[]; doc: StoreDoc };
+/** A version-1 landing page (or nothing) wrapped into a store document with defaults. */
+export function migrateStore(page: unknown): StoreDoc;
+export function isLegacyPage(doc: unknown): boolean;
+export function defaultStore(store?: { name?: string; tagline?: string }): StoreDoc;
+/** A template page with that template's settings and default blocks (unknown template → the page default). */
+export function templatePage(page: StorePageKey, template?: string): TemplatePage;
+export function newBlock(page: StorePageKey, type: string): TemplateBlock;
+/** A slot or content section's definition on a page (slot: true for app-rendered blocks), or null. */
+export function blockDef(page: StorePageKey, type: string): ((SlotDef | SectionTypeDef) & { slot: boolean }) | null;
+export function defaultChrome(): StoreChrome;
+export function defaultCard(): StoreCard;
+/** Every uploaded-image reference in a document. */
+export function storeMediaRefs(doc: unknown): MediaRef[];
+/** Validate an object against a field list with the section rules; problems are pushed onto `errors`. */
+export function validateFields(defs: FieldDef[], obj: unknown, path: string, errors: ValidationError[]): Record<string, unknown>;