@incodetech/prizma-core-screens 0.1.0

package/dist/GeolocationErrorScreen.js

@@ -0,0 +1,56 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import { IconWifiOff } from '@incodetech/prizma-core-icons';
+import { PrizmaResultScreen } from './ResultScreen';
+import './ScreenLayout.css';
+/**
+ * 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(({ 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 (_jsx(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 ? (_jsx("span", { className: [
+                'prizma-screen-layout__glyph',
+                'prizma-screen-layout__glyph--negative',
+                overrides?.align === 'left' ? 'prizma-screen-layout__glyph--left' : '',
+            ]
+                .filter(Boolean)
+                .join(' '), children: _jsx(IconWifiOff, { size: "l" }) })) : 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/dist/GeolocationIntroScreen.d.ts

@@ -0,0 +1,49 @@
+import React, { type ReactNode } from 'react';
+import { 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 declare const GeolocationIntroScreen: React.ForwardRefExoticComponent<GeolocationIntroScreenProps & React.RefAttributes<HTMLDivElement>>;
+export default GeolocationIntroScreen;

package/dist/GeolocationIntroScreen.js

@@ -0,0 +1,38 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import { PrizmaIllustrationGeolocation } from '@incodetech/prizma-core-web/illustration-geolocation';
+import { PrizmaTutorialScreen } from './TutorialScreen';
+import './ScreenLayout.css';
+/**
+ * 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(({ 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 (_jsx(PrizmaTutorialScreen, { ref: ref, title: copy.title, subtitle: located ? (location ?? copy.subtitle) : copy.subtitle, ctaLabel: copy.ctaLabel, illustration: illustration ?? _jsx(PrizmaIllustrationGeolocation, { active: located, decorative: true }), verifiedLabel: strings.verifiedLabel, navLabel: strings.navLabel, screenId: screenId, overrides: overrides, onAction: onAction, ...shell }));
+});
+GeolocationIntroScreen.displayName = 'GeolocationIntroScreen';
+export default GeolocationIntroScreen;

package/dist/GeolocationPermissionScreen.d.ts

@@ -0,0 +1,38 @@
+import React from 'react';
+import { 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 declare const GeolocationPermissionScreen: React.ForwardRefExoticComponent<GeolocationPermissionScreenProps & React.RefAttributes<HTMLDivElement>>;
+export default GeolocationPermissionScreen;

package/dist/GeolocationPermissionScreen.js

@@ -0,0 +1,30 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import { PrizmaResultScreen } from './ResultScreen';
+import './ScreenLayout.css';
+/**
+ * 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(({ strings, variant = 'skip', screenId = `geolocation-permission-${variant}`, overrides, onAction, ...shell }, ref) => (_jsx(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/dist/GeolocationStrings.d.ts

@@ -0,0 +1,157 @@
+/**
+ * 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;
+        };
+    };
+}

package/dist/GeolocationStrings.js

@@ -0,0 +1,28 @@
+// 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).
+export {};

package/dist/IdCaptureAgeVerificationScreen.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { type PrizmaListScreenProps } from './ListScreen';
+import type { PrizmaScreenActionHandler, PrizmaScreenOverrides } from './types';
+import type { IdCaptureStrings } from './IdCaptureStrings';
+import './ScreenLayout.css';
+export interface IdCaptureAgeVerificationScreenProps extends Omit<PrizmaListScreenProps, 'title' | 'subtitle' | 'children' | 'ctaLabel' | 'verifiedLabel' | 'navLabel'> {
+    /** Module copy — this screen reads the `ageVerification` slice. */
+    strings: IdCaptureStrings;
+    screenId?: string;
+    overrides?: PrizmaScreenOverrides;
+    onAction?: PrizmaScreenActionHandler;
+}
+/**
+ * ID Capture — age-verification consent, built on the `PrizmaListScreen`
+ * archetype (GUIDELINES.md §6-G).
+ * Figma: purple section `1-1-2-id` of the `Age verification` group.
+ *
+ * Logo nav → Title → three reassurance rows → CTA → verified tag. The rows are
+ * Core's `PrizmaCardListCommonIssues` (Figma `list-unordered`), so the row
+ * geometry, the icon slot and the title/description typography are Core's, and
+ * the Spacing/24 under the title block is the archetype's — this file used to
+ * declare it as `.id-capture-info-list` (deleted; #F-31).
+ */
+export declare const IdCaptureAgeVerificationScreen: React.ForwardRefExoticComponent<IdCaptureAgeVerificationScreenProps & React.RefAttributes<HTMLDivElement>>;
+export default IdCaptureAgeVerificationScreen;

package/dist/IdCaptureAgeVerificationScreen.js

@@ -0,0 +1,38 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import { IconCalendar, IconIdFrontScan, IconLockCheck } from '@incodetech/prizma-core-icons';
+import { PrizmaCardListCommonIssues } from '@incodetech/prizma-core-web/card-list';
+import { PrizmaListScreen } from './ListScreen';
+import './ScreenLayout.css';
+/**
+ * The three rows' leading icons, in the order the purple section lists them:
+ * scan the ID · we only read the date of birth · the rest is deleted. From the
+ * canonical bank only (§10) — Figma draws small ID-card thumbnails, which the
+ * 24px `Icon/Size/m` row slot of Core's redesigned list does not take.
+ * DEVIATIONS.md #IDC-24.
+ */
+const ROW_ICONS = [
+    _jsx(IconIdFrontScan, { size: "m" }, "scan"),
+    _jsx(IconCalendar, { size: "m" }, "dob"),
+    _jsx(IconLockCheck, { size: "m" }, "privacy"),
+];
+/**
+ * ID Capture — age-verification consent, built on the `PrizmaListScreen`
+ * archetype (GUIDELINES.md §6-G).
+ * Figma: purple section `1-1-2-id` of the `Age verification` group.
+ *
+ * Logo nav → Title → three reassurance rows → CTA → verified tag. The rows are
+ * Core's `PrizmaCardListCommonIssues` (Figma `list-unordered`), so the row
+ * geometry, the icon slot and the title/description typography are Core's, and
+ * the Spacing/24 under the title block is the archetype's — this file used to
+ * declare it as `.id-capture-info-list` (deleted; #F-31).
+ */
+export const IdCaptureAgeVerificationScreen = forwardRef(({ strings, screenId = 'id-capture-age-verification', overrides, onAction, ...shell }, ref) => (_jsx(PrizmaListScreen, { ref: ref, title: strings.ageVerification.title, subtitle: strings.ageVerification.subtitle, ctaLabel: strings.ageVerification.ctaLabel, verifiedLabel: strings.verifiedLabel, navLabel: strings.navLabel, screenId: screenId, overrides: overrides, onAction: onAction, ...shell, children: _jsx(PrizmaCardListCommonIssues, { items: strings.ageVerification.rows.map((row, i) => ({
+            icon: ROW_ICONS[i % ROW_ICONS.length],
+            title: row.title,
+            subtitle: row.description,
+            showSubtitle: Boolean(row.description),
+        })) }) })));
+IdCaptureAgeVerificationScreen.displayName = 'IdCaptureAgeVerificationScreen';
+export default IdCaptureAgeVerificationScreen;

package/dist/IdCaptureAnalyzingScreen.d.ts

@@ -0,0 +1,41 @@
+import React, { type ReactNode } from 'react';
+import { type PrizmaScreenShellProps } from './ScreenShell';
+import type { PrizmaScreenActionHandler, PrizmaScreenOverrides } from './types';
+import type { IdCaptureDocumentType, IdCaptureStrings } from './IdCaptureStrings';
+import './ScreenLayout.css';
+import './IdCaptureLayout.css';
+export interface IdCaptureAnalyzingScreenProps extends Omit<PrizmaScreenShellProps, 'dark' | 'title' | 'children'> {
+    /** Module copy — this screen reads the `analyzing` slice. */
+    strings: IdCaptureStrings;
+    /** Which document was captured — Core `PrizmaIdCapture.type`. */
+    documentType?: IdCaptureDocumentType;
+    /** Portrait document orientation — the `↕️ vertical` groups. */
+    vertical?: boolean;
+    /** How far along the upload/analysis is, 0–100 (Core `PrizmaLoadingBar`). */
+    progress?: number;
+    /** The captured document still (<img>) being analyzed. */
+    still?: ReactNode;
+    screenId?: string;
+    overrides?: PrizmaScreenOverrides;
+    onAction?: PrizmaScreenActionHandler;
+}
+/**
+ * ID Capture — analyzing the captured still.
+ * Figma: purple sections `1-9-1` / `1-9-2-id-analyzing`,
+ * `1-16-1` / `1-16-2-id-back-analyzing`, `3-9-1-id-passport-analyzing`,
+ * `2-9-1-id-vertical-analyzing`, `4-9-1-id-passport-vertical-analyzing`.
+ *
+ * NOT the Processing archetype (§6-C) and not a spinner screen: every purple
+ * analyzing section puts a `Loading bar` + its status line in the SAME top band
+ * the Title occupies on the result screens, with the still below it in the
+ * capture frame — the identical three-band recipe (see `IdCaptureLayout.css`),
+ * so the screen is the result layout with the Title swapped for the bar. Core
+ * owns both halves: `PrizmaLoadingBar` draws the track, the fill and the status
+ * title, and `PrizmaIdCapture`'s `analyzing` state draws the positive frame and
+ * the sweep over the still.
+ *
+ * The bar's `state="analyzing"` is what tints the fill; the screen never picks
+ * a colour of its own.
+ */
+export declare const IdCaptureAnalyzingScreen: React.ForwardRefExoticComponent<IdCaptureAnalyzingScreenProps & React.RefAttributes<HTMLDivElement>>;
+export default IdCaptureAnalyzingScreen;

package/dist/IdCaptureAnalyzingScreen.js

@@ -0,0 +1,30 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import { PrizmaLoadingBar } from '@incodetech/prizma-core-web/loading-bar';
+import { PrizmaIdCapture } from '@incodetech/prizma-core-web/id-capture';
+import { PrizmaTag } from '@incodetech/prizma-core-web/tag';
+import { PrizmaScreenShell } from './ScreenShell';
+import './ScreenLayout.css';
+import './IdCaptureLayout.css';
+/**
+ * ID Capture — analyzing the captured still.
+ * Figma: purple sections `1-9-1` / `1-9-2-id-analyzing`,
+ * `1-16-1` / `1-16-2-id-back-analyzing`, `3-9-1-id-passport-analyzing`,
+ * `2-9-1-id-vertical-analyzing`, `4-9-1-id-passport-vertical-analyzing`.
+ *
+ * NOT the Processing archetype (§6-C) and not a spinner screen: every purple
+ * analyzing section puts a `Loading bar` + its status line in the SAME top band
+ * the Title occupies on the result screens, with the still below it in the
+ * capture frame — the identical three-band recipe (see `IdCaptureLayout.css`),
+ * so the screen is the result layout with the Title swapped for the bar. Core
+ * owns both halves: `PrizmaLoadingBar` draws the track, the fill and the status
+ * title, and `PrizmaIdCapture`'s `analyzing` state draws the positive frame and
+ * the sweep over the still.
+ *
+ * The bar's `state="analyzing"` is what tints the fill; the screen never picks
+ * a colour of its own.
+ */
+export const IdCaptureAnalyzingScreen = forwardRef(({ strings, documentType = 'id', vertical = false, progress = 30, still, screenId = 'id-capture-analyzing', overrides, onAction, ...shell }, ref) => (_jsxs(PrizmaScreenShell, { ref: ref, ...shell, children: [_jsxs("div", { className: "prizma-screen-layout__content prizma-screen-layout__content--no-nav id-capture-on-surface", children: [_jsx("div", { className: "id-capture-band id-capture-band--top", children: _jsx(PrizmaLoadingBar, { progress: progress, state: "analyzing", showTitle: true, title: strings.analyzing.title }) }), _jsx(PrizmaIdCapture, { type: documentType, state: "analyzing", isVertical: vertical, mode: "overlay", encryptedLabel: strings.encryptedLabel, still: still }), _jsx("div", { className: "id-capture-band" })] }), _jsx("div", { className: "prizma-screen-layout__footer", children: _jsx(PrizmaTag, { label: strings.verifiedLabel }) })] })));
+IdCaptureAnalyzingScreen.displayName = 'IdCaptureAnalyzingScreen';
+export default IdCaptureAnalyzingScreen;

package/dist/IdCaptureCommonIssuesScreen.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+import { type PrizmaListScreenProps } from './ListScreen';
+import type { PrizmaScreenActionHandler, PrizmaScreenOverrides } from './types';
+import type { IdCaptureStrings } from './IdCaptureStrings';
+import './ScreenLayout.css';
+export interface IdCaptureCommonIssuesScreenProps extends Omit<PrizmaListScreenProps, 'title' | 'children' | 'glyph' | 'ctaLabel' | 'linkLabel' | 'verifiedLabel' | 'navLabel'> {
+    /** Module copy — this screen reads the `commonIssues` slice. */
+    strings: IdCaptureStrings;
+    screenId?: string;
+    overrides?: PrizmaScreenOverrides;
+    onAction?: PrizmaScreenActionHandler;
+}
+/**
+ * ID Capture — the "Common issues" help screen the stage's "?" opens, built on
+ * the `PrizmaListScreen` archetype (GUIDELINES.md §6-G).
+ * Figma: purple section `1-5-2-id-common-issues` of the front-side group.
+ *
+ * Glyph → Title → three explanatory rows → a tertiary link that switches to
+ * manual capture → the retry CTA. `showHeader={false}` keeps the section's
+ * logo-free chrome while still reserving the nav row, so every offset matches the
+ * rest of the module (owner rule 2026-08-18).
+ *
+ * Figma draws the header glyph as a filled 64px dark disc with a white question
+ * mark. Core's icon bank ships the OUTLINE question-circle and there is no
+ * filled-disc primitive, so the glyph is the bank icon in the archetype's
+ * non-status glyph slot at Title/Icon/Size — the same resolution the Face
+ * Capture pilot reached for its Wi-Fi glyph (DEVIATIONS.md #10) and the same
+ * outline-over-filled rule as the status marks (#15). DEVIATIONS.md #IDC-25.
+ */
+export declare const IdCaptureCommonIssuesScreen: React.ForwardRefExoticComponent<IdCaptureCommonIssuesScreenProps & React.RefAttributes<HTMLDivElement>>;
+export default IdCaptureCommonIssuesScreen;

package/dist/IdCaptureCommonIssuesScreen.js

@@ -0,0 +1,49 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import { IconBankCardSearch, IconHide, IconImage, IconQuestionCircle, } from '@incodetech/prizma-core-icons';
+import { PrizmaCardListCommonIssues } from '@incodetech/prizma-core-web/card-list';
+import { PrizmaListScreen } from './ListScreen';
+import './ScreenLayout.css';
+/**
+ * The three rows' leading icons, in the order the purple section lists them:
+ * glare present · blur present · info is not readable. Canonical bank only
+ * (§10); the closest bank glyphs to Figma's drawings are the image mark, the
+ * crossed-out eye and the card-with-magnifier.
+ */
+const ROW_ICONS = [
+    _jsx(IconImage, { size: "m" }, "glare"),
+    _jsx(IconHide, { size: "m" }, "blur"),
+    _jsx(IconBankCardSearch, { size: "m" }, "readable"),
+];
+/**
+ * ID Capture — the "Common issues" help screen the stage's "?" opens, built on
+ * the `PrizmaListScreen` archetype (GUIDELINES.md §6-G).
+ * Figma: purple section `1-5-2-id-common-issues` of the front-side group.
+ *
+ * Glyph → Title → three explanatory rows → a tertiary link that switches to
+ * manual capture → the retry CTA. `showHeader={false}` keeps the section's
+ * logo-free chrome while still reserving the nav row, so every offset matches the
+ * rest of the module (owner rule 2026-08-18).
+ *
+ * Figma draws the header glyph as a filled 64px dark disc with a white question
+ * mark. Core's icon bank ships the OUTLINE question-circle and there is no
+ * filled-disc primitive, so the glyph is the bank icon in the archetype's
+ * non-status glyph slot at Title/Icon/Size — the same resolution the Face
+ * Capture pilot reached for its Wi-Fi glyph (DEVIATIONS.md #10) and the same
+ * outline-over-filled rule as the status marks (#15). DEVIATIONS.md #IDC-25.
+ */
+export const IdCaptureCommonIssuesScreen = forwardRef(({ strings, screenId = 'id-capture-common-issues', showHeader = false, overrides, onAction, ...shell }, ref) => (_jsx(PrizmaListScreen, { ref: ref, showHeader: showHeader, glyph: _jsx("span", { className: [
+            'prizma-screen-layout__glyph',
+            'prizma-screen-layout__glyph--neutral',
+            overrides?.align === 'left' ? 'prizma-screen-layout__glyph--left' : '',
+        ]
+            .filter(Boolean)
+            .join(' '), children: _jsx(IconQuestionCircle, { size: "l" }) }), title: strings.commonIssues.title, ctaLabel: strings.commonIssues.ctaLabel, linkLabel: strings.commonIssues.manualLabel, verifiedLabel: strings.verifiedLabel, navLabel: strings.navLabel, screenId: screenId, overrides: overrides, onAction: onAction, ...shell, children: _jsx(PrizmaCardListCommonIssues, { items: strings.commonIssues.rows.map((row, i) => ({
+            icon: ROW_ICONS[i % ROW_ICONS.length],
+            title: row.title,
+            subtitle: row.description,
+            showSubtitle: Boolean(row.description),
+        })) }) })));
+IdCaptureCommonIssuesScreen.displayName = 'IdCaptureCommonIssuesScreen';
+export default IdCaptureCommonIssuesScreen;