@incodetech/prizma-core-screens 0.1.0

package/src/GeolocationBrowserStepsScreen.tsx

@@ -0,0 +1,173 @@
+import React, { forwardRef, type ReactNode } from 'react';
+import {
+  IconArrowLeft,
+  IconFolderFileOpen,
+  IconGeoPin,
+  IconLock,
+  IconLockCheck,
+  IconMobilePhone,
+  IconNumberedList,
+  IconTextAi,
+} from '@incodetech/prizma-core-icons';
+import { PrizmaCardListCommonIssues } from '@incodetech/prizma-core-web/card-list';
+import { PrizmaListScreen, type PrizmaListScreenProps } from './ListScreen';
+import type { PrizmaScreenActionHandler, PrizmaScreenOverrides } from './types';
+import type {
+  GeolocationBrowser,
+  GeolocationStepKind,
+  GeolocationStrings,
+} from './GeolocationStrings';
+import './ScreenLayout.css';
+
+/**
+ * Step kind → canonical bank glyph. ONE map, in one place, for the same reason
+ * Document Capture's common-issues map exists (DEVIATIONS #DC-23): Figma leads
+ * every row with OS/browser chrome the Prizma bank does not ship — a ⋮ overflow
+ * menu, a gear, a permission toggle, Safari's "AA" control and each browser's
+ * own logo. Shipping those would mean inventing primitives and bundling brand
+ * rasters, both forbidden (rule 1, GUIDELINES §10), so each row takes the
+ * nearest canonical glyph:
+ *
+ *   addressBar  → IconTextAi        Safari's "AA" is the address-bar text control
+ *   menu        → IconNumberedList  the ⋮ overflow opens a menu list
+ *   settings    → IconLock          site settings sit behind the address-bar lock
+ *   permissions → IconLockCheck     a granted permission
+ *   location    → IconGeoPin        near-exact
+ *   device      → IconMobilePhone   the device's Settings app
+ *   apps        → IconFolderFileOpen the app list / app drawer
+ *   return      → IconArrowLeft     "return here and refresh" (Figma draws the
+ *                                   browser's logo — a brand raster, never bundled)
+ *
+ * Owner decision needed: mint the eight glyphs, or bless these substitutions.
+ * NOT YET RECORDED: DEVIATIONS.md has no Geolocation section, so this is an
+ * open escalation rather than a settled ruling. Verified against the frames on
+ * 2026-08-19 — every section leads its rows with OS/browser chrome, and the
+ * last row of each browser section draws that browser's own logo (Chrome disc,
+ * Firefox flame, Opera O, Samsung Internet mark).
+ */
+const STEP_ICONS: Record<GeolocationStepKind, ReactNode> = {
+  addressBar: <IconTextAi size="m" />,
+  menu: <IconNumberedList size="m" />,
+  settings: <IconLock size="m" />,
+  permissions: <IconLockCheck size="m" />,
+  location: <IconGeoPin size="m" />,
+  device: <IconMobilePhone size="m" />,
+  apps: <IconFolderFileOpen size="m" />,
+  return: <IconArrowLeft size="m" />,
+};
+
+export interface GeolocationBrowserStepsScreenProps
+  extends Omit<
+    PrizmaListScreenProps,
+    | 'status'
+    | 'title'
+    | 'subtitle'
+    | 'children'
+    | 'ctaLabel'
+    | 'secondaryCtaLabel'
+    | 'linkLabel'
+    | 'verifiedLabel'
+    | 'navLabel'
+  > {
+  /** Module copy — this screen reads the `browserSteps` slice. */
+  strings: GeolocationStrings;
+  /** Which browser's steps to show. Default `safariIos`. */
+  browser?: GeolocationBrowser;
+  /**
+   * Offer the second action. Default `true`. Figma's Samsung Internet section
+   * draws the primary alone, because that flow cannot skip the step.
+   */
+  showSkip?: boolean;
+  screenId?: string;
+  overrides?: PrizmaScreenOverrides;
+  onAction?: PrizmaScreenActionHandler;
+}
+
+/**
+ * Geolocation — "Follow the next steps to allow Incode to access your
+ * location", built on the List archetype (GUIDELINES.md §6-G,
+ * `PrizmaListScreen`).
+ *
+ * ONE screen for all NINE purple sections of the Web group. They draw the
+ * identical skeleton — title block → a step list filling the middle → the
+ * refresh CTA — and differ only in the rows, because re-enabling location is a
+ * different journey in Safari, Chrome, Firefox, Opera and Samsung Internet, on
+ * iOS and on Android. Nine files would have been nine chances to drift.
+ *
+ * The rows are Core's `PrizmaCardListCommonIssues` verbatim; only the leading
+ * glyph is chosen here, from the canonical bank (see `STEP_ICONS`).
+ *
+ * The title block is LEFT-aligned for this whole family. Every
+ * `Geolocation.allowLocation.<browser>` section starts the two-line headline —
+ * and the browser label under it — flush at the gutter, over left-led step
+ * rows; a centred headline above a left-aligned list reads as a mistake. The
+ * screen therefore DEFAULTS the archetype's own `align` override to `left`
+ * rather than declaring any alignment of its own, and a host that passes
+ * `overrides.align` still wins.
+ *
+ * Two things Figma draws that this screen does not, both reported rather than
+ * worked around:
+ * - **Mixed weight inside a row.** Figma bolds the actionable fragment ("Tap
+ *   **Three dots** in the top right"); Core's row `title` is a plain `string`,
+ *   so the sentence renders in one weight. Core request: a `ReactNode` title.
+ * - **Primary above secondary.** Figma stacks "Refresh page" over "Skip this
+ *   step" on all nine sections; archetype G's band renders the secondary first
+ *   (`ListScreen.tsx`), so these screens ship inverted against their frames.
+ *   The archetype owns the order and no module re-declares it — archetype G
+ *   needs a `ctaOrder` slot the way archetype F already has `ctaOrientation`.
+ *   ESCALATED, NOT RESOLVED: DEVIATIONS.md still has no Geolocation section, so
+ *   there is no ruling to cite yet.
+ */
+export const GeolocationBrowserStepsScreen = forwardRef<
+  HTMLDivElement,
+  GeolocationBrowserStepsScreenProps
+>(
+  (
+    {
+      strings,
+      browser = 'safariIos',
+      showSkip = true,
+      screenId = `geolocation-allow-location-${browser}`,
+      overrides,
+      onAction,
+      ...shell
+    },
+    ref,
+  ) => {
+    const slice = strings.browserSteps.browsers[browser];
+    /* Family default, not a local re-declaration: the archetype already owns a
+       left variant, so the screen only picks which of ITS variants this family
+       uses. An explicit `overrides.align` from the host still wins. */
+    const alignedOverrides: PrizmaScreenOverrides = {
+      ...overrides,
+      align: overrides?.align ?? 'left',
+    };
+
+    return (
+      <PrizmaListScreen
+        ref={ref}
+        title={strings.browserSteps.title}
+        subtitle={slice?.label}
+        ctaLabel={strings.browserSteps.ctaLabel}
+        secondaryCtaLabel={showSkip ? strings.browserSteps.skipLabel : undefined}
+        verifiedLabel={strings.verifiedLabel}
+        navLabel={strings.navLabel}
+        screenId={screenId}
+        overrides={alignedOverrides}
+        onAction={onAction}
+        {...shell}
+      >
+        <PrizmaCardListCommonIssues
+          items={(slice?.steps ?? []).map((step) => ({
+            icon: STEP_ICONS[step.kind],
+            title: step.label,
+            showSubtitle: false,
+          }))}
+        />
+      </PrizmaListScreen>
+    );
+  },
+);
+GeolocationBrowserStepsScreen.displayName = 'GeolocationBrowserStepsScreen';
+
+export default GeolocationBrowserStepsScreen;

package/src/GeolocationErrorScreen.tsx

@@ -0,0 +1,113 @@
+import React, { forwardRef } from 'react';
+import { IconWifiOff } from '@incodetech/prizma-core-icons';
+import { PrizmaResultScreen, type PrizmaResultScreenProps } from './ResultScreen';
+import type { PrizmaScreenActionHandler, PrizmaScreenOverrides } from './types';
+import type { GeolocationErrorVariant, GeolocationStrings } from './GeolocationStrings';
+import './ScreenLayout.css';
+
+export interface GeolocationErrorScreenProps
+  extends Omit<
+    PrizmaResultScreenProps,
+    | 'status'
+    | 'title'
+    | 'subtitle'
+    | 'glyph'
+    | 'ctaLabel'
+    | 'verifiedLabel'
+    | 'navLabel'
+  > {
+  /** Module copy — this screen reads the `error` slice its `variant` names. */
+  strings: GeolocationStrings;
+  /** Which purple `Geolocation.error.*` section to render. Default `locationUnavailable`. */
+  variant?: GeolocationErrorVariant;
+  screenId?: string;
+  overrides?: PrizmaScreenOverrides;
+  onAction?: PrizmaScreenActionHandler;
+}
+
+/**
+ * Geolocation — the error verdicts, built on the Result archetype
+ * (GUIDELINES.md §6-F, `PrizmaResultScreen`).
+ *
+ * ONE screen for the four purple `Geolocation.error.*` sections. All four draw
+ * the identical skeleton — a centred mark + title + supporting line over a
+ * single CTA — and differ only in copy and in which mark leads:
+ *
+ * - `locationUnavailable` — weak/inaccurate signal, "Try again"
+ * - `quit`                — attempts exhausted, the step is required
+ * - `skip`                — attempts exhausted, the step is optional
+ * - `noNetwork`           — the connectivity family every module carries
+ *
+ * Figma draws the first three with a filled amber disc; Core renders the
+ * canonical OUTLINE warning mark (icon-outline sweep, DEVIATIONS #15). The
+ * module Figma is one sweep behind, exactly as Face Capture's and ID Capture's
+ * result screens were.
+ *
+ * `noNetwork` KEEPS the logo header and the verified tag even though its purple
+ * section draws neither: the owner rule of 2026-08-18 (#F-30, #F-34) makes the
+ * chrome constant across every screen so nothing shifts between states, and all
+ * modules' connectivity screens must read identically (#PI-8).
+ *
+ * The Wi-Fi mark is Figma's `Icon / Wi-Fi`; Core's `PrizmaTitle` icon allowlist
+ * is `status | spinner | none`, so it rides the archetype's `glyph` slot with
+ * the foundation's `__glyph` class, drawn from the canonical icon bank (#10).
+ */
+export const GeolocationErrorScreen = forwardRef<HTMLDivElement, GeolocationErrorScreenProps>(
+  (
+    {
+      strings,
+      variant = 'locationUnavailable',
+      screenId = `geolocation-error-${variant}`,
+      overrides,
+      onAction,
+      ...shell
+    },
+    ref,
+  ) => {
+    const noConnection = variant === 'noNetwork';
+    const copy = noConnection
+      ? strings.error.noConnection
+      : variant === 'quit'
+        ? strings.error.quit
+        : variant === 'skip'
+          ? strings.error.skip
+          : strings.error.locationUnavailable;
+
+    return (
+      <PrizmaResultScreen
+        ref={ref}
+        /* The connectivity screen leads with the Wi-Fi glyph instead of a
+           status mark; the other three carry the canonical warning mark, which
+           is what the module Figma draws (amber, not red). */
+        status={noConnection ? 'none' : 'warning'}
+        glyph={
+          noConnection ? (
+            <span
+              className={[
+                'prizma-screen-layout__glyph',
+                'prizma-screen-layout__glyph--negative',
+                overrides?.align === 'left' ? 'prizma-screen-layout__glyph--left' : '',
+              ]
+                .filter(Boolean)
+                .join(' ')}
+            >
+              <IconWifiOff size="l" />
+            </span>
+          ) : undefined
+        }
+        title={copy.title}
+        subtitle={copy.subtitle}
+        ctaLabel={copy.ctaLabel}
+        verifiedLabel={strings.verifiedLabel}
+        navLabel={strings.navLabel}
+        screenId={screenId}
+        overrides={overrides}
+        onAction={onAction}
+        {...shell}
+      />
+    );
+  },
+);
+GeolocationErrorScreen.displayName = 'GeolocationErrorScreen';
+
+export default GeolocationErrorScreen;

package/src/GeolocationIntroScreen.tsx

@@ -0,0 +1,100 @@
+import React, { forwardRef, type ReactNode } from 'react';
+import { PrizmaIllustrationGeolocation } from '@incodetech/prizma-core-web/illustration-geolocation';
+import { PrizmaTutorialScreen, type PrizmaTutorialScreenProps } from './TutorialScreen';
+import type { PrizmaScreenActionHandler, PrizmaScreenOverrides } from './types';
+import type { GeolocationIntroState, GeolocationStrings } from './GeolocationStrings';
+import './ScreenLayout.css';
+
+export interface GeolocationIntroScreenProps
+  extends Omit<
+    PrizmaTutorialScreenProps,
+    | 'title'
+    | 'subtitle'
+    | 'disclaimer'
+    | 'ctaLabel'
+    | 'ctaLoadingLabel'
+    | 'illustration'
+    | 'verifiedLabel'
+    | 'navLabel'
+  > {
+  /** Module copy — this screen reads the `intro` slice (+ shared labels). */
+  strings: GeolocationStrings;
+  /** Which purple intro section to render. Default `request`. */
+  state?: GeolocationIntroState;
+  /**
+   * The resolved place shown on `located` ("Mexico City, Mexico"). Runtime data,
+   * never copy — the host's geocoder produces it, so it does not belong in
+   * `strings`. Falls back to `strings.intro.located.subtitle`.
+   */
+  location?: string;
+  /** Replace Core's geolocation illustration (host artwork / a still). */
+  illustration?: ReactNode;
+  screenId?: string;
+  overrides?: PrizmaScreenOverrides;
+  onAction?: PrizmaScreenActionHandler;
+}
+
+/**
+ * Geolocation — the two intro sections, built on the `PrizmaTutorialScreen`
+ * archetype (GUIDELINES.md §6-A).
+ *
+ * ONE screen for both purple sections, because they draw the identical
+ * skeleton — nav → title block → illustration filling the middle → CTA → tag —
+ * and differ only in copy and in which state of the illustration is showing:
+ *
+ * - `request` (`geolocation.default`)  — "We need to determine your current
+ *   location", inactive artwork, CTA asks for permission.
+ * - `located` (`Geolocation.continue`) — "You are currently in:" with the
+ *   resolved place, active artwork (brand pin dropped), CTA advances the flow.
+ *
+ * The artwork is Core's own `PrizmaIllustrationGeolocation`, whose `active`
+ * axis is exactly this pair of states — nothing is inlined here (§10).
+ *
+ * Its drawing differs from the module Figma's, which draws a folded street map
+ * with a pin dropped on it — grey with a ✕ through the pin on `geolocation.default`,
+ * brand blue on `Geolocation.continue`. Core's illustration wins (rule 4), and
+ * the divergence is ESCALATED, NOT RESOLVED: DEVIATIONS.md still has no
+ * Geolocation section, so there is no numbered ruling to cite yet.
+ *
+ * Figma also draws a nav ✕ on both sections; it is deliberately not built here
+ * (#PI-9).
+ */
+export const GeolocationIntroScreen = forwardRef<HTMLDivElement, GeolocationIntroScreenProps>(
+  (
+    {
+      strings,
+      state = 'request',
+      location,
+      illustration,
+      screenId = `geolocation-intro-${state}`,
+      overrides,
+      onAction,
+      ...shell
+    },
+    ref,
+  ) => {
+    const located = state === 'located';
+    const copy = located ? strings.intro.located : strings.intro.request;
+
+    return (
+      <PrizmaTutorialScreen
+        ref={ref}
+        title={copy.title}
+        subtitle={located ? (location ?? copy.subtitle) : copy.subtitle}
+        ctaLabel={copy.ctaLabel}
+        illustration={
+          illustration ?? <PrizmaIllustrationGeolocation active={located} decorative />
+        }
+        verifiedLabel={strings.verifiedLabel}
+        navLabel={strings.navLabel}
+        screenId={screenId}
+        overrides={overrides}
+        onAction={onAction}
+        {...shell}
+      />
+    );
+  },
+);
+GeolocationIntroScreen.displayName = 'GeolocationIntroScreen';
+
+export default GeolocationIntroScreen;

package/src/GeolocationPermissionScreen.tsx

@@ -0,0 +1,88 @@
+import React, { forwardRef } from 'react';
+import { PrizmaResultScreen, type PrizmaResultScreenProps } from './ResultScreen';
+import type { PrizmaScreenActionHandler, PrizmaScreenOverrides } from './types';
+import type {
+  GeolocationPermissionVariant,
+  GeolocationStrings,
+} from './GeolocationStrings';
+import './ScreenLayout.css';
+
+export interface GeolocationPermissionScreenProps
+  extends Omit<
+    PrizmaResultScreenProps,
+    | 'status'
+    | 'title'
+    | 'subtitle'
+    | 'glyph'
+    | 'ctaLabel'
+    | 'secondaryCtaLabel'
+    | 'verifiedLabel'
+    | 'navLabel'
+  > {
+  /** Module copy — this screen reads the `permission` slice. */
+  strings: GeolocationStrings;
+  /** Which second action the flow offers. Default `skip`. */
+  variant?: GeolocationPermissionVariant;
+  screenId?: string;
+  overrides?: PrizmaScreenOverrides;
+  onAction?: PrizmaScreenActionHandler;
+}
+
+/**
+ * Geolocation — "Allow location access", built on the Result archetype
+ * (GUIDELINES.md §6-F, `PrizmaResultScreen`).
+ *
+ * ONE screen for the two purple sections `Geolocation.AllowLocation` and
+ * `Geolocation.AllowLocation.quit`: the user declined the OS prompt, so the
+ * screen reports the blocked state (warning mark → title → subtitle) and offers
+ * to open the OS settings. They differ only in the second action — skip the
+ * step, or quit the process — which is a copy variant, not a second screen.
+ *
+ * The warning mark is Core's outline status icon, not the module Figma's filled
+ * amber disc: the outline sweep of 2026-07-28 settled that for every module
+ * (DEVIATIONS #15, #DC-34).
+ *
+ * Figma draws the filled primary ABOVE the outlined second action on both
+ * sections ("Open settings" over "Skip this step" / "Quit process"); archetype F
+ * stacks the secondary first (`ResultScreen.tsx`), so these two screens ship
+ * inverted against their frames. The archetype owns the order and no module
+ * re-declares it — archetype F needs a `ctaOrder` slot alongside the
+ * `ctaOrientation` it already has. ESCALATED, NOT RESOLVED: DEVIATIONS.md still
+ * has no Geolocation section, so there is no ruling to cite yet.
+ */
+export const GeolocationPermissionScreen = forwardRef<
+  HTMLDivElement,
+  GeolocationPermissionScreenProps
+>(
+  (
+    {
+      strings,
+      variant = 'skip',
+      screenId = `geolocation-permission-${variant}`,
+      overrides,
+      onAction,
+      ...shell
+    },
+    ref,
+  ) => (
+    <PrizmaResultScreen
+      ref={ref}
+      status="warning"
+      title={strings.permission.title}
+      subtitle={strings.permission.subtitle}
+      ctaLabel={strings.permission.ctaLabel}
+      secondaryCtaLabel={
+        variant === 'quit' ? strings.permission.quitLabel : strings.permission.skipLabel
+      }
+      verifiedLabel={strings.verifiedLabel}
+      navLabel={strings.navLabel}
+      screenId={screenId}
+      overrides={overrides}
+      onAction={onAction}
+      {...shell}
+    />
+  ),
+);
+GeolocationPermissionScreen.displayName = 'GeolocationPermissionScreen';
+
+export default GeolocationPermissionScreen;

package/src/GeolocationStrings.ts

@@ -0,0 +1,193 @@
+// Geolocation — copy contract.
+//
+// Figma: `📍 Geolocation - Screens specs + Localization` and
+// `📍 Geolocation 🌐 Web - Allow location - Screens specs + Localization`
+// (xg1t3GnUS95A4bLrM3lyOG, page 2002:1727). The two parent groups hold these
+// purple sections:
+//
+//   geolocation.default                  — the location request intro
+//   geolocation.permission               — the NATIVE iOS permission alert (not built, see below)
+//   Geolocation.AllowLocation            — permission refused, "Skip this step"
+//   Geolocation.AllowLocation.quit       — permission refused, "Quit process"
+//   Geolocation.continue                 — located, shows the resolved place
+//   Geolocation.error.locationUnavailable— signal too weak, retry
+//   Geolocation.error.quit               — attempts exhausted, step is required
+//   Geolocation.error.skip               — attempts exhausted, step is optional
+//   Geolocation.error.noNetwork          — the connectivity family every module carries
+//   Geolocation.allowLocation.<browser>  — nine per-browser "turn location on" step lists
+//
+// `geolocation.permission` is the iOS system alert ("Allow 'Incode' to use your
+// location?" over a live Apple Maps tile) drawn as flow documentation. It is not
+// a Prizma surface: none of its chrome exists in Core and rebuilding it would
+// mean inventing primitives and shipping platform rasters — both forbidden
+// (rule 1, GUIDELINES §10). Same call as ID Capture's OS dialogs (DEVIATIONS
+// #IDC-26) and Document Capture's iOS action sheets (#DC-20).
+//
+// No hardcoded English anywhere in a screen: every visible string arrives here,
+// so the host's locale pack drives the module (the file ships ES + PT columns).
+
+/**
+ * The two intro sections. Same layout — title block, geolocation illustration,
+ * one CTA — so they are states of one screen rather than two screens:
+ * - `request` — `geolocation.default`, location not yet known (inactive artwork)
+ * - `located` — `Geolocation.continue`, the resolved place in the subtitle
+ *   (active artwork: brand pin dropped on the map)
+ */
+export type GeolocationIntroState = 'request' | 'located';
+
+/**
+ * The `Geolocation.AllowLocation*` sections. Identical screens except for the
+ * second action: the flow either lets the user skip the step or forces a quit.
+ */
+export type GeolocationPermissionVariant = 'skip' | 'quit';
+
+/**
+ * The `Geolocation.error.*` sections.
+ * - `locationUnavailable` — weak signal, retry is offered
+ * - `quit`                — attempts exhausted and the step is required
+ * - `skip`                — attempts exhausted but the step is optional
+ * - `noNetwork`           — the connectivity family (Wi-Fi glyph, DEVIATIONS #10)
+ */
+export type GeolocationErrorVariant =
+  | 'locationUnavailable'
+  | 'quit'
+  | 'skip'
+  | 'noNetwork';
+
+/**
+ * The nine `Geolocation.allowLocation.*` sections of the Web group. Each is the
+ * same screen with a different step list, because "turn location back on" is a
+ * different journey in every browser.
+ *
+ * `samsungAndroid` is the section Figma labels `…web.opera.Android` a second
+ * time (4936:72487): its rows read "Sites and downloads" / "Site permissions"
+ * and its return row draws the Samsung Internet mark, so it is Samsung Internet,
+ * not a second Opera. Named for what it draws.
+ */
+export type GeolocationBrowser =
+  | 'safariIos'
+  | 'chromeIos'
+  | 'firefoxIos'
+  | 'operaIos'
+  | 'chromeAndroid'
+  | 'firefoxAndroid'
+  | 'operaAndroid'
+  | 'samsungAndroid'
+  | 'unrecognizedAndroid';
+
+/**
+ * What a browser step is ABOUT, not what glyph it draws. The screen owns the
+ * kind → canonical bank icon map so no host ever passes artwork, and so the
+ * substitutions live in exactly one place (DEVIATIONS #DC-23 precedent — Figma
+ * draws OS/browser chrome the Prizma icon bank does not ship).
+ */
+export type GeolocationStepKind =
+  /** The browser's address bar (Safari's "AA" control). */
+  | 'addressBar'
+  /** The ⋮ / ⋯ overflow menu. */
+  | 'menu'
+  /** A settings screen (browser settings, site settings). */
+  | 'settings'
+  /** A permissions list. */
+  | 'permissions'
+  /** The location permission itself. */
+  | 'location'
+  /** The device's own Settings app. */
+  | 'device'
+  /** The app list / app drawer. */
+  | 'apps'
+  /** "Return here and refresh" — Figma draws the browser's own logo. */
+  | 'return';
+
+/** One row of a browser's step list. */
+export interface GeolocationStep {
+  /** Chooses the leading canonical icon. Never artwork. */
+  kind: GeolocationStepKind;
+  /**
+   * The whole instruction as one line. Figma bolds the actionable fragment
+   * inside the sentence; Core's row title is a plain `string`, so the emphasis
+   * is not expressible — reported, not worked around (see the screen's docs).
+   */
+  label: string;
+}
+
+/** One browser's slice of the step-list screen. */
+export interface GeolocationBrowserSteps {
+  /**
+   * The browser name under the title ("Safari", "Chrome · Android"). Figma
+   * draws it on the Safari section only and leaves the other eight to identify
+   * themselves through artwork — each section's last row leads with that
+   * browser's own logo. Prizma never bundles brand rasters (rule 1,
+   * GUIDELINES §10), so without a label those sections are indistinguishable:
+   * `…chrome.iOS`, `…firefox.iOS` and `…chrome.android` carry the same four
+   * rows and would render as one screen three times. Every browser therefore
+   * SHOULD carry a label, extending the precedent Figma itself sets on Safari.
+   * Still optional so a host that ships its own logo artwork can drop it.
+   */
+  label?: string;
+  /** The steps, in order. */
+  steps: GeolocationStep[];
+}
+
+export interface GeolocationStrings {
+  /** "verified by" attribution in the footer tag. */
+  verifiedLabel: string;
+  /** Accessible name for the logo nav row. */
+  navLabel?: string;
+
+  /** geolocation.default + Geolocation.continue */
+  intro: {
+    /** `geolocation.default` — "We need to determine your current location". */
+    request: {
+      title: string;
+      subtitle?: string;
+      /** Primary CTA ("Continue"). */
+      ctaLabel: string;
+    };
+    /**
+     * `Geolocation.continue` — "You are currently in:". The place itself
+     * ("Mexico City, Mexico") is runtime data, not copy: it arrives as the
+     * screen's `location` prop and lands in the subtitle. `subtitle` here is the
+     * fallback for hosts that have no resolved place to show.
+     */
+    located: {
+      title: string;
+      subtitle?: string;
+      ctaLabel: string;
+    };
+  };
+
+  /** Geolocation.AllowLocation + Geolocation.AllowLocation.quit */
+  permission: {
+    /** H2 ("Allow location access"). */
+    title: string;
+    /** H5 ("to complete the process"). */
+    subtitle?: string;
+    /** Primary CTA ("Open settings"). */
+    ctaLabel: string;
+    /** Second action on the `skip` variant ("Skip this step"). */
+    skipLabel: string;
+    /** Second action on the `quit` variant ("Quit process"). */
+    quitLabel: string;
+  };
+
+  /** Geolocation.allowLocation.<browser> — the Web group's nine sections. */
+  browserSteps: {
+    /** H2, shared by all nine ("Follow the next steps to allow Incode to access your location"). */
+    title: string;
+    /** Primary CTA ("Refresh page"). */
+    ctaLabel: string;
+    /** Second action ("Skip this step"). Omit on flows where the step is required. */
+    skipLabel?: string;
+    /** One entry per browser. */
+    browsers: Record<GeolocationBrowser, GeolocationBrowserSteps>;
+  };
+
+  /** Geolocation.error.* — one slice per variant. */
+  error: {
+    locationUnavailable: { title: string; subtitle?: string; ctaLabel: string };
+    quit: { title: string; subtitle?: string; ctaLabel: string };
+    skip: { title: string; subtitle?: string; ctaLabel: string };
+    noConnection: { title: string; subtitle?: string; ctaLabel: string };
+  };
+}