@plantops/ui 0.1.0

package/dist/feedback/error-copy.d.ts

@@ -0,0 +1,38 @@
+/**
+ * What each `IamErrorCode` says to a person (Doc 06 §2 → the screen).
+ *
+ * The server's `message` is written for an operator reading a log: accurate,
+ * terse, and occasionally about a constraint name. This is the other half —
+ * what an admin should be told and, more usefully, what they should do next.
+ * It lives in `libs/ui` because it is copy, and copy is part of the design
+ * language: the gatepass console must not invent a second, differently-worded
+ * explanation of a 403.
+ *
+ * Two rules the table obeys, both from the spec rather than from taste:
+ *
+ * - **A denial never speculates about what exists.** Doc 06 §2 requires that a
+ *   403 not reveal whether the target exists in another tenant, and copy is
+ *   exactly where that leaks: "this role belongs to another client" would say
+ *   out loud what the status code was careful not to.
+ * - **`ACCOUNT_LOCKED` gets its own words.** Doc 03 §8 makes 423 a distinct
+ *   state with a distinct remedy — an administrator unlocks it; retrying the
+ *   password never will — and Doc 09's login screen is required to say so
+ *   rather than folding it into "sign-in failed".
+ */
+import { IamErrorCode } from '@plantops/contracts';
+/** How prominently a failure should be shown. */
+export type ErrorTone = 'error' | 'warning' | 'info';
+export interface ErrorCopy {
+    /** Headline. A statement of what happened, never an apology. */
+    title: string;
+    /** One or two sentences: what it means, and what to do. */
+    description: string;
+    tone: ErrorTone;
+    /** Whether repeating the same request could plausibly succeed. */
+    retryable: boolean;
+}
+/** Copy for a request that never reached the API at all. */
+export declare const TRANSPORT_ERROR_COPY: ErrorCopy;
+/** The copy for a code. Unknown codes fall back to the transport wording. */
+export declare function errorCopyFor(code: IamErrorCode | null | undefined): ErrorCopy;
+//# sourceMappingURL=error-copy.d.ts.map

package/dist/feedback/error-copy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-copy.d.ts","sourceRoot":"","sources":["../../src/feedback/error-copy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD,iDAAiD;AACjD,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAErD,MAAM,WAAW,SAAS;IACxB,gEAAgE;IAChE,KAAK,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,SAAS,CAAC;IAChB,kEAAkE;IAClE,SAAS,EAAE,OAAO,CAAC;CACpB;AAuED,4DAA4D;AAC5D,eAAO,MAAM,oBAAoB,EAAE,SAMjC,CAAC;AAEH,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,GAAG,SAAS,GAAG,SAAS,CAG7E"}

package/dist/feedback/error-copy.js

@@ -0,0 +1,97 @@
+/**
+ * What each `IamErrorCode` says to a person (Doc 06 §2 → the screen).
+ *
+ * The server's `message` is written for an operator reading a log: accurate,
+ * terse, and occasionally about a constraint name. This is the other half —
+ * what an admin should be told and, more usefully, what they should do next.
+ * It lives in `libs/ui` because it is copy, and copy is part of the design
+ * language: the gatepass console must not invent a second, differently-worded
+ * explanation of a 403.
+ *
+ * Two rules the table obeys, both from the spec rather than from taste:
+ *
+ * - **A denial never speculates about what exists.** Doc 06 §2 requires that a
+ *   403 not reveal whether the target exists in another tenant, and copy is
+ *   exactly where that leaks: "this role belongs to another client" would say
+ *   out loud what the status code was careful not to.
+ * - **`ACCOUNT_LOCKED` gets its own words.** Doc 03 §8 makes 423 a distinct
+ *   state with a distinct remedy — an administrator unlocks it; retrying the
+ *   password never will — and Doc 09's login screen is required to say so
+ *   rather than folding it into "sign-in failed".
+ */
+import { IamErrorCode } from '@plantops/contracts';
+const COPY = Object.freeze({
+    [IamErrorCode.VALIDATION_FAILED]: {
+        title: 'Check the highlighted fields',
+        description: 'Some values were rejected. Correct them and submit again.',
+        tone: 'warning',
+        retryable: false,
+    },
+    [IamErrorCode.AUTH_REQUIRED]: {
+        title: 'Your session has ended',
+        description: 'Sign in again to continue.',
+        tone: 'info',
+        retryable: false,
+    },
+    [IamErrorCode.INVALID_CREDENTIALS]: {
+        title: 'Sign-in failed',
+        description: 'That email and password combination was not accepted for this client. Check the client, the address and the password, then try again.',
+        tone: 'error',
+        retryable: true,
+    },
+    [IamErrorCode.PERMISSION_DENIED]: {
+        title: 'You do not have access to this',
+        description: 'Your roles do not include the permission this screen needs. An administrator can grant it by binding you to a role that carries it.',
+        tone: 'warning',
+        retryable: false,
+    },
+    [IamErrorCode.SCOPE_DENIED]: {
+        title: 'Not permitted here',
+        description: 'You hold this permission, but not at a place in the organisation that covers what you are trying to reach. Access follows the org tree — ask for a binding higher up, or at the right node.',
+        tone: 'warning',
+        retryable: false,
+    },
+    [IamErrorCode.NOT_FOUND]: {
+        title: 'Not found',
+        description: 'This item no longer exists, or you cannot reach it.',
+        tone: 'info',
+        retryable: false,
+    },
+    [IamErrorCode.CONFLICT]: {
+        title: 'That conflicts with something already there',
+        description: 'A record with these details already exists, or the change would break a rule the server enforces. The details below say which.',
+        tone: 'warning',
+        retryable: false,
+    },
+    [IamErrorCode.ACCOUNT_LOCKED]: {
+        title: 'This account is locked',
+        description: 'Too many failed sign-in attempts, or an administrator locked it. Signing in will keep failing until an administrator unlocks the account — a password reset will not clear the lock.',
+        tone: 'error',
+        retryable: false,
+    },
+    [IamErrorCode.RATE_LIMITED]: {
+        title: 'Too many requests',
+        description: 'You have made too many attempts. Wait a moment and try again.',
+        tone: 'warning',
+        retryable: true,
+    },
+    [IamErrorCode.INTERNAL_ERROR]: {
+        title: 'Something went wrong on the server',
+        description: 'The request did not complete. If it keeps happening, quote the request id below to whoever runs this deployment.',
+        tone: 'error',
+        retryable: true,
+    },
+});
+/** Copy for a request that never reached the API at all. */
+export const TRANSPORT_ERROR_COPY = Object.freeze({
+    title: 'Could not reach the server',
+    description: 'The request did not get an answer — the network, a proxy, or the service being down. Check your connection and try again.',
+    tone: 'error',
+    retryable: true,
+});
+/** The copy for a code. Unknown codes fall back to the transport wording. */
+export function errorCopyFor(code) {
+    if (code == null)
+        return TRANSPORT_ERROR_COPY;
+    return COPY[code] ?? TRANSPORT_ERROR_COPY;
+}

package/dist/feedback/page-header.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+export interface PageHeaderProps {
+    title: React.ReactNode;
+    /** One sentence on what the screen is for. Worth writing. */
+    description?: React.ReactNode;
+    /** Trail above the title. Last entry is the current screen. */
+    breadcrumbs?: {
+        title: React.ReactNode;
+        href?: string;
+    }[];
+    /** Right-hand actions — normally one primary button and a menu. */
+    actions?: React.ReactNode;
+    /** Tabs or filters that belong to the header rather than the body. */
+    footer?: React.ReactNode;
+}
+export declare function PageHeader({ title, description, breadcrumbs, actions, footer, }: PageHeaderProps): React.ReactElement;
+//# sourceMappingURL=page-header.d.ts.map

package/dist/feedback/page-header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-header.d.ts","sourceRoot":"","sources":["../../src/feedback/page-header.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC;IACvB,6DAA6D;IAC7D,WAAW,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC9B,+DAA+D;IAC/D,WAAW,CAAC,EAAE;QAAE,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC1D,mEAAmE;IACnE,OAAO,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,sEAAsE;IACtE,MAAM,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC1B;AAED,wBAAgB,UAAU,CAAC,EACzB,KAAK,EACL,WAAW,EACX,WAAW,EACX,OAAO,EACP,MAAM,GACP,EAAE,eAAe,GAAG,KAAK,CAAC,YAAY,CAoCtC"}

package/dist/feedback/page-header.js

@@ -0,0 +1,23 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The top of every screen: what this is, and the actions that belong to it.
+ *
+ * A component rather than a convention because the *placement* of the primary
+ * action is what makes a console feel like one product. Doc 09 §4 also puts a
+ * requirement here that a hand-rolled header would keep forgetting: actions the
+ * subject lacks permission for are hidden, so the action slot has to be the
+ * kind of thing a caller can conditionally fill — hence `actions` as a node
+ * rather than a button spec.
+ */
+import { Breadcrumb, Space, Typography } from 'antd';
+import { spacing } from '../theme/tokens';
+export function PageHeader({ title, description, breadcrumbs, actions, footer, }) {
+    return (_jsxs("header", { style: { marginBlockEnd: spacing.lg }, children: [breadcrumbs !== undefined && breadcrumbs.length > 0 && (_jsx(Breadcrumb, { items: breadcrumbs, style: { marginBlockEnd: spacing.xs, fontSize: 12 } })), _jsxs("div", { style: {
+                    display: 'flex',
+                    alignItems: 'flex-start',
+                    justifyContent: 'space-between',
+                    gap: spacing.md,
+                    flexWrap: 'wrap',
+                }, children: [_jsxs("div", { style: { minWidth: 0 }, children: [_jsx(Typography.Title, { level: 3, style: { margin: 0, fontWeight: 600 }, children: title }), description !== undefined && (_jsx(Typography.Paragraph, { type: "secondary", style: { margin: `${spacing.xxs}px 0 0`, maxWidth: 720 }, children: description }))] }), actions !== undefined && _jsx(Space, { wrap: true, children: actions })] }), footer !== undefined && _jsx("div", { style: { marginBlockStart: spacing.md }, children: footer })] }));
+}

package/dist/feedback/state-panels.d.ts

@@ -0,0 +1,50 @@
+import * as React from 'react';
+import { type ErrorCopy } from './error-copy';
+export interface ScreenLoadingProps {
+    /** `'panel'` for a first paint, `'inline'` for a refresh inside a screen. */
+    variant?: 'panel' | 'inline';
+    /** Rows of skeleton text, for a variant that stands in for known content. */
+    rows?: number;
+    label?: string;
+}
+export declare function ScreenLoading({ variant, rows, label, }: ScreenLoadingProps): React.ReactElement;
+export interface ScreenEmptyProps {
+    title?: string;
+    description?: React.ReactNode;
+    /** The one thing to do about it — "Add the first user". */
+    action?: React.ReactNode;
+}
+export declare function ScreenEmpty({ title, description, action, }: ScreenEmptyProps): React.ReactElement;
+export interface ScreenErrorProps {
+    /** From `errorCopyFor(code)` — the words. */
+    copy: ErrorCopy;
+    /**
+     * The server's own message, shown under the copy when it adds something.
+     *
+     * Kept because a `CONFLICT` whose message names the duplicate field is far
+     * more useful than the generic sentence, and suppressed when it is only a
+     * restatement.
+     */
+    detail?: string | null;
+    /** Correlates with the server's logs and audit trail (Doc 06 §2). */
+    requestId?: string | null;
+    /** Field-level complaints from a `VALIDATION_FAILED`. */
+    details?: readonly {
+        field: string;
+        message: string;
+    }[];
+    /** Shown only when the failure is plausibly transient. */
+    onRetry?: () => void;
+    /** An escape route — "Back to the dashboard". */
+    action?: React.ReactNode;
+}
+/**
+ * A failed screen, explained.
+ *
+ * `requestId` is rendered in a monospace, selectable line rather than hidden in
+ * a console: it is the only handle an operator has for finding this exact
+ * failure in the server's logs and audit trail, and the person who can read it
+ * out is the one looking at the screen.
+ */
+export declare function ScreenError({ copy, detail, requestId, details, onRetry, action, }: ScreenErrorProps): React.ReactElement;
+//# sourceMappingURL=state-panels.d.ts.map

package/dist/feedback/state-panels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-panels.d.ts","sourceRoot":"","sources":["../../src/feedback/state-panels.tsx"],"names":[],"mappings":"AA0BA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,EAAE,KAAK,SAAS,EAAkB,MAAM,cAAc,CAAC;AAE9D,MAAM,WAAW,kBAAkB;IACjC,6EAA6E;IAC7E,OAAO,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;IAC7B,6EAA6E;IAC7E,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,aAAa,CAAC,EAC5B,OAAiB,EACjB,IAAQ,EACR,KAAK,GACN,EAAE,kBAAkB,GAAG,KAAK,CAAC,YAAY,CAgBzC;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC9B,2DAA2D;IAC3D,MAAM,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC1B;AAED,wBAAgB,WAAW,CAAC,EAC1B,KAA0B,EAC1B,WAAW,EACX,MAAM,GACP,EAAE,gBAAgB,GAAG,KAAK,CAAC,YAAY,CASvC;AAQD,MAAM,WAAW,gBAAgB;IAC/B,6CAA6C;IAC7C,IAAI,EAAE,SAAS,CAAC;IAChB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,qEAAqE;IACrE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,yDAAyD;IACzD,OAAO,CAAC,EAAE,SAAS;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACxD,0DAA0D;IAC1D,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,iDAAiD;IACjD,MAAM,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,EAC1B,IAAI,EACJ,MAAM,EACN,SAAS,EACT,OAAO,EACP,OAAO,EACP,MAAM,GACP,EAAE,gBAAgB,GAAG,KAAK,CAAC,YAAY,CAkDvC"}

package/dist/feedback/state-panels.js

@@ -0,0 +1,46 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The four things a screen shows when it is not showing data: loading, empty,
+ * denied, broken.
+ *
+ * Written once because they are the states screens get wrong. Left to each
+ * page, "denied" becomes a blank area, "empty" becomes a spinner that never
+ * stops, and the difference between "you have no users yet" and "you may not
+ * see users" — which are opposite messages with opposite next actions —
+ * disappears.
+ *
+ * {@link ScreenError} is the one that matters most. Doc 09 §4 requires the
+ * console to render a 403 cleanly on a deep link into a screen the menu hid,
+ * because client-side hiding is UX and the server is the enforcement. That is
+ * this component with the copy from `error-copy.ts`.
+ */
+import { ExclamationCircleOutlined, InboxOutlined, LockOutlined, ReloadOutlined, StopOutlined, } from '@ant-design/icons';
+import { Button, Result, Skeleton, Space, Spin, Typography } from 'antd';
+import { spacing } from '../theme/tokens';
+export function ScreenLoading({ variant = 'panel', rows = 4, label, }) {
+    if (variant === 'inline') {
+        return (_jsxs(Space, { size: "small", style: { padding: spacing.md }, children: [_jsx(Spin, { size: "small" }), label !== undefined && (_jsx(Typography.Text, { type: "secondary", children: label }))] }));
+    }
+    return (_jsx("div", { style: { padding: spacing.lg }, "aria-busy": "true", "aria-live": "polite", children: _jsx(Skeleton, { active: true, paragraph: { rows }, title: true }) }));
+}
+export function ScreenEmpty({ title = 'Nothing here yet', description, action, }) {
+    return (_jsx(Result, { icon: _jsx(InboxOutlined, { style: { color: 'var(--ant-color-text-quaternary)' } }), title: title, subTitle: description, extra: action }));
+}
+const TONE_ICON = {
+    error: _jsx(ExclamationCircleOutlined, { style: { color: 'var(--ant-color-error)' } }),
+    warning: _jsx(StopOutlined, { style: { color: 'var(--ant-color-warning)' } }),
+    info: _jsx(LockOutlined, { style: { color: 'var(--ant-color-info)' } }),
+};
+/**
+ * A failed screen, explained.
+ *
+ * `requestId` is rendered in a monospace, selectable line rather than hidden in
+ * a console: it is the only handle an operator has for finding this exact
+ * failure in the server's logs and audit trail, and the person who can read it
+ * out is the one looking at the screen.
+ */
+export function ScreenError({ copy, detail, requestId, details, onRetry, action, }) {
+    const showDetail = detail != null && detail.trim() !== '' && detail.trim() !== copy.description;
+    return (_jsx(Result, { icon: TONE_ICON[copy.tone], title: copy.title, subTitle: _jsxs(Space, { direction: "vertical", size: spacing.xs, style: { maxWidth: 620 }, children: [_jsx(Typography.Text, { type: "secondary", children: copy.description }), showDetail && (_jsx(Typography.Text, { type: "secondary", italic: true, children: detail })), details !== undefined && details.length > 0 && (_jsx("ul", { style: { margin: 0, paddingInlineStart: spacing.lg, textAlign: 'start' }, children: details.map((item) => (_jsx("li", { children: _jsxs(Typography.Text, { type: "secondary", children: [_jsx("strong", { children: item.field }), " \u2014 ", item.message] }) }, `${item.field}:${item.message}`))) })), requestId != null && requestId !== '' && (_jsxs(Typography.Text, { type: "secondary", copyable: { text: requestId }, style: { fontFamily: 'var(--ant-font-family-code)', fontSize: 12 }, children: ["Request ", requestId] }))] }), extra: _jsxs(Space, { children: [action, copy.retryable && onRetry !== undefined && (_jsx(Button, { icon: _jsx(ReloadOutlined, {}), onClick: onRetry, children: "Try again" }))] }) }));
+}

package/dist/forms/auth-layout.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+export interface AuthLayoutProps {
+    children: React.ReactNode;
+    /** The console's name, beside the mark — "IAM", "Gatepass". */
+    product?: string;
+    title?: string;
+    subtitle?: React.ReactNode;
+    /** Small print under the card — an environment badge, a support address. */
+    footer?: React.ReactNode;
+}
+export declare function AuthLayout({ children, product, title, subtitle, footer, }: AuthLayoutProps): React.ReactElement;
+//# sourceMappingURL=auth-layout.d.ts.map

package/dist/forms/auth-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-layout.d.ts","sourceRoot":"","sources":["../../src/forms/auth-layout.tsx"],"names":[],"mappings":"AAYA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAK/B,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,+DAA+D;IAC/D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B,4EAA4E;IAC5E,MAAM,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC1B;AAED,wBAAgB,UAAU,CAAC,EACzB,QAAQ,EACR,OAAO,EACP,KAAiB,EACjB,QAAQ,EACR,MAAM,GACP,EAAE,eAAe,GAAG,KAAK,CAAC,YAAY,CAyCtC"}

package/dist/forms/auth-layout.js

@@ -0,0 +1,28 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The page a signed-out person sees: a centred card on a branded field.
+ *
+ * Shared with the consoles that come later so that sign-in, password reset and
+ * "your session ended" all look like the same door into the same product. The
+ * card is the only thing on the page — an unauthenticated visitor has exactly
+ * one thing to do, and every additional element is a way to not do it.
+ */
+import { Card, Typography } from 'antd';
+import { Brand } from '../layout/brand';
+import { navSurface, palette, spacing } from '../theme/tokens';
+export function AuthLayout({ children, product, title = 'Sign in', subtitle, footer, }) {
+    return (_jsxs("main", { style: {
+            minHeight: '100vh',
+            display: 'flex',
+            flexDirection: 'column',
+            alignItems: 'center',
+            justifyContent: 'center',
+            gap: spacing.lg,
+            padding: spacing.lg,
+            // A single wash rather than an image: it renders identically on every
+            // deployment, costs no request, and cannot be the asset someone forgot
+            // to copy into the container.
+            background: `radial-gradient(1200px 600px at 50% -10%, ${palette.primary}22, transparent 60%), ${navSurface.background}`,
+        }, children: [_jsx(Brand, { product: product }), _jsxs(Card, { style: { width: '100%', maxWidth: 420 }, styles: { body: { padding: spacing.xl } }, children: [_jsx(Typography.Title, { level: 4, style: { marginBlockStart: 0 }, children: title }), subtitle !== undefined && (_jsx(Typography.Paragraph, { type: "secondary", style: { marginBlockEnd: spacing.lg }, children: subtitle })), children] }), footer !== undefined && (_jsx(Typography.Text, { style: { color: navSurface.text, fontSize: 12 }, children: footer }))] }));
+}

package/dist/forms/credentials-form.d.ts

@@ -0,0 +1,34 @@
+import * as React from 'react';
+import type { ErrorCopy } from '../feedback/error-copy';
+export interface CredentialsFormValues {
+    client_slug: string;
+    email: string;
+    password: string;
+}
+export interface CredentialsFormProps {
+    onSubmit: (values: CredentialsFormValues) => void | Promise<void>;
+    submitting?: boolean;
+    /** Shown above the fields. `null` clears it. */
+    error?: ErrorCopy | null;
+    /** The server's own sentence, under the copy, when it adds something. */
+    errorDetail?: string | null;
+    /** Pre-fills the tenant — from the last successful sign-in, or a subdomain. */
+    defaultClientSlug?: string;
+    /**
+     * Hides the tenant field, for a deployment that serves one organisation
+     * (Doc 11 §6.5).
+     *
+     * The value is still submitted — as a hidden field carrying
+     * `defaultClientSlug` — because the tenant half of the credential has not gone
+     * anywhere, it simply is not the user's to choose. Hiding it is where the
+     * change ends: the API refuses a login that names a different organisation
+     * whether or not the form ever showed a box, which is what makes this a UX
+     * decision rather than a control.
+     */
+    hideClientField?: boolean;
+    /** e.g. a "Forgot password?" link. Rendered under the submit button. */
+    footer?: React.ReactNode;
+    submitLabel?: string;
+}
+export declare function CredentialsForm({ onSubmit, submitting, error, errorDetail, defaultClientSlug, hideClientField, footer, submitLabel, }: CredentialsFormProps): React.ReactElement;
+//# sourceMappingURL=credentials-form.d.ts.map

package/dist/forms/credentials-form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credentials-form.d.ts","sourceRoot":"","sources":["../../src/forms/credentials-form.tsx"],"names":[],"mappings":"AA8BA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAGxD,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,gDAAgD;IAChD,KAAK,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;IACzB,yEAAyE;IACzE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,+EAA+E;IAC/E,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;;;;;;OAUG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wEAAwE;IACxE,MAAM,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,eAAe,CAAC,EAC9B,QAAQ,EACR,UAAkB,EAClB,KAAK,EACL,WAAW,EACX,iBAAsB,EACtB,eAAuB,EACvB,MAAM,EACN,WAAuB,GACxB,EAAE,oBAAoB,GAAG,KAAK,CAAC,YAAY,CAiG3C"}

package/dist/forms/credentials-form.js

@@ -0,0 +1,37 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The sign-in form: client, email, password (Doc 09 §1, Doc 06 §3).
+ *
+ * Presentational on purpose — it takes values in and hands values out, and
+ * knows nothing about `IamClient`, tokens or routing. That is what makes it
+ * reusable by the gatepass and visitor consoles, which sign in against the same
+ * IAM with the same three fields but land somewhere else afterwards.
+ *
+ * ## Why the client field comes first
+ *
+ * `POST /auth/login` takes `client_slug` because the same email address can
+ * exist in several tenants (Doc 06 §8), so the tenant is not a detail — it is
+ * the first thing that has to be right, and a person who types their address
+ * before realising they are signing in to the wrong plant has to start over.
+ * It is remembered between visits for the same reason: almost nobody signs in
+ * to two tenants, and the one who does is the one who will notice the field.
+ *
+ * ## Errors
+ *
+ * The form renders whatever copy it is given, and the caller decides which. The
+ * distinction that must survive is 401 vs 423: Doc 03 §8 makes a locked account
+ * a different state with a different remedy, and telling someone their password
+ * was wrong when the account is locked sends them to reset a password that will
+ * not help.
+ */
+import { LockOutlined, MailOutlined, ShopOutlined } from '@ant-design/icons';
+import { Alert, Button, Form, Input, Typography } from 'antd';
+import { spacing } from '../theme/tokens';
+export function CredentialsForm({ onSubmit, submitting = false, error, errorDetail, defaultClientSlug = '', hideClientField = false, footer, submitLabel = 'Sign in', }) {
+    const [form] = Form.useForm();
+    return (_jsxs(Form, { form: form, layout: "vertical", requiredMark: false, initialValues: { client_slug: defaultClientSlug, email: '', password: '' }, onFinish: onSubmit, disabled: submitting, size: "large", children: [error != null && (_jsx(Form.Item, { children: _jsx(Alert, { type: error.tone === 'info' ? 'info' : error.tone, showIcon: true, message: error.title, description: _jsxs(_Fragment, { children: [_jsx("div", { children: error.description }), errorDetail != null && errorDetail !== '' && (_jsx(Typography.Text, { type: "secondary", italic: true, style: { fontSize: 12 }, children: errorDetail }))] }) }) })), hideClientField ? (_jsx(Form.Item, { name: "client_slug", hidden: true, children: _jsx(Input, { type: "hidden" }) })) : (_jsx(Form.Item, { name: "client_slug", label: "Client", rules: [{ required: true, message: 'Which client are you signing in to?' }], extra: "The short name of your organisation in PlantOps.", children: _jsx(Input, { prefix: _jsx(ShopOutlined, {}), placeholder: "acme-industries", autoComplete: "organization", autoCapitalize: "none", spellCheck: false }) })), _jsx(Form.Item, { name: "email", label: "Email", rules: [
+                    { required: true, message: 'Enter your email address.' },
+                    { type: 'email', message: 'That does not look like an email address.' },
+                ], children: _jsx(Input, { prefix: _jsx(MailOutlined, {}), placeholder: "you@company.com", autoComplete: "username", inputMode: "email", spellCheck: false }) }), _jsx(Form.Item, { name: "password", label: "Password", rules: [{ required: true, message: 'Enter your password.' }], children: _jsx(Input.Password, { prefix: _jsx(LockOutlined, {}), placeholder: "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022", autoComplete: "current-password" }) }), _jsx(Form.Item, { style: { marginBlockEnd: footer === undefined ? 0 : spacing.sm }, children: _jsx(Button, { type: "primary", htmlType: "submit", block: true, loading: submitting, children: submitLabel }) }), footer] }));
+}

package/dist/icons/icon-registry.d.ts

@@ -0,0 +1,25 @@
+import * as React from 'react';
+type IconComponent = React.ComponentType<{
+    className?: string;
+}>;
+/** True when the key has a mapping — for a catalog editor's preview. */
+export declare function isKnownIconKey(key: string): boolean;
+/** Every key this frontend understands, sorted — for an icon picker. */
+export declare function knownIconKeys(): string[];
+/** The component for a key, or the fallback. Prefer {@link NavIcon} in JSX. */
+export declare function iconForKey(key: string | null | undefined): IconComponent;
+export interface NavIconProps {
+    /** The `icon` string from a `NavNodeDTO`. `null`/absent is expected. */
+    iconKey?: string | null;
+    className?: string;
+}
+/**
+ * Renders a registry icon key.
+ *
+ * Always renders something. A menu whose rows are sometimes 14px shorter
+ * because one node's icon key was misspelt is worse than one that shows a
+ * neutral glyph.
+ */
+export declare function NavIcon({ iconKey, className }: NavIconProps): React.ReactElement;
+export {};
+//# sourceMappingURL=icon-registry.d.ts.map

package/dist/icons/icon-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"icon-registry.d.ts","sourceRoot":"","sources":["../../src/icons/icon-registry.tsx"],"names":[],"mappings":"AAiEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,KAAK,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAwDjE,wEAAwE;AACxE,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED,wEAAwE;AACxE,wBAAgB,aAAa,IAAI,MAAM,EAAE,CAExC;AAED,+EAA+E;AAC/E,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,aAAa,CAGxE;AAED,MAAM,WAAW,YAAY;IAC3B,wEAAwE;IACxE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,YAAY,GAAG,KAAK,CAAC,YAAY,CAGhF"}

package/dist/icons/icon-registry.js

@@ -0,0 +1,102 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * `icon` keys from the registry → the icon set this design language uses
+ * (Doc 05 §7).
+ *
+ * Doc 05 is explicit that `nav_node.icon` is "a string key the frontend maps to
+ * its icon set", and Doc 02 is explicit that the catalog is data written by
+ * platform admins at runtime. Both together mean this map is the *only* place
+ * the two vocabularies meet, and that it will always be incomplete: an admin
+ * can type `"forklift"` into a manifest tonight and no amount of care here
+ * anticipates it. So an unknown key is a normal, non-fatal outcome that falls
+ * back to a neutral glyph — never a crash, and never a blank space that makes
+ * the menu row jump out of alignment with its neighbours.
+ *
+ * The keys are deliberately generic nouns (`users`, `key`, `sitemap`) rather
+ * than antd component names. A manifest that said `TeamOutlined` would pin the
+ * *database* to this icon library, and swapping icon sets would then mean a
+ * migration rather than an edit to this file.
+ *
+ * Adding a key: add the row, and mention it in the application's manifest
+ * documentation. Gatepass and visitor management will add their own domain
+ * nouns here (`gate`, `pass`, `vehicle`, `visitor`); the block below is
+ * pre-seeded with them so those manifests can be written before their consoles
+ * exist.
+ */
+import { ApartmentOutlined, AppstoreOutlined, AuditOutlined, BankOutlined, BarChartOutlined, BellOutlined, CarOutlined, ClusterOutlined, ContainerOutlined, DashboardOutlined, DatabaseOutlined, FileTextOutlined, FolderOutlined, GlobalOutlined, GoldOutlined, HomeOutlined, IdcardOutlined, InboxOutlined, KeyOutlined, LinkOutlined, LockOutlined, PartitionOutlined, ProfileOutlined, SafetyCertificateOutlined, SafetyOutlined, ScheduleOutlined, SearchOutlined, SettingOutlined, ShopOutlined, SolutionOutlined, TagOutlined, TeamOutlined, ThunderboltOutlined, ToolOutlined, UserOutlined, WarningOutlined, } from '@ant-design/icons';
+/**
+ * The registry. Keys are the strings that appear in `nav_node.icon`.
+ *
+ * The first block is what `deploy/manifests/iam.manifest.json` uses today; the rest is the
+ * shared vocabulary later applications draw on.
+ */
+const ICONS = Object.freeze({
+    // ── Used by the IAM's own manifest ───────────────────────────────────────
+    building: BankOutlined,
+    grid: AppstoreOutlined,
+    briefcase: ShopOutlined,
+    key: KeyOutlined,
+    scroll: AuditOutlined,
+    shield: SafetyOutlined,
+    sitemap: ApartmentOutlined,
+    badge: IdcardOutlined,
+    users: TeamOutlined,
+    link: LinkOutlined,
+    // ── General vocabulary ───────────────────────────────────────────────────
+    home: HomeOutlined,
+    dashboard: DashboardOutlined,
+    user: UserOutlined,
+    settings: SettingOutlined,
+    search: SearchOutlined,
+    bell: BellOutlined,
+    file: FileTextOutlined,
+    folder: FolderOutlined,
+    tag: TagOutlined,
+    chart: BarChartOutlined,
+    database: DatabaseOutlined,
+    globe: GlobalOutlined,
+    lock: LockOutlined,
+    warning: WarningOutlined,
+    tool: ToolOutlined,
+    bolt: ThunderboltOutlined,
+    cluster: ClusterOutlined,
+    partition: PartitionOutlined,
+    certificate: SafetyCertificateOutlined,
+    profile: ProfileOutlined,
+    // ── Reserved for the operational modules (Doc 00 §9) ─────────────────────
+    gate: GoldOutlined,
+    pass: SolutionOutlined,
+    vehicle: CarOutlined,
+    visitor: IdcardOutlined,
+    schedule: ScheduleOutlined,
+    inbox: InboxOutlined,
+    container: ContainerOutlined,
+});
+/** The glyph an unrecognised key renders as. */
+const FALLBACK_ICON = AppstoreOutlined;
+/** True when the key has a mapping — for a catalog editor's preview. */
+export function isKnownIconKey(key) {
+    return key in ICONS;
+}
+/** Every key this frontend understands, sorted — for an icon picker. */
+export function knownIconKeys() {
+    return Object.keys(ICONS).sort();
+}
+/** The component for a key, or the fallback. Prefer {@link NavIcon} in JSX. */
+export function iconForKey(key) {
+    if (key === null || key === undefined)
+        return FALLBACK_ICON;
+    return ICONS[key] ?? FALLBACK_ICON;
+}
+/**
+ * Renders a registry icon key.
+ *
+ * Always renders something. A menu whose rows are sometimes 14px shorter
+ * because one node's icon key was misspelt is worse than one that shows a
+ * neutral glyph.
+ */
+export function NavIcon({ iconKey, className }) {
+    const Icon = iconForKey(iconKey);
+    return _jsx(Icon, { className: className });
+}

package/dist/index.d.ts

@@ -0,0 +1,52 @@
+/**
+ * `@plantops/ui` — the shared React presentation layer for every PlantOps
+ * console (Doc 08 §2).
+ *
+ * Ant Design 6 supplies the components; this library supplies the *product*:
+ * the design tokens, the theme built from them, the shell every console renders
+ * inside, the icon-key registry Doc 05 §7 requires, and the handful of patterns
+ * that must not be reinvented per screen — page headers, list tables bound to
+ * the pagination envelope, status tags, and the four not-showing-data states.
+ *
+ * ## The rule that keeps it reusable
+ *
+ * Nothing here calls the IAM. The library depends on `@plantops/contracts` for
+ * types and on nothing else in the workspace — enforced by the `scope:ui`
+ * boundary in the root ESLint config — so a component takes data and callbacks
+ * and returns markup. The stateful half (a client, tokens, grants, navigation
+ * fetching) lives in `@plantops/web-kit`, which depends on this.
+ *
+ * That split is what makes the gatepass and visitor consoles cheap: they mount
+ * the same `<PlantOpsThemeProvider>` and `<AppShell>`, render the same
+ * `<NavMenu>` from their own `/iam/navigation` response, and inherit the
+ * product's appearance without inheriting the IAM's screens.
+ *
+ * ```tsx
+ * <PlantOpsThemeProvider>
+ *   <AppShell brand={<Brand product="Gatepass" />} nav={<NavMenu … />}>
+ *     <PageHeader title="Passes" />
+ *     <DataTable result={page} columns={columns} rowKey={(r) => r.id} />
+ *   </AppShell>
+ * </PlantOpsThemeProvider>
+ * ```
+ */
+export * from './data/data-table';
+export * from './data/scope-tree';
+export * from './data/scope-tree-select';
+export * from './data/status-tag';
+export * from './feedback/error-copy';
+export * from './feedback/page-header';
+export * from './feedback/state-panels';
+export * from './forms/auth-layout';
+export * from './forms/credentials-form';
+export * from './icons/icon-registry';
+export * from './layout/app-shell';
+export * from './layout/brand';
+export * from './layout/nav-menu';
+export * from './layout/nav-tree';
+export * from './layout/user-menu';
+export * from './theme/color-mode';
+export * from './theme/theme';
+export * from './theme/theme-provider';
+export * from './theme/tokens';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,cAAc,wBAAwB,CAAC;AACvC,cAAc,gBAAgB,CAAC"}