@object-ui/auth 17.5.0 → 17.7.0

package/README.md

@@ -25,16 +25,18 @@ npm install @object-ui/auth
 ## Quick Start
 
 ```tsx
-import { AuthProvider, useAuth, AuthGuard } from '@object-ui/auth';
-import { createAuthClient } from '@object-ui/auth';
+import type { ReactNode } from 'react';
+import { AuthProvider, AuthGuard, createAuthClient, useAuth } from '@object-ui/auth';
 
-const authClient = createAuthClient({
-  baseURL: 'https://api.example.com/auth',
-});
+// Your app supplies the sign-in page shown to unauthenticated visitors.
+declare const LoginPage: () => ReactNode;
+
+const authUrl = 'https://api.example.com/auth';
+const authClient = createAuthClient({ baseURL: authUrl });
 
 function App() {
   return (
-    <AuthProvider client={authClient}>
+    <AuthProvider authUrl={authUrl} client={authClient}>
       <AuthGuard fallback={<LoginPage />}>
         <Dashboard />
       </AuthGuard>
@@ -57,12 +59,21 @@ function Dashboard() {
 
 ### AuthProvider
 
-Wraps your application with authentication context:
+Wraps your application with authentication context. `authUrl` is **required**;
+`client` is optional, and when you pass one it is used instead of the client
+`AuthProvider` would otherwise build from `authUrl`:
 
 ```tsx
-<AuthProvider client={authClient}>
+import type { ReactNode } from 'react';
+import { AuthProvider } from '@object-ui/auth';
+import type { AuthClient } from '@object-ui/auth';
+
+declare const authClient: AuthClient;
+declare const App: () => ReactNode;
+
+<AuthProvider authUrl="/api/v1/auth" client={authClient}>
   <App />
-</AuthProvider>
+</AuthProvider>;
 ```
 
 ### useAuth
@@ -70,6 +81,8 @@ Wraps your application with authentication context:
 Hook for accessing auth state and methods:
 
 ```tsx
+import { useAuth } from '@object-ui/auth';
+
 const {
   user,
   session,
@@ -100,9 +113,14 @@ const {
 Protects children from unauthenticated access:
 
 ```tsx
+import type { ReactNode } from 'react';
+import { AuthGuard, LoginForm } from '@object-ui/auth';
+
+declare const ProtectedContent: () => ReactNode;
+
 <AuthGuard fallback={<LoginForm />}>
   <ProtectedContent />
-</AuthGuard>
+</AuthGuard>;
 ```
 
 ### LoginForm / RegisterForm / ForgotPasswordForm
@@ -110,9 +128,40 @@ Protects children from unauthenticated access:
 Pre-built authentication form components:
 
 ```tsx
-<LoginForm onSuccess={() => navigate('/dashboard')} />
-<RegisterForm onSuccess={() => navigate('/welcome')} />
-<ForgotPasswordForm onSuccess={() => navigate('/check-email')} />
+import { ForgotPasswordForm, LoginForm, RegisterForm } from '@object-ui/auth';
+
+declare const navigate: (to: string) => void;
+
+<LoginForm onSuccess={() => navigate('/dashboard')} />;
+<RegisterForm onSuccess={() => navigate('/welcome')} />;
+<ForgotPasswordForm onSuccess={() => navigate('/check-email')} />;
+```
+
+`labels` is how the forms take translated text, and it reaches the social
+provider buttons the server's `/auth/config` turns on: `socialButton`
+is a template whose `{provider}` is replaced with the provider's display name
+(defaults "Continue with {provider}" on `LoginForm`, "Sign up with {provider}"
+on `RegisterForm`), and `orText` is the divider under the buttons (default
+"or continue with email").
+
+When the server requires email verification, a registration ends in the user's
+inbox, and the verification link is the only way back. `verificationCallbackURL`
+says where that link lands, e.g. the invitation the user signed up from. It is
+sent as better-auth's sign-up `callbackURL` (the same value as the fourth
+argument of `useAuth().signUp`). The server accepts only a root-relative path
+or an absolute URL on a trusted origin, and refuses a document-relative `./…`
+with `INVALID_CALLBACK_URL`, which fails the sign-up. Resolve an SPA route
+against its mount first. Omitted, the server default (`/`) applies.
+
+```tsx
+import { RegisterForm } from '@object-ui/auth';
+
+declare const navigate: (to: string) => void;
+
+<RegisterForm
+  verificationCallbackURL="/_console/accept-invitation/inv_123"
+  onVerificationRequired={(email) => navigate(`/verify-email-prompt?email=${encodeURIComponent(email)}`)}
+/>;
 ```
 
 ### UserMenu
@@ -120,7 +169,9 @@ Pre-built authentication form components:
 Displays current user info with avatar and sign-out:
 
 ```tsx
-<UserMenu />
+import { UserMenu } from '@object-ui/auth';
+
+<UserMenu />;
 ```
 
 ### createAuthenticatedFetch
@@ -129,6 +180,8 @@ Creates a fetch wrapper that injects the stored Bearer token (plus
 `X-Tenant-ID` and `Accept-Language`) into API requests:
 
 ```tsx
+import { createAuthenticatedFetch } from '@object-ui/auth';
+
 const authedFetch = createAuthenticatedFetch();
 
 // For fetches whose target URL comes from view metadata (`provider: 'api'`
@@ -137,6 +190,178 @@ const authedFetch = createAuthenticatedFetch();
 const apiProviderFetch = createAuthenticatedFetch({ sameOriginOnly: true });
 ```
 
+### getSessionOwnerChangeCount / subscribeSessionOwnerChange
+
+When the session resolves to a different user than the one this browser last
+held, `AuthProvider` drops the previous user's client state (objectui#5664).
+That clears storage only. State already derived from that storage and held in
+memory, such as the UI language the boot resolved, has to be re-derived by
+whoever owns it. These two exports tell that owner a change happened in this
+page-load (objectui#10193). The count lets an owner that mounts after the purge
+still see it:
+
+```tsx
+import { useSyncExternalStore } from 'react';
+import { getSessionOwnerChangeCount, subscribeSessionOwnerChange } from '@object-ui/auth';
+
+const ownerChanges = useSyncExternalStore(
+  subscribeSessionOwnerChange,
+  getSessionOwnerChangeCount,
+  getSessionOwnerChangeCount,
+);
+```
+
+The count lives in memory for one page-load and is never persisted.
+`@object-ui/app-shell`'s `useSignedInUserLocale` is the in-repo consumer.
+
+## The `X-Tenant-ID` edge contract
+
+`createAuthenticatedFetch` stamps `X-Tenant-ID` on the requests it wraps. This section is
+that header's contract: what it means, who stamps it, who reads it, what a reader may
+assume, and the one window in which it is not sent at all.
+
+It is written down because **a grep cannot answer any of those questions from this
+repository.** The header's only non-CORS consumer lives in the **cloud** repository, so a
+search confined to this repo and the framework (`objectstack`) finds zero readers and
+reads as *"nothing consumes this stamp"*. That reading is what
+[objectui#5279](https://github.com/objectstack-ai/objectui/issues/5279) was filed on, and
+it is false. Do not act on it.
+
+### What it means
+
+A **routing hint** for the hosting edge — *this request belongs to tenant `<id>`*:
+
+```http
+X-Tenant-ID: <better-auth activeOrganizationId>
+```
+
+The value is the active **organization** id, the same id the session carries as
+`session.activeOrganizationId`. The header is **not** an identity claim, **not** an
+authorization input, and **not** what scopes rows.
+
+### Who stamps it
+
+| | |
+| --- | --- |
+| Stamped by | `createAuthenticatedFetch` ([`src/createAuthenticatedFetch.ts`](src/createAuthenticatedFetch.ts)) |
+| Value read from | `ActiveOrganizationStorage` ([`src/ActiveOrganizationStorage.ts`](src/ActiveOrganizationStorage.ts)) — `localStorage`, key `auth-active-organization-id:u:$userId` (per-user since objectui#5664; the bare key is the retired pre-#5664 spelling) |
+| Condition | that storage holds a non-empty value |
+| *Not* conditioned on | the URL being an `/api/` call. `Authorization` and `Accept-Language` are; this is not |
+| Suppressed by | `createAuthenticatedFetch({ sameOriginOnly: true })` for cross-origin URLs — it returns before any header work |
+| Precedence | overwrites an `X-Tenant-ID` the caller passed in `init.headers` |
+
+`ActiveOrganizationStorage` has exactly one writer, [`AuthProvider`](src/AuthProvider.tsx):
+
+| Event | Effect |
+| --- | --- |
+| `refreshOrganizations` — after `getSession` &rarr; `listOrganizations` &rarr; `getActiveOrganization` resolves (including the ADR-0081 single-membership repair) | set |
+| `switchOrganization` — the org switcher | set, or clear when the server returns no org |
+| `deleteOrganization` / `leaveOrganization`, when the active org is the one going away | clear |
+| sign-out | clear |
+
+### Who reads it
+
+**The cloud edge — yes.** The non-test readers are recorded on objectui#5279:
+`packages/service-tenant/src/tenant-context.ts` (header resolution) and
+`packages/tenant-router/src/spec/turso-multi-tenant.zod.ts`, both in the `cloud`
+repository. That repository is not readable from this one, so those paths are cited as the
+recorded reading rather than re-derived here.
+
+**Its configuration contract, though, IS readable from here**, because this package
+depends on `@objectstack/spec`. `TenantRoutingConfigSchema` (`@objectstack/spec/cloud`) is
+what configures a tenant resolver; parsing an empty config on the version this package
+resolves today (17.1.0) yields:
+
+```text
+enabled:               false
+identificationSources: ["subdomain", "header", "jwt_claim"]
+tenantHeaderName:      "X-Tenant-ID"
+jwtOrganizationClaim:  "organizationId"
+```
+
+Two consequences matter to a client author:
+
+- **The header name is configurable.** `X-Tenant-ID` is its default, not a constant.
+- **The header is one of six identification sources** (`subdomain`, `custom_domain`,
+  `header`, `jwt_claim`, `session`, `default`), and in the default precedence it ranks
+  **second, behind `subdomain`**. On a subdomain-routed deployment it is not the thing
+  that picks the tenant, and a deployment may leave it out of `identificationSources`
+  entirely.
+
+**The framework (`objectstack`) — no.** `resolveAuthzContext`
+(`packages/core/src/security/resolve-authz-context.ts`) derives `tenantId` from the
+API-key principal or from `session.activeOrganizationId`, and from no header;
+`packages/verify/src/harness.org-context.test.ts` pins it — *"`session.activeOrganizationId`
+is the ONE field `resolveAuthzContext` reads into `tenantId`"*. Environment and kernel
+routing read the hostname and `X-Environment-Id`. The framework's only other mentions are
+the CORS preflight allow-list (`DEFAULT_CORS_ALLOW_HEADERS`, whose comment describes
+`X-Tenant-ID` / `X-Environment-Id` as what routes "a request to its environment") and
+`plugin-sharing`, which records that trusting `x-tenant-id` as identity **was a
+vulnerability**: its secure default stopped reading identity from headers because doing so
+let a client forge attribution and enumerate or revoke other users' links.
+
+### What a reader may assume
+
+A reader **may**:
+
+- use it to select the tenant database or environment to route to, subject to its own
+  `identificationSources` precedence;
+- treat it as a hint that may be absent, stale, or contradicted by the session.
+
+A reader **may not**:
+
+- treat it as authenticated identity, or as an authorization decision. It is
+  client-controlled — any caller can send any value, and `plugin-sharing` is the recorded
+  precedent for what happens to a server that trusts it;
+- assume the row scoping it sees downstream came from this header. It did not: the
+  framework scopes from the session;
+- assume the header is present. See below.
+
+### The unstamped-first-request gap
+
+The stamp reads storage that `AuthProvider` fills only **after** `getSession` &rarr;
+`listOrganizations` &rarr; `getActiveOrganization` resolves. Every request that leaves
+before that chain completes carries **no** `X-Tenant-ID` at all.
+
+The window opens in five situations:
+
+1. a browser that has never signed in, or whose site data was cleared, including a private
+   window;
+2. the page load in which the user signs in — from the sign-in response until the
+   organization chain resolves;
+3. after sign-out, which clears the storage, until a new organization resolves;
+4. outside a browser (SSR, tests, a worker), where `localStorage` is unavailable and the
+   storage falls back to a per-process in-memory value that starts empty on every cold
+   start;
+5. a browser where `localStorage` exists but **rejects writes** (Safari private browsing,
+   quota exhaustion). There the window never closes — the in-memory fallback is written
+   but never read back, because `get()` only falls back when reading itself *throws*, and
+   a rejected write leaves reads working and returning `null`. Reported on objectui#5279
+   as a separate defect; it is not fixed here.
+
+Case 1 is not theoretical in this codebase: `app-shell`'s `MetadataProvider` issues its
+eager `app` metadata fetch inside exactly this window, which is why its first-boot cache
+scope needed its own reasoning
+([`packages/app-shell/src/providers/MetadataProvider.tsx`](../app-shell/src/providers/MetadataProvider.tsx),
+pinned by `MetadataProvider.firstBootOrgScope.test.tsx`).
+
+**What a reader observes in the window:** the header is **absent**, never
+present-and-empty. A resolver must fall through to its next configured identification
+source — `subdomain` already outranks it by default, with `jwt_claim`, `session` and
+`defaultTenantId` behind it — rather than fail closed on the absence. It must also not
+cache a routing decision taken inside the window as *the* tenant for the session: the very
+next request will normally carry the header.
+
+**Why the gap does not corrupt data scoping.** A response computed inside the window is
+still computed for the right tenant, because the framework takes `tenantId` from the
+session rather than from the header. The gap is a *routing-input* gap, not a scoping gap.
+This is the same reasoning objectui#5243 relied on when it relabelled a metadata cache
+entry that had been written in the window.
+
+**Closing the gap is a separate decision, not an omission.** The cloud readers observe the
+current behaviour, so changing when the header first appears changes what they see. If it
+should be closed, it needs its own card.
+
 ## Server Feature Flags (`GET /auth/config`)
 
 `createAuthClient().getConfig()` fetches the server's public auth configuration. The
@@ -177,13 +402,16 @@ not a gap.
 
 Preview mode allows visitors (e.g. marketplace customers) to explore the platform without registering or logging in. The `AuthProvider` auto-authenticates with a simulated user identity and bypasses login/registration screens.
 
-This feature aligns with the `PreviewModeConfig` from `@objectstack/spec/kernel` ([spec PR #676](https://github.com/objectstack-ai/spec/pull/676)).
+This capability is host-supplied and has no `@objectstack/spec` anchor. It aligned with `PreviewModeConfig` from `@objectstack/spec/kernel` until that symbol was retired upstream (objectstack#11846), which removed it together with the `RuntimeMode` value `'preview'`; the spec this package resolves no longer exports it. The `previewMode` prop below is unaffected — it is the host's to supply, and always was.
 
 ### Usage
 
 ```tsx
+import type { ReactNode } from 'react';
 import { AuthProvider, PreviewBanner } from '@object-ui/auth';
 
+declare const Dashboard: () => ReactNode;
+
 function App() {
   return (
     <AuthProvider
@@ -229,6 +457,8 @@ import { PreviewBanner } from '@object-ui/auth';
 Use the `useAuth` hook to check if the app is in preview mode:
 
 ```tsx
+import { useAuth } from '@object-ui/auth';
+
 function MyComponent() {
   const { isPreviewMode, previewMode } = useAuth();
 

package/dist/ActiveOrganizationStorage.d.ts

@@ -0,0 +1,199 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * Drop the outgoing user's client state wholesale — part 3 of the fix.
+ *
+ * Order is load-bearing and mirrors `clear()`'s: the in-memory active org goes
+ * FIRST, because `ActiveOrganizationStorage.get()` falls through to
+ * `_memoryValue` whenever the persisted read is null, which is exactly the
+ * state this function leaves behind (objectui#5703). Sweeping storage first
+ * would leave the outgoing user's org id live in memory for the rest of the
+ * page-load — the SPA sign-out-then-sign-in path never reloads.
+ *
+ * Both stores are swept. `sessionStorage` is per-TAB, not per-session, so the
+ * previous user's `objectui:metadata:*` seed (their PERMISSION-FILTERED app
+ * list) and their `objectui-ctx-*` scope picks survive into whoever signs in
+ * next in that tab unless something removes them.
+ */
+export declare function purgePreviousUserClientState(): void;
+/**
+ * The number of owner changes {@link SessionUserScope.adopt} has performed in
+ * this page-load — `0` until a DIFFERENT user than the one the browser
+ * previously held is adopted.
+ *
+ * ## Why a count and not only an event (objectui#10193)
+ *
+ * The purge sweeps the previous owner's STORAGE, but state that was already
+ * derived from that storage before the purge — the UI language the boot
+ * resolved out of the previous owner's language slots, above all — lives in
+ * memory and is untouched by it. Whoever owns such state has to re-derive it,
+ * and the component that does may mount AFTER the purge happened (the shell
+ * mounts behind the session gate, the purge fires as the session resolves). A
+ * bare event would be missed by it; a count lets a late reader compare against
+ * what it has already handled. Shaped for React's `useSyncExternalStore`
+ * together with {@link subscribeSessionOwnerChange}.
+ */
+export declare function getSessionOwnerChangeCount(): number;
+/**
+ * Be told each time {@link SessionUserScope.adopt} drops a previous owner's
+ * state. Returns the unsubscribe function. A listener that throws is reported
+ * and skipped, never allowed to break the sign-in path that called `adopt`.
+ */
+export declare function subscribeSessionOwnerChange(listener: () => void): () => void;
+/**
+ * Which user's client state this browser holds, and the transition that drops
+ * the previous user's state.
+ */
+export declare const SessionUserScope: {
+    /**
+     * Memory copy of the pointer. Read FIRST by {@link current}: once this
+     * page-load has adopted a user, that answer is authoritative for this tab
+     * even if another tab has since written a different id, and it is the only
+     * copy in a browser whose `localStorage` rejects writes.
+     */
+    _userId: string | null;
+    /** The user whose state this browser holds, or `null` if it has never held one. */
+    current(): string | null;
+    /**
+     * Record `userId` as the owner of this browser's client state, dropping the
+     * previous owner's state wholesale when it changes.
+     *
+     * Returns `true` when it dropped a previous owner's state, `false`
+     * otherwise (same user, first-ever owner, empty id). A drop is also reported
+     * to {@link subscribeSessionOwnerChange} listeners and counted by
+     * {@link getSessionOwnerChangeCount} (objectui#10193): the purge clears
+     * storage, and anything already derived from that storage in memory is the
+     * listener's to re-derive.
+     *
+     * Idempotent: re-adopting the same user purges nothing. Called from
+     * `AuthProvider` for real sessions only — the synthetic `preview-user` /
+     * `guest` identities never reach it, so a preview mount cannot purge a real
+     * user's state.
+     *
+     * Because the decision reads the PERSISTED pointer, anything that deletes
+     * that pointer without deleting the state it describes would silently retire
+     * this invariant. `apps/console/src/lib/auth-preflight.ts` is the one place
+     * that sweeps auth keys before render, and it says so in its own comment:
+     * it removes every active-org spelling and leaves `auth-session-user-id`
+     * alone on purpose.
+     */
+    adopt(userId: string): boolean;
+    /**
+     * Forget the in-memory pointer. Test seam only — production has no reason to
+     * un-know who is signed in, and sign-out deliberately KEEPS the persisted
+     * pointer so that the next sign-in by a DIFFERENT user still sees a previous
+     * owner to purge.
+     */
+    _resetForTests(): void;
+};
+/**
+ * Get/set the active organization id that {@link createAuthenticatedFetch}
+ * stamps as `X-Tenant-ID`.
+ *
+ * `AuthProvider` is the only writer, at four moments: `refreshOrganizations`
+ * sets it once the `getSession` -> `listOrganizations` ->
+ * `getActiveOrganization` chain resolves (including the ADR-0081
+ * single-membership repair), `switchOrganization` sets or clears it,
+ * `deleteOrganization` / `leaveOrganization` clear it when the active org is
+ * the one going away, and sign-out clears it.
+ *
+ * Because the first of those is asynchronous, this reads EMPTY for the first
+ * stretch of a boot, and every request that leaves in that window carries no
+ * tenant header at all. That window is a documented part of the header's
+ * contract, not an accident to paper over — see the "unstamped-first-request
+ * gap" section of this package's README (objectui#5279).
+ */
+export declare const ActiveOrganizationStorage: {
+    _memoryValue: string | null;
+    /**
+     * Keys whose removal by {@link clear} did not stick — the value was still
+     * readable afterwards (objectui#5731).
+     *
+     * {@link get} refuses to answer from the persisted layer for a key in here,
+     * which is the mechanism that keeps a cleared organization cleared. Held in
+     * memory, so it lasts exactly one page-load: a browser that starts fresh
+     * re-measures rather than inheriting a verdict.
+     */
+    _unremovedKeys: Set<string>;
+    /**
+     * The active org id for the CURRENT user, or `null`.
+     *
+     * READ ORDER — a non-null `localStorage` read wins; anything else falls
+     * through to `_memoryValue`. Returning the `localStorage` read
+     * UNCONDITIONALLY (what this did before objectui#5703) left the fallback
+     * reachable only when the read THREW, and there is a real browser state
+     * where the read does not throw and the fallback is still the only copy:
+     * `localStorage` present and readable but REJECTING WRITES — Safari private
+     * browsing, and any quota-exhausted origin, where `setItem` throws
+     * `QuotaExceededError`. `set()` swallows that failure into `_memoryValue`
+     * (correctly — the fallback is right there), and `get()` then never
+     * consulted it: the value was stored and could not be read back, so
+     * `X-Tenant-ID` went unstamped for the whole session, not just the early
+     * requests.
+     *
+     * WHY FALLING BACK ON `null` DOES NOT RESURRECT A CLEARED ORG. After
+     * `clear()` the `localStorage` read is null by construction, so this
+     * fallback fires — and it must answer `null`, because sign-out is one of
+     * `clear()`'s callers. It does, because `clear()` nulls `_memoryValue` too.
+     * That property is what makes this read order safe rather than an
+     * incidental detail of `clear()`'s body, so it is pinned by test
+     * (`__tests__/activeOrgStorageFallback-5703.test.tsx`) instead of being
+     * re-derived by whoever edits `clear()` next.
+     *
+     * The same reasoning is why a change of session user purges through
+     * {@link purgePreviousUserClientState} rather than by removing keys: the
+     * outgoing user's id in `_memoryValue` would otherwise outlive their
+     * persisted key on the SPA sign-out-then-sign-in path (objectui#5664).
+     */
+    get(): string | null;
+    /**
+     * With no session user known this writes to memory ONLY. That is not a
+     * degraded path to apologise for — it is the fix: a persisted write with no
+     * owner is the un-namespaced key this card retired.
+     */
+    set(orgId: string): void;
+    /**
+     * Drop the active organization, from memory and from the persisted key.
+     *
+     * POSTCONDITION: {@link get} answers `null` afterwards. Sign-out is one of
+     * the callers, so that is a security-relevant guarantee rather than a
+     * convenience — and before objectui#5731 it was not one, because a
+     * `removeItem` that failed was swallowed and the surviving key won `get()`'s
+     * read order.
+     *
+     * ## Why a failed removal is neither thrown nor returned (objectui#5731)
+     *
+     * Every caller arrives here AFTER the transition it is following up on has
+     * already happened, and not one of them can act on a storage failure:
+     *
+     *  - `AuthProvider`'s `purgeSignedOutClientCaches` — the session is already
+     *    ended. Sign-out cannot be refused because a key would not delete.
+     *  - `switchOrganization` — the server already switched or cleared the
+     *    active org; a throw would report a successful switch as a failure and
+     *    route the caller into its error branch.
+     *  - `deleteOrganization` / `leaveOrganization` — the org is already deleted
+     *    or already left.
+     *  - {@link purgePreviousUserClientState}, via {@link SessionUserScope.adopt}
+     *    — runs on the SIGN-IN path inside an `AuthProvider` effect, where a
+     *    throw breaks the boot of the ARRIVING user.
+     *
+     * A `boolean` return only moves the problem one step: all five call sites
+     * would have nothing to write in the failure branch, and a return value that
+     * every caller ignores reads as handled when it is not. So the invariant is
+     * restored HERE, where it can be, and the failure is reported to the console,
+     * where a human can find it.
+     *
+     * The third shape considered and rejected was re-writing the key with an
+     * empty value. That relocates the fix into every consumer's truthiness test
+     * (`createAuthenticatedFetch` does `if (activeOrgId)`), which is the lenient
+     * consumer AGENTS.md #0.1 forbids, and it leaves a signed-out browser holding
+     * a live key.
+     */
+    clear(): void;
+};
+//# sourceMappingURL=ActiveOrganizationStorage.d.ts.map

package/dist/ActiveOrganizationStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActiveOrganizationStorage.d.ts","sourceRoot":"","sources":["../src/ActiveOrganizationStorage.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAyOH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,4BAA4B,IAAI,IAAI,CAInD;AAkBD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,IAAI,MAAM,CAEnD;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAK5E;AAaD;;;GAGG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;;;;OAKG;aACc,MAAM,GAAG,IAAI;IAE9B,mFAAmF;eACxE,MAAM,GAAG,IAAI;IAKxB;;;;;;;;;;;;;;;;;;;;;;OAsBG;kBACW,MAAM,GAAG,OAAO;IA+B9B;;;;;OAKG;sBACe,IAAI;CAGvB,CAAC;AAqBF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,yBAAyB;kBACd,MAAM,GAAG,IAAI;IAEnC;;;;;;;;OAQG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;WACI,MAAM,GAAG,IAAI;IAsBpB;;;;OAIG;eACQ,MAAM,GAAG,IAAI;IAOxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;aACM,IAAI;CAyCd,CAAC"}