@clue-ai/browser-sdk 0.0.1

package/dist/core/types.d.ts

@@ -0,0 +1,413 @@
+import type { InternalMetricsSnapshot } from "../internal/metrics";
+import type { FrontendEventCategory, FrontendEventName, FrontendEventStatus, ParameterCaptureMode, SdkCollectionMode } from "./contracts";
+export type { FrontendEventCategory, FrontendEventName, FrontendEventStatus, ParameterCaptureMode, SdkCollectionMode, } from "./contracts";
+export type ClueConsentState = "granted" | "denied" | "unknown";
+export type ClueEnvironment = string;
+export type TransportProfile = "standard" | "authoring_realtime";
+export type CanonicalJsonValue = string | number | boolean | null | CanonicalJsonValue[] | {
+    [key: string]: CanonicalJsonValue;
+};
+export type RequestLifecycleOutcome = "completed" | "failed" | "aborted" | "unknown";
+export type DiagnosticCollectionConfig = {
+    enabledCollectors?: string[];
+    scope?: Record<string, string | number | boolean | null>;
+    ttlMs?: number;
+    expiresAt?: string;
+    budgetWindowMs?: number;
+    maxEventsPerWindow?: number;
+    sampleRate?: number;
+    reason?: string;
+    enabledBy?: string;
+};
+export type ClueInitOptions = {
+    endpoint: string;
+    projectKey: string;
+    environment: ClueEnvironment;
+    localSetupCheck?: {
+        endpoint?: string;
+    };
+    serviceKey?: string;
+    producerId?: string;
+    browserTokenProvider?: () => string | Promise<string>;
+    transportProfile?: TransportProfile;
+    autocapture?: boolean;
+    captureNetwork?: boolean;
+    captureErrors?: boolean;
+    captureFrustration?: boolean;
+    capturePerformance?: boolean;
+    network?: {
+        tracePropagationOrigins?: string[];
+        important4xxPathPrefixes?: string[];
+        interactionPropagationWindowMs?: number;
+    };
+    batch?: {
+        enabled?: boolean;
+        maxSize?: number;
+        flushIntervalMs?: number;
+        maxEventBytes?: number;
+        maxPayloadBytes?: number;
+    };
+    privacy?: {
+        deniedKeys?: string[];
+        allowedValuePaths?: string[];
+    };
+    sampling?: {
+        sessionSampleRate?: number;
+    };
+    collection?: {
+        mode?: SdkCollectionMode;
+        diagnostic?: DiagnosticCollectionConfig;
+    };
+    release?: {
+        frontendRelease?: string;
+    };
+    featureFlagsProvider?: () => string[];
+    experimentVariantProvider?: () => string | null;
+};
+export type ResolvedClueConfig = {
+    endpoint: string;
+    originalEndpoint: string;
+    localSetupCheckEndpoint: string | null;
+    projectKey: string;
+    environment: ClueEnvironment;
+    serviceKey: string;
+    producerId: string;
+    browserTokenProvider: (() => string | Promise<string>) | null;
+    transportProfile: TransportProfile;
+    autocapture: boolean;
+    captureNetwork: boolean;
+    captureErrors: boolean;
+    captureFrustration: boolean;
+    capturePerformance: boolean;
+    network: {
+        tracePropagationOrigins: string[];
+        important4xxPathPrefixes: string[];
+        interactionPropagationWindowMs: number;
+    };
+    batch: {
+        enabled: boolean;
+        maxSize: number;
+        flushIntervalMs: number;
+        maxEventBytes: number;
+        maxPayloadBytes: number;
+    };
+    privacy: {
+        deniedKeys: string[];
+        allowedValuePaths: string[];
+    };
+    sampling: {
+        sessionSampleRate: number;
+    };
+    collection: {
+        mode: SdkCollectionMode;
+        diagnostic: {
+            enabledCollectors: string[];
+            scope: Record<string, string | number | boolean | null>;
+            ttlMs: number;
+            expiresAt: string | null;
+            budgetWindowMs: number;
+            maxEventsPerWindow: number;
+            sampleRate: number;
+            reason: string | null;
+            enabledBy: string | null;
+        };
+    };
+    release: {
+        frontendRelease: string | null;
+    };
+    featureFlagsProvider?: () => string[];
+    experimentVariantProvider?: () => string | null;
+};
+export type ClueBrowserSdk = {
+    init(options: ClueInitOptions): void;
+    identify(userId: string, traits?: ClueSubjectTraits): void;
+    setAccount(accountId: string, traits?: ClueSubjectTraits): void;
+    logout(): void;
+    reset(): void;
+    track(eventName: string, properties?: Record<string, unknown>, metrics?: Record<string, number>): void;
+    setConsent(consent: ClueConsentState): void;
+    getInternalMetrics(): InternalMetricsSnapshot;
+};
+export type CostCapability = "event_collection" | "ai_generation" | "raw_archive" | "retention_growth";
+export type LimitKind = "monthly_overage_amount_limit" | "internal_cost_limit" | "internal_limit" | "operator_global_monthly_cost_limit";
+export type ThresholdStage = "info" | "warning" | "urgent" | "reached";
+export type LimitReason = {
+    limitKind: LimitKind;
+    meterKey: string;
+    thresholdStage: ThresholdStage;
+    currentValue: number;
+    limitValue: number;
+    retryAfterAt: string | null;
+};
+export type IngestUsageGovernorFeedback = {
+    disabledCapabilities: CostCapability[];
+    limitReasons: LimitReason[];
+    retryAfterAt: string | null;
+};
+export type ParameterSnapshotLeafType = "string" | "number" | "boolean" | "null" | "object" | "array";
+export type ParameterSnapshotLeaf = {
+    type: ParameterSnapshotLeafType;
+    value: unknown;
+    capture_mode: ParameterCaptureMode;
+    truncated_reason?: "max_event_bytes";
+    original_size_bytes?: number;
+};
+export type ParameterSnapshotValue = ParameterSnapshotLeaf | ParameterSnapshotValue[] | {
+    [key: string]: ParameterSnapshotValue;
+};
+export type CanonicalBaseEvent = {
+    event_id: string;
+    source_event_id?: string;
+    source_schema_version?: string;
+    source_event_type?: string;
+    source_event_kind?: string;
+    producer_id: string | null;
+    event_name: FrontendEventName;
+    custom_event_name?: string | null;
+    event_category: FrontendEventCategory;
+    event_source: "browser_sdk";
+    event_version: number;
+    occurred_at: string;
+    ingested_at: string;
+    status: FrontendEventStatus;
+    sdk_collection_mode: SdkCollectionMode;
+    /**
+     * Server-populated only. SDK runtime does not authoritatively stamp tenant identity.
+     */
+    tenant_id?: string | null;
+    anonymous_id: string | null;
+    user_id: string | null;
+    account_id: string | null;
+    organization_id?: string | null;
+    user_profile?: ClueSubjectProfile;
+    account_profile?: ClueSubjectProfile;
+    workspace_id: string | null;
+    session_id: string | null;
+    tab_id: string;
+    trace_id: string | null;
+    request_id: string | null;
+    request_span_id: string | null;
+    interaction_id: string | null;
+    correlation_id: string | null;
+    surface_type: "web";
+    environment: ClueEnvironment;
+    frontend_release: string | null;
+    backend_release: string | null;
+    feature_flags: string[];
+    experiment_variant: string | null;
+    device_type: string | null;
+    browser: string | null;
+    os: string | null;
+    locale: string | null;
+    country: string | null;
+    referrer: string | null;
+    browser_family?: string | null;
+    browser_major_version?: string | null;
+    browser_engine?: string | null;
+    os_family?: string | null;
+    os_major_version?: string | null;
+    timezone?: string | null;
+    pointer_type_candidate?: string | null;
+    touch_capable?: boolean | null;
+    cookies_enabled?: boolean | null;
+    local_storage_available?: boolean | null;
+    session_storage_available?: boolean | null;
+    service_worker_supported?: boolean | null;
+    webgl_supported?: boolean | null;
+    reduced_motion?: string | null;
+    color_scheme?: string | null;
+    account_status?: string | null;
+    plan_tier?: string | null;
+    billing_status?: string | null;
+    customer_lifecycle_stage?: string | null;
+    organization_size_bucket?: string | null;
+    user_role?: string | null;
+    permission_group?: string | null;
+    onboarding_state?: string | null;
+    trial_days_remaining_bucket?: string | null;
+    customer_health_bucket?: string | null;
+    collector_name?: string | null;
+    aggregation_kind?: string | null;
+    summary_window_ms?: number | null;
+    summary_count?: number | null;
+    dropped_count?: number | null;
+    sample_rate?: number | null;
+    budget_window_ms?: number | null;
+    rate_limit_key?: string | null;
+    performance_kind?: string | null;
+    rating?: string | null;
+    metric_name?: string | null;
+    metric_value_bucket?: string | null;
+    long_task_count?: number | null;
+    resource_failure_count?: number | null;
+    slow_resource_count?: number | null;
+    worst_duration_bucket?: string | null;
+    outcome_class?: string | null;
+    decision_type?: string | null;
+    decision_result?: string | null;
+    reason_code?: string | null;
+    attempt_status?: RequestLifecycleOutcome | null;
+    submit_result?: string | null;
+    result_source?: string | null;
+    request_schema_hash?: string | null;
+    response_schema_hash?: string | null;
+    request_shape_size?: number | null;
+    response_shape_size?: number | null;
+    masked_value_count?: number | null;
+    forbidden_value_count?: number | null;
+    truncated_value_count?: number | null;
+    allowed_value_keys?: string[];
+    view_id?: string | null;
+    screen_key?: string | null;
+    path?: string | null;
+    url_canonical?: string | null;
+    referrer_url_canonical?: string | null;
+    page_title_candidate?: string | null;
+    route_name_candidate?: string | null;
+    primary_heading_candidate?: string | null;
+    stable_key?: string | null;
+    stable_key_quality?: string | null;
+    form_key?: string | null;
+    from_view_id?: string | null;
+    to_view_id?: string | null;
+    from_screen_key?: string | null;
+    to_screen_key?: string | null;
+    from_path?: string | null;
+    to_path?: string | null;
+    method?: string | null;
+    path_template?: string | null;
+    status_code?: number | null;
+    duration_ms?: number | null;
+    target_service?: string | null;
+    time_on_page_ms?: number | null;
+    properties: Record<string, unknown>;
+    metrics: Record<string, number>;
+    request_parameters_snapshot_json?: ParameterSnapshotValue;
+    response_parameters_snapshot_json?: ParameterSnapshotValue;
+    request_metadata?: Record<string, unknown>;
+    response_metadata?: Record<string, unknown>;
+    target_object_hint?: CanonicalJsonValue;
+};
+export type ClueContext = {
+    producer_id: string | null;
+    anonymous_id: string | null;
+    user_id: string | null;
+    account_id: string | null;
+    organization_id?: string | null;
+    user_profile: ClueSubjectProfile | null;
+    account_profile: ClueSubjectProfile | null;
+    workspace_id: string | null;
+    session_id: string | null;
+    tab_id: string;
+    trace_id: string | null;
+    request_id: string | null;
+    request_span_id: string | null;
+    interaction_id: string | null;
+    correlation_id: string | null;
+    environment: ClueEnvironment;
+    sdk_collection_mode: SdkCollectionMode;
+    frontend_release: string | null;
+    feature_flags: string[];
+    experiment_variant: string | null;
+    plan: string | null;
+    role: string | null;
+    locale: string | null;
+    country: string | null;
+    device_type: string | null;
+    browser: string | null;
+    os: string | null;
+    referrer: string | null;
+    browser_family?: string | null;
+    browser_major_version?: string | null;
+    browser_engine?: string | null;
+    os_family?: string | null;
+    os_major_version?: string | null;
+    timezone?: string | null;
+    pointer_type_candidate?: string | null;
+    touch_capable?: boolean | null;
+    cookies_enabled?: boolean | null;
+    local_storage_available?: boolean | null;
+    session_storage_available?: boolean | null;
+    service_worker_supported?: boolean | null;
+    webgl_supported?: boolean | null;
+    reduced_motion?: string | null;
+    color_scheme?: string | null;
+    account_status?: string | null;
+    plan_tier?: string | null;
+    billing_status?: string | null;
+    customer_lifecycle_stage?: string | null;
+    organization_size_bucket?: string | null;
+    user_role?: string | null;
+    permission_group?: string | null;
+    onboarding_state?: string | null;
+    trial_days_remaining_bucket?: string | null;
+    customer_health_bucket?: string | null;
+};
+export type SessionContext = {
+    sessionId: string | null;
+    startedAtMs: number | null;
+    lastActivityAtMs: number | null;
+};
+export type IdentityContext = {
+    anonymousId: string | null;
+    userId: string | null;
+    traits: ClueSubjectTraits;
+};
+export type AccountContext = {
+    accountId: string | null;
+    organizationId: string | null;
+    workspaceId: string | null;
+    traits: ClueSubjectTraits;
+};
+export type ClueSubjectProfile = {
+    display_name: string | null;
+    avatar_url: string | null;
+    email: string | null;
+    role: string | null;
+    plan: string | null;
+};
+export type ClueSubjectTraits = Record<string, unknown> & {
+    plan?: string | null;
+    role?: string | null;
+    email?: string | null;
+    email_address?: string | null;
+    emailAddress?: string | null;
+    display_name?: string | null;
+    displayName?: string | null;
+    avatar_url?: string | null;
+    avatarUrl?: string | null;
+    workspace_id?: string | null;
+    workspaceId?: string | null;
+    organization_id?: string | null;
+    organizationId?: string | null;
+};
+export type ClueInternalLogger = {
+    debug: (message: string, details?: Record<string, unknown>) => void;
+    warn: (message: string, details?: Record<string, unknown>) => void;
+    error: (message: string, details?: Record<string, unknown>) => void;
+};
+export type RawEventName = FrontendEventName;
+export type RawCapturedEvent = {
+    type: RawEventName;
+    occurredAtMs?: number;
+    payload: Record<string, unknown>;
+};
+export type CaptureEventHandler = (event: RawCapturedEvent) => void;
+export type CaptureModuleContext = {
+    onEvent: CaptureEventHandler;
+    onInternalError: (source: string, error: unknown) => void;
+    getViewId: () => string | null;
+    getConsent: () => ClueConsentState;
+    getObservationContext?: () => {
+        anonymousId: string | null;
+        userId: string | null;
+        accountId: string | null;
+        organizationId?: string | null;
+        sessionId: string | null;
+        tabId: string | null;
+    };
+    shouldIgnoreElement?: (element: Element) => boolean;
+};
+export type CaptureStopHandle = {
+    stop: () => void;
+};

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/usage-governor.d.ts

@@ -0,0 +1,7 @@
+import type { CostCapability, IngestUsageGovernorFeedback } from "./types";
+export declare const DEFAULT_INGEST_USAGE_GOVERNOR_FEEDBACK: IngestUsageGovernorFeedback;
+export declare const normalizeIngestUsageGovernorFeedback: (feedback?: Partial<IngestUsageGovernorFeedback> | null) => IngestUsageGovernorFeedback;
+export declare const mergeIngestUsageGovernorFeedback: (current: IngestUsageGovernorFeedback | null, incoming: IngestUsageGovernorFeedback | null) => IngestUsageGovernorFeedback | null;
+export declare const parseGovernorFeedbackEnvelope: (value: unknown) => IngestUsageGovernorFeedback | null;
+export declare const isCostCapabilityDisabled: (feedback: Pick<IngestUsageGovernorFeedback, "disabledCapabilities">, capability: CostCapability) => boolean;
+export declare const hasUsageGovernorFeedbackChanged: (current: IngestUsageGovernorFeedback, next: IngestUsageGovernorFeedback) => boolean;

package/dist/core/usage-governor.js

@@ -0,0 +1,127 @@
+export const DEFAULT_INGEST_USAGE_GOVERNOR_FEEDBACK = {
+    disabledCapabilities: [],
+    limitReasons: [],
+    retryAfterAt: null,
+};
+const COST_CAPABILITIES = new Set([
+    "event_collection",
+    "ai_generation",
+    "raw_archive",
+    "retention_growth",
+]);
+const LIMIT_KINDS = new Set([
+    "monthly_overage_amount_limit",
+    "internal_cost_limit",
+    "internal_limit",
+    "operator_global_monthly_cost_limit",
+]);
+const THRESHOLD_STAGES = new Set([
+    "info",
+    "warning",
+    "urgent",
+    "reached",
+]);
+const asRecord = (value) => {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return null;
+};
+const asCostCapability = (value) => {
+    return typeof value === "string" && COST_CAPABILITIES.has(value)
+        ? value
+        : null;
+};
+const asLimitKind = (value) => {
+    return typeof value === "string" && LIMIT_KINDS.has(value)
+        ? value
+        : null;
+};
+const asThresholdStage = (value) => {
+    return typeof value === "string" &&
+        THRESHOLD_STAGES.has(value)
+        ? value
+        : null;
+};
+const asNonNegativeNumber = (value) => {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0
+        ? value
+        : null;
+};
+const asNullableString = (value) => {
+    return typeof value === "string" ? value : null;
+};
+const parseLimitReason = (value) => {
+    const record = asRecord(value);
+    if (!record) {
+        return null;
+    }
+    const limitKind = asLimitKind(record.limitKind);
+    const thresholdStage = asThresholdStage(record.thresholdStage);
+    const currentValue = asNonNegativeNumber(record.currentValue);
+    const limitValue = asNonNegativeNumber(record.limitValue);
+    const retryAfterAt = record.retryAfterAt === null ? null : asNullableString(record.retryAfterAt);
+    if (!limitKind ||
+        typeof record.meterKey !== "string" ||
+        !thresholdStage ||
+        currentValue === null ||
+        limitValue === null ||
+        retryAfterAt === undefined) {
+        return null;
+    }
+    return {
+        limitKind,
+        meterKey: record.meterKey,
+        thresholdStage,
+        currentValue,
+        limitValue,
+        retryAfterAt,
+    };
+};
+const uniqueCapabilities = (capabilities) => [...new Set(capabilities)];
+export const normalizeIngestUsageGovernorFeedback = (feedback) => {
+    const disabledCapabilities = Array.isArray(feedback?.disabledCapabilities)
+        ? feedback.disabledCapabilities
+            .map(asCostCapability)
+            .filter((capability) => capability !== null)
+        : [];
+    const limitReasons = Array.isArray(feedback?.limitReasons)
+        ? feedback.limitReasons
+            .map(parseLimitReason)
+            .filter((reason) => reason !== null)
+        : [];
+    return {
+        disabledCapabilities: uniqueCapabilities(disabledCapabilities),
+        limitReasons,
+        retryAfterAt: typeof feedback?.retryAfterAt === "string" ? feedback.retryAfterAt : null,
+    };
+};
+export const mergeIngestUsageGovernorFeedback = (current, incoming) => {
+    if (!current) {
+        return incoming;
+    }
+    if (!incoming) {
+        return current;
+    }
+    return {
+        disabledCapabilities: uniqueCapabilities([
+            ...current.disabledCapabilities,
+            ...incoming.disabledCapabilities,
+        ]),
+        limitReasons: [...current.limitReasons, ...incoming.limitReasons],
+        retryAfterAt: current.retryAfterAt ?? incoming.retryAfterAt,
+    };
+};
+export const parseGovernorFeedbackEnvelope = (value) => {
+    const payload = asRecord(value);
+    const governor = asRecord(payload?.governor);
+    if (!governor) {
+        return null;
+    }
+    return normalizeIngestUsageGovernorFeedback(governor);
+};
+export const isCostCapabilityDisabled = (feedback, capability) => feedback.disabledCapabilities.includes(capability);
+export const hasUsageGovernorFeedbackChanged = (current, next) => current.retryAfterAt !== next.retryAfterAt ||
+    current.disabledCapabilities.join("|") !==
+        next.disabledCapabilities.join("|") ||
+    JSON.stringify(current.limitReasons) !== JSON.stringify(next.limitReasons);

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+import { createClueBrowserSdk } from "./core/sdk";
+import type { ClueBrowserSdk, ClueConsentState, ClueInitOptions, ClueSubjectTraits } from "./core/types";
+import type { InternalMetricsSnapshot } from "./internal/metrics";
+export declare const ClueInit: (options: ClueInitOptions) => void;
+export declare const ClueIdentify: (userId: string, traits?: ClueSubjectTraits) => void;
+export declare const ClueSetAccount: (accountId: string, traits?: ClueSubjectTraits) => void;
+export declare const reset: () => void;
+export declare const ClueLogout: () => void;
+export declare const ClueTrack: (eventName: string, properties?: Record<string, unknown>, metrics?: Record<string, number>) => void;
+export declare const setConsent: (consent: ClueConsentState) => void;
+export declare const getInternalMetrics: () => InternalMetricsSnapshot;
+export { attachNextRouterIntegration } from "./integrations/next-router";
+export { attachReactRouterIntegration } from "./integrations/react-router";
+export type { ClueBrowserSdk, ClueConsentState, ClueInitOptions, ClueSubjectTraits, InternalMetricsSnapshot, };
+export { createClueBrowserSdk };
+declare const _default: ClueBrowserSdk;
+export default _default;

package/dist/index.js

@@ -0,0 +1,36 @@
+import { createClueBrowserSdk } from "./core/sdk";
+const GLOBAL_SDK_KEY = "__clue_browser_sdk_singleton__";
+const globalWithClueSdk = globalThis;
+const existingSdk = globalWithClueSdk[GLOBAL_SDK_KEY];
+const sdk = existingSdk ?? createClueBrowserSdk();
+if (!existingSdk) {
+    globalWithClueSdk[GLOBAL_SDK_KEY] = sdk;
+}
+export const ClueInit = (options) => {
+    sdk.init(options);
+};
+export const ClueIdentify = (userId, traits) => {
+    sdk.identify(userId, traits);
+};
+export const ClueSetAccount = (accountId, traits) => {
+    sdk.setAccount(accountId, traits);
+};
+export const reset = () => {
+    sdk.reset();
+};
+export const ClueLogout = () => {
+    sdk.logout();
+};
+export const ClueTrack = (eventName, properties, metrics) => {
+    sdk.track(eventName, properties, metrics);
+};
+export const setConsent = (consent) => {
+    sdk.setConsent(consent);
+};
+export const getInternalMetrics = () => {
+    return sdk.getInternalMetrics();
+};
+export { attachNextRouterIntegration } from "./integrations/next-router";
+export { attachReactRouterIntegration } from "./integrations/react-router";
+export { createClueBrowserSdk };
+export default sdk;

package/dist/integrations/next-router.d.ts

@@ -0,0 +1,16 @@
+export type NextRouterEventsLike = {
+    on: (event: string, handler: (...args: unknown[]) => void) => void;
+    off: (event: string, handler: (...args: unknown[]) => void) => void;
+};
+export type NextRouterLike = {
+    asPath?: string;
+    events: NextRouterEventsLike;
+};
+export type NextRouterIntegrationOptions = {
+    router: NextRouterLike;
+    onRouteChange: (fromPath: string, toPath: string) => void;
+};
+export type NextRouterIntegrationHandle = {
+    detach: () => void;
+};
+export declare const attachNextRouterIntegration: (options: NextRouterIntegrationOptions) => NextRouterIntegrationHandle;

package/dist/integrations/next-router.js

@@ -0,0 +1,18 @@
+export const attachNextRouterIntegration = (options) => {
+    const { router, onRouteChange } = options;
+    let lastPath = router.asPath ?? "";
+    const handler = (nextUrl) => {
+        const nextPath = typeof nextUrl === "string" ? nextUrl : (router.asPath ?? "");
+        if (!nextPath || nextPath === lastPath) {
+            return;
+        }
+        onRouteChange(lastPath, nextPath);
+        lastPath = nextPath;
+    };
+    router.events.on("routeChangeComplete", handler);
+    return {
+        detach: () => {
+            router.events.off("routeChangeComplete", handler);
+        },
+    };
+};

package/dist/integrations/react-router.d.ts

@@ -0,0 +1,7 @@
+export type ReactRouterIntegrationOptions = {
+    onRouteChange: (fromPath: string, toPath: string) => void;
+};
+export type ReactRouterIntegrationHandle = {
+    detach: () => void;
+};
+export declare const attachReactRouterIntegration: (options: ReactRouterIntegrationOptions) => ReactRouterIntegrationHandle;

package/dist/integrations/react-router.js

@@ -0,0 +1,37 @@
+export const attachReactRouterIntegration = (options) => {
+    if (typeof window === "undefined") {
+        return {
+            detach: () => undefined,
+        };
+    }
+    let lastPath = window.location.pathname;
+    const emit = () => {
+        const nextPath = window.location.pathname;
+        if (nextPath === lastPath) {
+            return;
+        }
+        options.onRouteChange(lastPath, nextPath);
+        lastPath = nextPath;
+    };
+    const originalPushState = history.pushState;
+    const originalReplaceState = history.replaceState;
+    history.pushState = function (...args) {
+        originalPushState.apply(this, args);
+        emit();
+    };
+    history.replaceState = function (...args) {
+        originalReplaceState.apply(this, args);
+        emit();
+    };
+    const popstateHandler = () => {
+        emit();
+    };
+    window.addEventListener("popstate", popstateHandler, true);
+    return {
+        detach: () => {
+            history.pushState = originalPushState;
+            history.replaceState = originalReplaceState;
+            window.removeEventListener("popstate", popstateHandler, true);
+        },
+    };
+};