@oxy.so/core 7.16.0 → 7.18.0

package/dist/esm/server/middleware.js

@@ -1,5 +1,6 @@
 import { hasBoundedServiceTokenLifetime } from './serviceTokenLifetime.js';
 import { appPermissionErrorBody, appPermissionErrorStatus, assertApplicationPermissionKey, OxyAppPermissionError, } from './appPermissions.js';
+import { accessErrorStatus, authorityErrorBody, OxyAccessError, } from './callerAuthority.js';
 import { accountActorChainSchema, } from '@oxy.so/contracts';
 import { jwtDecode } from 'jwt-decode';
 import { loadNodeCrypto } from '@oxy.so/protocol';
@@ -130,7 +131,7 @@ export function createOxyMiddleware(host) {
      * @returns Express middleware function
      */
     function auth(options = {}) {
-        const { debug = false, onError, onRefusal, loadUser = false, optional = false, serviceTokenJwksUrl = new URL('/.well-known/jwks.json', host.baseURL).toString(), expectedIssuer = OXY_JWT_ISSUER, expectedAudience = OXY_JWT_AUDIENCE, } = options;
+        const { debug = false, onError, onRefusal, loadUser = false, optional = false, serviceTokenJwksUrl = new URL('/.well-known/jwks.json', host.baseURL).toString(), expectedIssuer = OXY_JWT_ISSUER, expectedAudience = host.defaultAudience ?? OXY_JWT_AUDIENCE, } = options;
         const strictPresentedBearer = Boolean(options.supervisedAction || options.strictOptionalBearer || options.liveSession);
         /**
          * Make a refusal observable to the HOST, without telling the client
@@ -1166,7 +1167,108 @@ export function createOxyMiddleware(host) {
             res.status(status).json(appPermissionErrorBody(status));
         };
     }
-    return { auth, socket, service, requireScope, requireAppPermission };
+    /**
+     * One gate for both caller-access readers: read the id from the route
+     * parameter, ask, admit on `permission`, answer a refusal by its outcome.
+     */
+    function requireCallerAccess(method, permission, options, read, admit) {
+        const { param, deny = 403, respond = true, ...lookup } = options;
+        if (typeof permission !== 'string' || permission.trim() === '') {
+            throw new Error(`${method}: permission must be a non-empty string`);
+        }
+        if (typeof param !== 'string' || param.trim() === '') {
+            throw new Error(`${method}: param must name the route parameter that holds the id`);
+        }
+        if (deny !== 403 && deny !== 404) {
+            throw new Error(`${method}: deny must be 403 or 404`);
+        }
+        return async (req, res, next) => {
+            let refusal;
+            const id = req.params?.[param];
+            try {
+                if (typeof id !== 'string' || id === '') {
+                    throw new OxyAccessError('ACCESS_DENIED', `No ${param} on this route`);
+                }
+                const access = await read(req, id, lookup);
+                if (access.has(permission)) {
+                    admit(req, access);
+                    next();
+                    return;
+                }
+                refusal = new OxyAccessError('ACCESS_DENIED', `Missing permission ${permission}`, {
+                    permission,
+                });
+            }
+            catch (error) {
+                if (!(error instanceof OxyAccessError)) {
+                    next(error);
+                    return;
+                }
+                refusal = new OxyAccessError(error.code, error.message, {
+                    permission,
+                    cause: error.cause ?? error,
+                });
+            }
+            if (refusal.code === 'ACCESS_UNAVAILABLE') {
+                logger.warn(`[oxy.auth] ${method} could not ask Oxy`, {
+                    component: 'auth',
+                    method,
+                    permission,
+                    path: req.path,
+                });
+            }
+            if (!respond) {
+                next(refusal);
+                return;
+            }
+            const status = accessErrorStatus(refusal, deny);
+            res.status(status).json(authorityErrorBody(status));
+        };
+    }
+    /**
+     * Express middleware: the person behind the request must hold `permission`
+     * in the Oxy ACCOUNT named by the route parameter `param` (an organization,
+     * store, channel). Mount after `auth()`. On success the answer is on
+     * `req.oxyAccountAccess`. See `OxyServer.accountAccessFor`.
+     *
+     * @example
+     * ```typescript
+     * router.patch('/stores/:storeId', oxy.middleware.requireAccountAccess('account:update', { param: 'storeId', fresh: true }), handler);
+     * ```
+     */
+    function requireAccountAccess(permission, options) {
+        return requireCallerAccess('requireAccountAccess', permission, options, (req, id, lookup) => host.accountAccessFor(req, id, lookup), (req, access) => {
+            req.oxyAccountAccess = access;
+        });
+    }
+    /**
+     * Express middleware: the person behind the request must hold the
+     * application permission `permission` (`app:read`, `app:update`,
+     * `webhooks:update`, …) over the APPLICATION named by the route parameter
+     * `param`, through the account that owns it. Mount after `auth()`. On
+     * success the answer is on `req.oxyApplicationAccess`. See
+     * `OxyServer.applicationAccessFor`; for THIS backend's own operator keys use
+     * `requireAppPermission` instead.
+     *
+     * @example
+     * ```typescript
+     * router.get('/apps/:appId/payments', oxy.middleware.requireApplicationAccess('app:read', { param: 'appId' }), handler);
+     * ```
+     */
+    function requireApplicationAccess(permission, options) {
+        return requireCallerAccess('requireApplicationAccess', permission, options, (req, id, lookup) => host.applicationAccessFor(req, id, lookup), (req, access) => {
+            req.oxyApplicationAccess = access;
+        });
+    }
+    return {
+        auth,
+        socket,
+        service,
+        requireScope,
+        requireAppPermission,
+        requireAccountAccess,
+        requireApplicationAccess,
+    };
 }
 function isExactNonEmptyServiceClaim(value) {
     return typeof value === 'string' && value.length > 0 && value.trim() === value;

package/dist/esm/server/namespaces.js

@@ -58,6 +58,14 @@ const SERVICE_RECONCILE_RATE_LIMIT_MAX_WAIT_MS = 60000;
 const SHA256_HEX_PATTERN = /^[a-f0-9]{64}$/;
 /** A header value fetch accepts on every runtime: printable ASCII only. */
 const HEADER_SAFE_PATTERN = /^[\x20-\x7e]*$/;
+/** The `RequestOptions` half of {@link ServiceCallOptions}, only the fields that were set. */
+function serviceCallRequestOptions(options) {
+    return {
+        ...(options.signal ? { signal: options.signal } : {}),
+        ...(options.timeout !== undefined ? { timeout: options.timeout } : {}),
+        ...(options.retry !== undefined ? { retry: options.retry } : {}),
+    };
+}
 /** The headers both streamed service uploads share. */
 function uploadHeaders(mime, description) {
     return {
@@ -147,10 +155,13 @@ export class ServerAssetsApi extends AssetsApi {
          *   changes the file's visibility.
          * - `remove`: only references this application holds. Never trashes or
          *   deletes the file.
+         *
+         * Both take {@link ServiceCallOptions} for each request they send — e.g.
+         * `{ retry: false, timeout: 5000 }` from an outbox that retries by itself.
          */
         this.references = {
-            add: (references) => this.sendReferences('POST', references),
-            remove: (references) => this.sendReferences('DELETE', references),
+            add: (references, options = {}) => this.sendReferences('POST', references, options),
+            remove: (references, options = {}) => this.sendReferences('DELETE', references, options),
             /**
              * Reconcile this application's references of ONE entity type with its
              * real inventory (ADR 0043 D6) — the safety net for a reference a crash or
@@ -309,13 +320,13 @@ export class ServerAssetsApi extends AssetsApi {
             await release();
         return result;
     }
-    async sendReferences(method, references) {
+    async sendReferences(method, references, options) {
         const results = [];
         for (let start = 0; start < references.length; start += SERVICE_REFERENCES_CHUNK_SIZE) {
             const chunk = references
                 .slice(start, start + SERVICE_REFERENCES_CHUNK_SIZE)
                 .map(({ fileId, entityType, entityId }) => ({ fileId, entityType, entityId }));
-            const res = await lane(this.ctx).request(method, '/assets/service/references', { references: chunk }, { cache: false });
+            const res = await lane(this.ctx).request(method, '/assets/service/references', { references: chunk }, { ...serviceCallRequestOptions(options), cache: false });
             results.push(...res.results);
         }
         return results;

package/dist/esm/server/safeFetch.js

@@ -28,6 +28,16 @@
  *    response; without one, a server that sends its headers and stalls holds
  *    any other reader open.
  *
+ * NOT FOR OXY'S OWN HOSTS
+ * -----------------------
+ * `safeFetch` is for UNTRUSTED or caller-influenced URLs only. Never use it to
+ * reach a first-party host (`api.oxy.so`, any `*.oxy.so`, an Oxy product's
+ * API): inside the VPC those names resolve to the internal load balancer
+ * (split-horizon DNS), a private address this module refuses by design. Call
+ * Oxy through `OxyServer` — its namespaces, `serviceRequest`, or
+ * `createServiceClient({ baseURL, audience }).fetch` for another Oxy product.
+ * A refusal of such a host says so in its message.
+ *
  * Node-only: this module imports `node:http`/`node:https`/`node:dns` and is
  * exported solely from `@oxy.so/core/server`. It MUST NOT be reachable from the
  * browser `@oxy.so/core` entry.
@@ -37,6 +47,7 @@ import https from 'node:https';
 import { lookup as dnsLookup } from 'node:dns/promises';
 import { isIP } from 'node:net';
 import { URL } from 'node:url';
+import { isLoopbackOrigin, isOfficialWebOrigin } from '../utils/officialOrigins.js';
 import { withDeadline } from './deadline.js';
 import { extractEmbeddedIpv4, ipv4InCidr, ipv6InCidr } from './ipCidr.js';
 /** Maximum accepted length of an input URL (DoS guard). */
@@ -246,6 +257,21 @@ export async function assertSafePublicUrl(rawUrl, options = {}) {
         family: chosen.family === 4 ? 4 : 6,
     };
 }
+/** What a refusal of a first-party Oxy host adds to its reason. */
+const FIRST_PARTY_HOST_HINT = 'first-party Oxy host: inside the VPC it resolves to a private address, which safeFetch refuses by design; call it through OxyServer (its namespaces, serviceRequest, or createServiceClient().fetch), not safeFetch';
+/** `reason`, plus the first-party hint when `rawUrl` names an official Oxy host. */
+function rejectionReason(rawUrl, reason) {
+    let origin;
+    try {
+        origin = new URL(rawUrl).origin;
+    }
+    catch {
+        return reason;
+    }
+    return isOfficialWebOrigin(origin) && !isLoopbackOrigin(origin)
+        ? `${reason} (${FIRST_PARTY_HOST_HINT})`
+        : reason;
+}
 /** Marker error for a blocked SSRF target (map to 403 at the route layer). */
 export class SsrfRejection extends Error {
     constructor(reason) {
@@ -342,7 +368,9 @@ export async function safeFetch(rawUrl, options = {}) {
             signal,
         });
         if (!guard.ok) {
-            throw guard.incomplete ? new UpstreamError(guard.reason) : new SsrfRejection(guard.reason);
+            throw guard.incomplete
+                ? new UpstreamError(guard.reason)
+                : new SsrfRejection(rejectionReason(currentUrl, guard.reason));
         }
         const target = new URL(currentUrl);
         const requestOptions = buildRequestOptions(target, guard.ip, guard.family, method, baseHeaders, signal);

package/dist/esm/server/userClient.js

@@ -0,0 +1,121 @@
+/**
+ * Calling Oxy AS the person behind a request.
+ *
+ * A backend's `OxyServer` is a process singleton authenticated as the backend
+ * itself; a user's bearer must never be planted on it (`setTokens`,
+ * `session.setAccessToken`), because every concurrent request would then speak
+ * as that user. A read that must be answered for the person — their own
+ * account graph, an application they manage, their profile — goes through an
+ * {@link OxyUserClient}: every namespace of `OxyServices`, bound to that one
+ * bearer, sharing no mutable state with the server.
+ *
+ * ```ts
+ * // Express, after oxy.middleware.auth():
+ * const node = await oxy.withUser(req, (user) => user.accounts.get(accountId));
+ * ```
+ *
+ * What makes it safe to create one per request:
+ *
+ * - **No response cache.** The client is built with `enableCache: false`, so
+ *   one person's answers are never served to anyone, including the same
+ *   person's next request, and nothing is registered with the module-wide
+ *   cache sweep.
+ * - **Exactly this bearer, every time.** Every request carries it as an
+ *   explicit `Authorization` header: never refreshed (that is the user's own
+ *   client's job), never dropped for an expired or opaque token, never
+ *   replaced by the server's service token. Oxy answers a revoked or expired
+ *   bearer 401, which the access readers map to `ACCESS_SESSION_REQUIRED`.
+ * - **Deterministic end.** `withUser` disposes the client when the callback
+ *   settles, so a reference that escapes the callback holds no bearer. A
+ *   client from `asUser` that is never disposed holds no global resource
+ *   either; it is collected with its last reference.
+ *
+ * Node only; reachable solely from `@oxy.so/core/server`.
+ */
+import { OxyServices } from '../OxyServices.js';
+import { isBearerToken, OxyAccessError } from './callerAuthority.js';
+/** The transport settings a user client inherits from its server; never auth, cache or app identity. */
+const INHERITED_TRANSPORT_KEYS = [
+    'baseURL',
+    'cloudURL',
+    'requestTimeout',
+    'enableRetry',
+    'maxRetries',
+    'retryDelay',
+    'maxConcurrentRequests',
+    'requestQueueSize',
+    'enableLogging',
+    'logLevel',
+    'onRequestStart',
+    'onRequestEnd',
+    'onRequestError',
+];
+/** The transport half of a server config, for a user client. */
+export function userClientConfig(config) {
+    const transport = {};
+    for (const key of INHERITED_TRANSPORT_KEYS) {
+        if (config[key] !== undefined)
+            transport[key] = config[key];
+    }
+    return { ...transport, enableCache: false };
+}
+/**
+ * The user bearer `source` carries. Throws `OxyAccessError`
+ * (`ACCESS_SESSION_REQUIRED`) for a request with no user session — anonymous,
+ * or authenticated by a SERVICE token, whose bearer is the calling service's
+ * and never a person's.
+ */
+export function userBearerOf(source) {
+    if (typeof source === 'string') {
+        if (!isBearerToken(source)) {
+            throw new OxyAccessError('ACCESS_SESSION_REQUIRED', 'A user client needs a bearer token');
+        }
+        return source;
+    }
+    if (source.serviceApp) {
+        throw new OxyAccessError('ACCESS_SESSION_REQUIRED', 'This request is authenticated by a service token; a user client needs a person’s session');
+    }
+    const token = source.accessToken;
+    if (typeof token !== 'string' || !isBearerToken(token)) {
+        throw new OxyAccessError('ACCESS_SESSION_REQUIRED', 'No verified user session on this request; mount middleware.auth() first');
+    }
+    return token;
+}
+/**
+ * Every `OxyServices` namespace, authenticated as one person. Create it with
+ * `OxyServer.withUser` (disposed for you) or `OxyServer.asUser` (dispose it
+ * yourself); the constructor is not part of the public contract.
+ */
+export class OxyUserClient extends OxyServices {
+    /** @internal Use `OxyServer.asUser` / `OxyServer.withUser`. */
+    constructor(config, accessToken) {
+        super(config);
+        this.bearer = accessToken;
+        // For the namespaces that read the session's identity (`session.userId`).
+        this.http.setTokens(accessToken);
+    }
+    /**
+     * Every namespace call goes through here: it carries this client's bearer
+     * explicitly, which also keeps the response out of any cache and out of
+     * request de-duplication. Rejects once the client is disposed.
+     */
+    async request(method, url, data, options = {}) {
+        const bearer = this.bearer;
+        if (!bearer)
+            throw new Error('This Oxy user client has been disposed');
+        // This client speaks as its person only: no caller-supplied credential,
+        // in any letter case, rides along.
+        const headers = {};
+        for (const [name, value] of Object.entries(options.headers ?? {})) {
+            if (name.toLowerCase() !== 'authorization')
+                headers[name] = value;
+        }
+        headers.Authorization = `Bearer ${bearer}`;
+        return super.request(method, url, data, { ...options, headers });
+    }
+    /** Forget the bearer: every later call rejects. */
+    dispose() {
+        this.bearer = null;
+        super.dispose();
+    }
+}

package/dist/esm/utils/cache.js

@@ -41,6 +41,10 @@ export class TTLCache {
         this.cache = new Map();
         this.hits = 0;
         this.misses = 0;
+        /** Registered for the shared expiry sweep (see {@link registerCacheForCleanup}). */
+        this.swept = false;
+        /** The sweep generation this cache registered in; {@link stopAllCleanupIntervals} ends it. */
+        this.sweptGeneration = -1;
         this.defaultTTL = defaultTTL;
         this.maxEntries = maxEntries;
     }
@@ -59,6 +63,7 @@ export class TTLCache {
         if (now >= entry.expiresAt) {
             this.cache.delete(key);
             this.misses++;
+            this.syncSweep();
             return null;
         }
         // Re-insert so Map order is recency order and eviction drops the LRU.
@@ -90,8 +95,7 @@ export class TTLCache {
             if (oldest !== undefined)
                 this.cache.delete(oldest);
         }
-        if (!cleanupInterval && activeCaches.has(this))
-            updateCleanupInterval();
+        this.syncSweep();
     }
     /**
      * Delete a specific cache entry
@@ -100,10 +104,8 @@ export class TTLCache {
      */
     delete(key) {
         const deleted = this.cache.delete(key);
-        // Only the delete that EMPTIES this cache can let the timer stop; checking
-        // on every delete made bulk invalidation O(deletes x caches).
-        if (deleted && this.cache.size === 0 && activeCaches.has(this))
-            updateCleanupInterval();
+        if (deleted)
+            this.syncSweep();
         return deleted;
     }
     /**
@@ -113,8 +115,7 @@ export class TTLCache {
         this.cache.clear();
         this.hits = 0;
         this.misses = 0;
-        if (activeCaches.has(this))
-            updateCleanupInterval();
+        this.syncSweep();
     }
     /**
      * Delete every entry whose key matches, in ONE pass.
@@ -128,8 +129,8 @@ export class TTLCache {
                 removed++;
             }
         }
-        if (removed > 0 && this.cache.size === 0 && activeCaches.has(this))
-            updateCleanupInterval();
+        if (removed > 0)
+            this.syncSweep();
         return removed;
     }
     /**
@@ -143,6 +144,7 @@ export class TTLCache {
             return false;
         if (Date.now() >= entry.expiresAt) {
             this.cache.delete(key);
+            this.syncSweep();
             return false;
         }
         return true;
@@ -162,6 +164,7 @@ export class TTLCache {
                 this.cache.delete(key);
             }
         }
+        this.syncSweep();
         return validKeys;
     }
     /**
@@ -177,8 +180,29 @@ export class TTLCache {
                 removed++;
             }
         }
+        if (removed > 0)
+            this.syncSweep();
         return removed;
     }
+    /**
+     * Start or stop being swept: a registered cache is held by the shared sweep
+     * ONLY while it has entries to expire. An empty cache is referenced by
+     * nothing global, so a client nobody disposed is collected with its cache.
+     */
+    setSwept(swept) {
+        this.swept = swept;
+        this.sweptGeneration = sweepGeneration;
+        this.syncSweep();
+    }
+    syncSweep() {
+        if (this.swept && this.sweptGeneration === sweepGeneration && this.cache.size > 0) {
+            sweptCaches.add(this);
+        }
+        else {
+            sweptCaches.delete(this);
+        }
+        updateCleanupInterval();
+    }
     /**
      * Get cache size (number of entries)
      */
@@ -217,23 +241,30 @@ export function createCache(ttl = 5 * 60 * 1000) {
     return new TTLCache(ttl);
 }
 /**
- * Global cache cleanup interval (runs every minute)
- * This helps prevent memory leaks from expired cache entries
+ * The shared expiry sweep: one unref'd interval, running only while some
+ * registered cache holds entries.
+ *
+ * `sweptCaches` holds exactly the registered caches that are NON-EMPTY. A
+ * cache joins when it gains its first entry and leaves when it is emptied — by
+ * the sweep itself once its entries expire — so the module never pins a cache
+ * that has nothing to expire. That is what keeps a short-lived client that was
+ * never disposed (one per request, say) collectable: the most it can be held
+ * for is its entries' TTL.
  */
 let cleanupInterval = null;
-const activeCaches = new Set();
+const sweptCaches = new Set();
+/** Bumped by {@link stopAllCleanupIntervals}, which ends every registration. */
+let sweepGeneration = 0;
 /**
  * Register a cache for automatic cleanup
  * @param cache Cache instance to register
  */
 export function registerCacheForCleanup(cache) {
-    activeCaches.add(cache);
-    updateCleanupInterval();
+    cache.setSwept(true);
 }
 /** Empty registered caches need no timer; importing a client must stay inert. */
 function updateCleanupInterval() {
-    const hasEntries = [...activeCaches].some((cache) => cache.size() > 0);
-    if (!hasEntries) {
+    if (sweptCaches.size === 0) {
         if (cleanupInterval)
             clearInterval(cleanupInterval);
         cleanupInterval = null;
@@ -242,25 +273,29 @@ function updateCleanupInterval() {
     if (cleanupInterval)
         return;
     cleanupInterval = setInterval(() => {
-        for (const cache of activeCaches)
+        // `cleanup()` removes an emptied cache from the set as it goes.
+        for (const cache of [...sweptCaches])
             cache.cleanup();
-        updateCleanupInterval();
     }, 60000);
     cleanupInterval.unref?.();
 }
 /** Unregister a cache without changing its entries or TTL behavior. */
 export function unregisterCacheFromCleanup(cache) {
-    activeCaches.delete(cache);
-    updateCleanupInterval();
+    cache.setSwept(false);
 }
 /**
  * Stop all cleanup intervals (useful for testing)
  * This will clear the interval and unregister all caches
  */
 export function stopAllCleanupIntervals() {
+    sweepGeneration += 1;
+    sweptCaches.clear();
     if (cleanupInterval) {
         clearInterval(cleanupInterval);
         cleanupInterval = null;
     }
-    activeCaches.clear();
+}
+/** How many caches the shared sweep currently holds (tests). @internal */
+export function sweptCacheCount() {
+    return sweptCaches.size;
 }

package/dist/types/api/accounts.d.ts

@@ -1,4 +1,4 @@
-import type { OrganizationType } from '@oxy.so/contracts';
+import type { AccountAccessGrant, OrganizationType } from '@oxy.so/contracts';
 /**
  * `oxy.accounts` — the unified account graph (`/accounts`).
  *
@@ -118,6 +118,13 @@ export interface AccountNode {
      * ownership is implicit). Use `callerMembership.permissions` to gate UI.
      */
     callerMembership: AccountMember | null;
+    /**
+     * The caller's EFFECTIVE access to this account — role, permissions and
+     * where it comes from, `self` included (where `callerMembership` is `null`).
+     * Present on single-account reads (`accounts.get`); a backend asks
+     * `OxyServer.accountAccessFor`.
+     */
+    callerAccess?: AccountAccessGrant;
     /** Number of direct child accounts (present when the API computes it). */
     childCount?: number;
     /** Direct children, populated when the list is requested with `tree:true`. */

package/dist/types/api/apps.d.ts

@@ -17,7 +17,7 @@
  */
 import type { AppAssertionChallengeRequest, AppAssertionChallengeResponse, AppAssertionRequest, AppAssertionResponse, AppAttestKeyRequest, AppAttestKeyResponse } from '@oxy.so/contracts';
 import type { OxyContext } from '../client/context';
-import type { AccountMember, AccountSuccessResult } from './accounts';
+import type { AccountMember, AccountRole, AccountSuccessResult } from './accounts';
 /**
  * Application classification. Set only by Oxy platform staff — never editable
  * through the normal member-facing update path.
@@ -92,12 +92,30 @@ export interface Application {
     createdAt: string;
     updatedAt: string;
     /**
-     * The caller's effective membership in the OWNING account (direct or
-     * inherited), embedded by the API on list/detail responses, or `null` when the
-     * caller has no membership. Use `callerMembership.permissions` to gate UI.
+     * The caller's access to this application, derived from their effective
+     * role over the OWNING account (direct or inherited), embedded by the API on
+     * list/detail responses, or `null` when the caller has no membership. Use
+     * `callerMembership.permissions` to gate UI; a backend asks
+     * `OxyServer.applicationAccessFor`.
+     *
+     * The wire shape is {@link ApplicationCallerMembership} — only `role` and
+     * `permissions` of this `AccountMember` type are present. The type is
+     * corrected in 8.0 (ADR 0054); changing it in a minor would break compiles.
      */
     callerMembership?: AccountMember | null;
 }
+/**
+ * The caller's access to an application as the API actually embeds it: the role they
+ * hold over the owning account and the APPLICATION permissions it maps to
+ * (`app:read`, `app:update`, `webhooks:update`, …). There is no per-application
+ * member row, so this is not an `AccountMember`.
+ */
+export interface ApplicationCallerMembership {
+    role: AccountRole;
+    permissions: string[];
+    source: 'account';
+    ownerAccountId: string;
+}
 /**
  * Client-facing ApplicationCredential shape (an application's OAuth client
  * credentials). The raw secret is NEVER part of this shape — it is returned

package/dist/types/index.d.ts

@@ -43,7 +43,7 @@ export { buildUserDid } from './api/identity';
 export type { IdentityApi, VerifyDomainResult, RemoveDomainResult, RotateKeyProof, RotateKeyOptions, RotateKeyResult, } from './api/identity';
 export { ACCOUNT_CATEGORY_IDS, MAX_ACCOUNT_CATEGORIES, SELECTABLE_ACCOUNT_CATEGORY_IDS, isSelectableAccountCategoryId, kindAcceptsAccountCategories, } from './api/accounts';
 export type { AccountsApi, AccountKind, AccountCategoryId, AccountRelationship, AccountRole, AccountMemberStatus, AccountMemberSource, AccountMember, AccountNode, ListAccountsOptions, CreateAccountInput, UpdateAccountInput, UpdateAccountMemberInput, TransferAccountOwnershipInput, AccountSuccessResult, SwitchAccountResult, } from './api/accounts';
-export type { AppsApi, AppAssertionsApi, Application, ApplicationType, ApplicationStatus, ApplicationCredential, ApplicationCredentialType, ApplicationCredentialStatus, ApplicationEnvironment, CreateApplicationInput, UpdateApplicationInput, CreateApplicationCredentialInput, RotateApplicationCredentialInput, ApplicationCredentialWithSecret, RotateApplicationCredentialResult, ApplicationUsagePeriod, ApplicationUsageSummary, ApplicationUsageByDay, ApplicationUsageByEndpoint, ApplicationUsageStats, PublicApplication, ConnectedApp, ConnectedMcpClient, ApplicationDeleteResult, ApplicationFilesWebhook, } from './api/apps';
+export type { AppsApi, AppAssertionsApi, Application, ApplicationCallerMembership, ApplicationType, ApplicationStatus, ApplicationCredential, ApplicationCredentialType, ApplicationCredentialStatus, ApplicationEnvironment, CreateApplicationInput, UpdateApplicationInput, CreateApplicationCredentialInput, RotateApplicationCredentialInput, ApplicationCredentialWithSecret, RotateApplicationCredentialResult, ApplicationUsagePeriod, ApplicationUsageSummary, ApplicationUsageByDay, ApplicationUsageByEndpoint, ApplicationUsageStats, PublicApplication, ConnectedApp, ConnectedMcpClient, ApplicationDeleteResult, ApplicationFilesWebhook, } from './api/apps';
 export type { LinkedAccountsApi } from './api/linkedAccounts';
 export type { AgencyApi, AccountCapabilityPolicy, AvailableCapabilityCatalog, CapabilityExecutionAuthorization, CreateDelegationGrantInput, DelegationCatalogBinding, DelegationGrantView, PutAccountCapabilityPolicyInput, UpdateDelegationGrantInput, } from './api/agency';
 export type { StoreApi, StoreCategory, StoreRating, StoreListingSummary, StoreListingDetail, StoreScreenshot, StoreScreenshotPlatform, StoreReview, StoreOwnReview, WriteStoreReviewInput, StoreListingStatus, PublisherListing, WriteListingInput, AddScreenshotInput, UpdateScreenshotInput, StorePage, StorePageOptions, StoreReviewsOptions, } from './api/store';