@modelprofile.com/authswitch 8.1.0 → 8.2.0

package/readme.md

@@ -49,8 +49,11 @@ const receipt = await client.getOperation(operation.id);
 ```
 
 Browser code can import the credential-free DTOs from
-`@modelprofile.com/authswitch/authority-contract`. A backend binds an account to a
-runtime incarnation by exact account ID, login ID and purpose, and keeps the returned
+`@modelprofile.com/authswitch/authority-contract`. The backend-only binding, access and release
+requests are named by `@modelprofile.com/authswitch/authority-runtime-contract`, and the one-time
+import's own DTOs by `@modelprofile.com/authswitch/authority-import-contract`; the runtime contract
+belongs to the runtime socket and its capability must never reach a browser. A backend binds an
+account to a runtime incarnation by exact account ID, login ID and purpose, and keeps the returned
 capability private. Targeted reauthentication likewise requires the exact login; an
 account's presentation default never selects a grant for either action. Completed and
 interrupted operations remain discoverable through `getOperation()` and paged
@@ -76,6 +79,31 @@ the runtime and clears its durable run before internal revocation. Binding relea
 or changes ownership of the account grant. External-binding recovery after an owner crash remains
 a prerequisite for the full account-mutation cutover.
 
+Every route on either socket answers in one of three ways: a result, a **refusal**, or a fault. A refusal
+is an answer -- the daemon completed its check, nothing was left half-done, and its message says what the
+owner does instead -- so it crosses the wire marked, with the message verbatim beside
+`{ reason, code }`. A fault is anything the daemon did not decide: the transport replaces its text with
+`Internal server error`, and a caller must never present that as if it said what to do next. A malformed
+request is neither; it keeps its own text and carries no marker, because a caller's own bug is not an
+instruction for an owner.
+
+`asAuthSwitchRefusal(error)` from `@modelprofile.com/authswitch/authority-contract` is the one reader of
+that marker: it answers `{ code, instruction }` for a refusal and `null` for a fault. The code is the
+closed `TAuthSwitchRefusalCode` set, which is what a client branches on without reading the text:
+`authority_closing`, `not_found`, `account_changed`, `account_busy`, `login_unavailable`,
+`native_owner_holds_login`, `claude_home_unregistered`, `claude_handoff_pending`,
+`claude_receipt_missing` and `import_refusal`. The instruction is authored for the owner and contains no
+path, credential or digest; only an importer refusal may name the process the owner has to stop.
+
+The import routes keep the marker they published in 8.1.0, `authswitch_import_refusal`, and
+`isAuthSwitchImportRefusal` from `@modelprofile.com/authswitch/authority-import-contract` is the same
+reader asking for the `import_refusal` code, so a consumer written against 8.1.0 keeps working and a
+client of this release still reads the payload a daemon of that release answers with. The distinction
+matters most for `import.submit`: a refusal there is a submit that decided -- it left nothing half-done,
+and the ledger row it wrote says where that source stands -- while an unmarked failure leaves the outcome
+unknown, and that source must then be read with `authswitch.authority.import.status` rather than
+submitted again.
+
 `AuthSwitchClient.subscribe(onSnapshot, onEvent, signal, { onStatus })` reports `current`
 after a fresh snapshot or verified heartbeat, `unavailable` on disconnect or resync, and
 `closed` on abort. Keep cached account actions disabled while status is not `current`.
@@ -167,6 +195,35 @@ If the daemon is unavailable before the first response, it fails with a fixed di
 stderr and leaves stdout empty. The older native-store commands documented below still coexist until the coordinated
 major-version migration and removal; these authority routes never use them.
 
+### The Claude native home
+
+The daemon serves Claude Code's own credential store, which stays the native store that Claude Code
+reads. `authswitch.authority.claude.switch`, `.handoff` and `.handoffs` on the management socket move
+that one home between two authority logins and report the journal of those moves, and
+`authswitch.authority.usage` answers for an Anthropic account from it. The home is
+`CLAUDE_CONFIG_DIR` or `~/.claude`, and the authority identifies it by the hash of the credential file
+Claude Code owns -- the same value the import publishes as that source's path hash, which is what lets a
+verified receipt adopt it.
+
+The daemon is wired for that home whether or not Claude Code is installed, so `doctor` reports
+`claudeNativeAuthority: configured` on any host; the `claudeHomes` page is what says whether a home has
+been adopted. Until a verified `claude_native` import has adopted one, every Claude route refuses. A
+`CLAUDE_CONFIG_DIR` that is not an absolute path is refused when the daemon starts, because the same
+variable also decides which file the import would read; it is never resolved against a working directory.
+
+A switch is only attempted when the host can prove Claude Code uses that native login: exactly the
+verified Claude Code release, a subscriber login in the store, no credential override in the
+environment, no managed or local settings selecting another auth source, and no scoped Claude session
+running. Anything else refuses and leaves both logins where they were. A move that reaches the home and
+then cannot complete that proof is quarantined with `problem: unsupported_effective_auth`, and the
+handoff's optional `proofFailure` names which condition failed -- `unsupported_release`, `subscription`,
+`override`, `settings`, `profile`, `profile_unreadable` or `running_session` -- so an owner is told what
+to change. It is absent whenever `problem` is anything else. The settings that proof reads are the ones
+the daemon may speak for: the user settings file of the resolved home and the managed settings directory.
+A project's `.claude/settings.json` is read from the working directory of each running Claude session,
+never from the daemon's own, which is its service unit's and selects nothing. While a login is in the
+native home, Claude Code is its only refresher; the authority takes it back by the same journaled handoff.
+
 ## The one-time account import
 
 The three `authority import` commands move the accounts that existed before the authority into it.
@@ -189,6 +246,12 @@ Each source is classified by who refreshes its login **after** the import.
   credential. It is verified by a provider read with the access token already in the store, which rotates
   nothing. Two refreshers on one rotating refresh token is the failure this avoids.
 
+A verified Claude projection also adopts the native home it came from, so the daemon may serve Claude
+switches for it. The receipt is what adopts it, and a home belongs to one login at a time: a second home
+for a login another one already holds -- a `.credentials.json` copied to another `CLAUDE_CONFIG_DIR` --
+and a home whose active login has since moved are both refused with the importer's own code, so the
+submit is known to have decided, the ledger row stays `verified` and no home changed.
+
 `import submit` takes the source id and the digest the owner read in the inventory. The daemon re-reads the
 source itself and refuses if the digest changed, so approving one source can never import a different one;
 no credential crosses the socket for a source this package can read. It refuses while an authswitch watch, a

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@modelprofile.com/authswitch',
-  version: '8.1.0',
+  version: '8.2.0',
   description: 'Manage Codex, OpenCode and Claude Code accounts with guided switching and live usage status'
 }

package/ts/authority-contract.ts

@@ -2,6 +2,99 @@ import type { ITypedRequest } from '@api.global/typedrequest-interfaces';
 import type { IAuthSwitchUsageSnapshot } from './classes.authorityusage.js';
 export type { IAuthSwitchUsageSnapshot } from './classes.authorityusage.js';
 
+/**
+ * Why the authority declined, as a closed set a client branches on without reading the text.
+ *
+ * A refusal is an answer: the daemon did the check, nothing was left half-done, and the message says what
+ * the owner does instead. Everything else stays a fault whose text the transport replaces, and a caller
+ * must never present a fault as if it said what to do next.
+ */
+export type TAuthSwitchRefusalCode =
+  | 'authority_closing'
+  | 'not_found'
+  | 'account_changed'
+  | 'account_busy'
+  | 'login_unavailable'
+  | 'native_owner_holds_login'
+  | 'claude_home_unregistered'
+  | 'claude_handoff_pending'
+  | 'claude_receipt_missing'
+  | 'import_refusal';
+
+/** The marker the importer has published since 8.1.0; it keeps its own value on the wire. */
+export const authSwitchImportRefusalMarker = 'authswitch_import_refusal';
+export const authSwitchRefusalReason = 'authswitch_refusal';
+
+export type TAuthSwitchRefusalReason = typeof authSwitchRefusalReason | typeof authSwitchImportRefusalMarker;
+
+/** Everything a refusal puts on the wire beside its message: two literals, never a value of its own. */
+export interface IAuthSwitchRefusalData {
+  reason: TAuthSwitchRefusalReason;
+  code: TAuthSwitchRefusalCode;
+}
+
+/** What the owner is told when the answer is an instruction rather than a fault. */
+export interface IAuthSwitchRefusal {
+  code: TAuthSwitchRefusalCode;
+  /** The instruction, authored by the handler that declined. */
+  instruction: string;
+}
+
+const refusalCodes: ReadonlySet<string> = new Set<TAuthSwitchRefusalCode>([
+  'authority_closing', 'not_found', 'account_changed', 'account_busy',
+  'login_unavailable', 'native_owner_holds_login', 'claude_home_unregistered',
+  'claude_handoff_pending', 'claude_receipt_missing', 'import_refusal',
+]);
+
+const isRefusalCode = (value: unknown): value is TAuthSwitchRefusalCode =>
+  typeof value === 'string' && refusalCodes.has(value);
+
+/** The importer keeps the marker it published; every other code shares the authority's own. */
+const reasonOf = (code: TAuthSwitchRefusalCode): TAuthSwitchRefusalReason =>
+  code === 'import_refusal' ? authSwitchImportRefusalMarker : authSwitchRefusalReason;
+
+/**
+ * One refusal, thrown by a handler and turned into a marked answer by the router that owns the wire.
+ *
+ * It accepts nothing but a code of the closed set and the text the owner is to read, and builds the marker
+ * from the code alone, so no handler can attach a value of its own to what a client branches on.
+ */
+export class AuthSwitchRefusal extends Error {
+  public readonly code: TAuthSwitchRefusalCode;
+
+  constructor(code: TAuthSwitchRefusalCode, instruction: string) {
+    super(instruction);
+    this.code = code;
+  }
+
+  /** Everything this refusal puts on the wire beside its message. */
+  public get data(): IAuthSwitchRefusalData { return { reason: reasonOf(this.code), code: this.code }; }
+}
+
+/**
+ * The refusal an error answer carries, or null when it is a fault whose text says nothing.
+ *
+ * This is the only reader of `errorData` in the package: the importer's published predicate is expressed
+ * through it, so a caller never has to know which of the two markers a route uses.
+ *
+ * 8.1.0 marked the importer's refusal with the reason alone. A per-user daemon keeps running across an
+ * upgrade until its owner restarts it, so a newer client still meets that payload, and it names the one
+ * refusal that release could answer with -- which is why it is read rather than treated as a fault.
+ */
+export const asAuthSwitchRefusal = (error: unknown): IAuthSwitchRefusal | null => {
+  if (error instanceof AuthSwitchRefusal) return { code: error.code, instruction: error.message };
+  if (typeof error !== 'object' || error === null || !('errorData' in error)) return null;
+  const data: unknown = error.errorData;
+  if (typeof data !== 'object' || data === null || !('reason' in data)) return null;
+  const code: unknown = 'code' in data ? data.code : undefined;
+  const instruction = 'message' in error && typeof error.message === 'string' ? error.message : '';
+  if (data.reason === authSwitchImportRefusalMarker) {
+    return code === undefined || code === 'import_refusal' ? { code: 'import_refusal', instruction } : null;
+  }
+  if (data.reason !== authSwitchRefusalReason || !isRefusalCode(code)) return null;
+  return { code, instruction };
+};
+
 /** Credential-free account management contract. Safe to import in browser code. */
 export type TAuthSwitchLoginPurpose = 'openai_managed' | 'claude_host_native' | 'claude_container_setup' | 'opencode_native';
 export type TAuthSwitchLoginHealth = 'ready' | 'refreshing' | 'retry_wait' | 'needs_reauth' | 'unverified' | 'pending_handoff' | 'handoff_quarantined' | 'removed';
@@ -234,6 +327,17 @@ export interface IAuthSwitchPreuseOperation {
   revision: number;
 }
 
+/**
+ * Why the host could not prove that Claude Code uses its own native login.
+ *
+ * Each value names one condition of that proof, so an owner is told what to change: install the supported
+ * release, sign in to a subscriber plan, remove a credential override or a settings source, let the
+ * profile read succeed, or close the running session.
+ */
+export type TAuthSwitchClaudeProofFailure =
+  | 'unsupported_release' | 'override' | 'profile' | 'profile_unreadable'
+  | 'settings' | 'subscription' | 'running_session';
+
 /** Credential-free native file ownership result. It makes no claim about a running session's active request. */
 export interface IAuthSwitchClaudeNativeHandoff {
   id: string;
@@ -243,6 +347,8 @@ export interface IAuthSwitchClaudeNativeHandoff {
   phase: 'reserved' | 'prepared' | 'committed' | 'aborted' | 'quarantined';
   problem: 'none' | 'native_uncertain' | 'foreign_or_torn' | 'unsupported_effective_auth' | 'database_uncertain';
   runningEffectiveAuth: 'no_scoped_sessions' | 'unsupported_effective_auth' | null;
+  /** Which condition of the native-login proof failed, when `problem` is `unsupported_effective_auth`. */
+  proofFailure?: TAuthSwitchClaudeProofFailure;
   updatedAt: string;
 }
 

package/ts/authority-import-contract.ts

@@ -1,4 +1,5 @@
 import type { ITypedRequest } from '@api.global/typedrequest-interfaces';
+import { asAuthSwitchRefusal, authSwitchImportRefusalMarker } from './authority-contract.js';
 
 /**
  * The one-time account import: reading the legacy stores that existed before the authority, and the
@@ -148,20 +149,20 @@ export type TAuthSwitchImportAction = 'none' | 'resume' | 'device_login';
 /**
  * Marks an error answer whose text is an instruction for the owner, not a report of a fault.
  *
- * The daemon sets it on the refusals the importer authors and on nothing else. Every other failure answers
- * with the transport's own sanitised text, which a caller must never present as if it said what to do next --
- * for a submit in particular, an unmarked failure means the outcome is unknown and the source must be read
- * with `authswitch.authority.import.status` rather than submitted again.
+ * The daemon sets it on the refusals the importer authors and on nothing else: a refusal any other route
+ * authors carries the authority's own marker, and a failure neither of them decided answers with the
+ * transport's sanitised text, which a caller must never present as if it said what to do next. For a
+ * submit in particular, an unmarked failure means the outcome is unknown and the source must be read with
+ * `authswitch.authority.import.status` rather than submitted again.
+ *
+ * It is one code of the authority's refusal contract (`./authority-contract`), which every route now uses;
+ * this marker keeps its own value on the wire so a consumer written against 8.1.0 keeps working.
  */
-export const authSwitchImportRefusalReason = 'authswitch_import_refusal';
+export const authSwitchImportRefusalReason = authSwitchImportRefusalMarker;
 
 /** True when the daemon answered with an importer refusal, so `error.message` is the instruction to show. */
-export const isAuthSwitchImportRefusal = (error: unknown): boolean => {
-  if (typeof error !== 'object' || error === null || !('errorData' in error)) return false;
-  const data = error.errorData;
-  return typeof data === 'object' && data !== null && 'reason' in data
-    && data.reason === authSwitchImportRefusalReason;
-};
+export const isAuthSwitchImportRefusal = (error: unknown): boolean =>
+  asAuthSwitchRefusal(error)?.code === 'import_refusal';
 
 /**
  * Where one source stands, read from the migration ledger, the grant it produced and its handoff.

package/ts/classes.authoritybroker.ts

@@ -1,6 +1,7 @@
 import * as plugins from './plugins.js';
 import type { IAuthSwitchAccount, IAuthSwitchAccountEvent, IAuthSwitchBinding, IAuthSwitchLogin,
   IAuthSwitchOperation, IAuthSwitchSnapshot } from './authority-contract.js';
+import { AuthSwitchRefusal } from './authority-contract.js';
 import { AuthSwitchAuthorityDatabase } from './classes.authoritydatabase.js';
 import type { IStoredAuthorityAccount, IStoredAuthorityBinding, IStoredAuthorityGrant,
   IStoredAuthorityDeviceOperation } from './classes.authoritymodels.js';
@@ -554,7 +555,7 @@ export class AuthSwitchAuthorityBroker {
     if (!isId(accountId) || !validRevision(expectedRevision) || !safeLabel(label)) throw new Error('Invalid account change.');
     const updateId = plugins.crypto.randomUUID();
     const updated = await this.database.changeAccount(updateId, accountId, account => {
-      if (!account || account.removed || account.revision !== expectedRevision) throw new Error('Account changed; refresh before editing.');
+      if (!account || account.removed || account.revision !== expectedRevision) throw new AuthSwitchRefusal('account_changed', 'Account changed; refresh before editing.');
       return { ...account, label, revision: account.revision + 1, updateId,
         statusObservedAt: new Date(this.now()).toISOString() };
     });

package/ts/classes.authorityclient.ts

@@ -68,7 +68,13 @@ export interface IAuthSwitchSubscriptionOptions {
   heartbeatMs?: number;
 }
 
-/** Node-only client for the per-user daemon. Each request has its own bounded Unix connection. */
+/**
+ * Node-only client for the per-user daemon. Each request has its own bounded Unix connection.
+ *
+ * Every method takes an optional `AbortSignal`. A referenced socket with a 35 second timeout outlives a
+ * consumer's own stop unless that consumer can cancel the read, so the signal is what releases it; it
+ * detaches this request only and never cancels work the daemon already owns.
+ */
 export class AuthSwitchClient {
   private readonly target: plugins.typedrequest.TypedTarget;
   private readonly runtimeTarget: plugins.typedrequest.TypedTarget;
@@ -119,9 +125,10 @@ export class AuthSwitchClient {
       { submission, callerQuiescent: true, acknowledgeRunOrder: true }, 120_000, true, signal)).result;
   }
 
-  public async getUsage(accountId: string, loginId: string, force = false): Promise<IReq_AuthSwitchUsage['response']['usage']> {
+  public async getUsage(accountId: string, loginId: string, force = false,
+    signal?: AbortSignal): Promise<IReq_AuthSwitchUsage['response']['usage']> {
     return (await this.request<IReq_AuthSwitchUsage>('authswitch.authority.usage',
-      { accountId, loginId, force })).usage;
+      { accountId, loginId, force }, 35_000, false, signal)).usage;
   }
 
   /** Assemble a consistent view from bounded database pages; restart if a writer changes the revision. */
@@ -258,8 +265,10 @@ export class AuthSwitchClient {
     return (await this.request<IReq_AuthSwitchBeginReauth>('authswitch.authority.reauth',
       { operationId, accountId, loginId, purpose, flow: 'device' }, 35_000, false, signal)).operation;
   }
-  public listOperations(after?: string, limit?: number): Promise<IReq_AuthSwitchListOperations['response']> {
-    return this.request<IReq_AuthSwitchListOperations>('authswitch.authority.operations', { after, limit });
+  public listOperations(after?: string, limit?: number,
+    signal?: AbortSignal): Promise<IReq_AuthSwitchListOperations['response']> {
+    return this.request<IReq_AuthSwitchListOperations>('authswitch.authority.operations',
+      { after, limit }, 35_000, false, signal);
   }
   public async getOperation(operationId: string, signal?: AbortSignal): Promise<IReq_AuthSwitchGetOperation['response']['operation']> {
     return (await this.request<IReq_AuthSwitchGetOperation>('authswitch.authority.operation',
@@ -284,27 +293,39 @@ export class AuthSwitchClient {
     return (await this.request<IReq_AuthSwitchCancelPreuse>(
       'authswitch.authority.preuse.cancel', { operationId }, 35_000, false, signal)).operation;
   }
-  public async renameAccount(accountId: string, expectedRevision: number, label: string): Promise<IReq_AuthSwitchRenameAccount['response']['account']> {
-    return (await this.request<IReq_AuthSwitchRenameAccount>('authswitch.authority.rename', { accountId, expectedRevision, label })).account;
+  public async renameAccount(accountId: string, expectedRevision: number, label: string,
+    signal?: AbortSignal): Promise<IReq_AuthSwitchRenameAccount['response']['account']> {
+    return (await this.request<IReq_AuthSwitchRenameAccount>('authswitch.authority.rename',
+      { accountId, expectedRevision, label }, 35_000, false, signal)).account;
   }
-  public async removeAccount(accountId: string, expectedRevision: number): Promise<IReq_AuthSwitchRemoveAccount['response']['account']> {
-    return (await this.request<IReq_AuthSwitchRemoveAccount>('authswitch.authority.remove', { accountId, expectedRevision })).account;
+  public async removeAccount(accountId: string, expectedRevision: number,
+    signal?: AbortSignal): Promise<IReq_AuthSwitchRemoveAccount['response']['account']> {
+    return (await this.request<IReq_AuthSwitchRemoveAccount>('authswitch.authority.remove',
+      { accountId, expectedRevision }, 35_000, false, signal)).account;
   }
-  public async switchClaudeNative(accountId: string, loginId: string): Promise<IReq_AuthSwitchSwitchClaudeNative['response']['handoff']> {
+  public async switchClaudeNative(accountId: string, loginId: string,
+    signal?: AbortSignal): Promise<IReq_AuthSwitchSwitchClaudeNative['response']['handoff']> {
     return (await this.request<IReq_AuthSwitchSwitchClaudeNative>('authswitch.authority.claude.switch',
-      { accountId, loginId, purpose: 'claude_host_native' })).handoff;
+      { accountId, loginId, purpose: 'claude_host_native' }, 35_000, false, signal)).handoff;
   }
-  public async getClaudeNativeHandoff(operationId: string): Promise<IReq_AuthSwitchClaudeNativeHandoff['response']['handoff']> {
-    return (await this.request<IReq_AuthSwitchClaudeNativeHandoff>('authswitch.authority.claude.handoff', { operationId })).handoff;
+  public async getClaudeNativeHandoff(operationId: string,
+    signal?: AbortSignal): Promise<IReq_AuthSwitchClaudeNativeHandoff['response']['handoff']> {
+    return (await this.request<IReq_AuthSwitchClaudeNativeHandoff>('authswitch.authority.claude.handoff',
+      { operationId }, 35_000, false, signal)).handoff;
   }
-  public listClaudeNativeHandoffs(after?: string, limit?: number): Promise<IReq_AuthSwitchClaudeNativeHandoffs['response']> {
-    return this.request<IReq_AuthSwitchClaudeNativeHandoffs>('authswitch.authority.claude.handoffs', { after, limit });
+  public listClaudeNativeHandoffs(after?: string, limit?: number,
+    signal?: AbortSignal): Promise<IReq_AuthSwitchClaudeNativeHandoffs['response']> {
+    return this.request<IReq_AuthSwitchClaudeNativeHandoffs>('authswitch.authority.claude.handoffs',
+      { after, limit }, 35_000, false, signal);
   }
-  public bindAccount(input: IReq_AuthSwitchBindAccount['request']): Promise<IReq_AuthSwitchBindAccount['response']> {
-    return this.request<IReq_AuthSwitchBindAccount>('authswitch.authority.bind', input);
+  public bindAccount(input: IReq_AuthSwitchBindAccount['request'],
+    signal?: AbortSignal): Promise<IReq_AuthSwitchBindAccount['response']> {
+    return this.request<IReq_AuthSwitchBindAccount>('authswitch.authority.bind', input, 35_000, false, signal);
   }
-  public resolveAccess(input: IReq_AuthSwitchResolveAccess['request']): Promise<IReq_AuthSwitchResolveAccess['response']> {
-    return this.request<IReq_AuthSwitchResolveAccess>('authswitch.authority.resolveAccess', input, 35_000, true);
+  public resolveAccess(input: IReq_AuthSwitchResolveAccess['request'],
+    signal?: AbortSignal): Promise<IReq_AuthSwitchResolveAccess['response']> {
+    return this.request<IReq_AuthSwitchResolveAccess>('authswitch.authority.resolveAccess',
+      input, 35_000, true, signal);
   }
   public releaseBinding(input: IReq_AuthSwitchReleaseBinding['request'], signal?: AbortSignal): Promise<IReq_AuthSwitchReleaseBinding['response']> {
     return this.request<IReq_AuthSwitchReleaseBinding>('authswitch.authority.release', input, 35_000, true, signal);
@@ -320,9 +341,10 @@ export class AuthSwitchRuntimeClient {
       postMethod: (payload, options) => post(runtimeSocketPath, payload, options?.signal),
     });
   }
-  public resolveAccess(input: IReq_AuthSwitchResolveAccess['request']): Promise<IReq_AuthSwitchResolveAccess['response']> {
+  public resolveAccess(input: IReq_AuthSwitchResolveAccess['request'],
+    signal?: AbortSignal): Promise<IReq_AuthSwitchResolveAccess['response']> {
     return new plugins.typedrequest.TypedRequest<IReq_AuthSwitchResolveAccess>(this.target,
-      'authswitch.authority.resolveAccess').fire(input, { timeoutMs: 35_000, maxRetries: 0 });
+      'authswitch.authority.resolveAccess').fire(input, { timeoutMs: 35_000, maxRetries: 0, abortSignal: signal });
   }
   public releaseBinding(input: IReq_AuthSwitchReleaseBinding['request'], signal?: AbortSignal): Promise<IReq_AuthSwitchReleaseBinding['response']> {
     return new plugins.typedrequest.TypedRequest<IReq_AuthSwitchReleaseBinding>(this.target,