@orthacms/users-admin 0.0.0-reserve.0

package/dist/lib/presentation/components/PasswordResetCard/index.js

@@ -0,0 +1,109 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState } from 'react';
+import { defineMessages, useIntl } from 'react-intl';
+import { KeyRound } from 'lucide-react';
+import { Alert, AlertDescription, Button, Card, CardContent, CardDescription, CardHeader, CardTitle, Spinner, toast } from '@orthacms/design-system';
+import { useHasPermission } from '@orthacms/identity-admin';
+import { HTTP_STATUS } from '@orthacms/utils-admin';
+import { useIssuePasswordReset } from '../../../application/useIssuePasswordReset';
+import { passwordResetLinkFor } from '../../../infrastructure/passwordResetLink';
+import { PasswordResetLinkDialog } from '../PasswordResetLinkDialog';
+/** Intl descriptors for {@link PasswordResetCard}, co-located with the component. */
+const messages = defineMessages({
+    title: { id: 'users.passwordReset.title', defaultMessage: 'Password' },
+    body: {
+        id: 'users.passwordReset.body',
+        defaultMessage: 'Generate a single-use link this member can open to set a new password. Nothing changes until they use it; when they do, every device signed in to their account is signed out.'
+    },
+    deliveryNote: {
+        id: 'users.passwordReset.deliveryNote',
+        defaultMessage: 'Nothing is emailed yet — you copy the link and send it yourself. Generating a new link stops any earlier one from working.'
+    },
+    generate: {
+        id: 'users.passwordReset.generate',
+        defaultMessage: 'Generate reset link'
+    },
+    generating: {
+        id: 'users.passwordReset.generating',
+        defaultMessage: 'Generating reset link…'
+    },
+    pending: {
+        id: 'users.passwordReset.pending',
+        defaultMessage: 'This member hasn’t accepted their invite, so there’s no password to reset. Resend their invite instead.'
+    },
+    disabled: {
+        id: 'users.passwordReset.disabled',
+        defaultMessage: 'This member is suspended and can’t sign in, so a reset link would do nothing. Reactivate them first.'
+    },
+    noPermission: {
+        id: 'users.passwordReset.noPermission',
+        defaultMessage: 'You don’t have permission to reset another member’s password.'
+    },
+    recentlyIssued: {
+        id: 'users.passwordReset.recentlyIssued',
+        defaultMessage: 'A reset link was just generated for this member. Wait {seconds, plural, one {a second} other {# seconds}} — generating another now would kill the one you already have.'
+    },
+    conflict: {
+        id: 'users.passwordReset.conflict',
+        defaultMessage: 'This member’s account changed while you were looking at it. Reload the page and try again.'
+    },
+    failed: {
+        id: 'users.passwordReset.failed',
+        defaultMessage: 'Couldn’t generate a reset link. Please try again.'
+    }
+});
+/**
+ * The Access tab's password card: an admin generates a single-use reset link
+ * for an active member and hands it over.
+ *
+ * This is the whole "forgot my password" story today. There is no self-service
+ * flow, because there is no mailer to send a link to (identity epic #11) — so
+ * the recovery path runs through someone who can already be asked to vouch for
+ * the person, which is a reasonable place for it to sit in the meantime.
+ *
+ * Only an `active` member qualifies: a `pending` one has no password yet (they
+ * finish through the invite link) and a `disabled` one cannot sign in at all,
+ * so a link for either is a link to nowhere. The server enforces both; the card
+ * says so up front instead of letting the button fail.
+ */
+export function PasswordResetCard({ member }) {
+    const intl = useIntl();
+    const canUpdate = useHasPermission('users:update');
+    const issueReset = useIssuePasswordReset();
+    // The minted link, held only until the dialog is dismissed. It is never
+    // re-fetchable — the server keeps only its hash — so this state is the one
+    // copy that exists.
+    const [link, setLink] = useState(null);
+    const blockedReason = member.status === 'pending'
+        ? messages.pending
+        : member.status === 'disabled'
+            ? messages.disabled
+            : !canUpdate
+                ? messages.noPermission
+                : null;
+    const generate = () => {
+        issueReset.mutate(member.id, {
+            onSuccess: (issued) => setLink(passwordResetLinkFor(issued.resetToken)),
+            onError: (error) => {
+                // A 409 is actionable and the body says how: the cooldown
+                // carries the wait, so the admin is told to hold rather than
+                // told "something conflicted" and left to guess.
+                if (error.status === HTTP_STATUS.CONFLICT) {
+                    const body = error.details;
+                    toast.error(body?.code === 'PASSWORD_RESET_RECENTLY_SENT'
+                        ? intl.formatMessage(messages.recentlyIssued, {
+                            seconds: body.retryAfterSeconds ?? 60
+                        })
+                        : intl.formatMessage(messages.conflict));
+                    return;
+                }
+                toast.error(intl.formatMessage(messages.failed));
+            }
+        });
+    };
+    return (_jsxs(Card, { children: [_jsxs(CardHeader, { children: [_jsxs(CardTitle, { className: "flex items-center gap-2", children: [_jsx(KeyRound, { "aria-hidden": true, className: "size-5 text-muted-foreground" }), intl.formatMessage(messages.title)] }), _jsx(CardDescription, { children: intl.formatMessage(messages.body) })] }), _jsxs(CardContent, { className: "space-y-3", children: [blockedReason ? (_jsx(Alert, { children: _jsx(AlertDescription, { children: intl.formatMessage(blockedReason) }) })) : (_jsx("p", { className: "text-sm text-muted-foreground", children: intl.formatMessage(messages.deliveryNote) })), _jsx(Button, { variant: "outline", onClick: generate, disabled: blockedReason !== null || issueReset.isPending, children: issueReset.isPending ? (_jsxs(_Fragment, { children: [_jsx(Spinner, { "aria-hidden": "true" }), _jsx("span", { className: "sr-only", children: intl.formatMessage(messages.generating) })] })) : (intl.formatMessage(messages.generate)) })] }), _jsx(PasswordResetLinkDialog, { link: link, email: member.email, open: link !== null, onOpenChange: (open) => {
+                    if (!open) {
+                        setLink(null);
+                    }
+                } })] }));
+}

package/dist/lib/presentation/components/PasswordResetLinkDialog/index.d.ts

@@ -0,0 +1,27 @@
+/** Props for {@link PasswordResetLinkDialog}. */
+type PasswordResetLinkDialogProps = {
+    /** The freshly minted reset link, or `null` when there is none to show. */
+    link: string | null;
+    /** Whose account the link resets. */
+    email: string;
+    /** Whether the dialog is open. */
+    open: boolean;
+    /** Called when the dialog opens or closes. */
+    onOpenChange: (open: boolean) => void;
+};
+/**
+ * Shows the password-reset link an admin just generated. Generating rotates the
+ * token, which kills any link already outstanding — so handing the new one over
+ * is not a nicety, it is the rest of the operation.
+ *
+ * Because of that, dismissing before copying is guarded. Esc, an overlay click
+ * and the close button all reach `onOpenChange(false)` by reflex, and the link
+ * is not re-fetchable: losing it leaves the member with no way to reset and the
+ * admin with no live link, recoverable only by generating another — which the
+ * server refuses for the first minute, so the mistake is not even immediately
+ * fixable. So the first dismissal without a copy asks; once copied, it closes
+ * freely.
+ */
+export declare function PasswordResetLinkDialog({ link, email, open, onOpenChange }: PasswordResetLinkDialogProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/presentation/components/PasswordResetLinkDialog/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/presentation/components/PasswordResetLinkDialog/index.tsx"],"names":[],"mappings":"AA8CA,iDAAiD;AACjD,KAAK,4BAA4B,GAAG;IAChC,2EAA2E;IAC3E,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,qCAAqC;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,kCAAkC;IAClC,IAAI,EAAE,OAAO,CAAC;IACd,8CAA8C;IAC9C,YAAY,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;CACzC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CAAC,EACpC,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,YAAY,EACf,EAAE,4BAA4B,+BAyF9B"}

package/dist/lib/presentation/components/PasswordResetLinkDialog/index.js

@@ -0,0 +1,79 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { defineMessages, useIntl } from 'react-intl';
+import { Alert, AlertDescription, Button, Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle } from '@orthacms/design-system';
+import { TriangleAlert } from 'lucide-react';
+import { PasswordResetLinkPanel } from '../PasswordResetLinkPanel';
+/** Intl descriptors for {@link PasswordResetLinkDialog}, co-located with the component. */
+const messages = defineMessages({
+    title: {
+        id: 'users.passwordResetLinkDialog.title',
+        defaultMessage: 'Send this link to {email}'
+    },
+    description: {
+        id: 'users.passwordResetLinkDialog.description',
+        defaultMessage: 'Any earlier reset link stopped working the moment this one was created, so this is the link they need. It’s shown once — copy it before you close this.'
+    },
+    done: {
+        id: 'users.passwordResetLinkDialog.done',
+        defaultMessage: 'Done'
+    },
+    uncopied: {
+        id: 'users.passwordResetLinkDialog.uncopied',
+        defaultMessage: 'You haven’t copied the link yet, and it can’t be shown again. Closing now leaves {email} with no way to reset until you generate another one.'
+    },
+    closeAnyway: {
+        id: 'users.passwordResetLinkDialog.closeAnyway',
+        defaultMessage: 'Close without copying'
+    },
+    keepOpen: {
+        id: 'users.passwordResetLinkDialog.keepOpen',
+        defaultMessage: 'Keep it open'
+    }
+});
+/**
+ * Shows the password-reset link an admin just generated. Generating rotates the
+ * token, which kills any link already outstanding — so handing the new one over
+ * is not a nicety, it is the rest of the operation.
+ *
+ * Because of that, dismissing before copying is guarded. Esc, an overlay click
+ * and the close button all reach `onOpenChange(false)` by reflex, and the link
+ * is not re-fetchable: losing it leaves the member with no way to reset and the
+ * admin with no live link, recoverable only by generating another — which the
+ * server refuses for the first minute, so the mistake is not even immediately
+ * fixable. So the first dismissal without a copy asks; once copied, it closes
+ * freely.
+ */
+export function PasswordResetLinkDialog({ link, email, open, onOpenChange }) {
+    const intl = useIntl();
+    const [copied, setCopied] = useState(false);
+    const [confirmingClose, setConfirmingClose] = useState(false);
+    // A new link is a new chance to lose it — reset the guard whenever one
+    // arrives, so a second generate doesn't inherit the first one's "copied".
+    useEffect(() => {
+        if (link !== null) {
+            setCopied(false);
+            setConfirmingClose(false);
+        }
+    }, [link]);
+    /** Close for real, clearing the guard. */
+    const close = () => {
+        setConfirmingClose(false);
+        onOpenChange(false);
+    };
+    /** Every dismissal path funnels through here so none of them can slip past. */
+    const requestClose = () => {
+        if (copied) {
+            close();
+            return;
+        }
+        setConfirmingClose(true);
+    };
+    return (_jsx(Dialog, { open: open, onOpenChange: (next) => {
+            if (next) {
+                onOpenChange(true);
+                return;
+            }
+            requestClose();
+        }, children: _jsxs(DialogContent, { children: [_jsxs(DialogHeader, { children: [_jsx(DialogTitle, { children: intl.formatMessage(messages.title, { email }) }), _jsx(DialogDescription, { children: intl.formatMessage(messages.description) })] }), link && (_jsx(PasswordResetLinkPanel, { link: link, email: email, onCopied: () => setCopied(true) })), confirmingClose ? (_jsxs(Alert, { variant: "destructive", role: "alert", children: [_jsx(TriangleAlert, { "aria-hidden": true }), _jsx(AlertDescription, { children: intl.formatMessage(messages.uncopied, { email }) })] })) : null, _jsx(DialogFooter, { children: confirmingClose ? (_jsxs(_Fragment, { children: [_jsx(Button, { variant: "outline", onClick: () => setConfirmingClose(false), children: intl.formatMessage(messages.keepOpen) }), _jsx(Button, { variant: "destructive", onClick: close, children: intl.formatMessage(messages.closeAnyway) })] })) : (_jsx(Button, { onClick: requestClose, children: intl.formatMessage(messages.done) })) })] }) }));
+}

package/dist/lib/presentation/components/PasswordResetLinkPanel/index.d.ts

@@ -0,0 +1,31 @@
+/** Props for {@link PasswordResetLinkPanel}. */
+type PasswordResetLinkPanelProps = {
+    /** The full reset URL to hand over. */
+    link: string;
+    /** Whose account the link resets — named in the warning so the risk is concrete. */
+    email: string;
+    /**
+     * Called once the link has actually reached the clipboard. Lets a container
+     * tell "captured" from "about to be lost" — the dialog guards its dismissal
+     * on it.
+     */
+    onCopied?: () => void;
+};
+/**
+ * The reveal-once password-reset link, with a copy button and a plain warning
+ * about what the link is. Mirrors the invite-link panel and the API-token reveal
+ * dialog: the secret exists only in the caller's state, is never re-fetchable,
+ * and this is the single chance to capture it.
+ *
+ * The warning is blunter than the invite one on purpose. An invite link creates
+ * an account nobody holds yet; this one overwrites the credential of an account
+ * that already exists, so whoever opens it is *taking over* something rather
+ * than claiming something unclaimed.
+ *
+ * It exists because nothing emails resets yet — the admin is the delivery
+ * channel. When a mailer lands (identity epic #11) this becomes a fallback for
+ * deployments with no SMTP rather than the only path.
+ */
+export declare function PasswordResetLinkPanel({ link, email, onCopied }: PasswordResetLinkPanelProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/presentation/components/PasswordResetLinkPanel/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/presentation/components/PasswordResetLinkPanel/index.tsx"],"names":[],"mappings":"AAoCA,gDAAgD;AAChD,KAAK,2BAA2B,GAAG;IAC/B,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,oFAAoF;IACpF,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;CACzB,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,EACnC,IAAI,EACJ,KAAK,EACL,QAAQ,EACX,EAAE,2BAA2B,+BAoD7B"}

package/dist/lib/presentation/components/PasswordResetLinkPanel/index.js

@@ -0,0 +1,64 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { defineMessages, useIntl } from 'react-intl';
+import { Check, Copy, TriangleAlert } from 'lucide-react';
+import { Alert, AlertDescription, Button, toast } from '@orthacms/design-system';
+/** Intl descriptors for {@link PasswordResetLinkPanel}, co-located with the component. */
+const messages = defineMessages({
+    copy: {
+        id: 'users.passwordResetLink.copy',
+        defaultMessage: 'Copy link'
+    },
+    copied: {
+        id: 'users.passwordResetLink.copied',
+        defaultMessage: 'Password reset link copied to clipboard'
+    },
+    copyFailed: {
+        id: 'users.passwordResetLink.copyFailed',
+        defaultMessage: 'Couldn’t reach the clipboard. Select the link and copy it manually.'
+    },
+    warning: {
+        id: 'users.passwordResetLink.warning',
+        defaultMessage: 'This link is shown once and works once. Anyone who opens it can set the password for {email} and take over that account — send it the way you’d send a password, not in a public channel.'
+    },
+    linkLabel: {
+        id: 'users.passwordResetLink.linkLabel',
+        defaultMessage: 'Password reset link for {email}'
+    }
+});
+/**
+ * The reveal-once password-reset link, with a copy button and a plain warning
+ * about what the link is. Mirrors the invite-link panel and the API-token reveal
+ * dialog: the secret exists only in the caller's state, is never re-fetchable,
+ * and this is the single chance to capture it.
+ *
+ * The warning is blunter than the invite one on purpose. An invite link creates
+ * an account nobody holds yet; this one overwrites the credential of an account
+ * that already exists, so whoever opens it is *taking over* something rather
+ * than claiming something unclaimed.
+ *
+ * It exists because nothing emails resets yet — the admin is the delivery
+ * channel. When a mailer lands (identity epic #11) this becomes a fallback for
+ * deployments with no SMTP rather than the only path.
+ */
+export function PasswordResetLinkPanel({ link, email, onCopied }) {
+    const intl = useIntl();
+    const [copied, setCopied] = useState(false);
+    const copy = async () => {
+        try {
+            await navigator.clipboard.writeText(link);
+            setCopied(true);
+            onCopied?.();
+            toast.success(intl.formatMessage(messages.copied));
+        }
+        catch {
+            // Clipboard access can be denied (insecure origin, permissions).
+            // The link is selectable in the field, so say so rather than
+            // failing silently.
+            toast.error(intl.formatMessage(messages.copyFailed));
+        }
+    };
+    return (_jsxs("div", { className: "flex flex-col gap-4", children: [_jsxs("div", { className: "flex min-w-0 items-center gap-2", children: [_jsx("input", { readOnly: true, value: link, "aria-label": intl.formatMessage(messages.linkLabel, {
+                            email
+                        }), onFocus: (e) => e.currentTarget.select(), className: "min-w-0 flex-1 truncate rounded-md bg-muted px-3 py-2 font-mono text-sm" }), _jsxs(Button, { type: "button", variant: "outline", className: "shrink-0", onClick: copy, children: [copied ? _jsx(Check, { "aria-hidden": true }) : _jsx(Copy, { "aria-hidden": true }), intl.formatMessage(messages.copy)] })] }), _jsxs(Alert, { children: [_jsx(TriangleAlert, { "aria-hidden": true }), _jsx(AlertDescription, { children: intl.formatMessage(messages.warning, { email }) })] })] }));
+}

package/dist/lib/presentation/components/RolePicker/index.d.ts

@@ -0,0 +1,21 @@
+import type { MemberRole } from '../../../domain/types/member';
+/**
+ * A radio-card selector over the three assignable system roles, with each
+ * role's description and a "Current" badge on the saved one. Controlled: the
+ * parent owns `value` and decides what "apply" does. Used by the detail page's
+ * Role tab (and available to the invite flow).
+ */
+export declare function RolePicker({ value, current, disabled, onChange }: {
+    /**
+     * The selected role, or `null` for a member holding a custom role — no card
+     * is then marked selected, rather than one being picked on their behalf.
+     */
+    value: MemberRole | null;
+    /** The member's currently-saved role, badged as "Current". */
+    current?: MemberRole | null;
+    /** Disables selection (read-only / in-flight). */
+    disabled?: boolean;
+    /** Called with the newly-picked role. */
+    onChange: (role: MemberRole) => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/presentation/components/RolePicker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/presentation/components/RolePicker/index.tsx"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAyC/D;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,EACvB,KAAK,EACL,OAAO,EACP,QAAgB,EAChB,QAAQ,EACX,EAAE;IACC;;;OAGG;IACH,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IACzB,8DAA8D;IAC9D,OAAO,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IAC5B,kDAAkD;IAClD,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,yCAAyC;IACzC,QAAQ,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;CACxC,+BAsDA"}

package/dist/lib/presentation/components/RolePicker/index.js

@@ -0,0 +1,51 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { defineMessages, useIntl } from 'react-intl';
+import { Badge, Label, RadioGroup, RadioGroupItem, cn } from '@orthacms/design-system';
+/** Intl descriptors for {@link RolePicker}, co-located with the component. */
+const messages = defineMessages({
+    adminName: { id: 'users.rolePicker.adminName', defaultMessage: 'Admin' },
+    adminDesc: {
+        id: 'users.rolePicker.adminDesc',
+        defaultMessage: 'Full access: manage members, roles, workspaces, and content.'
+    },
+    contributorName: {
+        id: 'users.rolePicker.contributorName',
+        defaultMessage: 'Contributor'
+    },
+    contributorDesc: {
+        id: 'users.rolePicker.contributorDesc',
+        defaultMessage: 'Can read members and work within their workspaces.'
+    },
+    viewerName: { id: 'users.rolePicker.viewerName', defaultMessage: 'Viewer' },
+    viewerDesc: {
+        id: 'users.rolePicker.viewerDesc',
+        defaultMessage: 'Read-only access to members and workspaces.'
+    },
+    current: { id: 'users.rolePicker.current', defaultMessage: 'Current' },
+    group: { id: 'users.rolePicker.group', defaultMessage: 'Global role' }
+});
+const ROLES = [
+    { key: 'admin', name: messages.adminName, desc: messages.adminDesc },
+    {
+        key: 'contributor',
+        name: messages.contributorName,
+        desc: messages.contributorDesc
+    },
+    { key: 'viewer', name: messages.viewerName, desc: messages.viewerDesc }
+];
+/**
+ * A radio-card selector over the three assignable system roles, with each
+ * role's description and a "Current" badge on the saved one. Controlled: the
+ * parent owns `value` and decides what "apply" does. Used by the detail page's
+ * Role tab (and available to the invite flow).
+ */
+export function RolePicker({ value, current, disabled = false, onChange }) {
+    const intl = useIntl();
+    return (_jsx(RadioGroup, { value: value ?? undefined, onValueChange: (next) => onChange(next), disabled: disabled, "aria-label": intl.formatMessage(messages.group), className: "gap-3", children: ROLES.map((role) => {
+            const id = `role-${role.key}`;
+            const selected = value === role.key;
+            return (_jsxs(Label, { htmlFor: id, className: cn('flex cursor-pointer items-start gap-3 rounded-lg border p-4 transition-colors', selected
+                    ? 'border-primary bg-primary/5'
+                    : 'hover:bg-muted/50', disabled && 'cursor-not-allowed opacity-70'), children: [_jsx(RadioGroupItem, { id: id, value: role.key, className: "mt-0.5" }), _jsxs("div", { className: "space-y-1", children: [_jsxs("div", { className: "flex items-center gap-2", children: [_jsx("span", { className: "text-sm font-medium", children: intl.formatMessage(role.name) }), current === role.key ? (_jsx(Badge, { variant: "secondary", className: "rounded-xl border-border", children: intl.formatMessage(messages.current) })) : null] }), _jsx("p", { className: "text-xs text-muted-foreground", children: intl.formatMessage(role.desc) })] })] }, role.key));
+        }) }));
+}

package/dist/lib/presentation/components/SessionCard/index.d.ts

@@ -0,0 +1,15 @@
+import type { UserSession } from '../../../application/useUserSessions';
+/**
+ * One of a member's live sessions: device/user-agent, originating IP, when it
+ * was last seen, and a Revoke action. The caller's own session is badged and
+ * its Revoke button disabled, so an admin can't sign themselves out from here.
+ */
+export declare function SessionCard({ session, busy, onRevoke }: {
+    /** The session to render. */
+    session: UserSession;
+    /** Whether a revoke for this session is in flight. */
+    busy?: boolean;
+    /** Revoke handler. */
+    onRevoke: (session: UserSession) => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/presentation/components/SessionCard/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/presentation/components/SessionCard/index.tsx"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AAuBxE;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,EACxB,OAAO,EACP,IAAY,EACZ,QAAQ,EACX,EAAE;IACC,6BAA6B;IAC7B,OAAO,EAAE,WAAW,CAAC;IACrB,sDAAsD;IACtD,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,sBAAsB;IACtB,QAAQ,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,IAAI,CAAC;CAC5C,+BAyDA"}

package/dist/lib/presentation/components/SessionCard/index.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { defineMessages, useIntl } from 'react-intl';
+import { MonitorSmartphone } from 'lucide-react';
+import { Badge, Button, Card, CardContent, Spinner } from '@orthacms/design-system';
+/** Intl descriptors for {@link SessionCard}. */
+const messages = defineMessages({
+    unknownDevice: {
+        id: 'users.sessions.unknownDevice',
+        defaultMessage: 'Unknown device'
+    },
+    current: {
+        id: 'users.sessions.current',
+        defaultMessage: 'This session'
+    },
+    lastSeen: {
+        id: 'users.sessions.lastSeen',
+        defaultMessage: 'Last seen {when}'
+    },
+    revoke: { id: 'users.sessions.revoke', defaultMessage: 'Revoke' },
+    revokeLabel: {
+        id: 'users.sessions.revokeLabel',
+        defaultMessage: 'Revoke the session on {device}, last seen {when}'
+    }
+});
+/**
+ * One of a member's live sessions: device/user-agent, originating IP, when it
+ * was last seen, and a Revoke action. The caller's own session is badged and
+ * its Revoke button disabled, so an admin can't sign themselves out from here.
+ */
+export function SessionCard({ session, busy = false, onRevoke }) {
+    const intl = useIntl();
+    const device = session.userAgent?.trim() || intl.formatMessage(messages.unknownDevice);
+    const lastSeen = intl.formatDate(session.lastSeenAt, {
+        dateStyle: 'medium',
+        timeStyle: 'short'
+    });
+    return (_jsx(Card, { children: _jsxs(CardContent, { className: "flex items-center gap-3 pt-6", children: [_jsx("span", { className: "flex size-9 shrink-0 items-center justify-center rounded-lg bg-muted text-muted-foreground", children: _jsx(MonitorSmartphone, { "aria-hidden": true, className: "size-4" }) }), _jsxs("div", { className: "min-w-0 flex-1 space-y-0.5", children: [_jsxs("div", { className: "flex items-center gap-2", children: [_jsx("p", { className: "min-w-0 truncate text-sm font-medium", children: device }), session.current ? (_jsx(Badge, { variant: "secondary", className: "shrink-0 whitespace-nowrap rounded-xl border-border", children: intl.formatMessage(messages.current) })) : null] }), _jsxs("p", { className: "truncate text-xs text-muted-foreground", children: [session.ipAddress ? `${session.ipAddress} · ` : '', intl.formatMessage(messages.lastSeen, {
+                                    when: lastSeen
+                                })] })] }), _jsxs(Button, { variant: "ghost", size: "sm", className: "text-muted-foreground", disabled: busy || session.current, "aria-label": intl.formatMessage(messages.revokeLabel, {
+                        device,
+                        when: lastSeen
+                    }), onClick: () => onRevoke(session), children: [busy ? _jsx(Spinner, {}) : null, intl.formatMessage(messages.revoke)] })] }) }));
+}

package/dist/lib/presentation/components/ThemeSync/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Invisible bridge that pulls the signed-in user's stored theme from the server
+ * into the app-wide {@link useAppearance} provider once, on load. It renders
+ * nothing — it exists only for the effect — and is contributed into the shell's
+ * **sidebar footer**, the one region the shell keeps mounted in both the global
+ * and per-workspace sidebar contexts, so it stays mounted across every
+ * authenticated route (a member never has to open their Preferences tab, or
+ * even leave a workspace, for their saved theme to take effect).
+ *
+ * `localStorage` gives the instant, pre-paint theme (see the AppearanceProvider
+ * + the index.html bootstrap); this reconciles that guess with the durable,
+ * cross-device value the server holds, so signing in on a new device still
+ * lands on the user's chosen theme. Setting the same value is a no-op in the
+ * provider, so this never fights a change the user just made on the tab.
+ *
+ * A failed read is deliberately silent *here* — a background hydrate is not
+ * worth a toast on every route — but it is not silent overall: the Preferences
+ * tab reads the same query and surfaces the error where the user can act on it.
+ */
+export declare function ThemeSync(): null;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/presentation/components/ThemeSync/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/presentation/components/ThemeSync/index.tsx"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,SAAS,SAWxB"}

package/dist/lib/presentation/components/ThemeSync/index.js

@@ -0,0 +1,32 @@
+import { useEffect } from 'react';
+import { useAppearance } from '@orthacms/design-system';
+import { usePreferences } from '../../../application/usePreferences';
+/**
+ * Invisible bridge that pulls the signed-in user's stored theme from the server
+ * into the app-wide {@link useAppearance} provider once, on load. It renders
+ * nothing — it exists only for the effect — and is contributed into the shell's
+ * **sidebar footer**, the one region the shell keeps mounted in both the global
+ * and per-workspace sidebar contexts, so it stays mounted across every
+ * authenticated route (a member never has to open their Preferences tab, or
+ * even leave a workspace, for their saved theme to take effect).
+ *
+ * `localStorage` gives the instant, pre-paint theme (see the AppearanceProvider
+ * + the index.html bootstrap); this reconciles that guess with the durable,
+ * cross-device value the server holds, so signing in on a new device still
+ * lands on the user's chosen theme. Setting the same value is a no-op in the
+ * provider, so this never fights a change the user just made on the tab.
+ *
+ * A failed read is deliberately silent *here* — a background hydrate is not
+ * worth a toast on every route — but it is not silent overall: the Preferences
+ * tab reads the same query and surfaces the error where the user can act on it.
+ */
+export function ThemeSync() {
+    const { setTheme } = useAppearance();
+    const { data } = usePreferences();
+    useEffect(() => {
+        if (data) {
+            setTheme(data.theme);
+        }
+    }, [data, setTheme]);
+    return null;
+}

package/dist/lib/presentation/components/UserDetailLayout/UserDetailTabs/index.d.ts

@@ -0,0 +1,15 @@
+import type { Member } from '../../../../domain/types/member';
+/**
+ * The detail page's horizontal tab navigation — underline tabs between the
+ * hero and the active section. The account tabs (General, Role, Workspaces)
+ * are always shown; Sessions/Activity and Sign-in access are gated — without
+ * the permission the tab is hidden and its route redirects away, so a
+ * read-only admin never sees a dead link. Preferences is **self-only** — it
+ * carries the current user's own app settings (theme), so it shows only on
+ * their own profile. Links are absolute (`/users/:id/…`) so active state is
+ * unambiguous regardless of the matched tab.
+ */
+export declare function UserDetailTabs({ member }: {
+    member: Member;
+}): import("react").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/presentation/components/UserDetailLayout/UserDetailTabs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/presentation/components/UserDetailLayout/UserDetailTabs/index.tsx"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAC;AAmD9D;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,+BA6D5D"}

package/dist/lib/presentation/components/UserDetailLayout/UserDetailTabs/index.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { NavLink } from 'react-router-dom';
+import { defineMessages, useIntl } from 'react-intl';
+import { Activity, Ban, Building2, MonitorSmartphone, ShieldCheck, SlidersHorizontal, UserRound } from 'lucide-react';
+import { Badge, TabNav, TabNavLink } from '@orthacms/design-system';
+import { AuthStatus, useAuth, useHasPermission } from '@orthacms/identity-admin';
+/** Intl descriptors for {@link UserDetailTabs}, co-located with the component. */
+const messages = defineMessages({
+    general: { id: 'users.detail.rail.general', defaultMessage: 'General' },
+    role: { id: 'users.detail.rail.role', defaultMessage: 'Role' },
+    workspaces: {
+        id: 'users.detail.rail.workspaces',
+        defaultMessage: 'Workspaces'
+    },
+    sessions: { id: 'users.detail.rail.sessions', defaultMessage: 'Sessions' },
+    activity: { id: 'users.detail.rail.activity', defaultMessage: 'Activity' },
+    signInAccess: {
+        id: 'users.detail.rail.signInAccess',
+        defaultMessage: 'Sign-in access'
+    },
+    preferences: {
+        id: 'users.detail.rail.preferences',
+        defaultMessage: 'Preferences'
+    },
+    disabled: { id: 'users.detail.rail.disabled', defaultMessage: 'Disabled' },
+    nav: { id: 'users.detail.rail.nav', defaultMessage: 'User detail sections' }
+});
+/** One tab: an absolute-path `NavLink` whose active state underlines it. */
+function UserDetailTab({ to, icon: Icon, label, trailing }) {
+    return (_jsx(TabNavLink, { asChild: true, children: _jsxs(NavLink, { to: to, children: [_jsx(Icon, { "aria-hidden": true, className: "size-4 shrink-0" }), label, trailing ? (_jsx(Badge, { variant: "destructive-soft", children: trailing })) : null] }) }));
+}
+/**
+ * The detail page's horizontal tab navigation — underline tabs between the
+ * hero and the active section. The account tabs (General, Role, Workspaces)
+ * are always shown; Sessions/Activity and Sign-in access are gated — without
+ * the permission the tab is hidden and its route redirects away, so a
+ * read-only admin never sees a dead link. Preferences is **self-only** — it
+ * carries the current user's own app settings (theme), so it shows only on
+ * their own profile. Links are absolute (`/users/:id/…`) so active state is
+ * unambiguous regardless of the matched tab.
+ */
+export function UserDetailTabs({ member }) {
+    const intl = useIntl();
+    const canManage = useHasPermission('users:update');
+    const canReadActivity = useHasPermission('activity:read');
+    const auth = useAuth();
+    const isSelf = auth.status === AuthStatus.Authenticated && auth.user.id === member.id;
+    const base = `/users/${member.id}`;
+    return (_jsxs(TabNav, { "aria-label": intl.formatMessage(messages.nav), children: [_jsx(UserDetailTab, { to: `${base}/general`, icon: UserRound, label: intl.formatMessage(messages.general) }), _jsx(UserDetailTab, { to: `${base}/roles`, icon: ShieldCheck, label: intl.formatMessage(messages.role) }), _jsx(UserDetailTab, { to: `${base}/workspaces`, icon: Building2, label: intl.formatMessage(messages.workspaces) }), canManage ? (_jsx(UserDetailTab, { to: `${base}/sessions`, icon: MonitorSmartphone, label: intl.formatMessage(messages.sessions) })) : null, canReadActivity ? (_jsx(UserDetailTab, { to: `${base}/activity`, icon: Activity, label: intl.formatMessage(messages.activity) })) : null, canManage ? (_jsx(UserDetailTab, { to: `${base}/access`, icon: Ban, label: intl.formatMessage(messages.signInAccess), trailing: member.status === 'disabled'
+                    ? intl.formatMessage(messages.disabled)
+                    : undefined })) : null, isSelf ? (_jsx(UserDetailTab, { to: `${base}/preferences`, icon: SlidersHorizontal, label: intl.formatMessage(messages.preferences) })) : null] }));
+}

package/dist/lib/presentation/components/UserDetailLayout/UserHero/index.d.ts

@@ -0,0 +1,10 @@
+import type { Member } from '../../../../domain/types/member';
+/**
+ * The detail page's identity card: a large initials avatar, the member's name
+ * and email, their status and role badges, and the join date. Read-only — every
+ * edit lives in a tab below.
+ */
+export declare function UserHero({ member }: {
+    member: Member;
+}): import("react").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/presentation/components/UserDetailLayout/UserHero/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/presentation/components/UserDetailLayout/UserHero/index.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAC;AAU9D;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,+BAoCtD"}