@jini-ai/user-management 0.2.0

package/dist/admin/ports.d.ts

@@ -0,0 +1,187 @@
+import type { RoleRecord, PolicyRecord, PolicyPermissionRecord } from './models.js';
+export interface RolesCallOptions {
+    readonly signal?: AbortSignal;
+}
+export interface RolesApiPort {
+    listRoles(required: Record<string, never>, optional?: RolesCallOptions): Promise<{
+        roles: RoleRecord[];
+    }>;
+    listPolicies(required: Record<string, never>, optional?: RolesCallOptions): Promise<{
+        policies: PolicyRecord[];
+    }>;
+    createRole(required: {
+        name: string;
+    }, optional?: RolesCallOptions): Promise<{
+        role: RoleRecord;
+    }>;
+    updateRole(required: {
+        roleId: string;
+        name: string;
+    }, optional?: RolesCallOptions): Promise<{
+        role: RoleRecord;
+    }>;
+    deleteRole(required: {
+        roleId: string;
+    }, optional?: RolesCallOptions): Promise<void>;
+    createPolicy(required: {
+        name: string;
+    }, optional?: RolesCallOptions & {
+        description?: string;
+    }): Promise<{
+        policy: PolicyRecord;
+    }>;
+    updatePolicy(required: {
+        policyId: string;
+    }, optional?: RolesCallOptions & {
+        name?: string;
+        description?: string;
+    }): Promise<{
+        policy: PolicyRecord;
+    }>;
+    deletePolicy(required: {
+        policyId: string;
+    }, optional?: RolesCallOptions): Promise<void>;
+    listPolicyPermissions(required: {
+        policyId: string;
+    }, optional?: RolesCallOptions): Promise<{
+        policyPermissions: PolicyPermissionRecord[];
+    }>;
+    writePolicyPermission(required: {
+        policyId: string;
+        permission: string;
+    }, optional?: RolesCallOptions & {
+        resourceType?: string;
+    }): Promise<{
+        policyPermission: PolicyPermissionRecord;
+    }>;
+    removePolicyPermission(required: {
+        policyId: string;
+        policyPermissionId: string;
+    }, optional?: RolesCallOptions): Promise<void>;
+}
+/** Transport authenticates and applies a host API prefix. Server authorization is mandatory. */
+export interface RolesHttpTransport {
+    request<T>(required: {
+        path: string;
+        method: 'GET' | 'POST' | 'PATCH' | 'DELETE';
+        body?: Readonly<Record<string, unknown>>;
+    }, optional?: RolesCallOptions): Promise<T>;
+}
+export declare class RolesApiError extends Error {
+    readonly code: string;
+    constructor(required: {
+        code: string;
+        message: string;
+    }, optional?: ErrorOptions);
+}
+export interface UsersApiPort {
+    listUsers(required: Record<string, never>, optional?: RolesCallOptions): Promise<{
+        users: import('./models.js').AdminOperator[];
+    }>;
+    listRoles(required: Record<string, never>, optional?: RolesCallOptions): Promise<{
+        roles: RoleRecord[];
+    }>;
+    listPolicies(required: Record<string, never>, optional?: RolesCallOptions): Promise<{
+        policies: PolicyRecord[];
+    }>;
+    me(required: Record<string, never>, optional?: RolesCallOptions): Promise<import('./models.js').CallerInfo>;
+    createUser(required: {
+        username: string;
+        password: string;
+    }, optional?: RolesCallOptions & {
+        email?: string;
+    }): Promise<{
+        user: import('./models.js').AdminOperator;
+    }>;
+    updateUser(required: {
+        principalId: string;
+    }, optional?: RolesCallOptions & {
+        email?: string;
+    }): Promise<{
+        user: import('./models.js').AdminOperator;
+    }>;
+    disableUser(required: {
+        principalId: string;
+    }, optional?: RolesCallOptions): Promise<{
+        user: import('./models.js').AdminOperator;
+    }>;
+    enableUser(required: {
+        principalId: string;
+    }, optional?: RolesCallOptions): Promise<{
+        user: import('./models.js').AdminOperator;
+    }>;
+    resetUserPassword(required: {
+        principalId: string;
+        password: string;
+    }, optional?: RolesCallOptions): Promise<void>;
+    assignRole(required: {
+        principalId: string;
+        roleId: string;
+    }, optional?: RolesCallOptions): Promise<{
+        assignment: unknown;
+    }>;
+    attachPolicy(required: {
+        principalId: string;
+        policyId: string;
+    }, optional?: RolesCallOptions): Promise<{
+        attachment: unknown;
+    }>;
+    deleteUser(required: {
+        principalId: string;
+    }, optional?: RolesCallOptions): Promise<void>;
+}
+/** Effective wildcard ownership cannot be guessed from a role's display name. The host supplies
+ * an authoritative, current classification; missing or unresolved data always denies writes. */
+export interface UsersSafetyPort {
+    ownerStatus(required: {
+        principalId: string;
+    }, optional?: Record<string, never>): 'owner' | 'operator' | 'unknown';
+    readonly seededOwnerPrincipalId: string | null;
+}
+export interface MembersApiPort {
+    listMembers(required: Record<string, never>, optional?: RolesCallOptions & {
+        afterId?: string;
+        limit?: number;
+    }): Promise<{
+        members: import('./models.js').AdminMember[];
+    }>;
+    getMember(required: {
+        id: string;
+    }, optional?: RolesCallOptions): Promise<{
+        member: import('./models.js').AdminMember;
+    }>;
+    disableMember(required: {
+        id: string;
+    }, optional?: RolesCallOptions): Promise<{
+        member: import('./models.js').AdminMember;
+    }>;
+    requestMemberMagicLink(required: {
+        email: string;
+    }, optional?: RolesCallOptions & {
+        redirectPath?: string;
+    }): Promise<{
+        delivered: true;
+    }>;
+}
+/** The host scopes notifications before calling onRefresh, and owns event topic names. */
+export interface MembersRefreshPort {
+    subscribe(required: {
+        onRefresh: () => void;
+    }, optional?: Record<string, never>): () => void;
+}
+export interface AuthApiPort {
+    login(required: {
+        username: string;
+        password: string;
+    }, optional?: RolesCallOptions): Promise<{
+        user: import('./models.js').AdminAccount;
+    }>;
+}
+export declare class PeopleApiError extends Error {
+    readonly code: string;
+    constructor(required: {
+        code: string;
+        message: string;
+    }, optional?: ErrorOptions);
+}
+//# sourceMappingURL=ports.d.ts.map

package/dist/admin/ports.js

@@ -0,0 +1,17 @@
+export class RolesApiError extends Error {
+    code;
+    constructor(required, optional = {}) {
+        super(required.message, optional);
+        this.name = 'RolesApiError';
+        this.code = required.code;
+    }
+}
+export class PeopleApiError extends Error {
+    code;
+    constructor(required, optional = {}) {
+        super(required.message, optional);
+        this.name = 'PeopleApiError';
+        this.code = required.code;
+    }
+}
+//# sourceMappingURL=ports.js.map

package/dist/admin/react/components/DestructiveDialog.d.ts

@@ -0,0 +1,5 @@
+import type { ConfirmDialogProps } from '@jini-ai/ui-kit/react';
+/** Kept mounted on the shell: closing a row menu must not discard its pending confirmation.
+ * Both the frame and its controls are host-overridable through ui-kit. */
+export declare function DestructiveDialog(props: ConfirmDialogProps, _optional?: Record<string, never>): import("react").JSX.Element;
+//# sourceMappingURL=DestructiveDialog.d.ts.map

package/dist/admin/react/components/DestructiveDialog.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ConfirmDialog } from '@jini-ai/ui-kit/react';
+/** Kept mounted on the shell: closing a row menu must not discard its pending confirmation.
+ * Both the frame and its controls are host-overridable through ui-kit. */
+export function DestructiveDialog(props, _optional = {}) { return _jsx(ConfirmDialog, { ...props }); }
+//# sourceMappingURL=DestructiveDialog.js.map

package/dist/admin/react/components/MemberRow.d.ts

@@ -0,0 +1,5 @@
+import type { AdminMember } from '../../models.js';
+export declare function MemberRow({ member }: {
+    member: AdminMember;
+}, _optional?: Record<string, never>): import("react").JSX.Element;
+//# sourceMappingURL=MemberRow.d.ts.map

package/dist/admin/react/components/MemberRow.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Badge, Button, Menu, Notice, Spinner } from '@jini-ai/ui-kit/react';
+import { useMemberRow } from '../hooks/MembersPage.hooks.js';
+export function MemberRow({ member }, _optional = {}) {
+    const v = useMemberRow({ member });
+    return _jsxs(_Fragment, { children: [_jsxs("tr", { children: [_jsx("td", { children: _jsx(Button, { onPress: v.toggle, attrs: { 'aria-expanded': v.expanded }, children: member.email }) }), _jsx("td", { children: member.name ?? '—' }), _jsx("td", { children: _jsx(Badge, { children: member.status }) }), _jsx("td", { children: v.created }), _jsxs("td", { children: [v.items.length ? _jsx(Menu, { label: v.menuLabel, items: v.items }) : null, v.rs.error ? _jsx(Notice, { tone: "danger", children: v.rs.error }) : null, v.rs.notice ? _jsx(Notice, { children: v.rs.notice }) : null] })] }), v.expanded ? _jsx("tr", { children: _jsx("td", { colSpan: 5, children: v.loading ? _jsx(Spinner, { label: "Loading detail\u2026" }) : v.s.detailError ? _jsx(Notice, { tone: "danger", children: v.s.detailError }) : v.detail ? _jsxs("dl", { children: [_jsx("dt", { children: "ID" }), _jsx("dd", { children: v.detail.id }), _jsx("dt", { children: "Email verified" }), _jsx("dd", { children: v.verified }), _jsx("dt", { children: "Updated" }), _jsx("dd", { children: v.detail.updatedAt }), _jsx("dt", { children: "Version" }), _jsx("dd", { children: v.detail.version })] }) : null }) }) : null] });
+}
+//# sourceMappingURL=MemberRow.js.map

package/dist/admin/react/components/MembersConfirmation.d.ts

@@ -0,0 +1,2 @@
+export declare function MembersConfirmation(_required?: Record<string, never>, _optional?: Record<string, never>): import("react").JSX.Element;
+//# sourceMappingURL=MembersConfirmation.d.ts.map

package/dist/admin/react/components/MembersConfirmation.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ConfirmDialog } from '@jini-ai/ui-kit/react';
+import { useMembersConfirmation } from '../hooks/MembersPage.hooks.js';
+export function MembersConfirmation(_required = {}, _optional = {}) {
+    const props = useMembersConfirmation({});
+    return _jsx(ConfirmDialog, { ...props });
+}
+//# sourceMappingURL=MembersConfirmation.js.map

package/dist/admin/react/components/PermissionPanel.d.ts

@@ -0,0 +1,5 @@
+import type { PolicyRecord } from '../../models.js';
+export declare function PermissionPanel(props: {
+    policy: PolicyRecord;
+}, _optional?: Record<string, never>): import("react").JSX.Element;
+//# sourceMappingURL=PermissionPanel.d.ts.map

package/dist/admin/react/components/PermissionPanel.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, TextField, Spinner } from '@jini-ai/ui-kit/react';
+import { usePermissionPanel } from '../hooks/PermissionPanel.hooks.js';
+export function PermissionPanel(props, _optional = {}) {
+    const v = usePermissionPanel(props);
+    return _jsxs("div", { children: [_jsx("h3", { children: "Current permissions" }), v.loading ? _jsx(Spinner, { label: "Loading permissions\u2026" }) : v.empty ? _jsx("p", { children: "No permissions yet." }) :
+                _jsx("ul", { children: v.rows.map(row => _jsxs("li", { children: [_jsx("code", { children: row.permission }), row.resourceType ? _jsxs("span", { children: [" (", row.resourceType, ")"] }) : null, v.editable ? _jsx(Button, { onPress: row.requestRemove, pending: row.pending, attrs: { 'aria-label': row.removeLabel }, children: "Remove" }) : null] }, row.id)) }), v.editable ? _jsxs("form", { onSubmit: v.submit, children: [_jsx(TextField, { label: "Permission", value: v.permission, onValueChange: v.changePermission, placeholder: "e.g. content.write" }), _jsx(TextField, { label: "Resource type (optional)", value: v.resourceType, onValueChange: v.changeResourceType }), _jsx(Button, { type: "submit", pending: v.pending, disabled: v.addDisabled, children: "Add" })] }) : null] });
+}
+//# sourceMappingURL=PermissionPanel.js.map

package/dist/admin/react/components/PolicyRow.d.ts

@@ -0,0 +1,5 @@
+import type { PolicyRecord } from '../../models.js';
+export declare function PolicyRow(props: {
+    policy: PolicyRecord;
+}, _optional?: Record<string, never>): import("react").JSX.Element;
+//# sourceMappingURL=PolicyRow.d.ts.map

package/dist/admin/react/components/PolicyRow.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, TextField, Menu, Badge } from '@jini-ai/ui-kit/react';
+import { usePolicyRow } from '../hooks/PoliciesTab.hooks.js';
+import { PermissionPanel } from './PermissionPanel.js';
+export function PolicyRow(props, _optional = {}) {
+    const v = usePolicyRow(props);
+    return _jsxs(_Fragment, { children: [_jsxs("tr", { children: [_jsx("td", { children: v.editing ? _jsx(TextField, { label: "Policy new name", value: v.draft, onValueChange: v.changeName }) : v.name }), _jsx("td", { children: v.editing ? _jsx(TextField, { label: "Policy new description", value: v.draftDescription, onValueChange: v.changeDescription }) : v.description }), _jsx("td", { children: _jsx(Badge, { children: v.type }) }), _jsx("td", { children: v.editable ?
+                            v.editing ? _jsxs(_Fragment, { children: [_jsx(Button, { onPress: v.save, pending: v.pending, disabled: v.saveDisabled, children: "Save" }), _jsx(Button, { onPress: v.cancel, children: "Cancel" })] }) :
+                                _jsx(Menu, { label: v.menuLabel, items: v.menu }) : _jsx(Button, { onPress: v.viewPermissions, children: v.readLabel }) })] }), v.open ? _jsx("tr", { children: _jsx("td", { colSpan: 4, children: _jsx(PermissionPanel, { policy: props.policy }) }) }) : null] });
+}
+//# sourceMappingURL=PolicyRow.js.map

package/dist/admin/react/components/RoleRow.d.ts

@@ -0,0 +1,5 @@
+import type { RoleRecord } from '../../models.js';
+export declare function RoleRow(props: {
+    role: RoleRecord;
+}, _optional?: Record<string, never>): import("react").JSX.Element;
+//# sourceMappingURL=RoleRow.d.ts.map

package/dist/admin/react/components/RoleRow.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, TextField, Menu, Badge } from '@jini-ai/ui-kit/react';
+import { useRoleRow } from '../hooks/RolesTab.hooks.js';
+export function RoleRow(props, _optional = {}) {
+    const v = useRoleRow(props);
+    return _jsxs("tr", { children: [_jsx("td", { children: v.editing ? _jsx(TextField, { label: "Role new name", value: v.draft, onValueChange: v.changeName }) : v.name }), _jsx("td", { children: _jsx(Badge, { children: v.type }) }), _jsx("td", { children: v.editable ?
+                    v.editing ? _jsxs(_Fragment, { children: [_jsx(Button, { onPress: v.save, pending: v.pending, disabled: v.saveDisabled, children: "Save" }), _jsx(Button, { onPress: v.cancel, children: "Cancel" })] }) :
+                        _jsx(Menu, { label: v.menuLabel, items: v.menu }) : _jsx("span", { children: "\u2014" }) })] });
+}
+//# sourceMappingURL=RoleRow.js.map

package/dist/admin/react/components/UserRow.d.ts

@@ -0,0 +1,5 @@
+import type { AdminOperator } from '../../models.js';
+export declare function UserRow({ user }: {
+    user: AdminOperator;
+}, _optional?: Record<string, never>): import("react").JSX.Element;
+//# sourceMappingURL=UserRow.d.ts.map

package/dist/admin/react/components/UserRow.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Button, Badge, Menu, TextField, Select, Notice } from '@jini-ai/ui-kit/react';
+import { useUserRow } from '../hooks/UsersTab.hooks.js';
+export function UserRow({ user }, _optional = {}) {
+    const v = useUserRow({ user });
+    return _jsxs(_Fragment, { children: [_jsxs("tr", { children: [_jsx("td", { children: v.canExpand ? _jsx(Button, { onPress: v.toggle, attrs: { 'aria-expanded': v.expanded }, children: user.username }) : user.username }), _jsx("td", { children: user.email ?? '—' }), _jsx("td", { children: _jsx(Badge, { children: user.status }) }), _jsx("td", { children: v.roles }), _jsx("td", { children: v.policies }), _jsx("td", { children: v.items.length ? _jsx(Menu, { label: v.menuLabel, items: v.items, disabled: v.s.confirming || v.s.rowSavingId !== null }) : null })] }), v.expanded ? _jsx("tr", { children: _jsxs("td", { colSpan: 6, children: [v.s.grantError ? _jsx(Notice, { tone: "danger", children: v.s.grantError }) : null, v.canEmail ? _jsxs(_Fragment, { children: [_jsx(TextField, { label: "Email", type: "email", value: v.s.editEmail, onValueChange: v.email }), _jsx(Button, { onPress: v.saveEmail, pending: v.s.grantSaving, children: "Save email" })] }) : null, v.canGrants ? _jsxs(_Fragment, { children: [_jsx(Select, { label: "Assign role", value: v.s.pendingRoleId, onValueChange: v.role, options: v.roleOptions }), _jsx(Button, { onPress: v.assignRole, disabled: !v.s.pendingRoleId, pending: v.s.grantSaving, children: "Assign" }), _jsx(Select, { label: "Attach policy", value: v.s.pendingPolicyId, onValueChange: v.policy, options: v.policyOptions }), _jsx(Button, { onPress: v.attachPolicy, disabled: !v.s.pendingPolicyId, pending: v.s.grantSaving, children: "Attach" })] }) : null] }) }) : null] });
+}
+//# sourceMappingURL=UserRow.js.map

package/dist/admin/react/components/UsersConfirmation.d.ts

@@ -0,0 +1,3 @@
+/** Kept mounted independently of row menus. Confirmation and cancellation share ui-kit's guards. */
+export declare function UsersConfirmation(_required?: Record<string, never>, _optional?: Record<string, never>): import("react").JSX.Element;
+//# sourceMappingURL=UsersConfirmation.d.ts.map

package/dist/admin/react/components/UsersConfirmation.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { ConfirmDialog, TextField, Button, Notice } from '@jini-ai/ui-kit/react';
+import { useUsersConfirmation, newPasswordAttrs } from '../hooks/UsersTab.hooks.js';
+/** Kept mounted independently of row menus. Confirmation and cancellation share ui-kit's guards. */
+export function UsersConfirmation(_required = {}, _optional = {}) {
+    const v = useUsersConfirmation({});
+    return _jsx(ConfirmDialog, { ...v.confirm, body: _jsxs("div", { children: [_jsx("p", { children: v.s.pending?.user.username }), _jsx("p", { children: v.copy.body }), v.reset ? _jsxs(_Fragment, { children: [_jsx(TextField, { label: "New password", type: v.newType, attrs: newPasswordAttrs, value: v.s.newPassword, onValueChange: v.newPassword, disabled: v.s.confirming }), _jsx(Button, { onPress: v.toggleNew, attrs: { 'aria-pressed': v.s.showNewPassword }, children: v.newLabel }), _jsx(TextField, { label: "Confirm new password", type: v.confirmType, attrs: newPasswordAttrs, value: v.s.confirmPassword, onValueChange: v.confirmPassword, disabled: v.s.confirming }), _jsx(Button, { onPress: v.toggleConfirm, attrs: { 'aria-pressed': v.s.showConfirmPassword }, children: v.confirmLabel }), v.error ? _jsx(Notice, { tone: "danger", children: v.error }) : null] }) : null] }) });
+}
+//# sourceMappingURL=UsersConfirmation.js.map

package/dist/admin/react/hooks/AuthBinding.hooks.d.ts

@@ -0,0 +1,39 @@
+import type { ComponentType, LazyExoticComponent, ReactNode } from 'react';
+import type { AdminInstance } from '@jini-ai/admin/core/module';
+import type { AuthApiPort } from '../../ports.js';
+import { authModule } from '../../auth.module.js';
+import type { AdminAccount } from "../../models.js";
+export interface AuthScope {
+    readonly api: AuthApiPort;
+    readonly permissions: readonly string[];
+}
+export interface AuthPageProps {
+    readonly tabs: Readonly<Record<string, LazyExoticComponent<ComponentType<{
+        readonly params?: Readonly<Record<string, unknown>>;
+    }>>>>;
+    readonly description: ReturnType<AdminInstance['describe']>['pages'][number];
+    readonly title?: string;
+    readonly initialUsername?: string;
+    readonly onLogin: (required: {
+        user: AdminAccount;
+    }, optional?: Record<string, never>) => void;
+}
+export declare function useAuthScope(_required?: Record<string, never>, _optional?: Record<string, never>): AuthScope;
+/** Descriptor identity must be the exact enriched object supplied to createAdmin. */
+export declare function createAuthBinding({ module }: {
+    module: typeof authModule;
+}, _optional?: Record<string, never>): {
+    pages: {
+        auth: {
+            Page: LazyExoticComponent<typeof import("../pages/LoginPage.js").default>;
+            tabs: {
+                auth: LazyExoticComponent<typeof import("../tabs/AuthTab.js").default>;
+            };
+        };
+    };
+    Provider: ({ admin, children }: {
+        admin: AdminInstance;
+        children: ReactNode;
+    }, _optional?: Record<string, never>) => import("react").FunctionComponentElement<import("react").ProviderProps<AuthScope | null>>;
+};
+//# sourceMappingURL=AuthBinding.hooks.d.ts.map

package/dist/admin/react/hooks/AuthBinding.hooks.js

@@ -0,0 +1,21 @@
+import { createContext, createElement, lazy, useContext } from 'react';
+import { authModule } from '../../auth.module.js';
+const ScopeContext = createContext(null);
+export function useAuthScope(_required = {}, _optional = {}) {
+    const scope = useContext(ScopeContext);
+    if (!scope)
+        throw new Error('Auth admin scope is unavailable.');
+    return scope;
+}
+/** Descriptor identity must be the exact enriched object supplied to createAdmin. */
+export function createAuthBinding({ module }, _optional = {}) {
+    const pages = { auth: { Page: lazy(() => import('../pages/LoginPage.js')), tabs: { auth: lazy(() => import('../tabs/AuthTab.js')) } } };
+    function Provider({ admin, children }, _optional = {}) {
+        const ports = admin.scope({ module });
+        const description = admin.describe().pages.find(p => p.id === 'auth.auth');
+        const value = { api: ports.authApi, permissions: description?.grants ?? [] };
+        return createElement(ScopeContext.Provider, { value }, children);
+    }
+    return { pages, Provider };
+}
+//# sourceMappingURL=AuthBinding.hooks.js.map

package/dist/admin/react/hooks/LoginPage.hooks.d.ts

@@ -0,0 +1,54 @@
+import type { FormEvent } from 'react';
+import type { AuthState } from '../../models.js';
+import type { AuthController } from '../../controllers/auth.controller.js';
+import type { AuthPageProps } from './AuthBinding.hooks.js';
+export interface AuthView {
+    controller: AuthController;
+    state: AuthState;
+}
+export declare const AuthViewContext: import("react").Context<AuthView | null>;
+export declare function useLoginPage(props: AuthPageProps, _optional?: Record<string, never>): {
+    content: import("react").FunctionComponentElement<{
+        readonly params?: Readonly<Record<string, unknown>>;
+    } | ({
+        readonly params?: Readonly<Record<string, unknown>>;
+    } & import("react").RefAttributes<import("react").Component<{
+        readonly params?: Readonly<Record<string, unknown>>;
+    }, any, any>>)> | null;
+    visible: boolean;
+    view: {
+        state: AuthState;
+        controller: {
+            getSnapshot: (_required?: Record<string, never>, _optional?: Record<string, never>) => Readonly<AuthState>;
+            subscribe: ({ listener }: {
+                listener: () => void;
+            }, _optional?: Record<string, never>) => () => void;
+            dispose(_required?: Record<string, never>, _optional?: Record<string, never>): void;
+            setDraft({ patch }: {
+                patch: Pick<Partial<AuthState>, "username" | "password">;
+            }, _optional?: Record<string, never>): void;
+            submit(_required: Record<string, never>, _optional?: Record<string, never>): Promise<boolean>;
+        };
+    } | null;
+    title: string;
+};
+export declare function useAuthTab(_required?: Record<string, never>, _optional?: Record<string, never>): {
+    s: AuthState;
+    username: ({ value }: {
+        value: string;
+    }) => void;
+    password: ({ value }: {
+        value: string;
+    }) => void;
+    submit: (e: FormEvent) => void;
+    submitLabel: string;
+    usernameAttrs: {
+        autoComplete: string;
+        'data-jini-part': string;
+    };
+    passwordAttrs: {
+        autoComplete: string;
+        'data-jini-part': string;
+    };
+};
+//# sourceMappingURL=LoginPage.hooks.d.ts.map

package/dist/admin/react/hooks/LoginPage.hooks.js

@@ -0,0 +1,23 @@
+import { createElement, createContext, useContext, useMemo } from 'react';
+import { createAuthController } from '../../controllers/auth.controller.js';
+import { useAuthScope } from './AuthBinding.hooks.js';
+import { usePeopleController } from './PeopleController.hooks.js';
+export const AuthViewContext = createContext(null);
+export function useLoginPage(props, _optional = {}) {
+    const { api } = useAuthScope({});
+    const scope = useMemo(() => ({ api, onLogin: props.onLogin }), [api, props.onLogin]);
+    const { controller, state } = usePeopleController({ scope, key: props.initialUsername ?? 'admin',
+        create: () => createAuthController({ api, onLogin: props.onLogin }, { ...(props.initialUsername !== undefined ? { initialUsername: props.initialUsername } : {}) }), start: () => { },
+    });
+    return { content: props.tabs.auth ? createElement(props.tabs.auth, {}) : null, visible: props.description.visible && props.description.tabs.some(t => t.visible), view: state && controller ? { state, controller } : null, title: props.title ?? 'Sign in to your workspace' };
+}
+export function useAuthTab(_required = {}, _optional = {}) {
+    const v = useContext(AuthViewContext);
+    if (!v)
+        throw new Error('Login controller unavailable.');
+    const { state: s, controller: c } = v;
+    return { s, username: ({ value }) => c.setDraft({ patch: { username: value } }), password: ({ value }) => c.setDraft({ patch: { password: value } }),
+        submit: (e) => { e.preventDefault(); void c.submit({}); }, submitLabel: s.busy ? 'Signing in…' : 'Sign in',
+        usernameAttrs: { autoComplete: 'username', 'data-jini-part': 'username' }, passwordAttrs: { autoComplete: 'current-password', 'data-jini-part': 'password' } };
+}
+//# sourceMappingURL=LoginPage.hooks.js.map

package/dist/admin/react/hooks/MembersBinding.hooks.d.ts

@@ -0,0 +1,35 @@
+import type { ComponentType, LazyExoticComponent, ReactNode } from 'react';
+import type { AdminInstance } from '@jini-ai/admin/core/module';
+import type { MembersApiPort } from '../../ports.js';
+import { membersModule } from '../../members.module.js';
+import type { MembersRefreshPort } from "../../ports.js";
+export interface MembersScope {
+    readonly api: MembersApiPort;
+    readonly permissions: readonly string[];
+}
+export interface MembersPageProps {
+    readonly tabs: Readonly<Record<string, LazyExoticComponent<ComponentType<{
+        readonly params?: Readonly<Record<string, unknown>>;
+    }>>>>;
+    readonly description: ReturnType<AdminInstance['describe']>['pages'][number];
+    readonly refresh?: MembersRefreshPort;
+}
+export declare function useMembersScope(_required?: Record<string, never>, _optional?: Record<string, never>): MembersScope;
+/** Descriptor identity must be the exact enriched object supplied to createAdmin. */
+export declare function createMembersBinding({ module }: {
+    module: typeof membersModule;
+}, _optional?: Record<string, never>): {
+    pages: {
+        members: {
+            Page: LazyExoticComponent<typeof import("../pages/MembersPage.js").default>;
+            tabs: {
+                members: LazyExoticComponent<typeof import("../tabs/MembersTab.js").default>;
+            };
+        };
+    };
+    Provider: ({ admin, children }: {
+        admin: AdminInstance;
+        children: ReactNode;
+    }, _optional?: Record<string, never>) => import("react").FunctionComponentElement<import("react").ProviderProps<MembersScope | null>>;
+};
+//# sourceMappingURL=MembersBinding.hooks.d.ts.map

package/dist/admin/react/hooks/MembersBinding.hooks.js

@@ -0,0 +1,21 @@
+import { createContext, createElement, lazy, useContext } from 'react';
+import { membersModule } from '../../members.module.js';
+const ScopeContext = createContext(null);
+export function useMembersScope(_required = {}, _optional = {}) {
+    const scope = useContext(ScopeContext);
+    if (!scope)
+        throw new Error('Members admin scope is unavailable.');
+    return scope;
+}
+/** Descriptor identity must be the exact enriched object supplied to createAdmin. */
+export function createMembersBinding({ module }, _optional = {}) {
+    const pages = { members: { Page: lazy(() => import('../pages/MembersPage.js')), tabs: { members: lazy(() => import('../tabs/MembersTab.js')) } } };
+    function Provider({ admin, children }, _optional = {}) {
+        const ports = admin.scope({ module });
+        const description = admin.describe().pages.find(p => p.id === 'members.members');
+        const value = { api: ports.membersApi, permissions: description?.grants ?? [] };
+        return createElement(ScopeContext.Provider, { value }, children);
+    }
+    return { pages, Provider };
+}
+//# sourceMappingURL=MembersBinding.hooks.js.map

package/dist/admin/react/hooks/MembersPage.hooks.d.ts

@@ -0,0 +1,99 @@
+import type { MembersState, AdminMember } from '../../models.js';
+import type { MembersController } from '../../controllers/members.controller.js';
+import type { MenuItem } from '@jini-ai/ui-kit/react';
+import type { MembersPageProps } from './MembersBinding.hooks.js';
+export interface MembersView {
+    controller: MembersController;
+    state: MembersState;
+    canManage: boolean;
+}
+export declare const MembersViewContext: import("react").Context<MembersView | null>;
+export declare function useMembersView(_required?: Record<string, never>, _optional?: Record<string, never>): MembersView;
+export declare function useMembersPage(props: MembersPageProps, _optional?: Record<string, never>): {
+    content: import("react").FunctionComponentElement<{
+        readonly params?: Readonly<Record<string, unknown>>;
+    } | ({
+        readonly params?: Readonly<Record<string, unknown>>;
+    } & import("react").RefAttributes<import("react").Component<{
+        readonly params?: Readonly<Record<string, unknown>>;
+    }, any, any>>)> | null;
+    state: MembersState | null;
+    controller: {
+        getSnapshot: (_required?: Record<string, never>, _optional?: Record<string, never>) => Readonly<MembersState>;
+        subscribe: ({ listener }: {
+            listener: () => void;
+        }, _optional?: Record<string, never>) => () => void;
+        load: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<void>;
+        stateFor: ({ id }: {
+            id: string;
+        }, _optional?: Record<string, never>) => import("../../models.js").MemberRowState;
+        toggleDetail: ({ id }: {
+            id: string;
+        }, _optional?: Record<string, never>) => Promise<void>;
+        resendSignInLink: ({ id }: {
+            id: string;
+        }, _optional?: Record<string, never>) => Promise<boolean>;
+        confirmDestructive: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<boolean>;
+        requestDestructive({ id }: {
+            id: string;
+        }, _optional?: Record<string, never>): void;
+        cancelDestructive(_required: Record<string, never>, _optional?: Record<string, never>): void;
+        dispose(_required?: Record<string, never>, _optional?: Record<string, never>): void;
+    } | null;
+    canManage: boolean;
+    visible: boolean;
+    view: {
+        state: MembersState;
+        controller: {
+            getSnapshot: (_required?: Record<string, never>, _optional?: Record<string, never>) => Readonly<MembersState>;
+            subscribe: ({ listener }: {
+                listener: () => void;
+            }, _optional?: Record<string, never>) => () => void;
+            load: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<void>;
+            stateFor: ({ id }: {
+                id: string;
+            }, _optional?: Record<string, never>) => import("../../models.js").MemberRowState;
+            toggleDetail: ({ id }: {
+                id: string;
+            }, _optional?: Record<string, never>) => Promise<void>;
+            resendSignInLink: ({ id }: {
+                id: string;
+            }, _optional?: Record<string, never>) => Promise<boolean>;
+            confirmDestructive: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<boolean>;
+            requestDestructive({ id }: {
+                id: string;
+            }, _optional?: Record<string, never>): void;
+            cancelDestructive(_required: Record<string, never>, _optional?: Record<string, never>): void;
+            dispose(_required?: Record<string, never>, _optional?: Record<string, never>): void;
+        };
+        canManage: boolean;
+    } | null;
+    retry: () => void;
+};
+export declare function useMemberRow({ member }: {
+    member: AdminMember;
+}, _optional?: Record<string, never>): {
+    s: MembersState;
+    rs: import("../../models.js").MemberRowState;
+    items: MenuItem[];
+    menuLabel: string;
+    expanded: boolean;
+    detail: AdminMember | undefined;
+    loading: boolean;
+    toggle: () => void;
+    verified: string;
+    created: string;
+};
+export declare function useMembersConfirmation(_required?: Record<string, never>, _optional?: Record<string, never>): {
+    open: boolean;
+    title: string;
+    body: string;
+    confirmLabel: string;
+    tone: "warning";
+    consequence: string;
+    pending: boolean;
+    agentMayConfirm: boolean;
+    onConfirm: () => Promise<void>;
+    onCancel: () => void;
+};
+//# sourceMappingURL=MembersPage.hooks.d.ts.map