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

package/README.md

@@ -21,6 +21,8 @@ formats. Native Argon2 is optional; construct its adapter with
 `new Argon2PasswordHasher({ loadBinding: loadArgon2Binding }, { memoryCost: 19456 })`.
 Server entry imports never pull in React or a native binding eagerly.
 
+`ensurePrincipal({ principalRepo, externalId, displayName }, { workspaceId, clock })` from the server entry ensures only a credential-free user principal (no roles/policies), using the trimmed external ID as its principal ID; scope defaults to `"local"`, inputs allow 1–255 trimmed characters, and existing rows remain unchanged. It requires the optional atomic `PrincipalRepoPort.insertIfAbsent` capability (otherwise it fails closed); durable adapters must enforce composite-key uniqueness across processes. `InMemoryPrincipalRepo` implements it for tests/dev only.
+
 React consumers install compatible React/React DOM and `@jini-ai/{ui,admin,agentic}`
 peers. These peers are optional for universal/server consumers. Mount Users
 inside `FetchQueryProvider` from `@jini-ai/ui/panel-kit`; the current provider owns

package/dist/admin/adapters/http.js

@@ -52,18 +52,28 @@ export function createHttpMembersApi({ transport, workspaceId }, { basePath = '/
         return transport.request({ path, method, ...(body ? { body } : {}) }, o.signal ? { signal: o.signal } : {});
     };
     return {
-        listMembers: (_r, o = {}) => { const query = new URLSearchParams(); if (o.afterId !== undefined)
-            query.set('afterId', o.afterId); if (o.limit !== undefined)
-            query.set('limit', String(o.limit)); return request(`${root}${query.size ? `?${query}` : ''}`, 'GET', o); },
+        listMembers: (_r, o = {}) => {
+            const query = new URLSearchParams();
+            if (o.afterId !== undefined) {
+                query.set('afterId', o.afterId);
+            }
+            if (o.limit !== undefined) {
+                query.set('limit', String(o.limit));
+            }
+            const suffix = query.size ? `?${query}` : '';
+            return request(`${root}${suffix}`, 'GET', o);
+        },
         getMember: (r, o = {}) => request(`${root}/${encodeURIComponent(r.id)}`, 'GET', o),
         disableMember: (r, o = {}) => request(`${root}/${encodeURIComponent(r.id)}/disable`, 'POST', o),
         requestMemberMagicLink: (r, o = {}) => request(`${root}/request-magic-link`, 'POST', o, { email: r.email, ...(o.redirectPath !== undefined ? { redirectPath: o.redirectPath } : {}) }),
     };
 }
 export function createHttpAuthApi({ transport }, { authPath = '/auth' } = {}) {
-    return { login: async (r, o = {}) => {
+    return {
+        login: async (r, o = {}) => {
             o.signal?.throwIfAborted();
             return transport.request({ path: `${authPath.replace(/\/$/, '')}/login`, method: 'POST', body: { username: r.username, password: r.password } }, o.signal ? { signal: o.signal } : {});
-        } };
+        }
+    };
 }
 //# sourceMappingURL=http.js.map

package/dist/admin/adapters/memory.js

@@ -9,7 +9,10 @@ function inWorkspace(records, workspaceId) {
 function check(o) { o.signal?.throwIfAborted(); }
 /** Unknown ids deliberately fail closed: they are neither owner nor operator. */
 function ownership({ known, owners, principalId }) {
-    return known.has(principalId) ? owners.has(principalId) ? 'owner' : 'operator' : 'unknown';
+    if (!known.has(principalId)) {
+        return 'unknown';
+    }
+    return owners.has(principalId) ? 'owner' : 'operator';
 }
 /** Isolated fake of the server wire contract, including immutable and issuer guards.
  * It is not a production authorizer or a persistent identity repository. */
@@ -22,38 +25,44 @@ export function createMemoryRolesApi({ workspaceId }, options = {}) {
     const id = () => {
         let next;
         do {
-            next = `memory-${++sequence}`;
+            ++sequence;
+            next = `memory-${sequence}`;
         } while (roles.has(next) || policies.has(next) || permissions.has(next));
         return next;
     };
     const fail = (code, message) => { throw new RolesApiError({ code, message }); };
     const write = (o) => {
         check(o);
-        if (!canManageRoles({ permissions: grants }))
+        if (!canManageRoles({ permissions: grants })) {
             fail('FORBIDDEN', 'Missing role.manage.');
+        }
     };
     const name = (v) => {
         const n = v.trim().normalize('NFC');
-        if (!n)
+        if (!n) {
             fail('VALIDATION_ERROR', 'Name is required.');
+        }
         return n;
     };
     const unique = (map, n, except) => {
-        if ([...map.values()].some(r => r.id !== except && r.name.toLowerCase() === n.toLowerCase()))
+        if ([...map.values()].some(r => r.id !== except && r.name.toLowerCase() === n.toLowerCase())) {
             fail('RESOURCE_CONFLICT', 'Name already exists.');
+        }
     };
     const getRole = (roleId) => roles.get(roleId) ?? fail('RESOURCE_NOT_FOUND', 'Role not found.');
     const getPolicy = (policyId) => policies.get(policyId) ?? fail('RESOURCE_NOT_FOUND', 'Policy not found.');
     const editableRole = (roleId) => {
         const r = getRole(roleId);
-        if (r.isBuiltin)
+        if (r.isBuiltin) {
             fail('VALIDATION_ERROR', 'Built-in role is immutable.');
+        }
         return r;
     };
     const editablePolicy = (policyId) => {
         const p = getPolicy(policyId);
-        if (p.isBuiltin || p.isFrozen)
+        if (p.isBuiltin || p.isFrozen) {
             fail('VALIDATION_ERROR', 'Built-in or frozen policy is immutable.');
+        }
         return p;
     };
     return {
@@ -64,16 +73,18 @@ export function createMemoryRolesApi({ workspaceId }, options = {}) {
         async deleteRole(r, o = {}) {
             write(o);
             editableRole(r.roleId);
-            if (options.referencedRoleIds?.includes(r.roleId))
+            if (options.referencedRoleIds?.includes(r.roleId)) {
                 fail('RESOURCE_CONFLICT', 'Role is still assigned.');
+            }
             roles.delete(r.roleId);
         },
         async createPolicy(r, o = {}) { write(o); const n = name(r.name); unique(policies, n); const policy = { id: id(), workspaceId, name: n, isBuiltin: false, isFrozen: false, ...(o.description !== undefined ? { description: o.description } : {}) }; policies.set(policy.id, policy); return { policy: { ...policy } }; },
         async updatePolicy(r, o = {}) {
             write(o);
             const old = editablePolicy(r.policyId);
-            if (o.name === undefined && o.description === undefined)
+            if (o.name === undefined && o.description === undefined) {
                 fail('VALIDATION_ERROR', 'At least one of name or description is required.');
+            }
             const n = o.name === undefined ? old.name : name(o.name);
             unique(policies, n, old.id);
             const policy = { ...old, name: n, ...(o.description !== undefined ? { description: o.description } : {}) };
@@ -83,21 +94,26 @@ export function createMemoryRolesApi({ workspaceId }, options = {}) {
         async deletePolicy(r, o = {}) {
             write(o);
             editablePolicy(r.policyId);
-            if (options.referencedPolicyIds?.includes(r.policyId))
+            if (options.referencedPolicyIds?.includes(r.policyId)) {
                 fail('RESOURCE_CONFLICT', 'Policy is still attached.');
+            }
             policies.delete(r.policyId);
-            for (const p of permissions.values())
-                if (p.policyId === r.policyId)
+            for (const p of permissions.values()) {
+                if (p.policyId === r.policyId) {
                     permissions.delete(p.id);
+                }
+            }
         },
         async listPolicyPermissions(r, o = {}) { check(o); getPolicy(r.policyId); return { policyPermissions: [...permissions.values()].filter(p => p.policyId === r.policyId).map(p => ({ ...p })) }; },
         async writePolicyPermission(r, o = {}) {
             write(o);
             editablePolicy(r.policyId);
-            if (!catalog.has(r.permission))
+            if (!catalog.has(r.permission)) {
                 fail('PERMISSION_UNKNOWN', 'Unrecognized permission.');
-            if (!hasAdminGrant({ permissions: grants, permission: r.permission }))
+            }
+            if (!hasAdminGrant({ permissions: grants, permission: r.permission })) {
                 fail('GRANT_EXCEEDS_ISSUER', 'Grant exceeds issuer.');
+            }
             const resourceType = o.resourceType || null;
             const policyPermission = { id: id(), workspaceId, policyId: r.policyId, permission: r.permission, resourceType, constraintJson: null };
             permissions.set(policyPermission.id, policyPermission);
@@ -107,8 +123,9 @@ export function createMemoryRolesApi({ workspaceId }, options = {}) {
             write(o);
             editablePolicy(r.policyId);
             const p = permissions.get(r.policyPermissionId);
-            if (!p || p.policyId !== r.policyId)
+            if (!p || p.policyId !== r.policyId) {
                 fail('RESOURCE_NOT_FOUND', 'Permission not found on this policy.');
+            }
             permissions.delete(r.policyPermissionId);
         },
     };
@@ -135,24 +152,36 @@ export function createMemoryUsersApi({ workspaceId }, options = {}) {
     function write(id, action, o) {
         check(o);
         const user = get(id);
-        if (trash.has(id))
+        if (trash.has(id)) {
             fail('USER_IN_TRASH', 'This user is in the Trash; restore them first.');
-        if (action === 'delete' && id === caller.user.id)
+        }
+        if (action === 'delete' && id === caller.user.id) {
             fail('SELF_DELETE', 'You cannot delete your own account.');
-        if (!userActionAllowed({ user, action, permissions: grants, caller, safety }))
+        }
+        if (!userActionAllowed({ user, action, permissions: grants, caller, safety })) {
             fail('FORBIDDEN', 'Mutation denied.');
+        }
         return user;
     }
-    const password = (value) => { if (!value || [...value].length > 512)
-        fail('VALIDATION_ERROR', 'Password must be present and no more than 512 characters.'); };
+    const password = (value) => {
+        if (!value || [...value].length > 512) {
+            fail('VALIDATION_ERROR', 'Password must be present and no more than 512 characters.');
+        }
+    };
     /** Disabling or deleting an active owner must leave another active owner behind. */
     function keepAnotherActiveOwner(u, _optional = {}) {
-        if (u.status === 'active' && owners.has(u.principalId) && [...users.values()].filter(v => v.status === 'active' && owners.has(v.principalId)).length <= 1)
+        if (u.status === 'active' && owners.has(u.principalId) && [...users.values()].filter(v => v.status === 'active' && owners.has(v.principalId)).length <= 1) {
             fail('OWNER_REQUIRED', 'The workspace must keep at least one active owner.');
+        }
+    }
+    function clamp(contents) {
+        if (grants.includes('*')) {
+            return;
+        }
+        if (!contents || contents.some(p => !grants.includes(p))) {
+            fail('GRANT_EXCEEDS_ISSUER', 'Grant exceeds issuer.');
+        }
     }
-    function clamp(contents) { if (grants.includes('*'))
-        return; if (!contents || contents.some(p => !grants.includes(p)))
-        fail('GRANT_EXCEEDS_ISSUER', 'Grant exceeds issuer.'); }
     return {
         async listUsers(_r, o = {}) { check(o); return { users: [...users.values()].filter(u => !trash.has(u.principalId)).map(clone) }; },
         async listRoles(_r, o = {}) { check(o); return { roles: roles.map(r => ({ ...r })) }; },
@@ -160,18 +189,22 @@ export function createMemoryUsersApi({ workspaceId }, options = {}) {
         async me(_r, o = {}) { check(o); return structuredClone(caller); },
         async createUser(r, o = {}) {
             check(o);
-            if (!hasAdminGrant({ permissions: grants, permission: 'user.manage' }))
+            if (!hasAdminGrant({ permissions: grants, permission: 'user.manage' })) {
                 fail('FORBIDDEN', 'Missing user.manage.');
+            }
             const username = r.username.trim().normalize('NFC').toLowerCase();
-            if (!username)
+            if (!username) {
                 fail('VALIDATION_ERROR', 'Username is required.');
+            }
             password(r.password);
             const existing = [...users.values()].find(u => u.username.normalize('NFC').toLowerCase() === username);
-            if (existing)
+            if (existing) {
                 fail(trash.has(existing.principalId) ? 'USERNAME_IN_TRASH' : 'RESOURCE_CONFLICT', 'Username already exists.');
+            }
             let principalId;
             do {
-                principalId = `memory-user-${++sequence}`;
+                ++sequence;
+                principalId = `memory-user-${sequence}`;
             } while (users.has(principalId));
             const user = { principalId, workspaceId, username, status: 'active', createdAt: new Date(0).toISOString(), roleIds: [], policyIds: [], ...(o.email !== undefined ? { email: o.email } : {}) };
             users.set(principalId, user);
@@ -187,10 +220,24 @@ export function createMemoryUsersApi({ workspaceId }, options = {}) {
         },
         async enableUser(r, o = {}) { const u = write(r.principalId, 'enable', o); const user = { ...u, status: 'active' }; users.set(u.principalId, user); return { user: clone(user) }; },
         async resetUserPassword(r, o = {}) { write(r.principalId, 'reset', o); password(r.password); options.onPasswordReset?.(r); },
-        async assignRole(r, o = {}) { const u = write(r.principalId, 'grants', o); if (!roles.some(v => v.id === r.roleId))
-            fail('RESOURCE_NOT_FOUND', 'Role not found.'); clamp(options.rolePermissions?.[r.roleId]); users.set(u.principalId, { ...u, roleIds: [...new Set([...u.roleIds, r.roleId])] }); return { assignment: { principalId: u.principalId, roleId: r.roleId } }; },
-        async attachPolicy(r, o = {}) { const u = write(r.principalId, 'grants', o); if (!policies.some(v => v.id === r.policyId))
-            fail('RESOURCE_NOT_FOUND', 'Policy not found.'); clamp(options.policyPermissions?.[r.policyId]); users.set(u.principalId, { ...u, policyIds: [...new Set([...u.policyIds, r.policyId])] }); return { attachment: { principalId: u.principalId, policyId: r.policyId } }; },
+        async assignRole(r, o = {}) {
+            const u = write(r.principalId, 'grants', o);
+            if (!roles.some(v => v.id === r.roleId)) {
+                fail('RESOURCE_NOT_FOUND', 'Role not found.');
+            }
+            clamp(options.rolePermissions?.[r.roleId]);
+            users.set(u.principalId, { ...u, roleIds: [...new Set([...u.roleIds, r.roleId])] });
+            return { assignment: { principalId: u.principalId, roleId: r.roleId } };
+        },
+        async attachPolicy(r, o = {}) {
+            const u = write(r.principalId, 'grants', o);
+            if (!policies.some(v => v.id === r.policyId)) {
+                fail('RESOURCE_NOT_FOUND', 'Policy not found.');
+            }
+            clamp(options.policyPermissions?.[r.policyId]);
+            users.set(u.principalId, { ...u, policyIds: [...new Set([...u.policyIds, r.policyId])] });
+            return { attachment: { principalId: u.principalId, policyId: r.policyId } };
+        },
         async deleteUser(r, o = {}) { const u = write(r.principalId, 'delete', o); keepAnotherActiveOwner(u); users.set(u.principalId, { ...u, status: 'disabled' }); trash.add(u.principalId); },
     };
 }
@@ -198,21 +245,39 @@ export function createMemoryMembersApi({ workspaceId }, { members = [], permissi
     const grants = Object.freeze([...permissions]);
     const rows = new Map(inWorkspace(members, workspaceId).map(m => [m.id, { ...m }]));
     const fail = (code, message) => { throw new PeopleApiError({ code, message }); };
-    const gate = (o) => { check(o); if (!hasAdminGrant({ permissions: grants, permission: 'member.manage' }))
-        fail('FORBIDDEN', 'Missing member.manage.'); };
+    const gate = (o) => {
+        check(o);
+        if (!hasAdminGrant({ permissions: grants, permission: 'member.manage' })) {
+            fail('FORBIDDEN', 'Missing member.manage.');
+        }
+    };
     const get = (id) => rows.get(id) ?? fail('RESOURCE_NOT_FOUND', 'Member not found.');
     return {
         async listMembers(_r, o = {}) { check(o); const limit = o.limit !== undefined && Number.isFinite(o.limit) && o.limit > 0 ? Math.floor(o.limit) : 100; return { members: [...rows.values()].sort((a, b) => a.id.localeCompare(b.id)).filter(m => o.afterId === undefined || m.id > o.afterId).slice(0, limit).map(m => ({ ...m })) }; },
         async getMember(r, o = {}) { check(o); return { member: { ...get(r.id) } }; },
         async disableMember(r, o = {}) { gate(o); const old = get(r.id); const member = old.status === 'disabled' ? old : { ...old, status: 'disabled', version: old.version + 1, updatedAt: new Date(0).toISOString() }; rows.set(member.id, member); return { member: { ...member } }; },
-        async requestMemberMagicLink(r, o = {}) { gate(o); if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(r.email.trim()))
-            fail('VALIDATION_ERROR', 'Invalid email.'); return { delivered: true }; },
+        async requestMemberMagicLink(r, o = {}) {
+            gate(o);
+            const address = /^[^\s@]+@([^\s@]+)$/.exec(r.email.trim());
+            if (!address || !address[1].slice(1, -1).includes('.')) {
+                fail('VALIDATION_ERROR', 'Invalid email.');
+            }
+            return { delivered: true };
+        },
     };
 }
 /** Deterministic credential fake; production hashing/session policy stays in the server entry. */
 export function createMemoryAuthApi({ accounts }, _optional = {}) {
     const rows = accounts.map(a => ({ ...a, user: { ...a.user } }));
-    return { async login(r, o = {}) { check(o); const found = rows.find(a => a.user.username.normalize('NFC').toLowerCase() === r.username.trim().normalize('NFC').toLowerCase()); if (!r.password || !found || found.disabled || found.password !== r.password)
-            throw new PeopleApiError({ code: 'UNAUTHENTICATED', message: 'invalid username or password' }); return { user: { ...found.user } }; } };
+    return {
+        async login(r, o = {}) {
+            check(o);
+            const found = rows.find(a => a.user.username.normalize('NFC').toLowerCase() === r.username.trim().normalize('NFC').toLowerCase());
+            if (!r.password || !found || found.disabled || found.password !== r.password) {
+                throw new PeopleApiError({ code: 'UNAUTHENTICATED', message: 'invalid username or password' });
+            }
+            return { user: { ...found.user } };
+        }
+    };
 }
 //# sourceMappingURL=memory.js.map

package/dist/admin/conformance/index.js

@@ -1,11 +1,12 @@
+function assert(value, message) {
+    if (!value) {
+        throw new Error(message);
+    }
+}
 /** Mutates a disposable, authenticated backend. Caller must hold role.manage and content.read.
  * Permission vocabulary can be supplied for another server's catalog. Cleanup failures are failures. */
 export async function runRolesApiConformance({ api }, { permission = 'content.read', prefix = `conformance-${Date.now()}` } = {}) {
     const passed = [], failed = [];
-    const assert = (value, message) => {
-        if (!value)
-            throw new Error(message);
-    };
     async function check(name, run) {
         try {
             await run();
@@ -56,12 +57,15 @@ export async function runRolesApiConformance({ api }, { permission = 'content.re
         await check('policy deletion cascades own permissions', async () => { await api.writePolicyPermission({ policyId: policyId, permission }); await api.deletePolicy({ policyId: policyId }); assert(!(await api.listPolicies({})).policies.some(p => p.id === policyId), 'policy deletion absent'); policyId = undefined; });
     }
     finally {
-        if (roleId)
+        if (roleId) {
             await check('cleanup role', async () => { await api.deleteRole({ roleId: roleId }); assert(!(await api.listRoles({})).roles.some(r => r.id === roleId), 'role deletion absent'); });
-        if (policyId)
+        }
+        if (policyId) {
             await check('cleanup policy', async () => { await api.deletePolicy({ policyId: policyId }); });
-        if (otherPolicyId)
+        }
+        if (otherPolicyId) {
             await check('cleanup other policy', async () => { await api.deletePolicy({ policyId: otherPolicyId }); });
+        }
     }
     return { passed, failed };
 }
@@ -69,8 +73,6 @@ export async function runRolesApiConformance({ api }, { permission = 'content.re
  * to the host. Members are disable-only, so conformance takes a dedicated fixture id. */
 export async function runUsersApiConformance({ api }, { prefix = `users-${Date.now()}`, roleId, policyId } = {}) {
     const passed = [], failed = [];
-    const assert = (value, message) => { if (!value)
-        throw new Error(message); };
     const check = async (name, run) => { try {
         await run();
         passed.push(name);
@@ -87,10 +89,12 @@ export async function runUsersApiConformance({ api }, { prefix = `users-${Date.n
         await check('disable and enable operator', async () => { assert((await api.disableUser({ principalId: principalId })).user.status === 'disabled', 'disable missing'); assert((await api.enableUser({ principalId: principalId })).user.status === 'active', 'enable missing'); });
         // eslint-disable-next-line sonarjs/no-hardcoded-passwords -- Disposable-user conformance fixture for an explicitly isolated authenticated host; this is not an application credential.
         await check('reset password', async () => { await api.resetUserPassword({ principalId: principalId, password: 'replacement' }); });
-        if (roleId)
+        if (roleId) {
             await check('assign role', async () => { await api.assignRole({ principalId: principalId, roleId }); assert((await api.listUsers({})).users.find(u => u.principalId === principalId)?.roleIds.includes(roleId), 'role missing'); });
-        if (policyId)
+        }
+        if (policyId) {
             await check('attach policy', async () => { await api.attachPolicy({ principalId: principalId, policyId }); assert((await api.listUsers({})).users.find(u => u.principalId === principalId)?.policyIds.includes(policyId), 'policy missing'); });
+        }
         await check('aborted write does not persist', async () => { const abort = new AbortController(); abort.abort(); let rejected = false; try {
             await api.updateUser({ principalId: principalId }, { email: 'bad@example.test', signal: abort.signal });
         }
@@ -99,15 +103,14 @@ export async function runUsersApiConformance({ api }, { prefix = `users-${Date.n
         } assert(rejected && (await api.listUsers({})).users.find(u => u.principalId === principalId)?.email === 'after@example.test', 'abort ignored'); });
     }
     finally {
-        if (principalId)
+        if (principalId) {
             await check('delete moves out of roster', async () => { await api.deleteUser({ principalId: principalId }); assert(!(await api.listUsers({})).users.some(u => u.principalId === principalId), 'trashed user still listed'); });
+        }
     }
     return { passed, failed };
 }
 export async function runMembersApiConformance({ api, memberId }, _optional = {}) {
     const passed = [], failed = [];
-    const assert = (value, message) => { if (!value)
-        throw new Error(message); };
     const check = async (name, run) => { try {
         await run();
         passed.push(name);
@@ -136,22 +139,37 @@ export async function runAuthApiConformance({ api, credentials, expectedUserId }
     catch (error) {
         failed.push({ name, error });
     } };
-    await check('login returns expected account', async () => { if ((await api.login(credentials)).user.id !== expectedUserId)
-        throw new Error('wrong account'); });
-    await check('empty password is rejected', async () => { let rejected = false; try {
-        await api.login({ ...credentials, password: '' });
-    }
-    catch {
-        rejected = true;
-    } if (!rejected)
-        throw new Error('empty password authenticated'); });
-    await check('aborted login is rejected', async () => { const abort = new AbortController(); abort.abort(); let rejected = false; try {
-        await api.login(credentials, { signal: abort.signal });
-    }
-    catch {
-        rejected = true;
-    } if (!rejected)
-        throw new Error('abort ignored'); });
+    await check('login returns expected account', async () => {
+        if ((await api.login(credentials)).user.id !== expectedUserId) {
+            throw new Error('wrong account');
+        }
+    });
+    await check('empty password is rejected', async () => {
+        let rejected = false;
+        try {
+            await api.login({ ...credentials, password: '' });
+        }
+        catch {
+            rejected = true;
+        }
+        if (!rejected) {
+            throw new Error('empty password authenticated');
+        }
+    });
+    await check('aborted login is rejected', async () => {
+        const abort = new AbortController();
+        abort.abort();
+        let rejected = false;
+        try {
+            await api.login(credentials, { signal: abort.signal });
+        }
+        catch {
+            rejected = true;
+        }
+        if (!rejected) {
+            throw new Error('abort ignored');
+        }
+    });
     return { passed, failed };
 }
 //# sourceMappingURL=index.js.map

package/dist/admin/controllers/controller-store.js

@@ -7,16 +7,28 @@ export function createControllerStore({ initial }, _optional = {}) {
         getSnapshot(_required = {}, _optional = {}) { return state; },
         active(_required = {}, _optional = {}) { return !disposed; },
         set({ patch }, _optional = {}) {
-            if (disposed)
+            if (disposed) {
                 return;
+            }
             state = Object.freeze({ ...state, ...patch });
-            for (const listener of listeners)
+            for (const listener of listeners) {
                 listener();
+            }
+        },
+        subscribe({ listener }, _optional = {}) {
+            if (!disposed) {
+                listeners.add(listener);
+            }
+            return () => { listeners.delete(listener); };
+        },
+        dispose(_required = {}, _optional = {}) {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            abort.abort();
+            listeners.clear();
         },
-        subscribe({ listener }, _optional = {}) { if (!disposed)
-            listeners.add(listener); return () => { listeners.delete(listener); }; },
-        dispose(_required = {}, _optional = {}) { if (disposed)
-            return; disposed = true; abort.abort(); listeners.clear(); },
         call: { signal: abort.signal },
     };
 }

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

@@ -15,57 +15,73 @@ export function createMembersController({ api }, { permissions = [], refresh } =
     function patchRow(id, patch) { set({ rows: Object.freeze({ ...read({}).rows, [id]: Object.freeze({ ...stateFor({ id }), ...patch }) }) }); }
     const gate = () => store.active({}) && hasAdminGrant({ permissions: grants, permission: 'member.manage' });
     async function loadDetail(id) {
-        const generation = ++detailGeneration;
+        ++detailGeneration;
+        const generation = detailGeneration;
         set({ detailLoadingId: id, detailError: null });
         try {
             const { member } = await api.getMember({ id }, call);
-            if (generation === detailGeneration && read({}).expandedId === id)
+            if (generation === detailGeneration && read({}).expandedId === id) {
                 set({ detailById: Object.freeze({ ...read({}).detailById, [id]: Object.freeze({ ...member }) }) });
+            }
         }
         catch (error) {
-            if (generation === detailGeneration && read({}).expandedId === id)
+            if (generation === detailGeneration && read({}).expandedId === id) {
                 set({ detailError: report(error, 'Failed to load member detail.') });
+            }
         }
         finally {
-            if (generation === detailGeneration)
+            if (generation === detailGeneration) {
                 set({ detailLoadingId: null });
+            }
         }
     }
     async function load(_required, _optional = {}) {
-        if (!store.active({}))
+        if (!store.active({})) {
             return;
-        const generation = ++listGeneration;
+        }
+        ++listGeneration;
+        const generation = listGeneration;
         set({ error: null });
         try {
             const { members } = await api.listMembers({}, call);
-            if (generation !== listGeneration || !store.active({}))
+            if (generation !== listGeneration || !store.active({})) {
                 return;
+            }
             ++detailGeneration;
             set({ members: Object.freeze(members.map(m => Object.freeze({ ...m }))), detailById: {}, detailError: null, detailLoadingId: null });
             const id = read({}).expandedId;
-            if (id && row(id))
+            if (id && row(id)) {
                 await loadDetail(id);
-            else if (id)
+            }
+            else if (id) {
                 set({ expandedId: null });
+            }
+            else {
+                // With no expanded member, there is no detail selection to reconcile.
+            }
         }
         catch (error) {
-            if (generation === listGeneration)
+            if (generation === listGeneration) {
                 set({ error: report(error, 'failed to load members') });
+            }
         }
     }
     async function toggleDetail({ id }, _optional = {}) {
-        if (!store.active({}) || !row(id))
+        if (!store.active({}) || !row(id)) {
             return;
+        }
         ++detailGeneration;
         const next = read({}).expandedId === id ? null : id;
         set({ expandedId: next, detailError: null, detailLoadingId: null });
-        if (next && !read({}).detailById[next])
+        if (next && !read({}).detailById[next]) {
             await loadDetail(next);
+        }
     }
     async function resendSignInLink({ id }, _optional = {}) {
         const member = row(id);
-        if (!member || !gate() || stateFor({ id }).resending)
+        if (!member || !gate() || stateFor({ id }).resending) {
             return false;
+        }
         patchRow(id, { resending: true, error: null, notice: null });
         let sent = false;
         try {
@@ -83,8 +99,9 @@ export function createMembersController({ api }, { permissions = [], refresh } =
     }
     async function confirmDestructive(_required, _optional = {}) {
         const target = read({}).pending;
-        if (!target || !gate() || read({}).confirming || !row(target.id))
+        if (!target || !gate() || read({}).confirming || !row(target.id)) {
             return false;
+        }
         set({ confirming: true });
         patchRow(target.id, { disabling: true, error: null, notice: null });
         let disabled = false;
@@ -93,8 +110,10 @@ export function createMembersController({ api }, { permissions = [], refresh } =
             // Invalidate older reads before applying the write response, including the cached detail.
             ++listGeneration;
             ++detailGeneration;
-            set({ members: Object.freeze(list().map(m => m.id === member.id ? Object.freeze({ ...member }) : m)),
-                detailById: Object.freeze({ ...read({}).detailById, [member.id]: Object.freeze({ ...member }) }), detailLoadingId: null });
+            set({
+                members: Object.freeze(list().map(m => m.id === member.id ? Object.freeze({ ...member }) : m)),
+                detailById: Object.freeze({ ...read({}).detailById, [member.id]: Object.freeze({ ...member }) }), detailLoadingId: null
+            });
             patchRow(target.id, { notice: 'Member disabled.' });
             disabled = store.active({});
         }
@@ -103,8 +122,9 @@ export function createMembersController({ api }, { permissions = [], refresh } =
         }
         finally {
             patchRow(target.id, { disabling: false });
-            if (read({}).pending === target)
+            if (read({}).pending === target) {
                 set({ pending: null });
+            }
             set({ confirming: false });
         }
         return disabled;
@@ -112,10 +132,17 @@ export function createMembersController({ api }, { permissions = [], refresh } =
     const unsubscribe = refresh?.subscribe({ onRefresh: () => { void load({}); } });
     return {
         getSnapshot: store.getSnapshot, subscribe: store.subscribe, load, stateFor, toggleDetail, resendSignInLink, confirmDestructive,
-        requestDestructive({ id }, _optional = {}) { const member = row(id); if (gate() && member && member.status !== 'disabled' && !read({}).confirming)
-            set({ pending: Object.freeze({ ...member }) }); },
-        cancelDestructive(_required, _optional = {}) { if (!read({}).confirming)
-            set({ pending: null }); },
+        requestDestructive({ id }, _optional = {}) {
+            const member = row(id);
+            if (gate() && member && member.status !== 'disabled' && !read({}).confirming) {
+                set({ pending: Object.freeze({ ...member }) });
+            }
+        },
+        cancelDestructive(_required, _optional = {}) {
+            if (!read({}).confirming) {
+                set({ pending: null });
+            }
+        },
         dispose(_required = {}, _optional = {}) { unsubscribe?.(); store.dispose({}); ++listGeneration; ++detailGeneration; },
     };
 }