@swiftbrowser/web 0.1.0

package/src/symbols.ts

@@ -0,0 +1,595 @@
+/**
+ * SF Symbol names → lucide glyphs for the `image` element kind.
+ *
+ * The Swift side sends `Image(systemName:)` names unchanged; SF Symbols are
+ * not redistributable, so the renderer draws the closest glyph from lucide
+ * (ISC). Icons are inline SVG at `1em`, stroked with `currentColor`, so they
+ * follow the surrounding font size and foreground color like SF Symbols do.
+ *
+ * `.fill` variants: lucide only ships outlines, so a filled variant is drawn
+ * by filling the glyph's outer shape with `currentColor` and stroking the
+ * inner marks with the background color (`knockout`), or by filling every
+ * path (`solid`) when the glyph is a single silhouette.
+ */
+
+import {
+  Accessibility,
+  AlarmClock,
+  Archive,
+  ArrowDown,
+  ArrowDownToLine,
+  ArrowLeft,
+  ArrowLeftRight,
+  ArrowRight,
+  ArrowUp,
+  ArrowUpDown,
+  ArrowUpFromLine,
+  ArrowUpRight,
+  AtSign,
+  Battery,
+  Bell,
+  Bike,
+  Bluetooth,
+  Book,
+  BookOpen,
+  Bookmark,
+  Briefcase,
+  Bug,
+  Building,
+  Bus,
+  Calendar,
+  Camera,
+  Car,
+  ChartBar,
+  ChartLine,
+  ChartPie,
+  Check,
+  ChevronDown,
+  ChevronLeft,
+  ChevronRight,
+  ChevronUp,
+  ChevronsDown,
+  ChevronsLeft,
+  ChevronsRight,
+  ChevronsUp,
+  ChevronsUpDown,
+  Circle,
+  CircleAlert,
+  CircleArrowDown,
+  CircleArrowLeft,
+  CircleArrowRight,
+  CircleArrowUp,
+  CircleCheck,
+  CircleDot,
+  CircleEllipsis,
+  CircleMinus,
+  CirclePause,
+  CirclePlay,
+  CirclePlus,
+  CircleStop,
+  CircleQuestionMark,
+  CircleUser,
+  CircleX,
+  Clipboard,
+  Clock,
+  Cloud,
+  CloudLightning,
+  CloudMoon,
+  CloudRain,
+  CloudSnow,
+  CloudSun,
+  Code,
+  Cog,
+  Compass,
+  Copy,
+  CreditCard,
+  Crown,
+  Download,
+  Droplet,
+  Ellipsis,
+  Eye,
+  EyeOff,
+  FaceSlightlySmiling,
+  File,
+  FileText,
+  Flag,
+  Flame,
+  Folder,
+  Funnel,
+  Gamepad2,
+  Gift,
+  Globe,
+  GraduationCap,
+  Hand,
+  Hourglass,
+  Headphones,
+  Heart,
+  House,
+  Image,
+  Inbox,
+  Info,
+  Key,
+  Keyboard,
+  Laptop,
+  Leaf,
+  Lightbulb,
+  Link,
+  List,
+  ListChecks,
+  ListOrdered,
+  LoaderCircle,
+  Lock,
+  LockOpen,
+  LogIn,
+  LogOut,
+  Mail,
+  Map,
+  MapPin,
+  Menu,
+  MessageCircle,
+  MessageSquare,
+  Mic,
+  MicOff,
+  Minus,
+  Monitor,
+  Moon,
+  Music,
+  Package,
+  Paperclip,
+  Pause,
+  Pencil,
+  Phone,
+  Pin,
+  Plane,
+  Play,
+  Plus,
+  Power,
+  Printer,
+  QrCode,
+  RefreshCw,
+  Repeat,
+  RotateCcw,
+  RotateCw,
+  Search,
+  Send,
+  Settings,
+  Share,
+  Shield,
+  ShieldCheck,
+  ShoppingBag,
+  ShoppingCart,
+  Shuffle,
+  SkipBack,
+  SkipForward,
+  SlidersHorizontal,
+  Smartphone,
+  Sparkles,
+  Speaker,
+  Square,
+  SquareCheck,
+  SquarePen,
+  Star,
+  Sun,
+  Tag,
+  Target,
+  Terminal,
+  Timer,
+  ThumbsUp,
+  Trash,
+  TriangleAlert,
+  TrendingUp,
+  Trophy,
+  Tv,
+  Type,
+  Upload,
+  User,
+  Users,
+  Volume,
+  Volume1,
+  Volume2,
+  VolumeX,
+  Wallet,
+  Watch,
+  Wifi,
+  Wind,
+  Wrench,
+  X,
+  Zap,
+  ZoomIn,
+  ZoomOut,
+  createElement,
+  type IconNode,
+  Grid3x3,
+  LayoutGrid,
+  LayoutList,
+  MessageSquarePlus,
+  MessageSquareText,
+  Truck,
+  Utensils,
+} from 'lucide';
+
+/** How a glyph is painted; see the file comment. */
+export type GlyphFill = 'outline' | 'knockout' | 'solid';
+
+export interface SymbolGlyph {
+  icon: IconNode;
+  fill: GlyphFill;
+}
+
+const outline = (icon: IconNode): SymbolGlyph => ({ icon, fill: 'outline' });
+const knockout = (icon: IconNode): SymbolGlyph => ({ icon, fill: 'knockout' });
+const solid = (icon: IconNode): SymbolGlyph => ({ icon, fill: 'solid' });
+
+/** SF Symbol name → glyph. Keys are the exact `systemName` strings. */
+export const SF_SYMBOLS: Readonly<Record<string, SymbolGlyph>> = {
+  // Marks
+  plus: outline(Plus),
+  minus: outline(Minus),
+  checkmark: outline(Check),
+  'checkmark.circle': outline(CircleCheck),
+  'checkmark.circle.fill': knockout(CircleCheck),
+  'checkmark.square': outline(SquareCheck),
+  'checkmark.square.fill': knockout(SquareCheck),
+  checklist: outline(ListChecks),
+  xmark: outline(X),
+  'xmark.circle': outline(CircleX),
+  'xmark.circle.fill': knockout(CircleX),
+  'plus.circle': outline(CirclePlus),
+  'plus.circle.fill': knockout(CirclePlus),
+  'minus.circle': outline(CircleMinus),
+  'minus.circle.fill': knockout(CircleMinus),
+  'info.circle': outline(Info),
+  'info.circle.fill': knockout(Info),
+  'questionmark.circle': outline(CircleQuestionMark),
+  'questionmark.circle.fill': knockout(CircleQuestionMark),
+  'exclamationmark.circle': outline(CircleAlert),
+  'exclamationmark.circle.fill': knockout(CircleAlert),
+  'exclamationmark.triangle': outline(TriangleAlert),
+  'exclamationmark.triangle.fill': knockout(TriangleAlert),
+  ellipsis: outline(Ellipsis),
+  'ellipsis.circle': outline(CircleEllipsis),
+  'ellipsis.circle.fill': knockout(CircleEllipsis),
+
+  // Shapes
+  circle: outline(Circle),
+  'circle.fill': solid(Circle),
+  'circle.inset.filled': outline(CircleDot),
+  'largecircle.fill.circle': outline(CircleDot),
+  square: outline(Square),
+  'square.fill': solid(Square),
+  star: outline(Star),
+  'star.fill': solid(Star),
+  heart: outline(Heart),
+  'heart.fill': solid(Heart),
+  bolt: outline(Zap),
+  'bolt.fill': solid(Zap),
+  sparkles: outline(Sparkles),
+
+  // Chevrons and arrows
+  'chevron.left': outline(ChevronLeft),
+  'chevron.right': outline(ChevronRight),
+  'chevron.up': outline(ChevronUp),
+  'chevron.down': outline(ChevronDown),
+  'chevron.left.2': outline(ChevronsLeft),
+  'chevron.right.2': outline(ChevronsRight),
+  'chevron.up.2': outline(ChevronsUp),
+  'chevron.up.chevron.down': outline(ChevronsUpDown),
+  'chevron.down.2': outline(ChevronsDown),
+  'chevron.backward': outline(ChevronLeft),
+  'chevron.forward': outline(ChevronRight),
+  'arrow.left': outline(ArrowLeft),
+  'arrow.right': outline(ArrowRight),
+  'arrow.up': outline(ArrowUp),
+  'arrow.down': outline(ArrowDown),
+  'arrow.backward': outline(ArrowLeft),
+  'arrow.forward': outline(ArrowRight),
+  'arrow.up.right': outline(ArrowUpRight),
+  'arrow.left.arrow.right': outline(ArrowLeftRight),
+  'arrow.up.arrow.down': outline(ArrowUpDown),
+  'arrow.left.circle': outline(CircleArrowLeft),
+  'arrow.right.circle': outline(CircleArrowRight),
+  'arrow.up.circle': outline(CircleArrowUp),
+  'arrow.down.circle': outline(CircleArrowDown),
+  'arrow.down.to.line': outline(ArrowDownToLine),
+  'arrow.up.to.line': outline(ArrowUpFromLine),
+  'arrow.clockwise': outline(RotateCw),
+  'arrow.counterclockwise': outline(RotateCcw),
+  'arrow.triangle.2.circlepath': outline(RefreshCw),
+  'arrow.2.squarepath': outline(RefreshCw),
+  repeat: outline(Repeat),
+  shuffle: outline(Shuffle),
+  'square.and.arrow.up': outline(Share),
+  'square.and.arrow.down': outline(Download),
+  'arrow.down.doc': outline(Download),
+  'arrow.up.doc': outline(Upload),
+  'rectangle.portrait.and.arrow.right': outline(LogOut),
+  'rectangle.portrait.and.arrow.forward': outline(LogOut),
+  'arrow.right.to.line': outline(LogIn),
+
+  // Editing
+  trash: outline(Trash),
+  'trash.fill': outline(Trash),
+  pencil: outline(Pencil),
+  'square.and.pencil': outline(SquarePen),
+  'doc.on.doc': outline(Copy),
+  'doc.on.clipboard': outline(Clipboard),
+  paperclip: outline(Paperclip),
+  pin: outline(Pin),
+  'pin.fill': solid(Pin),
+  bookmark: outline(Bookmark),
+  'bookmark.fill': solid(Bookmark),
+  flag: outline(Flag),
+  'flag.fill': solid(Flag),
+  tag: outline(Tag),
+  'tag.fill': solid(Tag),
+  textformat: outline(Type),
+  'line.3.horizontal': outline(Menu),
+  'line.3.horizontal.decrease': outline(Funnel),
+  'line.3.horizontal.decrease.circle': outline(Funnel),
+  'slider.horizontal.3': outline(SlidersHorizontal),
+  'list.bullet': outline(List),
+  'list.number': outline(ListOrdered),
+  'chart.bar': outline(ChartBar),
+  'chart.xyaxis.line': outline(ChartLine),
+  'chart.pie': outline(ChartPie),
+  magnifyingglass: outline(Search),
+  'plus.magnifyingglass': outline(ZoomIn),
+  'minus.magnifyingglass': outline(ZoomOut),
+
+  // People and places
+  person: outline(User),
+  'person.fill': outline(User),
+  'person.2': outline(Users),
+  'person.circle': outline(CircleUser),
+  'person.circle.fill': knockout(CircleUser),
+  'person.crop.circle': outline(CircleUser),
+  'person.crop.circle.fill': knockout(CircleUser),
+  'figure.walk': outline(Accessibility),
+  'face.smiling': outline(FaceSlightlySmiling),
+  'hand.thumbsup': outline(ThumbsUp),
+  'hand.thumbsup.fill': solid(ThumbsUp),
+  'hand.raised': outline(Hand),
+  house: outline(House),
+  'house.fill': solid(House),
+  building: outline(Building),
+  'building.2': outline(Building),
+  graduationcap: outline(GraduationCap),
+  briefcase: outline(Briefcase),
+  'briefcase.fill': solid(Briefcase),
+  map: outline(Map),
+  location: outline(MapPin),
+  'location.fill': knockout(MapPin),
+  'mappin': outline(MapPin),
+  'mappin.and.ellipse': outline(MapPin),
+  globe: outline(Globe),
+  safari: outline(Compass),
+  scope: outline(Target),
+
+  // Communication
+  bell: outline(Bell),
+  'bell.fill': solid(Bell),
+  envelope: outline(Mail),
+  'envelope.fill': outline(Mail),
+  'envelope.open': outline(Inbox),
+  tray: outline(Inbox),
+  phone: outline(Phone),
+  'phone.fill': solid(Phone),
+  message: outline(MessageCircle),
+  'message.fill': solid(MessageCircle),
+  bubble: outline(MessageSquare),
+  'bubble.left': outline(MessageSquare),
+  at: outline(AtSign),
+  paperplane: outline(Send),
+  'paperplane.fill': outline(Send),
+  link: outline(Link),
+  'link.circle': outline(Link),
+
+  // Time
+  calendar: outline(Calendar),
+  clock: outline(Clock),
+  'clock.fill': knockout(Clock),
+  alarm: outline(AlarmClock),
+  'applewatch': outline(Watch),
+  stopwatch: outline(Timer),
+  timer: outline(Timer),
+  hourglass: outline(Hourglass),
+
+  // Media and devices
+  camera: outline(Camera),
+  'camera.fill': outline(Camera),
+  photo: outline(Image),
+  'photo.fill': outline(Image),
+  'photo.on.rectangle': outline(Image),
+  play: outline(Play),
+  'play.fill': solid(Play),
+  'play.circle': outline(CirclePlay),
+  'play.circle.fill': knockout(CirclePlay),
+  'pause.circle': outline(CirclePause),
+  'pause.circle.fill': knockout(CirclePause),
+  'stop.circle': outline(CircleStop),
+  pause: outline(Pause),
+  'pause.fill': solid(Pause),
+  stop: outline(Square),
+  'stop.fill': solid(Square),
+  'backward.end': outline(SkipBack),
+  'forward.end': outline(SkipForward),
+  'backward.end.fill': solid(SkipBack),
+  'forward.end.fill': solid(SkipForward),
+  'speaker': outline(Volume),
+  'speaker.wave.1': outline(Volume1),
+  'speaker.wave.2': outline(Volume2),
+  'speaker.wave.3': outline(Volume2),
+  'speaker.slash': outline(VolumeX),
+  'hifispeaker': outline(Speaker),
+  headphones: outline(Headphones),
+  mic: outline(Mic),
+  'mic.fill': outline(Mic),
+  'mic.slash': outline(MicOff),
+  'music.note': outline(Music),
+  tv: outline(Tv),
+  desktopcomputer: outline(Monitor),
+  laptopcomputer: outline(Laptop),
+  iphone: outline(Smartphone),
+  keyboard: outline(Keyboard),
+  printer: outline(Printer),
+  'qrcode': outline(QrCode),
+  gamecontroller: outline(Gamepad2),
+  'gamecontroller.fill': outline(Gamepad2),
+  wifi: outline(Wifi),
+  'antenna.radiowaves.left.and.right': outline(Wifi),
+  bluetooth: outline(Bluetooth),
+  'battery.100': outline(Battery),
+  power: outline(Power),
+  'cpu': outline(Terminal),
+  'chevron.left.forwardslash.chevron.right': outline(Code),
+  terminal: outline(Terminal),
+  'ant': outline(Bug),
+  'ladybug': outline(Bug),
+  wrench: outline(Wrench),
+  'wrench.and.screwdriver': outline(Wrench),
+  'wrench.fill': outline(Wrench),
+
+  // Documents
+  folder: outline(Folder),
+  'folder.fill': solid(Folder),
+  doc: outline(File),
+  'doc.fill': outline(File),
+  'doc.text': outline(FileText),
+  'doc.text.fill': outline(FileText),
+  archivebox: outline(Archive),
+  'shippingbox': outline(Package),
+  'shippingbox.fill': outline(Package),
+
+  // Settings and security
+  gear: outline(Settings),
+  gearshape: outline(Settings),
+  'gearshape.fill': outline(Settings),
+  'gearshape.2': outline(Cog),
+  lock: outline(Lock),
+  'lock.fill': solid(Lock),
+  'lock.open': outline(LockOpen),
+  'lock.open.fill': solid(LockOpen),
+  key: outline(Key),
+  'key.fill': solid(Key),
+  shield: outline(Shield),
+  'shield.fill': solid(Shield),
+  'checkmark.shield': outline(ShieldCheck),
+  'checkmark.shield.fill': knockout(ShieldCheck),
+  eye: outline(Eye),
+  'eye.fill': knockout(Eye),
+  'eye.slash': outline(EyeOff),
+  'eye.slash.fill': outline(EyeOff),
+
+  // Commerce
+  cart: outline(ShoppingCart),
+  'cart.fill': outline(ShoppingCart),
+  bag: outline(ShoppingBag),
+  'bag.fill': outline(ShoppingBag),
+  creditcard: outline(CreditCard),
+  'creditcard.fill': knockout(CreditCard),
+  wallet: outline(Wallet),
+  'wallet.pass': outline(Wallet),
+  gift: outline(Gift),
+  'gift.fill': outline(Gift),
+  crown: outline(Crown),
+  'crown.fill': solid(Crown),
+  trophy: outline(Trophy),
+  'trophy.fill': outline(Trophy),
+
+  // Nature and weather
+  'sun.max': outline(Sun),
+  'sun.max.fill': solid(Sun),
+  moon: outline(Moon),
+  'moon.fill': solid(Moon),
+  'moon.stars': outline(Moon),
+  cloud: outline(Cloud),
+  'cloud.fill': solid(Cloud),
+  'cloud.rain': outline(CloudRain),
+  'cloud.snow': outline(CloudSnow),
+  'cloud.sun': outline(CloudSun),
+  'cloud.sun.fill': solid(CloudSun),
+  'moon.circle.fill': solid(Moon),
+  'sun.max.circle.fill': solid(Sun),
+  'person.3': outline(Users),
+  'person.3.fill': solid(Users),
+  'chart.line.uptrend.xyaxis': outline(TrendingUp),
+  'square.grid.2x2': outline(LayoutGrid),
+  'circle.grid.3x3': outline(Grid3x3),
+  'fork.knife': outline(Utensils),
+  'text.bubble': outline(MessageSquareText),
+  'plus.bubble': outline(MessageSquarePlus),
+  'box.truck': outline(Truck),
+  'list.bullet.below.rectangle': outline(LayoutList),
+  'cloud.moon': outline(CloudMoon),
+  'cloud.bolt': outline(CloudLightning),
+  wind: outline(Wind),
+  leaf: outline(Leaf),
+  'leaf.fill': solid(Leaf),
+  flame: outline(Flame),
+  'flame.fill': solid(Flame),
+  drop: outline(Droplet),
+  'drop.fill': solid(Droplet),
+  lightbulb: outline(Lightbulb),
+  'lightbulb.fill': outline(Lightbulb),
+
+  // Transport
+  car: outline(Car),
+  'car.fill': outline(Car),
+  airplane: outline(Plane),
+  bus: outline(Bus),
+  'bus.fill': outline(Bus),
+  bicycle: outline(Bike),
+
+  // Reading
+  book: outline(Book),
+  'book.fill': solid(Book),
+  'book.closed': outline(Book),
+  'text.book.closed': outline(BookOpen),
+
+  // Activity
+  'rays': outline(LoaderCircle),
+  'circle.dotted': outline(LoaderCircle),
+};
+
+/** Number of SF Symbol names the renderer can draw. */
+export const SF_SYMBOL_COUNT = Object.keys(SF_SYMBOLS).length;
+
+export function lookupSymbol(systemName: string): SymbolGlyph | undefined {
+  return SF_SYMBOLS[systemName];
+}
+
+const SVG_NS = 'http://www.w3.org/2000/svg';
+
+/** Color used for inner marks of `knockout` glyphs; styles.css sets the variable. */
+const KNOCKOUT_COLOR = 'var(--sb-icon-knockout, var(--sb-color-system-background, #fff))';
+
+/**
+ * Build the `<svg>` for a symbol. Returns `null` for unknown names; the
+ * caller draws a placeholder in that case.
+ */
+export function renderSymbol(systemName: string): SVGElement | null {
+  const glyph = lookupSymbol(systemName);
+  if (!glyph) return null;
+  const svg = createElement(glyph.icon, {
+    width: '1em',
+    height: '1em',
+    'aria-hidden': 'true',
+    focusable: 'false',
+  });
+  if (svg.namespaceURI !== SVG_NS) return null;
+  svg.setAttribute('data-sb-symbol', systemName);
+  svg.setAttribute('data-sb-glyph-fill', glyph.fill);
+  if (glyph.fill === 'solid') {
+    for (const shape of Array.from(svg.children)) {
+      shape.setAttribute('fill', 'currentColor');
+    }
+  } else if (glyph.fill === 'knockout') {
+    const [outer, ...inner] = Array.from(svg.children);
+    outer?.setAttribute('fill', 'currentColor');
+    for (const mark of inner) {
+      mark.setAttribute('stroke', KNOCKOUT_COLOR);
+      mark.setAttribute('fill', 'none');
+    }
+  }
+  return svg;
+}

package/src/typography.ts

@@ -0,0 +1,76 @@
+/**
+ * Dynamic Type for the page: a thin layer over the layout engine's font
+ * resolution (`src/layout/typography.ts`), which is the single source of
+ * truth for Apple's Dynamic Type table (point sizes per text style and size
+ * category) and iOS line heights.
+ *
+ * The page writes one CSS custom property pair per text style on the device
+ * frame (`--sb-ts-<style>-size` / `-lh`) plus a `-scale` factor relative to
+ * Large, so styled text that is not laid out by the engine (chrome, the mock
+ * page before the first layout) still follows the selected size.
+ */
+
+import {
+  TEXT_STYLE_SIZES,
+  lineHeightFor,
+  textStyleSize,
+  type TextStyle,
+} from './layout/typography';
+import type { DynamicTypeSize } from './protocol';
+
+export {
+  DYNAMIC_TYPE_SIZES,
+  FONT_FAMILIES,
+  FONT_WEIGHTS,
+  LINE_HEIGHTS,
+  TEXT_STYLE_SIZES,
+  defaultFont,
+  lineHeightFor,
+  makeFont,
+  resolveFont,
+  textStyleSize,
+} from './layout/typography';
+export type { TextStyle } from './layout/typography';
+
+export const DEFAULT_TYPE_SIZE: DynamicTypeSize = 'large';
+
+export const TEXT_STYLES: readonly TextStyle[] = Object.keys(TEXT_STYLE_SIZES) as TextStyle[];
+
+/** Default weight of a text style (only `headline` differs from regular). */
+export const TEXT_STYLE_WEIGHT: Partial<Record<TextStyle, 'semibold'>> = {
+  headline: 'semibold',
+};
+
+export interface ResolvedTextStyle {
+  fontSize: number;
+  lineHeight: number;
+}
+
+/** Point size and line height of `style` at `size`. */
+export function resolveTextStyle(style: TextStyle, size: DynamicTypeSize): ResolvedTextStyle {
+  const fontSize = textStyleSize(style, size);
+  return { fontSize, lineHeight: lineHeightFor(fontSize) };
+}
+
+/** Scale factor of `style` at `size` relative to Large (`Font.system(size:relativeTo:)`). */
+export function relativeScale(style: TextStyle, size: DynamicTypeSize): number {
+  return textStyleSize(style, size) / textStyleSize(style, DEFAULT_TYPE_SIZE);
+}
+
+/** CSS custom property names the renderer reads for a text style. */
+export function textStyleVar(style: TextStyle, metric: 'size' | 'lh'): string {
+  return `--sb-ts-${style}-${metric}`;
+}
+
+/**
+ * Write every text style's size and line height for `size` as CSS custom
+ * properties on `target` (the device frame).
+ */
+export function applyTypeSizeVariables(target: HTMLElement, size: DynamicTypeSize): void {
+  for (const style of TEXT_STYLES) {
+    const { fontSize, lineHeight } = resolveTextStyle(style, size);
+    target.style.setProperty(textStyleVar(style, 'size'), `${fontSize}px`);
+    target.style.setProperty(textStyleVar(style, 'lh'), `${lineHeight}px`);
+    target.style.setProperty(`--sb-ts-${style}-scale`, String(relativeScale(style, size)));
+  }
+}

package/src/vite-env.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="vite/client" />
+
+// Injected by `define` in node/config.ts (every page; the landing page lists the apps, the app page reads its own entry).
+
+/** One registered app, as the landing page sees it (`LandingApp` in node/config.ts). */
+interface SBLandingApp {
+  /** URL-safe name (`?app=<name>`). */
+  name: string;
+  /** Card title; the spec's `displayName`, else `name`. */
+  displayName: string;
+  /** Card subtitle, when the spec has one. */
+  description?: string;
+  /** URL of the app's own icon (`/manifests/<name>-icon.png`), when the spec has one. */
+  icon?: string;
+  /** Languages the module carries locale data for; the page runs it in the viewer's when among them. */
+  locales?: string[];
+}
+
+/** The registered apps, in registry order. */
+declare const __SB_APPS__: readonly SBLandingApp[];
+/** Commit sha the site was built from (`GITHUB_SHA`, else `git rev-parse --short HEAD`, else "dev"). */
+declare const __SB_COMMIT__: string;
+/** Branch the site was built from (`GITHUB_REF_NAME`, else `git rev-parse --abbrev-ref HEAD`, else ""). */
+declare const __SB_BRANCH__: string;
+/** ISO 8601 timestamp of the build. */
+declare const __SB_BUILT_AT__: string;