@mushi-mushi/core 1.15.0 → 1.16.0

package/dist/index.d.ts

@@ -19,6 +19,8 @@ interface MushiConfig {
     integrations?: MushiIntegrationsConfig;
     offline?: MushiOfflineConfig;
     rewards?: MushiRewardsConfig;
+    /** Page-aware, user-data-aware in-SDK assistant (P5). */
+    assistant?: MushiAssistantConfig;
     debug?: boolean;
     enabled?: boolean;
     /** Hook called before a report is sent. Return null to cancel, or return the (possibly modified) report. */
@@ -1024,6 +1026,56 @@ interface MushiDiagnosticsResult {
      */
     bannerRendered: boolean;
 }
+/**
+ * Page-aware assistant (P5). The host app publishes a structured snapshot of
+ * what the current screen is showing; the SDK forwards only this narrow,
+ * server-validated subset so a malicious page cannot inject arbitrary prompt
+ * fields. Ported from the admin console's page-context registry.
+ */
+interface MushiPageContext {
+    /** Current route/path (e.g. '/activity'). */
+    route: string;
+    /** Human title of the screen. */
+    title?: string;
+    /** One-line description of what is on screen. */
+    summary?: string;
+    /** Active filters as a flat key/value map. */
+    filters?: Record<string, string | number | boolean | null | undefined>;
+    /** The focused/selected entity, if any. */
+    selection?: {
+        kind: string;
+        id: string;
+        label?: string;
+    } | null;
+}
+interface MushiAssistantConfig {
+    /**
+     * Enable the in-SDK assistant tab. Defaults to false; the console can also
+     * enable it via runtime config so it can be turned on without a rebuild.
+     */
+    enabled?: boolean;
+    /** Tab label (default: "Ask"). */
+    label?: string;
+    /** Greeting shown on an empty assistant thread. */
+    greeting?: string;
+    /** Suggested starter questions shown on an empty thread. */
+    suggestions?: string[];
+}
+interface MushiAssistantStep {
+    label: string;
+    detail?: string;
+}
+interface MushiAssistantReply {
+    /** 'answer' resolves the turn; 'clarify' asks the user a follow-up. */
+    kind: 'answer' | 'clarify';
+    text?: string;
+    steps?: MushiAssistantStep[];
+    /** For 'clarify' replies. */
+    question?: string;
+    options?: string[];
+    /** Server-assigned thread id so the next turn continues the conversation. */
+    threadId?: string;
+}
 interface MushiSDKInstance {
     /**
      * Open the reporter widget. With no options, opens to the category
@@ -1100,6 +1152,26 @@ interface MushiSDKInstance {
         name?: string;
         [k: string]: unknown;
     }): void;
+    /**
+     * Identify the current end user with a signed Mushi identity JWT minted by
+     * the host app's server (see `@mushi-mushi/node`'s `mintMushiIdentityToken`).
+     * This is the trust anchor for secure "My Reports", rewards-to-membership
+     * grants, and the per-user assistant data index — the backend re-verifies
+     * the signature against the project's identity secret. Unlike `identify()`,
+     * which is spoofable, claims from this token are trusted server-side.
+     *
+     * Pass `null` (or call on logout) to clear the identity and fall back to the
+     * anonymous reporter token.
+     */
+    identifyWithToken(token: string | null): void;
+    /**
+     * Publish the current screen's context so the in-SDK assistant can answer
+     * page-aware questions. Call on every route/selection change. Pass `null`
+     * to clear (e.g. on unmount). Only a narrow subset is sent to the server.
+     */
+    publishPageContext(context: MushiPageContext | null): void;
+    /** Open the widget on the assistant ("Ask") tab. */
+    openAssistant(): void;
     /**
      * Sentry-grade observability surface (2026-05-07).
      *
@@ -1227,6 +1299,16 @@ interface MushiApiClient {
         status: MushiReportStatus;
     }>>;
     getSdkConfig(): Promise<MushiApiResponse<MushiRuntimeSdkConfig>>;
+    /**
+     * Send one assistant turn. Forwards the page context + thread id; the
+     * end-user identity token (when set) travels on the X-Mushi-User-Token
+     * header so the backend can scope retrieval to the verified user.
+     */
+    askAssistant(input: {
+        message: string;
+        threadId?: string | null;
+        context?: MushiPageContext | null;
+    }): Promise<MushiApiResponse<MushiAssistantReply>>;
     getLatestSdkVersion(packageName: string): Promise<MushiApiResponse<MushiSdkVersionInfo>>;
     /**
      * Mushi v2.1: ship a single passive-discovery observation (route +
@@ -1347,11 +1429,9 @@ interface MushiApiClient {
     /** Whether the caller has a mushi_testers row. */
     getTesterStatus(jwt: string): Promise<MushiApiResponse<{
         is_tester: boolean;
-        tester: {
-            id: string;
-            public_handle: string | null;
-            display_name: string | null;
-        } | null;
+        tester_id: string | null;
+        public_handle: string | null;
+        display_name: string | null;
     }>>;
 }
 /**
@@ -1471,6 +1551,12 @@ interface ApiClientOptions {
     apiEndpoint?: string;
     timeout?: number;
     maxRetries?: number;
+    /**
+     * Returns the current signed end-user identity JWT, or null when the user is
+     * anonymous. When present it is sent on the X-Mushi-User-Token header so the
+     * backend can verify it and scope identity-bound features to that user.
+     */
+    getUserToken?: () => string | null | undefined;
 }
 declare const DEFAULT_API_ENDPOINT = "https://dxptnwrhwsqckaftyymj.supabase.co/functions/v1/api";
 declare const MUSHI_INTERNAL_HEADER = "X-Mushi-Internal";
@@ -1510,6 +1596,43 @@ declare function resolveRegionEndpoint(opts: {
     fetcher?: typeof fetch;
 }): Promise<string>;
 
+/**
+ * FILE: packages/core/src/env-config.ts
+ * PURPOSE: Reads Mushi credentials from the environment when they are not
+ *          supplied explicitly. This lets every framework init work with
+ *          zero-config — just run `npx mushi-mushi` once, add the .env.local
+ *          line, and the provider/plugin/init works without props.
+ *
+ * Resolution order per field:
+ *   1. Vite / SvelteKit / Angular (VITE_MUSHI_*)
+ *   2. Next.js (NEXT_PUBLIC_MUSHI_*)
+ *   3. Nuxt (NUXT_PUBLIC_MUSHI_*)
+ *   4. Expo managed workflow (EXPO_PUBLIC_MUSHI_*)
+ *   5. Node / React Native / server (bare MUSHI_*)
+ *
+ * Vite statically replaces `import.meta.env.VITE_*` at build time, so the
+ * literal key references here are intentional — they make bundlers replace
+ * the values even when accessed indirectly.
+ *
+ * Next.js and Expo, by contrast, do STATIC string replacement that only
+ * inlines literal `process.env.NEXT_PUBLIC_*` / `process.env.EXPO_PUBLIC_*`
+ * dot-notation references. A dynamic `process.env[key]` lookup is explicitly
+ * unsupported and silently resolves to `undefined` in production client
+ * bundles (Expo even ships an ESLint rule against it). Every `process.env`
+ * read below is therefore a literal, statically-analyzable reference.
+ */
+interface ResolvedEnvConfig {
+    projectId?: string;
+    apiKey?: string;
+    apiEndpoint?: string;
+}
+/**
+ * Reads Mushi projectId, apiKey, and (optionally) apiEndpoint from
+ * the environment. Returns only the fields that are present so callers
+ * can cleanly spread: `{ ...resolveEnvConfig(), ...explicitConfig }`.
+ */
+declare function resolveEnvConfig(): ResolvedEnvConfig;
+
 interface PreFilterResult {
     passed: boolean;
     reason?: string;
@@ -1802,4 +1925,208 @@ declare function createLogger(options: LoggerOptions): Logger;
  */
 declare const noopLogger: Logger;
 
-export { type ApiClientOptions, type BreadcrumbBuffer, type BreadcrumbBufferOptions, DEFAULT_API_ENDPOINT, type LogEntry, type LogFormat, type LogLevel, type Logger, type LoggerOptions, MAX_REPORT_PAYLOAD_BYTES, MAX_SCREENSHOT_DATA_URL_BYTES, MUSHI_INTERNAL_HEADER, MUSHI_INTERNAL_INIT_MARKER, type MushiActivityEvent, type MushiApiCascadeConfig, type MushiApiClient, type MushiApiResponse, type MushiBannerConfig, type MushiBannerLink, type MushiBetaChangelogEntry, type MushiBetaModeConfig, type MushiBreadcrumb, type MushiCaptureConfig, type MushiCaptureEventInput, type MushiCaptureExceptionOptions, type MushiConfig, type MushiConsoleEntry, type MushiCooldownConfig, type MushiCrossAppReport, type MushiCustomCategory, type MushiDiagnosticsResult, type MushiDiscoverInventoryConfig, type MushiDiscoveryEventPayload, type MushiEnvironment, type MushiEventHandler, type MushiEventType, type MushiHallOfFameEntry, type MushiIntegrationsConfig, type MushiInternalRequestKind, type MushiLeaderboardEntry, type MushiNetworkEntry, type MushiOfflineConfig, type MushiOnDeviceClassifier, type MushiOnDeviceClassifierInput, type MushiOnDeviceClassifierResult, type MushiPerformanceMetrics, type MushiPreFilterConfig, type MushiPreset, type MushiPrivacyConfig, type MushiProactiveConfig, type MushiRegion, type MushiReport, type MushiReportBuilder, type MushiReportCategory, type MushiReportStatus, type MushiReporterComment, type MushiReporterReport, type MushiReputationResult, type MushiRewardsConfig, type MushiRuntimeSdkConfig, type MushiSDKInstance, type MushiSdkVersionInfo, type MushiSelectedElement, type MushiSentryConfig, type MushiSentryContext, type MushiTesterReputation, type MushiTierResult, type MushiTimelineEntry, type MushiTimelineKind, type MushiTracePropagationConfig, type MushiUrlMatcher, type MushiWidgetAnchor, type MushiWidgetConfig, type NormalisedException, type OfflineQueue, type PayloadGuardResult, type PiiScrubberConfig, type PreFilterResult, REGION_ENDPOINTS, type RateLimiter, type RateLimiterConfig, captureEnvironment, checkReportPayloadSize, createApiClient, createBreadcrumbBuffer, createLogger, createOfflineQueue, createPiiScrubber, createPreFilter, createRateLimiter, estimateJsonBytes, formatBytes, getDeviceFingerprintHash, getReporterToken, getSessionId, newUuid, noopLogger, normaliseThrown, resolveRegionEndpoint, scrubPii };
+/**
+ * FILE: packages/core/src/design-tokens.ts
+ * PURPOSE: The single cross-platform source of truth for Mushi widget design.
+ *
+ * Every platform SDK (web Shadow-DOM CSS, React Native components, Capacitor
+ * native sheet) reads its colours, spacing, radii, typography, z-index scale,
+ * motion, launcher geometry, and default copy from this module so the widget
+ * renders coherently everywhere. `@mushi-mushi/core` is already a dependency
+ * of every platform package, which is why the tokens live here rather than in
+ * a separate published package — one import path, no extra build wiring.
+ *
+ * Colour values mirror the historical washi/vermillion palette previously
+ * inlined in `@mushi-mushi/web`'s styles.ts so the visual identity is
+ * unchanged; the difference is that RN and Capacitor now share the exact
+ * same constants instead of re-deriving their own.
+ */
+type MushiThemeMode = 'light' | 'dark';
+interface MushiColorPalette {
+    /** washi cream / dark wash — primary surface */
+    paper: string;
+    /** elevated surface (panels, sheets) */
+    paperRaised: string;
+    /** sumi black / cream type — primary text */
+    ink: string;
+    /** captions, descriptions */
+    inkMuted: string;
+    /** disabled, separators */
+    inkFaint: string;
+    /** dim text */
+    inkDim: string;
+    /** hairline rules */
+    rule: string;
+    /** stronger rules / borders */
+    ruleStrong: string;
+    /** 朱 hanko red — signature accent */
+    accent: string;
+    /** ~8–12% accent wash */
+    accentWash: string;
+    /** accessible text on the accent wash */
+    accentInk: string;
+    /** success */
+    ok: string;
+    /** danger / destructive */
+    danger: string;
+}
+/** Light-mode palette. */
+declare const MUSHI_COLORS_LIGHT: MushiColorPalette;
+/** Dark-mode palette. */
+declare const MUSHI_COLORS_DARK: MushiColorPalette;
+/** Resolve the palette for a theme mode. */
+declare function mushiPalette(mode: MushiThemeMode): MushiColorPalette;
+/**
+ * Spacing scale (px). Named by feel, matching the editorial design system so
+ * the same rhythm reads across web and native.
+ */
+declare const MUSHI_SPACING: {
+    readonly hairline: 2;
+    readonly tight: 4;
+    readonly snug: 8;
+    readonly comfy: 12;
+    readonly roomy: 16;
+    readonly lounge: 20;
+    readonly open: 24;
+    readonly wide: 32;
+};
+/** Corner radii (px). Tables/strips stay sharp; controls get soft corners. */
+declare const MUSHI_RADIUS: {
+    readonly none: 0;
+    readonly control: 4;
+    readonly card: 10;
+    readonly sheet: 16;
+    readonly pill: 999;
+};
+/** Typography stacks shared by every platform (system-first, no web-font fetch). */
+declare const MUSHI_TYPE: {
+    readonly fontDisplay: "'Iowan Old Style', 'Palatino Linotype', 'Palatino', 'Book Antiqua', 'Cambria', Georgia, 'Times New Roman', serif";
+    readonly fontBody: "system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI Variable Display', 'Segoe UI', sans-serif";
+    readonly fontMono: "ui-monospace, 'SF Mono', 'JetBrains Mono', Menlo, Consolas, 'Liberation Mono', monospace";
+    readonly sizeBody: 14;
+    readonly sizeLabel: 12;
+    readonly sizeTitle: 16;
+    readonly lineBody: 1.55;
+};
+/**
+ * z-index scale. The host element is pass-through; only interactive surfaces
+ * opt back into pointer events. Banner sits just under the FAB; panel above.
+ */
+declare const MUSHI_Z: {
+    readonly base: 99999;
+    /** banner sits one below the trigger so an open FAB overlaps it */
+    readonly banner: 99998;
+    /** report/assistant panel sits one above the trigger */
+    readonly panel: 100000;
+    /** element-selector overlay — always on top */
+    readonly overlay: 2147483647;
+};
+/** Motion signature — a soft back-out "stamp press". */
+declare const MUSHI_MOTION: {
+    readonly easeStamp: "cubic-bezier(0.22, 1, 0.36, 1)";
+    readonly durationFast: 200;
+    readonly durationPanel: 300;
+};
+/**
+ * Launcher geometry — the numbers that previously diverged between platforms
+ * (banner height, FAB size, default gutter, panel width). Centralising them
+ * is what fixes the "different on every app" + safe-area bleed problems.
+ */
+declare const MUSHI_GEOMETRY: {
+    readonly bannerHeight: 36;
+    readonly fabSize: 52;
+    readonly edgeTabWidth: 28;
+    /** default gutter from the screen edge (added on top of safe-area insets) */
+    readonly gutter: 24;
+    readonly panelWidth: 384;
+    /** below this viewport width the panel becomes a full-width bottom sheet */
+    readonly panelSheetBreakpoint: 480;
+};
+/**
+ * Default user-facing copy. Centralised so apps stop drifting on the banner
+ * label / CTA wording (seen as inconsistent across the four host apps).
+ */
+declare const MUSHI_COPY: {
+    readonly bannerLabel: "Beta";
+    readonly bannerMessage: "Help us improve — your feedback shapes what we ship.";
+    readonly bugCta: "Report a bug";
+    readonly featureCta: "Feature request";
+    readonly triggerText: "🐛";
+    readonly panelTitle: "Send feedback";
+    readonly myReportsTab: "My reports";
+    readonly assistantTab: "Ask";
+};
+/** A flat, serialisable snapshot of every token for a given theme mode. */
+interface MushiTokenSnapshot {
+    mode: MushiThemeMode;
+    colors: MushiColorPalette;
+    spacing: typeof MUSHI_SPACING;
+    radius: typeof MUSHI_RADIUS;
+    type: typeof MUSHI_TYPE;
+    z: typeof MUSHI_Z;
+    motion: typeof MUSHI_MOTION;
+    geometry: typeof MUSHI_GEOMETRY;
+    copy: typeof MUSHI_COPY;
+}
+/** Build a full token snapshot for a theme mode (used by RN/Capacitor). */
+declare function mushiTokens(mode: MushiThemeMode): MushiTokenSnapshot;
+
+/**
+ * FILE: packages/core/src/identity.ts
+ * PURPOSE: The signed-JWT end-user identity contract shared between the SDK
+ *          and the Mushi backend.
+ *
+ * The host app's server mints a short-lived JWT (HS256, signed with the
+ * project's identity secret obtained from the console) describing the
+ * currently-logged-in end user, and hands it to the SDK via
+ * `Mushi.identifyWithToken(jwt)`. The SDK never verifies the signature — it
+ * only base64url-decodes the payload to show the user's name locally and
+ * forwards the raw token to the backend, which verifies it against the
+ * per-project secret before trusting any claim. This mirrors the Featurebase
+ * `featurebaseJwt` model and is the trust anchor for "My Reports", rewards,
+ * and the per-user assistant data index.
+ *
+ * Anonymous reporters (logged-out) keep using the random reporter token; the
+ * signed JWT is purely additive.
+ */
+/** Claims carried by a Mushi end-user identity token. */
+interface MushiIdentityClaims {
+    /** Mushi external project id this token is scoped to. */
+    projectId: string;
+    /** The host app's stable id for this end user (becomes `external_user_id`). */
+    sub: string;
+    /** Optional display email (never stored raw server-side — hashed). */
+    email?: string;
+    /** Optional display name. */
+    name?: string;
+    /** Issued-at (seconds since epoch). */
+    iat?: number;
+    /** Expiry (seconds since epoch). Tokens should be short-lived (<= 1h). */
+    exp?: number;
+}
+/**
+ * Sentinel so callers can distinguish a Mushi identity token from the random
+ * anonymous reporter token (`mushi_<uuid>`). Identity tokens are standard JWTs
+ * (three dot-separated base64url segments), so this prefix is informational
+ * only and not embedded in the wire format.
+ */
+declare const MUSHI_IDENTITY_TOKEN_PREFIX = "mushi.identity";
+/**
+ * Build the canonical claims object a host server should sign. Exposed so the
+ * `@mushi-mushi/node` SDK and docs share one definition of the payload shape.
+ */
+declare function buildIdentityClaims(input: {
+    projectId: string;
+    userId: string;
+    email?: string;
+    name?: string;
+    ttlSeconds?: number;
+}): Required<Pick<MushiIdentityClaims, 'projectId' | 'sub' | 'iat' | 'exp'>> & Pick<MushiIdentityClaims, 'email' | 'name'>;
+/**
+ * Decode (WITHOUT verifying) the claims of an identity JWT. Returns null if the
+ * token is malformed. CLIENT-SIDE DISPLAY ONLY — never trust these claims for
+ * authorisation; the server re-verifies the signature.
+ */
+declare function parseIdentityToken(token: string): MushiIdentityClaims | null;
+
+export { type ApiClientOptions, type BreadcrumbBuffer, type BreadcrumbBufferOptions, DEFAULT_API_ENDPOINT, type LogEntry, type LogFormat, type LogLevel, type Logger, type LoggerOptions, MAX_REPORT_PAYLOAD_BYTES, MAX_SCREENSHOT_DATA_URL_BYTES, MUSHI_COLORS_DARK, MUSHI_COLORS_LIGHT, MUSHI_COPY, MUSHI_GEOMETRY, MUSHI_IDENTITY_TOKEN_PREFIX, MUSHI_INTERNAL_HEADER, MUSHI_INTERNAL_INIT_MARKER, MUSHI_MOTION, MUSHI_RADIUS, MUSHI_SPACING, MUSHI_TYPE, MUSHI_Z, type MushiActivityEvent, type MushiApiCascadeConfig, type MushiApiClient, type MushiApiResponse, type MushiAssistantConfig, type MushiAssistantReply, type MushiAssistantStep, type MushiBannerConfig, type MushiBannerLink, type MushiBetaChangelogEntry, type MushiBetaModeConfig, type MushiBreadcrumb, type MushiCaptureConfig, type MushiCaptureEventInput, type MushiCaptureExceptionOptions, type MushiColorPalette, type MushiConfig, type MushiConsoleEntry, type MushiCooldownConfig, type MushiCrossAppReport, type MushiCustomCategory, type MushiDiagnosticsResult, type MushiDiscoverInventoryConfig, type MushiDiscoveryEventPayload, type MushiEnvironment, type MushiEventHandler, type MushiEventType, type MushiHallOfFameEntry, type MushiIdentityClaims, type MushiIntegrationsConfig, type MushiInternalRequestKind, type MushiLeaderboardEntry, type MushiNetworkEntry, type MushiOfflineConfig, type MushiOnDeviceClassifier, type MushiOnDeviceClassifierInput, type MushiOnDeviceClassifierResult, type MushiPageContext, type MushiPerformanceMetrics, type MushiPreFilterConfig, type MushiPreset, type MushiPrivacyConfig, type MushiProactiveConfig, type MushiRegion, type MushiReport, type MushiReportBuilder, type MushiReportCategory, type MushiReportStatus, type MushiReporterComment, type MushiReporterReport, type MushiReputationResult, type MushiRewardsConfig, type MushiRuntimeSdkConfig, type MushiSDKInstance, type MushiSdkVersionInfo, type MushiSelectedElement, type MushiSentryConfig, type MushiSentryContext, type MushiTesterReputation, type MushiThemeMode, type MushiTierResult, type MushiTimelineEntry, type MushiTimelineKind, type MushiTokenSnapshot, type MushiTracePropagationConfig, type MushiUrlMatcher, type MushiWidgetAnchor, type MushiWidgetConfig, type NormalisedException, type OfflineQueue, type PayloadGuardResult, type PiiScrubberConfig, type PreFilterResult, REGION_ENDPOINTS, type RateLimiter, type RateLimiterConfig, type ResolvedEnvConfig, buildIdentityClaims, captureEnvironment, checkReportPayloadSize, createApiClient, createBreadcrumbBuffer, createLogger, createOfflineQueue, createPiiScrubber, createPreFilter, createRateLimiter, estimateJsonBytes, formatBytes, getDeviceFingerprintHash, getReporterToken, getSessionId, mushiPalette, mushiTokens, newUuid, noopLogger, normaliseThrown, parseIdentityToken, resolveEnvConfig, resolveRegionEndpoint, scrubPii };

package/dist/index.js

@@ -41,6 +41,7 @@ function formatBytes(n) {
 }
 
 // src/api-client.ts
+var MUSHI_USER_TOKEN_HEADER = "X-Mushi-User-Token";
 var DEFAULT_API_ENDPOINT = "https://dxptnwrhwsqckaftyymj.supabase.co/functions/v1/api";
 var MUSHI_INTERNAL_HEADER = "X-Mushi-Internal";
 var MUSHI_INTERNAL_INIT_MARKER = "__mushiInternal";
@@ -52,13 +53,15 @@ function createApiClient(options) {
     apiKey,
     apiEndpoint = DEFAULT_API_ENDPOINT,
     timeout = DEFAULT_TIMEOUT,
-    maxRetries = DEFAULT_MAX_RETRIES
+    maxRetries = DEFAULT_MAX_RETRIES,
+    getUserToken
   } = options;
   let baseUrl = apiEndpoint.replace(/\/$/, "");
   async function request(method, path, body, retries = maxRetries, internalKind, extraHeaders) {
     const url = `${baseUrl}${path}`;
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeout);
+    const userToken = getUserToken?.() ?? null;
     try {
       const response = await fetch(url, {
         method,
@@ -66,6 +69,7 @@ function createApiClient(options) {
           "Content-Type": "application/json",
           "X-Mushi-Api-Key": apiKey,
           "X-Mushi-Project": projectId,
+          ...userToken ? { [MUSHI_USER_TOKEN_HEADER]: userToken } : {},
           ...internalKind ? { [MUSHI_INTERNAL_HEADER]: internalKind } : {},
           ...extraHeaders
         },
@@ -168,6 +172,19 @@ function createApiClient(options) {
     async getSdkConfig() {
       return request("GET", "/v1/sdk/config", void 0, maxRetries, "sdk-config");
     },
+    async askAssistant(input) {
+      return request(
+        "POST",
+        "/v1/sdk/assistant",
+        {
+          message: input.message,
+          threadId: input.threadId ?? null,
+          context: input.context ?? null
+        },
+        1,
+        "community"
+      );
+    },
     async getLatestSdkVersion(packageName) {
       const query = new URLSearchParams({ package: packageName }).toString();
       return request("GET", `/v1/sdk/latest-version?${query}`, void 0, maxRetries, "sdk-config");
@@ -445,6 +462,60 @@ function writeCache(storage, projectId, entry) {
   }
 }
 
+// src/env-config.ts
+function first(...values) {
+  return values.find((v) => v !== void 0 && v !== "");
+}
+function tryImportMetaEnv(key) {
+  try {
+    const env = import.meta.env;
+    return typeof env === "object" && env !== null ? env[key] : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readProcessEnv(read) {
+  try {
+    return read();
+  } catch {
+    return void 0;
+  }
+}
+function resolveEnvConfig() {
+  const projectId = first(
+    tryImportMetaEnv("VITE_MUSHI_PROJECT_ID"),
+    tryImportMetaEnv("NEXT_PUBLIC_MUSHI_PROJECT_ID"),
+    tryImportMetaEnv("NUXT_PUBLIC_MUSHI_PROJECT_ID"),
+    tryImportMetaEnv("EXPO_PUBLIC_MUSHI_PROJECT_ID"),
+    readProcessEnv(() => process.env.NEXT_PUBLIC_MUSHI_PROJECT_ID),
+    readProcessEnv(() => process.env.EXPO_PUBLIC_MUSHI_PROJECT_ID),
+    readProcessEnv(() => process.env.MUSHI_PROJECT_ID)
+  );
+  const apiKey = first(
+    tryImportMetaEnv("VITE_MUSHI_API_KEY"),
+    tryImportMetaEnv("NEXT_PUBLIC_MUSHI_API_KEY"),
+    tryImportMetaEnv("NUXT_PUBLIC_MUSHI_API_KEY"),
+    tryImportMetaEnv("EXPO_PUBLIC_MUSHI_API_KEY"),
+    readProcessEnv(() => process.env.NEXT_PUBLIC_MUSHI_API_KEY),
+    readProcessEnv(() => process.env.EXPO_PUBLIC_MUSHI_API_KEY),
+    readProcessEnv(() => process.env.MUSHI_API_KEY)
+  );
+  const apiEndpoint = first(
+    tryImportMetaEnv("VITE_MUSHI_API_ENDPOINT"),
+    tryImportMetaEnv("NEXT_PUBLIC_MUSHI_API_ENDPOINT"),
+    tryImportMetaEnv("NUXT_PUBLIC_MUSHI_API_ENDPOINT"),
+    tryImportMetaEnv("EXPO_PUBLIC_MUSHI_API_ENDPOINT"),
+    readProcessEnv(() => process.env.NEXT_PUBLIC_MUSHI_API_ENDPOINT),
+    readProcessEnv(() => process.env.EXPO_PUBLIC_MUSHI_API_ENDPOINT),
+    readProcessEnv(() => process.env.MUSHI_API_ENDPOINT)
+  );
+  const result = {};
+  if (projectId) result.projectId = projectId;
+  if (apiKey) result.apiKey = apiKey;
+  if (apiEndpoint) result.apiEndpoint = apiEndpoint;
+  return result;
+}
+
 // src/pre-filter.ts
 var DEFAULT_MIN_LENGTH = 10;
 var DEFAULT_MAX_LENGTH = 2e3;
@@ -1500,6 +1571,159 @@ function normaliseThrown(thrown) {
   return { name: "Error", message: String(thrown) };
 }
 
-export { DEFAULT_API_ENDPOINT, MAX_REPORT_PAYLOAD_BYTES, MAX_SCREENSHOT_DATA_URL_BYTES, MUSHI_INTERNAL_HEADER, MUSHI_INTERNAL_INIT_MARKER, REGION_ENDPOINTS, captureEnvironment, checkReportPayloadSize, createApiClient, createBreadcrumbBuffer, createLogger, createOfflineQueue, createPiiScrubber, createPreFilter, createRateLimiter, estimateJsonBytes, formatBytes, getDeviceFingerprintHash, getReporterToken, getSessionId, newUuid, noopLogger, normaliseThrown, resolveRegionEndpoint, scrubPii };
+// src/design-tokens.ts
+var MUSHI_COLORS_LIGHT = {
+  paper: "#F8F4ED",
+  paperRaised: "#FFFFFF",
+  ink: "#0E0D0B",
+  inkMuted: "#5C5852",
+  inkFaint: "#9A9489",
+  inkDim: "#6E6760",
+  rule: "rgba(14,13,11,0.10)",
+  ruleStrong: "rgba(14,13,11,0.16)",
+  accent: "#E03C2C",
+  accentWash: "rgba(224,60,44,0.08)",
+  accentInk: "#7A1F15",
+  ok: "#16A34A",
+  danger: "#DC2626"
+};
+var MUSHI_COLORS_DARK = {
+  paper: "#0F0E0C",
+  paperRaised: "#1A1815",
+  ink: "#F2EBDD",
+  inkMuted: "#928B7E",
+  inkFaint: "#5A5650",
+  inkDim: "#7A7268",
+  rule: "rgba(242,235,221,0.10)",
+  ruleStrong: "rgba(242,235,221,0.18)",
+  accent: "#FF5A47",
+  accentWash: "rgba(255,90,71,0.12)",
+  accentInk: "#FFE5E0",
+  ok: "#4ADE80",
+  danger: "#F87171"
+};
+function mushiPalette(mode) {
+  return mode === "dark" ? MUSHI_COLORS_DARK : MUSHI_COLORS_LIGHT;
+}
+var MUSHI_SPACING = {
+  hairline: 2,
+  tight: 4,
+  snug: 8,
+  comfy: 12,
+  roomy: 16,
+  lounge: 20,
+  open: 24,
+  wide: 32
+};
+var MUSHI_RADIUS = {
+  none: 0,
+  control: 4,
+  card: 10,
+  sheet: 16,
+  pill: 999
+};
+var MUSHI_TYPE = {
+  fontDisplay: `'Iowan Old Style', 'Palatino Linotype', 'Palatino', 'Book Antiqua', 'Cambria', Georgia, 'Times New Roman', serif`,
+  fontBody: `system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI Variable Display', 'Segoe UI', sans-serif`,
+  fontMono: `ui-monospace, 'SF Mono', 'JetBrains Mono', Menlo, Consolas, 'Liberation Mono', monospace`,
+  sizeBody: 14,
+  sizeLabel: 12,
+  sizeTitle: 16,
+  lineBody: 1.55
+};
+var MUSHI_Z = {
+  base: 99999,
+  /** banner sits one below the trigger so an open FAB overlaps it */
+  banner: 99998,
+  /** report/assistant panel sits one above the trigger */
+  panel: 1e5,
+  /** element-selector overlay — always on top */
+  overlay: 2147483647
+};
+var MUSHI_MOTION = {
+  easeStamp: "cubic-bezier(0.22, 1, 0.36, 1)",
+  durationFast: 200,
+  durationPanel: 300
+};
+var MUSHI_GEOMETRY = {
+  bannerHeight: 36,
+  fabSize: 52,
+  edgeTabWidth: 28,
+  /** default gutter from the screen edge (added on top of safe-area insets) */
+  gutter: 24,
+  panelWidth: 384,
+  /** below this viewport width the panel becomes a full-width bottom sheet */
+  panelSheetBreakpoint: 480
+};
+var MUSHI_COPY = {
+  bannerLabel: "Beta",
+  bannerMessage: "Help us improve \u2014 your feedback shapes what we ship.",
+  bugCta: "Report a bug",
+  featureCta: "Feature request",
+  triggerText: "\u{1F41B}",
+  panelTitle: "Send feedback",
+  myReportsTab: "My reports",
+  assistantTab: "Ask"
+};
+function mushiTokens(mode) {
+  return {
+    mode,
+    colors: mushiPalette(mode),
+    spacing: MUSHI_SPACING,
+    radius: MUSHI_RADIUS,
+    type: MUSHI_TYPE,
+    z: MUSHI_Z,
+    motion: MUSHI_MOTION,
+    geometry: MUSHI_GEOMETRY,
+    copy: MUSHI_COPY
+  };
+}
+
+// src/identity.ts
+var MUSHI_IDENTITY_TOKEN_PREFIX = "mushi.identity";
+function buildIdentityClaims(input) {
+  const now = Math.floor(Date.now() / 1e3);
+  const ttl = input.ttlSeconds && input.ttlSeconds > 0 ? Math.min(input.ttlSeconds, 3600) : 600;
+  return {
+    projectId: input.projectId,
+    sub: input.userId,
+    ...input.email ? { email: input.email } : {},
+    ...input.name ? { name: input.name } : {},
+    iat: now,
+    exp: now + ttl
+  };
+}
+function base64UrlDecode(segment) {
+  const pad = segment.length % 4 === 0 ? "" : "=".repeat(4 - segment.length % 4);
+  const base64 = segment.replace(/-/g, "+").replace(/_/g, "/") + pad;
+  if (typeof atob === "function") return atob(base64);
+  const B = globalThis.Buffer;
+  if (B) return B.from(base64, "base64").toString("binary");
+  return "";
+}
+function parseIdentityToken(token) {
+  if (typeof token !== "string") return null;
+  const parts = token.split(".");
+  if (parts.length !== 3) return null;
+  try {
+    const json = base64UrlDecode(parts[1]);
+    const payload = JSON.parse(json);
+    const projectId = typeof payload.projectId === "string" ? payload.projectId : void 0;
+    const sub = typeof payload.sub === "string" ? payload.sub : void 0;
+    if (!projectId || !sub) return null;
+    return {
+      projectId,
+      sub,
+      ...typeof payload.email === "string" ? { email: payload.email } : {},
+      ...typeof payload.name === "string" ? { name: payload.name } : {},
+      ...typeof payload.iat === "number" ? { iat: payload.iat } : {},
+      ...typeof payload.exp === "number" ? { exp: payload.exp } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+
+export { DEFAULT_API_ENDPOINT, MAX_REPORT_PAYLOAD_BYTES, MAX_SCREENSHOT_DATA_URL_BYTES, MUSHI_COLORS_DARK, MUSHI_COLORS_LIGHT, MUSHI_COPY, MUSHI_GEOMETRY, MUSHI_IDENTITY_TOKEN_PREFIX, MUSHI_INTERNAL_HEADER, MUSHI_INTERNAL_INIT_MARKER, MUSHI_MOTION, MUSHI_RADIUS, MUSHI_SPACING, MUSHI_TYPE, MUSHI_Z, REGION_ENDPOINTS, buildIdentityClaims, captureEnvironment, checkReportPayloadSize, createApiClient, createBreadcrumbBuffer, createLogger, createOfflineQueue, createPiiScrubber, createPreFilter, createRateLimiter, estimateJsonBytes, formatBytes, getDeviceFingerprintHash, getReporterToken, getSessionId, mushiPalette, mushiTokens, newUuid, noopLogger, normaliseThrown, parseIdentityToken, resolveEnvConfig, resolveRegionEndpoint, scrubPii };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map