@jini-ai/user-management 0.6.15-rc.2 → 0.6.16

package/dist/admin/controllers/roles.controller.js

@@ -17,17 +17,20 @@ export function createRolesController({ api }, { permissions = [] } = {}) {
     const abort = new AbortController();
     const call = { signal: abort.signal };
     const set = (patch) => {
-        if (disposed)
+        if (disposed) {
             return;
+        }
         const immutablePatch = patch.permissionRows ? { ...patch, permissionRows: Object.freeze([...patch.permissionRows]) } : patch;
         state = Object.freeze({ ...state, ...immutablePatch });
-        for (const listener of listeners)
+        for (const listener of listeners) {
             listener();
+        }
     };
     const report = (error, fallback) => describeRolesError({ error, fallback });
     const gate = () => {
-        if (disposed || state.confirming)
+        if (disposed || state.confirming) {
             return false;
+        }
         if (!canManageRoles({ permissions: grants })) {
             set({ rowError: m.forbidden });
             return false;
@@ -68,147 +71,188 @@ export function createRolesController({ api }, { permissions = [] } = {}) {
             set({ rowError: report(error, fallback) });
         }
         finally {
-            if (state.rowSavingId === id)
+            if (state.rowSavingId === id) {
                 set({ rowSavingId: null });
+            }
         }
         return saved;
     }
     async function load(_required, _optional = {}) {
-        if (disposed)
+        if (disposed) {
             return;
-        const generation = ++listGeneration;
+        }
+        ++listGeneration;
+        const generation = listGeneration;
         set({ error: null });
         try {
             const [r, p] = await Promise.all([api.listRoles({}, call), api.listPolicies({}, call)]);
-            if (generation === listGeneration)
+            if (generation === listGeneration) {
                 set({ roles: rows(r.roles), policies: rows(p.policies) });
+            }
         }
         catch (error) {
-            if (generation === listGeneration)
+            if (generation === listGeneration) {
                 set({ error: report(error, 'Failed to load roles/policies.') });
+            }
         }
     }
     async function loadPermissions({ policyId }, _optional = {}) {
-        if (disposed || state.permissionPolicyId !== policyId)
+        if (disposed || state.permissionPolicyId !== policyId) {
             return;
+        }
         // Start order, rather than completion order, owns rows AND failures. Closing also invalidates.
-        const generation = ++permissionGeneration;
+        ++permissionGeneration;
+        const generation = permissionGeneration;
         set({ permissionsLoading: true });
         try {
             const result = await api.listPolicyPermissions({ policyId }, call);
-            if (generation === permissionGeneration && state.permissionPolicyId === policyId)
+            if (generation === permissionGeneration && state.permissionPolicyId === policyId) {
                 set({ permissionRows: rows(result.policyPermissions) });
+            }
         }
         catch (error) {
-            if (generation === permissionGeneration && state.permissionPolicyId === policyId)
+            if (generation === permissionGeneration && state.permissionPolicyId === policyId) {
                 set({ permissionRows: [], rowError: report(error, 'Failed to load permissions.') });
+            }
         }
         finally {
-            if (generation === permissionGeneration)
+            if (generation === permissionGeneration) {
                 set({ permissionsLoading: false });
+            }
         }
     }
     async function togglePermissions({ policyId }, _optional = {}) {
-        if (disposed || !policy(policyId))
+        if (disposed || !policy(policyId)) {
             return;
+        }
         const next = state.permissionPolicyId === policyId ? null : policyId;
         ++panelGeneration;
         ++permissionGeneration;
         // Clear first so reopening cannot flash the previous policy's permissions.
         set({ permissionPolicyId: next, permissionRows: [], permissionsLoading: false, permissionInput: '', resourceTypeInput: '', rowError: null });
-        if (next)
+        if (next) {
             await loadPermissions({ policyId: next });
+        }
     }
     async function createRole(_required, _optional = {}) {
-        if (!gate() || state.roleSaving)
+        if (!gate() || state.roleSaving) {
             return false;
+        }
         const name = state.roleName;
-        return formWrite({ saving: 'roleSaving', error: 'roleError', fallback: 'Failed to create role.', run: async () => {
+        return formWrite({
+            saving: 'roleSaving', error: 'roleError', fallback: 'Failed to create role.', run: async () => {
                 await api.createRole({ name }, call);
-                if (state.roleName === name)
+                if (state.roleName === name) {
                     set({ roleName: '' });
-            } });
+                }
+            }
+        });
     }
     async function createPolicy(_required, _optional = {}) {
-        if (!gate() || state.policySaving)
+        if (!gate() || state.policySaving) {
             return false;
+        }
         const name = state.policyName, description = state.policyDescription;
-        return formWrite({ saving: 'policySaving', error: 'policyError', fallback: 'Failed to create policy.', run: async () => {
+        return formWrite({
+            saving: 'policySaving', error: 'policyError', fallback: 'Failed to create policy.', run: async () => {
                 await api.createPolicy({ name }, { ...call, ...(description ? { description } : {}) });
-                if (state.policyName === name && state.policyDescription === description)
+                if (state.policyName === name && state.policyDescription === description) {
                     set({ policyName: '', policyDescription: '' });
-            } });
+                }
+            }
+        });
     }
     function editRole({ role: r }, _optional = {}) {
-        if (roleGate(role(r.id)))
+        if (roleGate(role(r.id))) {
             set({ editingRoleId: r.id, editingRoleName: r.name, rowError: null });
+        }
     }
     function editPolicy({ policy: p }, _optional = {}) {
-        if (policyGate(policy(p.id)))
+        if (policyGate(policy(p.id))) {
             set({ editingPolicyId: p.id, editingPolicyName: p.name, editingPolicyDescription: p.description ?? '', rowError: null });
+        }
     }
     async function saveRole(_required, _optional = {}) {
         const id = state.editingRoleId, name = state.editingRoleName;
-        if (!id || !roleGate(role(id)) || state.rowSavingId)
+        if (!id || !roleGate(role(id)) || state.rowSavingId) {
             return false;
-        return rowWrite({ id, fallback: 'Failed to rename role.', run: async () => {
+        }
+        return rowWrite({
+            id, fallback: 'Failed to rename role.', run: async () => {
                 await api.updateRole({ roleId: id, name }, call);
                 // A late save must not close another row's newer edit.
-                if (state.editingRoleId === id && state.editingRoleName === name)
+                if (state.editingRoleId === id && state.editingRoleName === name) {
                     set({ editingRoleId: null });
+                }
                 await load({});
-            } });
+            }
+        });
     }
     async function savePolicy(_required, _optional = {}) {
         const id = state.editingPolicyId, name = state.editingPolicyName, description = state.editingPolicyDescription;
-        if (!id || !policyGate(policy(id)) || state.rowSavingId)
+        if (!id || !policyGate(policy(id)) || state.rowSavingId) {
             return false;
-        return rowWrite({ id, fallback: 'Failed to update policy.', run: async () => {
+        }
+        return rowWrite({
+            id, fallback: 'Failed to update policy.', run: async () => {
                 await api.updatePolicy({ policyId: id }, { ...call, name, description });
-                if (state.editingPolicyId === id && state.editingPolicyName === name && state.editingPolicyDescription === description)
+                if (state.editingPolicyId === id && state.editingPolicyName === name && state.editingPolicyDescription === description) {
                     set({ editingPolicyId: null });
+                }
                 await load({});
-            } });
+            }
+        });
     }
     async function writePermission(_required, _optional = {}) {
         const id = state.permissionPolicyId, permission = state.permissionInput, resourceType = state.resourceTypeInput;
-        if (!id || !permission || !policyGate(policy(id)) || state.rowSavingId)
+        if (!id || !permission || !policyGate(policy(id)) || state.rowSavingId) {
             return false;
+        }
         const generation = panelGeneration;
-        return rowWrite({ id, fallback: 'Failed to add permission.', run: async () => {
+        return rowWrite({
+            id, fallback: 'Failed to add permission.', run: async () => {
                 await api.writePolicyPermission({ policyId: id, permission }, { ...call, ...(resourceType ? { resourceType } : {}) });
                 // Ordering alone cannot protect a trailing refresh: it always mints the newest generation.
                 // Check the CURRENT panel identity, and preserve a newer draft even on the same panel.
-                if (generation === panelGeneration && state.permissionInput === permission && state.resourceTypeInput === resourceType)
+                if (generation === panelGeneration && state.permissionInput === permission && state.resourceTypeInput === resourceType) {
                     set({ permissionInput: '', resourceTypeInput: '' });
-                if (state.permissionPolicyId === id)
+                }
+                if (state.permissionPolicyId === id) {
                     await loadPermissions({ policyId: id });
-            } });
+                }
+            }
+        });
     }
     function targetGate(target) {
-        if (target.kind === 'role')
+        if (target.kind === 'role') {
             return roleGate(role(target.role.id));
+        }
         return policyGate(policy(target.kind === 'policy' ? target.policy.id : target.policyId));
     }
     function capture(target) {
-        if (target.kind === 'role')
+        if (target.kind === 'role') {
             return Object.freeze({ kind: 'role', role: Object.freeze({ ...target.role }) });
-        if (target.kind === 'policy')
+        }
+        if (target.kind === 'policy') {
             return Object.freeze({ kind: 'policy', policy: Object.freeze({ ...target.policy }) });
+        }
         return Object.freeze({ kind: 'permission', policyId: target.policyId, row: Object.freeze({ ...target.row }) });
     }
     function requestDestructive({ target }, _optional = {}) {
-        if (state.confirming || !targetGate(target))
+        if (state.confirming || !targetGate(target)) {
             return;
-        if (target.kind === 'permission' && (state.permissionPolicyId !== target.policyId || !state.permissionRows.some(r => r.id === target.row.id)))
+        }
+        if (target.kind === 'permission' && (state.permissionPolicyId !== target.policyId || !state.permissionRows.some(r => r.id === target.row.id))) {
             return;
+        }
         // The menu closes after one click; shell confirmation survives that closure. Revoke also
         // needs confirmation: removing from an attached policy immediately changes live authority.
         set({ pending: capture(target), rowError: null });
     }
     function cancelDestructive(_required, _optional = {}) {
-        if (!state.confirming)
+        if (!state.confirming) {
             set({ pending: null });
+        }
     }
     async function destroy(target) {
         if (target.kind === 'role') {
@@ -227,14 +271,16 @@ export function createRolesController({ api }, { permissions = [] } = {}) {
         else {
             set({ removingPermissionId: target.row.id });
             await api.removePolicyPermission({ policyId: target.policyId, policyPermissionId: target.row.id }, call);
-            if (state.permissionPolicyId === target.policyId)
+            if (state.permissionPolicyId === target.policyId) {
                 await loadPermissions({ policyId: target.policyId });
+            }
         }
     }
     async function confirmDestructive(_required, _optional = {}) {
         const target = state.pending;
-        if (!target || state.confirming || state.rowSavingId || !targetGate(target))
+        if (!target || state.confirming || state.rowSavingId || !targetGate(target)) {
             return false;
+        }
         set({ confirming: true, rowError: null });
         let destroyed = false;
         try {
@@ -245,8 +291,9 @@ export function createRolesController({ api }, { permissions = [] } = {}) {
             set({ rowError: report(error, target.kind === 'permission' ? 'Failed to remove permission.' : `Failed to delete ${target.kind}.`) });
         }
         finally {
-            if (state.pending === target)
+            if (state.pending === target) {
                 set({ pending: null });
+            }
             set({ confirming: false, removingPermissionId: null });
         }
         return destroyed;
@@ -254,13 +301,15 @@ export function createRolesController({ api }, { permissions = [] } = {}) {
     return {
         getSnapshot(_required = {}, _optional = {}) { return state; },
         subscribe({ listener }, _optional = {}) {
-            if (!disposed)
+            if (!disposed) {
                 listeners.add(listener);
+            }
             return () => { listeners.delete(listener); };
         },
         dispose(_required = {}, _optional = {}) {
-            if (disposed)
+            if (disposed) {
                 return;
+            }
             disposed = true;
             abort.abort();
             ++listGeneration;

package/dist/admin/controllers/users.controller.js

@@ -37,8 +37,10 @@ export function createUsersController({ api, safety }, { permissions = [], openO
         if (read({}).rowSavingId || !gate(principalId, kind))
             return;
         const user = row(principalId);
-        set({ pending: Object.freeze({ kind, user: snapshotUser(user) }), rowError: null, passwordError: null,
-            newPassword: '', confirmPassword: '', showNewPassword: false, showConfirmPassword: false });
+        set({
+            pending: Object.freeze({ kind, user: snapshotUser(user) }), rowError: null, passwordError: null,
+            newPassword: '', confirmPassword: '', showNewPassword: false, showConfirmPassword: false
+        });
     }
     function maybeDeepLink() {
         const s = read({});
@@ -63,7 +65,8 @@ export function createUsersController({ api, safety }, { permissions = [], openO
     async function load(_required, _optional = {}) {
         if (!store.active({}))
             return;
-        const generation = ++listGeneration;
+        ++listGeneration;
+        const generation = listGeneration;
         set({ error: null });
         try {
             const [u, r, p] = await Promise.all([api.listUsers({}, call), api.listRoles({}, call), api.listPolicies({}, call)]);
@@ -86,8 +89,10 @@ export function createUsersController({ api, safety }, { permissions = [], openO
                     const caller = await api.me({}, call);
                     if (!store.active({}) || !caller.user || typeof caller.user.id !== 'string' || !caller.user.id)
                         return;
-                    const safeCaller = Object.freeze({ user: Object.freeze({ ...caller.user }), canManageUserTrash: caller.canManageUserTrash === true,
-                        ...(caller.effectivePermissions ? { effectivePermissions: Object.freeze([...caller.effectivePermissions]) } : {}) });
+                    const safeCaller = Object.freeze({
+                        user: Object.freeze({ ...caller.user }), canManageUserTrash: caller.canManageUserTrash === true,
+                        ...(caller.effectivePermissions ? { effectivePermissions: Object.freeze([...caller.effectivePermissions]) } : {})
+                    });
                     set({ caller: safeCaller });
                     maybeDeepLink();
                 }
@@ -127,12 +132,18 @@ export function createUsersController({ api, safety }, { permissions = [], openO
     /** Per-kind panel writes: the authority checked, the selection that must be present, the call,
      * and the selection cleared on success (email keeps its field, but still notifies). */
     const panelWrites = {
-        email: { action: 'email', fallback: 'failed to update email', cleared: {}, missing: () => false,
-            write: (principalId, s) => api.updateUser({ principalId }, { ...call, email: s.editEmail }) },
-        role: { action: 'grants', fallback: 'failed to assign role', cleared: { pendingRoleId: '' }, missing: s => !s.pendingRoleId,
-            write: (principalId, s) => api.assignRole({ principalId, roleId: s.pendingRoleId }, call) },
-        policy: { action: 'grants', fallback: 'failed to attach policy', cleared: { pendingPolicyId: '' }, missing: s => !s.pendingPolicyId,
-            write: (principalId, s) => api.attachPolicy({ principalId, policyId: s.pendingPolicyId }, call) },
+        email: {
+            action: 'email', fallback: 'failed to update email', cleared: {}, missing: () => false,
+            write: (principalId, s) => api.updateUser({ principalId }, { ...call, email: s.editEmail })
+        },
+        role: {
+            action: 'grants', fallback: 'failed to assign role', cleared: { pendingRoleId: '' }, missing: s => !s.pendingRoleId,
+            write: (principalId, s) => api.assignRole({ principalId, roleId: s.pendingRoleId }, call)
+        },
+        policy: {
+            action: 'grants', fallback: 'failed to attach policy', cleared: { pendingPolicyId: '' }, missing: s => !s.pendingPolicyId,
+            write: (principalId, s) => api.attachPolicy({ principalId, policyId: s.pendingPolicyId }, call)
+        },
     };
     /** Busy, expanded-row and authority checks run before the selection check, so only a refusal of authority reports. */
     function panelSavable(s, principalId, panel) {

package/dist/admin/error-copy.js

@@ -1,7 +1,9 @@
 /** Shared pieces of the People and Roles error-copy mappers (`describePeopleError`, `describeRolesError`). */
 /** The string `code` of a structured error, or undefined when there is none. */
 export function errorCode({ error }, _optional = {}) {
-    return error && typeof error === 'object' && 'code' in error && typeof error.code === 'string' ? error.code : undefined;
+    if (!error || typeof error !== 'object' || !('code' in error))
+        return undefined;
+    return typeof error.code === 'string' ? error.code : undefined;
 }
 /** A real Error's non-empty message, else the given fallback copy. */
 export function errorMessageOr({ error, fallback }, _optional = {}) {

package/dist/admin/ports.d.ts

@@ -1,3 +1,4 @@
+import type { AdminOperator, CallerInfo, AdminMember, AdminAccount } from './models.js';
 import type { RoleRecord, PolicyRecord, PolicyPermissionRecord } from './models.js';
 export interface RolesCallOptions {
     readonly signal?: AbortSignal;
@@ -76,7 +77,7 @@ export declare class RolesApiError extends Error {
 }
 export interface UsersApiPort {
     listUsers(required: Record<string, never>, optional?: RolesCallOptions): Promise<{
-        users: import('./models.js').AdminOperator[];
+        users: AdminOperator[];
     }>;
     listRoles(required: Record<string, never>, optional?: RolesCallOptions): Promise<{
         roles: RoleRecord[];
@@ -84,31 +85,31 @@ export interface UsersApiPort {
     listPolicies(required: Record<string, never>, optional?: RolesCallOptions): Promise<{
         policies: PolicyRecord[];
     }>;
-    me(required: Record<string, never>, optional?: RolesCallOptions): Promise<import('./models.js').CallerInfo>;
+    me(required: Record<string, never>, optional?: RolesCallOptions): Promise<CallerInfo>;
     createUser(required: {
         username: string;
         password: string;
     }, optional?: RolesCallOptions & {
         email?: string;
     }): Promise<{
-        user: import('./models.js').AdminOperator;
+        user: AdminOperator;
     }>;
     updateUser(required: {
         principalId: string;
     }, optional?: RolesCallOptions & {
         email?: string;
     }): Promise<{
-        user: import('./models.js').AdminOperator;
+        user: AdminOperator;
     }>;
     disableUser(required: {
         principalId: string;
     }, optional?: RolesCallOptions): Promise<{
-        user: import('./models.js').AdminOperator;
+        user: AdminOperator;
     }>;
     enableUser(required: {
         principalId: string;
     }, optional?: RolesCallOptions): Promise<{
-        user: import('./models.js').AdminOperator;
+        user: AdminOperator;
     }>;
     resetUserPassword(required: {
         principalId: string;
@@ -143,17 +144,17 @@ export interface MembersApiPort {
         afterId?: string;
         limit?: number;
     }): Promise<{
-        members: import('./models.js').AdminMember[];
+        members: AdminMember[];
     }>;
     getMember(required: {
         id: string;
     }, optional?: RolesCallOptions): Promise<{
-        member: import('./models.js').AdminMember;
+        member: AdminMember;
     }>;
     disableMember(required: {
         id: string;
     }, optional?: RolesCallOptions): Promise<{
-        member: import('./models.js').AdminMember;
+        member: AdminMember;
     }>;
     requestMemberMagicLink(required: {
         email: string;
@@ -174,7 +175,7 @@ export interface AuthApiPort {
         username: string;
         password: string;
     }, optional?: RolesCallOptions): Promise<{
-        user: import('./models.js').AdminAccount;
+        user: AdminAccount;
     }>;
 }
 export declare class PeopleApiError extends Error {

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

@@ -3,7 +3,8 @@ 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] });
+    const permissions = 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)) });
+    return _jsxs("div", { children: [_jsx("h3", { children: "Current permissions" }), v.loading ? _jsx(Spinner, { label: "Loading permissions\u2026" }) : permissions, 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.js

@@ -4,8 +4,9 @@ import { usePolicyRow } from '../hooks/PoliciesTab.hooks.js';
 import { PermissionPanel } from './PermissionPanel.js';
 export function PolicyRow(props, _optional = {}) {
     const v = usePolicyRow(props);
+    const editActions = 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 });
     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] });
+                            editActions : _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.js

@@ -3,8 +3,9 @@ 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);
+    const editActions = 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 });
     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" }) })] });
+                    editActions : _jsx("span", { children: "\u2014" }) })] });
 }
 //# sourceMappingURL=RoleRow.js.map

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

@@ -1,6 +1,5 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { ConfirmDialog, Notice } from '@jini-ai/ui-kit/react';
-import { SecretInput } from '@jini-ai/ui';
+import { ConfirmDialog, Notice, SecretInput } from '@jini-ai/ui-kit/react';
 import { useId } from 'react';
 import { useUsersConfirmation, newPasswordAttrs } from '../hooks/UsersTab.hooks.js';
 /** Kept mounted independently of row menus. Confirmation and cancellation share ui-kit's guards. */

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

@@ -3,8 +3,9 @@ import { createContext, useContext } from 'react';
 export const ScopeContext = createContext(null);
 export function useAuthScope(_required = {}, _optional = {}) {
     const scope = useContext(ScopeContext);
-    if (!scope)
+    if (!scope) {
         throw new Error('Auth admin scope is unavailable.');
+    }
     return scope;
 }
 //# sourceMappingURL=AuthScope.hooks.js.map

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

@@ -4,35 +4,48 @@ import { hasAdminGrant } from '../../people.rules.js';
 import { useMembersScope } from './MembersScope.hooks.js';
 import { usePeopleController } from './PeopleController.hooks.js';
 export const MembersViewContext = createContext(null);
-export function useMembersView(_required = {}, _optional = {}) { const v = useContext(MembersViewContext); if (!v)
-    throw new Error('Members controller unavailable.'); return v; }
+export function useMembersView(_required = {}, _optional = {}) {
+    const v = useContext(MembersViewContext);
+    if (!v) {
+        throw new Error('Members controller unavailable.');
+    }
+    return v;
+}
 export function useMembersPage(props, _optional = {}) {
     const { api, permissions } = useMembersScope({});
     const scope = useMemo(() => ({ api, refresh: props.refresh }), [api, props.refresh]);
     const key = JSON.stringify(permissions);
-    const { controller, state } = usePeopleController({ scope, key,
+    const { controller, state } = usePeopleController({
+        scope, key,
         create: () => createMembersController({ api }, { permissions, ...(props.refresh ? { refresh: props.refresh } : {}) }), start: c => { void c.load({}); },
     });
     const canManage = hasAdminGrant({ permissions, permission: 'member.manage' });
-    return { content: props.tabs.members ? createElement(props.tabs.members, {}) : null, state, controller, canManage, visible: props.description.visible && props.description.tabs.some(t => t.visible),
-        view: state && controller ? { state, controller, canManage } : null, retry: () => { void controller?.load({}); } };
+    return {
+        content: props.tabs.members ? createElement(props.tabs.members, {}) : null, state, controller, canManage, visible: props.description.visible && props.description.tabs.some(t => t.visible),
+        view: state && controller ? { state, controller, canManage } : null, retry: () => { void controller?.load({}); }
+    };
 }
 export function useMemberRow({ member }, _optional = {}) {
     const { state: s, controller: c, canManage } = useMembersView({}), id = member.id;
     const rs = c.stateFor({ id }), items = [];
     if (canManage) {
         items.push({ id: 'resend', label: 'Resend sign-in link', disabled: rs.resending, onPress: () => { void c.resendSignInLink({ id }); } });
-        if (member.status !== 'disabled')
+        if (member.status !== 'disabled') {
             items.push({ id: 'disable', label: 'Disable', disabled: rs.disabling, onPress: () => c.requestDestructive({ id }) });
+        }
     }
-    return { s, rs, items, menuLabel: `Actions for member "${member.email}"`, expanded: s.expandedId === id,
+    return {
+        s, rs, items, menuLabel: `Actions for member "${member.email}"`, expanded: s.expandedId === id,
         detail: s.detailById[id], loading: s.detailLoadingId === id, toggle: () => { void c.toggleDetail({ id }); },
-        verified: s.detailById[id]?.emailVerifiedAt ?? 'not verified', created: member.createdAt, };
+        verified: s.detailById[id]?.emailVerifiedAt ?? 'not verified', created: member.createdAt,
+    };
 }
 export function useMembersConfirmation(_required = {}, _optional = {}) {
     const { state: s, controller: c } = useMembersView({});
-    return { open: s.pending !== null, title: 'Disable this member?', body: s.pending ? `Disable "${s.pending.email}"? They will no longer be able to sign in.` : '',
+    return {
+        open: s.pending !== null, title: 'Disable this member?', body: s.pending ? `Disable "${s.pending.email}"? They will no longer be able to sign in.` : '',
         confirmLabel: 'Disable', tone: 'warning', consequence: 'revokes sign-in access', pending: s.confirming, agentMayConfirm: false,
-        onConfirm: async () => { await c.confirmDestructive({}); }, onCancel: () => c.cancelDestructive({}) };
+        onConfirm: async () => { await c.confirmDestructive({}); }, onCancel: () => c.cancelDestructive({})
+    };
 }
 //# sourceMappingURL=MembersPage.hooks.js.map

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

@@ -3,8 +3,9 @@ import { createContext, useContext } from 'react';
 export const ScopeContext = createContext(null);
 export function useMembersScope(_required = {}, _optional = {}) {
     const scope = useContext(ScopeContext);
-    if (!scope)
+    if (!scope) {
         throw new Error('Members admin scope is unavailable.');
+    }
     return scope;
 }
 //# sourceMappingURL=MembersScope.hooks.js.map

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

@@ -4,19 +4,27 @@ import { hasAdminGrant } from '../../people.rules.js';
 import { useUsersScope } from './UsersScope.hooks.js';
 import { usePeopleController } from './PeopleController.hooks.js';
 export const UsersViewContext = createContext(null);
-export function useUsersView(_required = {}, _optional = {}) { const v = useContext(UsersViewContext); if (!v)
-    throw new Error('Users controller unavailable.'); return v; }
+export function useUsersView(_required = {}, _optional = {}) {
+    const v = useContext(UsersViewContext);
+    if (!v) {
+        throw new Error('Users controller unavailable.');
+    }
+    return v;
+}
 export function useUsersPage(props, _optional = {}) {
     const { api, safety, permissions } = useUsersScope({});
     const scope = useMemo(() => ({ api, safety, closed: props.onOwnPasswordResetClosed }), [api, safety, props.onOwnPasswordResetClosed]);
     const key = JSON.stringify([permissions, props.openOwnPasswordReset]);
-    const { controller, state } = usePeopleController({ scope, key,
+    const { controller, state } = usePeopleController({
+        scope, key,
         create: () => createUsersController({ api, safety }, { permissions, ...(props.openOwnPasswordReset !== undefined ? { openOwnPasswordReset: props.openOwnPasswordReset } : {}), ...(props.onOwnPasswordResetClosed ? { onOwnPasswordResetClosed: props.onOwnPasswordResetClosed } : {}) }),
         start: c => { void c.load({}); void c.loadCaller({}); },
     });
     const visible = props.description.visible && props.description.tabs.some(t => t.visible);
-    return { content: props.tabs.users ? createElement(props.tabs.users, {}) : null, controller, state, visible, view: controller && state ? { controller, state, permissions } : null,
+    return {
+        content: props.tabs.users ? createElement(props.tabs.users, {}) : null, controller, state, visible, view: controller && state ? { controller, state, permissions } : null,
         readOnly: !hasAdminGrant({ permissions, permission: 'user.manage' }) && !hasAdminGrant({ permissions, permission: 'role.manage' }),
-        retry: () => { void controller?.load({}); } };
+        retry: () => { void controller?.load({}); }
+    };
 }
 //# sourceMappingURL=UsersPage.hooks.js.map

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

@@ -3,8 +3,9 @@ import { createContext, useContext } from 'react';
 export const ScopeContext = createContext(null);
 export function useUsersScope(_required = {}, _optional = {}) {
     const scope = useContext(ScopeContext);
-    if (!scope)
+    if (!scope) {
         throw new Error('Users admin scope is unavailable.');
+    }
     return scope;
 }
 //# sourceMappingURL=UsersScope.hooks.js.map