@posthog/browser-common 0.2.1 → 0.2.3

package/README.md

@@ -6,16 +6,17 @@ runtime, but it is not a public API surface and does not provide compatibility
 guarantees outside PostHog SDK packages.
 
 The shared extension contract includes the interface an extension implements
-(`Extension`), the host capabilities it is handed (`Client`), and small shared
-runtime primitives such as `Publisher`.
+(`Extension`), the host services it is handed (`Client`), the core analytics
+capability (`CoreExtension`), and small shared runtime primitives such as
+`Publisher`.
 
-An extension written against this contract runs unchanged across major versions of the web SDK:
+This contract is designed so an extension can run unchanged across major
+versions of the web SDK. Concrete host adapters remain owned by their SDK
+packages; browser-v1 and browser-v2 composition and loading integration are
+separate from this shared runtime.
 
-- **v1** is synchronous; extensions are registered statically.
-- **v2** is asynchronous; extensions are loaded dynamically.
-
-Each SDK provides a _client adapter_ that implements `Client` over its own
-internals, so extension code never depends on a specific SDK.
+A conforming SDK provides a _client adapter_ that implements `Client` over its
+own internals, so extension code never depends on a specific SDK.
 
 ## Concepts
 
@@ -24,7 +25,7 @@ internals, so extension code never depends on a specific SDK.
 What you implement. The host calls only `setup` and `dispose`:
 
 ```ts
-import type { Disposable, Extension } from '@posthog/browser-common'
+import { CoreExtension, type Disposable, type Extension } from '@posthog/browser-common'
 
 export function webContext(): Extension {
     let removeProperties: Disposable | undefined
@@ -32,7 +33,11 @@ export function webContext(): Extension {
     return {
         name: 'webContext',
         setup(client) {
-            removeProperties = client.registerDynamicEventProperties(() => ({
+            const core = client.getExtension(CoreExtension)
+            if (!core) {
+                throw new Error('CoreExtension is required')
+            }
+            removeProperties = core.registerDynamicEventProperties(() => ({
                 $current_url: window.location.href,
             }))
         },
@@ -48,23 +53,44 @@ may be async (final flush). Static config the app sets goes in your constructor,
 not on the `Client`.
 
 Anything in `setup` that returns a `Disposable` must be held by the extension
-and disposed in `dispose()`.
+and disposed in `dispose()`. Use `createDisposable(teardown)` when adapting a
+callback into idempotent teardown.
 
 ### `Client`
 
-What an extension is given in `setup` — the host's capability surface:
+What an extension is given in `setup` — the host's extension services:
 
-- **identity & session** (synchronous reads): `distinctId`, `anonymousId`, `groups`, `session`
-- **events**: `capture(...)`, `registerDynamicEventProperties(...)` (contribute properties), `onEvent(...)` (observe)
-- **transport**: `apiRequest(path, init?)`
-- **server config**: `getRemoteConfig()` (current), `onRemoteConfig(...)` (changes)
-- **lifecycle**: `onNewSession(...)`
+- **transport**: `projectToken`, `sendRequest(path, init?)`
 - **registry**: `getExtension(token)`
 - **storage & logging**: `kv`, `logger`
 
-Synchronous members are always-ready in-memory reads; everything that does I/O
-or waits for readiness (`capture`, `apiRequest`, `kv`, `getRemoteConfig`) is
-asynchronous.
+### `CoreExtension`
+
+A conforming host must register one `CoreExtension` before setting up product
+extensions. Resolve it through `client.getExtension(CoreExtension)` for behavior
+owned by the PostHog client's analytics core:
+
+- **identity & session**: `distinctId`, `anonymousId`, `groups`, `session`
+- **events**: `capture(...)`, `registerDynamicEventProperties(...)`, `onEvent(...)`
+- **lifecycle**: `onNewSession(...)`
+- **server config**: `getRemoteConfig()` (current), `onRemoteConfig(...)` (changes)
+
+Identity, session, and the public project token are always-ready synchronous
+reads. Operations that perform I/O, including `capture`, `sendRequest`, `kv`,
+and `getRemoteConfig`, are awaitable.
+
+### Host runtime
+
+PostHog browser SDK implementations share extension registration and teardown
+through `ExtensionRuntime`, imported from the dedicated
+`@posthog/browser-common/extension-runtime` subpath. It reserves names and
+capability tokens during setup, publishes providers only after successful
+readiness, and disposes extensions once in reverse registration order. Concrete
+SDKs still own the `Client` adapter, Core implementation, and SDK lifecycle
+hooks.
+
+`ExtensionRuntime` is host infrastructure, not part of the extension-author
+surface exported from the package root.
 
 ### `Publisher`
 
@@ -127,7 +153,5 @@ v1 → `Client` porting map.
 ## Status
 
 Early and internal. The package currently defines the extension contract, the
-shared `Publisher` helper, and directly imported browser utilities under
-`utils/*` subpaths. Additional shared runtime helpers — key-value stores, the
-registry implementation, and a test `Client` — will land alongside the first
-ported extension.
+core analytics capability, a shared host runtime, shared lifecycle helpers, and
+directly imported browser utilities under `utils/*` subpaths.

package/dist/client.d.ts

@@ -1,135 +1,62 @@
 import type { Logger } from '@posthog/core';
-import type { Disposable } from './disposable';
 import type { KeyValueStore } from './persistence';
-import type { Listener } from './pubsub';
 import type { ExtensionToken } from './token';
-/** The current session, stamped on events to tie them to a session and a browser tab. */
-export interface SessionContext {
-    /** The stable session identifier attached to events captured during this session. */
-    sessionId: string;
-    /** The logical browser tab/window identifier attached alongside the session id. */
-    windowId: string;
-    /** When the session started, as a Unix timestamp in milliseconds. */
-    sessionStartTimestamp: number;
-}
-/** Why a new session started (a `reset` also starts a new session). */
-export type NewSessionReason = 'initial' | 'reset' | 'idleTimeout' | 'maxLength' | 'crossTabAdoption';
-/** Details emitted when the client starts or adopts a new session. */
-export interface NewSessionInfo extends SessionContext {
-    /** The condition that caused this session to begin. */
-    reason: NewSessionReason;
-}
-/** A captured event, as observed by `onEvent`. */
-export interface CapturedEventInfo {
-    /** The event name supplied to {@link Client.capture}. */
-    event: string;
-    /** The final event properties after client defaults and dynamic properties are applied. */
-    properties: Record<string, unknown>;
-}
-/** Per-call capture overrides, mirroring the client's public capture options. */
-export interface CaptureOptions {
-    /** Override the event timestamp sent to PostHog. */
-    timestamp?: Date;
-    /** Override the event UUID used for de-duplication. */
-    uuid?: string;
-    /** Person properties to set, emitted as `$set`. */
-    set?: Record<string, unknown>;
-    /** Person properties to set if unset, emitted as `$set_once`. */
-    setOnce?: Record<string, unknown>;
-}
-/** A minimal response from {@link Client.apiRequest}. */
+/** A minimal response from {@link Client.sendRequest}. */
 export interface ApiResponse {
-    /** Whether the request completed with a 2xx status, or was queued for best-effort unload transport. */
-    ok: boolean;
-    /** The HTTP status code returned by the transport, or a client-defined best-effort status for unload sends. */
-    status: number;
-    /** Parse the response body as JSON; may be unavailable for best-effort unload requests. */
-    json(): Promise<unknown>;
-    /** Read the response body as text; may be unavailable for best-effort unload requests. */
-    text(): Promise<string>;
+    /** The HTTP status code returned by the transport, or a client-defined best-effort status for sendBeacon sends. */
+    statusCode: number;
+    /** The response body parsed as JSON when available. */
+    json?: unknown;
+    /** The response body as text when available. */
+    text?: string;
+    /** The transport error when the request failed before receiving an HTTP response. */
+    error?: unknown;
 }
-/** Options for sending a request through {@link Client.apiRequest}. */
-export interface ApiRequestInit {
-    /** HTTP method to use; defaults to the client's normal request method for the endpoint. */
+/** Configured host used to resolve a relative request path. */
+export type RequestTarget = 'api' | 'flags' | 'assets';
+/** Browser transport requested for a send. */
+export type RequestTransport = 'XHR' | 'fetch' | 'sendBeacon';
+/** Options for sending a request through {@link Client.sendRequest}. */
+export interface SendRequestInit {
+    /** Configured host to send through; defaults to the regular API host. */
+    target?: RequestTarget;
+    /** HTTP method to use; the host transport's default applies when omitted. */
     method?: 'GET' | 'POST';
     /** JSON-serialized by the client. */
     body?: unknown;
     /** Query string parameters appended to the request URL. */
     query?: Record<string, string>;
-    /**
-     * Mark this as a teardown send (pagehide / shutdown): the client picks the
-     * most reliable fire-and-forget transport available — `sendBeacon`, fetch
-     * `keepalive`, or sync XHR. The response is best-effort: `.json()` may be
-     * unusable (e.g. `sendBeacon` only reports "queued"), so callers must not
-     * depend on it.
-     */
-    unload?: boolean;
+    /** Additional headers merged with the host SDK's configured request headers. */
+    headers?: Record<string, string>;
+    /** Browser transport to prefer. `sendBeacon` returns a best-effort response immediately. */
+    transport?: RequestTransport;
     /** Abort the request if it does not complete within this many milliseconds. */
     timeoutMs?: number;
 }
-/**
- * Server-provided configuration, as returned by the remote config response
- * (sampling rates, suppression rules, feature enablement, quotas, …). A loose
- * record by design — each extension reads only the keys it owns.
- */
-export type RemoteConfig = Record<string, unknown>;
 /**
  * The host SDK's capability surface as seen by an extension — the client an
- * extension is handed in `setup`. Each SDK (v1, v2) provides it as a client
- * adapter over its own internals.
+ * extension is handed in `setup`. A conforming host provides it as an adapter
+ * over its own internals.
  *
- * Synchronous members are always-ready in-memory reads (identity, session);
- * asynchronous members do I/O or wait for something to become ready
- * (`capture`, `apiRequest`, `kv`, `getRemoteConfig`).
+ * Host services that may do I/O are awaitable; a host can complete them
+ * synchronously when its underlying implementation supports that. Core
+ * analytics behavior is provided separately by the core extension.
  */
 export interface Client {
-    /** The id events are currently attributed to — the anonymous id, or the identified user's id after `identify`. */
-    readonly distinctId: string;
-    /** The anonymous device id; used before `identify` and carried on identify events as `$anon_distinct_id`. */
-    readonly anonymousId: string;
-    /** Active group memberships (group type → group key), attached to events as `$groups`. */
-    readonly groups: Record<string, string>;
-    /** The current session, created on first read if needed; reading does not extend or rotate it. */
-    readonly session: SessionContext;
-    /** Records an analytics event through the client's normal pipeline. */
-    capture(event: string, properties?: Record<string, unknown> | null, options?: CaptureOptions): Promise<void>;
-    /**
-     * Registers a producer of properties merged into every captured event.
-     * Returns a {@link Disposable} that removes it; an extension disposes it in
-     * its own `dispose`. May be called more than once. The producer runs inline
-     * during event build, so it must be cheap and synchronous; it may return
-     * different properties each time (e.g. the current URL), and is recomputed
-     * per event rather than stored.
-     */
-    registerDynamicEventProperties(producer: () => Record<string, unknown>): Disposable;
-    /**
-     * Sends a request to a PostHog endpoint; the client owns auth, headers, and
-     * transport (fetch / XHR / keepalive). `path` is relative to the configured
-     * API host, e.g. `/s/`, `/flags/`, `/api/surveys/`.
-     */
-    apiRequest(path: string, init?: ApiRequestInit): Promise<ApiResponse>;
+    /** Public project token used to authenticate endpoint-specific requests. */
+    readonly projectToken: string;
     /**
-     * Resolves with the client's remote config once available, or `undefined`
-     * if the fetch failed (never rejects, never hangs).
-     * Re-readable: each call resolves with the current config, awaiting the
-     * first fetch if none has landed. `await` it in `setup` to block until
-     * config is known, or `.then()` it to reconfigure once it arrives; later
-     * changes arrive via `onRemoteConfig`.
+     * Sends a request through the host SDK's transport. The extension owns the
+     * endpoint-specific path, method, authentication shape, body, and headers.
      */
-    getRemoteConfig(): Promise<RemoteConfig | undefined>;
-    /** Fires when server-provided config arrives or changes. */
-    readonly onRemoteConfig: Listener<RemoteConfig>;
-    /** Fires for every captured event — hot path, keep handlers cheap and synchronous. */
-    readonly onEvent: Listener<CapturedEventInfo>;
-    /** Fires when a new session starts, including on reset (discriminate via `reason`). */
-    readonly onNewSession: Listener<NewSessionInfo>;
+    sendRequest(path: string, init?: SendRequestInit): Promise<ApiResponse>;
     /**
      * Resolves another registered extension by a capability token it provides, or
      * `undefined` if nothing registered provides it (not installed, or not loaded
      * yet). Lets one extension use another without importing its implementation.
      */
     getExtension<T>(token: ExtensionToken<T>): T | undefined;
-    /** Async key-value storage scoped to this client instance and extension. */
+    /** Awaitable key-value storage backed by the host client's persistence. */
     readonly kv: KeyValueStore;
     /** Logger that follows the host client's debug/noise policy. */
     readonly logger: Logger;

package/dist/config.js

@@ -26,7 +26,7 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     default: ()=>__WEBPACK_DEFAULT_EXPORT__
 });
-const packageVersion = "0.2.1";
+const packageVersion = "0.2.3";
 const Config = {
     DEBUG: false,
     LIB_VERSION: packageVersion,

package/dist/config.mjs

@@ -1,4 +1,4 @@
-const packageVersion = "0.2.1";
+const packageVersion = "0.2.3";
 const Config = {
     DEBUG: false,
     LIB_VERSION: packageVersion,

package/dist/core-extension.d.ts

@@ -0,0 +1,80 @@
+import type { JsonRecord, Properties } from '@posthog/types';
+import type { Disposable } from './disposable';
+import type { Extension } from './extension';
+import type { Listener } from './pubsub';
+import type { RemoteConfig } from './types/remote-config';
+import type { ExtensionToken } from './token';
+/** Recursively marks object properties as readonly while preserving callable values. */
+export type DeepReadonly<T> = T extends (...args: never[]) => unknown ? T : T extends object ? {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+} : T;
+/** The current session, stamped on events to tie them to a session and a browser tab. */
+export interface SessionContext {
+    /** The stable session identifier attached to events captured during this session. */
+    readonly sessionId: string;
+    /** The logical browser tab/window identifier attached alongside the session id. */
+    readonly windowId: string;
+    /** When the session started, as a Unix timestamp in milliseconds. */
+    readonly sessionStartTimestamp: number;
+}
+/** Why a new session started (a `reset` also starts a new session). */
+export type NewSessionReason = 'initial' | 'reset' | 'idleTimeout' | 'maxLength' | 'crossTabAdoption';
+/** Details emitted when the client starts or adopts a new session. */
+export interface NewSessionInfo extends SessionContext {
+    /** The condition that caused this session to begin. */
+    readonly reason: NewSessionReason;
+}
+/** A captured event, as observed by `onEvent`. */
+export interface CapturedEventInfo {
+    /** The finalized captured event name. */
+    readonly event: string;
+    /** The final event properties after client defaults and dynamic properties are applied. */
+    readonly properties: DeepReadonly<JsonRecord>;
+}
+/** Per-call capture overrides, mirroring the client's public capture options. */
+export interface CaptureOptions {
+    /** Override the event timestamp sent to PostHog. */
+    timestamp?: Date;
+    /** Override the event UUID used for de-duplication. */
+    uuid?: string;
+    /** Person properties to set, emitted as `$set`. */
+    set?: Record<string, unknown>;
+    /** Person properties to set if unset, emitted as `$set_once`. */
+    setOnce?: Record<string, unknown>;
+}
+/**
+ * The host SDK's core analytics behavior, exposed as an extension so shared
+ * extensions can depend on the event pipeline without depending on a concrete
+ * PostHog client implementation.
+ */
+export interface CoreExtension extends Extension {
+    /** The id events are currently attributed to. */
+    readonly distinctId: string;
+    /** The anonymous device id carried across identify calls. */
+    readonly anonymousId: string;
+    /** Active group memberships attached to events as `$groups`. */
+    readonly groups: DeepReadonly<Record<string, string>>;
+    /** The current session, created on first read if needed. */
+    readonly session: SessionContext;
+    /** Records an analytics event through the client's normal pipeline. */
+    capture(event: string, properties?: Properties | null, options?: CaptureOptions): Promise<void>;
+    /**
+     * Registers a producer of properties merged into every captured event.
+     * The producer runs inline while the event is built and must be synchronous.
+     */
+    registerDynamicEventProperties(producer: () => Record<string, unknown>): Disposable;
+    /** Fires for every captured event through a deeply readonly view. */
+    readonly onEvent: Listener<CapturedEventInfo>;
+    /** Fires when a new session starts, including on reset. */
+    readonly onNewSession: Listener<NewSessionInfo>;
+    /**
+     * Resolves with the current remote config, awaiting the first outcome when
+     * necessary. A failed outcome resolves to `undefined`; later successful
+     * changes are published through `onRemoteConfig`.
+     */
+    getRemoteConfig(): Promise<DeepReadonly<RemoteConfig> | undefined>;
+    /** Fires through a deeply readonly view when server-provided config arrives or changes successfully. */
+    readonly onRemoteConfig: Listener<DeepReadonly<RemoteConfig>>;
+}
+/** Capability token used to resolve the host SDK's core analytics extension. */
+export declare const CoreExtension: ExtensionToken<CoreExtension>;

package/dist/core-extension.js

@@ -0,0 +1,36 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    CoreExtension: ()=>CoreExtension
+});
+const CoreExtension = 'posthog.core';
+exports.CoreExtension = __webpack_exports__.CoreExtension;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "CoreExtension"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/core-extension.mjs

@@ -0,0 +1,2 @@
+const CoreExtension = 'posthog.core';
+export { CoreExtension };

package/dist/disposable.d.ts

@@ -11,3 +11,5 @@ export interface Disposable {
      */
     dispose(): void | Promise<void>;
 }
+/** Invokes teardown at most once and returns its first result to every caller. */
+export declare function createDisposable(dispose: () => void | Promise<void>): Disposable;

package/dist/disposable.js

@@ -1,5 +1,16 @@
 "use strict";
 var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
 (()=>{
     __webpack_require__.r = (exports1)=>{
         if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
@@ -12,7 +23,26 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
-for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+__webpack_require__.d(__webpack_exports__, {
+    createDisposable: ()=>createDisposable
+});
+function createDisposable(dispose) {
+    let active = true;
+    let result;
+    return {
+        dispose: ()=>{
+            if (active) {
+                active = false;
+                result = dispose();
+            }
+            return result;
+        }
+    };
+}
+exports.createDisposable = __webpack_exports__.createDisposable;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createDisposable"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {
     value: true
 });

package/dist/disposable.mjs

@@ -0,0 +1,14 @@
+function createDisposable(dispose) {
+    let active = true;
+    let result;
+    return {
+        dispose: ()=>{
+            if (active) {
+                active = false;
+                result = dispose();
+            }
+            return result;
+        }
+    };
+}
+export { createDisposable };

package/dist/extension-runtime.d.ts

@@ -0,0 +1,34 @@
+import { type Logger } from '@posthog/core';
+import type { Client } from './client';
+import type { Disposable } from './disposable';
+import type { Extension } from './extension';
+import type { ExtensionToken } from './token';
+/**
+ * Shared lifecycle and capability registry for browser extension hosts.
+ *
+ * Hosts provide the concrete Client adapter while this runtime coordinates
+ * names, capability readiness, setup failures, and reverse-order teardown.
+ */
+export declare class ExtensionRuntime implements Disposable {
+    private readonly _logger;
+    private readonly _extensions;
+    private readonly _registrationOrder;
+    private readonly _providerReservations;
+    private readonly _providers;
+    private _disposePromise;
+    constructor(_logger: Logger);
+    /**
+     * Sets up an extension and publishes its capabilities once setup succeeds.
+     * Names and tokens remain reserved while asynchronous setup is pending.
+     */
+    add(extension: Extension, client: Client): Promise<void>;
+    /** Resolves a capability only after its provider has completed setup. */
+    getExtension<T>(token: ExtensionToken<T>): T | undefined;
+    /** Disposes every registered extension once, in reverse registration order. */
+    dispose(): Promise<void>;
+    private _disposeAll;
+    private _handleSetupFailure;
+    private _disposeRegistration;
+    private _removeRegistration;
+    private _publishRegistration;
+}

package/dist/extension-runtime.js

@@ -0,0 +1,109 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ExtensionRuntime: ()=>ExtensionRuntime
+});
+const core_namespaceObject = require("@posthog/core");
+class ExtensionRuntime {
+    constructor(_logger){
+        this._logger = _logger;
+        this._extensions = new Map();
+        this._registrationOrder = [];
+        this._providerReservations = new Map();
+        this._providers = new Map();
+    }
+    async add(extension, client) {
+        if (this._disposePromise) throw new Error('Cannot add an extension to a disposed ExtensionRuntime');
+        if (this._extensions.has(extension.name)) throw new Error(`Browser extension "${extension.name}" is already registered`);
+        for (const token of extension.provides ?? [])if (this._providerReservations.has(token)) throw new Error(`Browser extension token "${token}" is already registered`);
+        const registered = {
+            extension,
+            setupPromise: Promise.resolve()
+        };
+        this._extensions.set(extension.name, registered);
+        this._registrationOrder.push(registered);
+        for (const token of extension.provides ?? [])this._providerReservations.set(token, registered);
+        let setupResult;
+        try {
+            setupResult = extension.setup(client);
+        } catch (error) {
+            registered.setupPromise = this._handleSetupFailure(registered, error);
+            return registered.setupPromise;
+        }
+        if (setupResult && (0, core_namespaceObject.isFunction)(setupResult.then)) registered.setupPromise = setupResult.then(()=>this._publishRegistration(registered)).catch((error)=>this._handleSetupFailure(registered, error));
+        else this._publishRegistration(registered);
+        return registered.setupPromise;
+    }
+    getExtension(token) {
+        return this._providers.get(token);
+    }
+    dispose() {
+        if (!this._disposePromise) this._disposePromise = this._disposeAll();
+        return this._disposePromise;
+    }
+    async _disposeAll() {
+        for (const registered of this._registrationOrder.slice().reverse()){
+            await registered.setupPromise;
+            await this._disposeRegistration(registered);
+        }
+        this._extensions.clear();
+        this._registrationOrder.length = 0;
+        this._providerReservations.clear();
+        this._providers.clear();
+    }
+    async _handleSetupFailure(registered, error) {
+        this._removeRegistration(registered);
+        this._logger.error(`Failed to set up browser extension "${registered.extension.name}"`, error);
+        if (this._disposePromise) return;
+        await this._disposeRegistration(registered);
+        const index = this._registrationOrder.indexOf(registered);
+        if (-1 !== index) this._registrationOrder.splice(index, 1);
+    }
+    _disposeRegistration(registered) {
+        if (!registered.disposalPromise) registered.disposalPromise = Promise.resolve().then(()=>registered.extension.dispose()).catch((error)=>{
+            this._logger.error(`Failed to dispose browser extension "${registered.extension.name}"`, error);
+        });
+        return registered.disposalPromise;
+    }
+    _removeRegistration(registered) {
+        if (this._extensions.get(registered.extension.name) === registered) this._extensions.delete(registered.extension.name);
+        for (const token of registered.extension.provides ?? []){
+            if (this._providerReservations.get(token) === registered) this._providerReservations.delete(token);
+            if (this._providers.get(token) === registered.extension) this._providers.delete(token);
+        }
+    }
+    _publishRegistration(registered) {
+        if (this._disposePromise || this._extensions.get(registered.extension.name) !== registered) return;
+        for (const token of registered.extension.provides ?? [])this._providers.set(token, registered.extension);
+    }
+}
+exports.ExtensionRuntime = __webpack_exports__.ExtensionRuntime;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "ExtensionRuntime"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});