@scalebun-release/react-native 2.5.0

package/src/analytics/automaticEvents.ts

@@ -0,0 +1,109 @@
+/**
+ * Canonical automatic-event bus.
+ *
+ * Every zero-instrumentation collector publishes here. EventTracker subscribes
+ * once and turns the observations into the same signed `/batch` envelopes used
+ * by public `track()` calls. Keeping collectors transport-agnostic prevents
+ * lifecycle/navigation/push/Engage from growing parallel ingestion lanes.
+ */
+
+export type AutomaticEventName =
+    | 'app_foregrounded'
+    | 'app_backgrounded'
+    | 'screen_viewed'
+    /** Device rotated. Absent entirely before — a layout-driven drop-off was invisible on mobile. */
+    | 'orientation_changed'
+    /** The OS warned the app it is under memory pressure — the leading indicator before an OOM kill. */
+    | 'memory_warning'
+    | 'deep_link_opened'
+    | 'element_interacted'
+    /** An opt-in element was on screen long enough to count as seen (<ScaleBunImpression>). */
+    | 'element_viewed'
+    /** An OS permission was granted or denied — the missing step in every mobile growth funnel. */
+    | 'permission_result'
+    | 'push_received'
+    | 'push_opened'
+    | 'in_app_displayed'
+    | 'in_app_clicked'
+    | 'in_app_dismissed'
+    | 'in_app_completed'
+    | 'in_app_interaction'
+    | 'in_app_render_failed'
+    | 'in_app_cta_open_failed'
+    | 'rating_prompt_eligible'
+    | 'rating_prompt_shown'
+    | 'rating_selected'
+    | 'rating_prompt_dismissed'
+    | 'store_redirect_clicked';
+
+export interface AutomaticEvent {
+    name: AutomaticEventName;
+    properties: Record<string, unknown>;
+    /** Original observation time. Delivery can be delayed while native coordinates resolve. */
+    timestamp?: number;
+}
+
+type AutomaticEventListener = (event: AutomaticEvent) => void;
+
+const listeners = new Set<AutomaticEventListener>();
+const pending: AutomaticEvent[] = [];
+const MAX_PENDING = 50;
+
+function compactProperties(
+    properties?: Record<string, unknown>,
+): Record<string, unknown> {
+    const out: Record<string, unknown> = { capture_source: 'automatic' };
+    for (const [key, value] of Object.entries(properties ?? {})) {
+        if (value !== undefined) out[key] = value;
+    }
+    return out;
+}
+
+export function emitAutomaticEvent(
+    name: AutomaticEventName,
+    properties?: Record<string, unknown>,
+    timestamp?: number,
+): void {
+    const event: AutomaticEvent = {
+        name,
+        properties: compactProperties(properties),
+        timestamp,
+    };
+    if (listeners.size === 0) {
+        pending.push(event);
+        if (pending.length > MAX_PENDING) pending.shift();
+        return;
+    }
+    for (const listener of listeners) {
+        try {
+            listener(event);
+        } catch {
+            // Automatic capture must never affect the host application.
+        }
+    }
+}
+
+export function subscribeAutomaticEvents(
+    listener: AutomaticEventListener,
+): () => void {
+    listeners.add(listener);
+    if (pending.length > 0) {
+        const buffered = pending.splice(0, pending.length);
+        for (const event of buffered) {
+            try {
+                listener(event);
+            } catch {
+                // A bad observer cannot poison later automatic events.
+            }
+        }
+    }
+    return () => {
+        listeners.delete(listener);
+    };
+}
+
+/** Test-only reset; intentionally not exported from the package entry point. */
+export function resetAutomaticEventsForTests(): void {
+    listeners.clear();
+    pending.splice(0, pending.length);
+}

package/src/analytics/batching.ts

@@ -0,0 +1,54 @@
+/**
+ * ScaleBun SDK — batch chunking contract (Phase 3 / Wave 1).
+ *
+ * The backend rejects any `/batch` request whose `events.length` exceeds
+ * MAX_BATCH_EVENTS with HTTP 413 BATCH_TOO_LARGE (accepted:0, rejected:all).
+ * The old backend behaviour silently sliced to the first 500 and 202'd — a
+ * silent data-loss defect. Now that the server rejects, the SDK must NEVER
+ * emit an oversized batch; it splits its queue into chunks of at most this
+ * value, preserving eventIds, ordering, identifiers, and timestamps.
+ *
+ * This constant MUST equal `MAX_BATCH_EVENTS` in the backend
+ * (scalebun-dashboard-backend/src/features/ingestion-v1/constants.ts).
+ * The shared contract test (`__tests__/batchChunking.test.ts`) pins the
+ * value so the two sides cannot drift.
+ */
+export const MAX_BATCH_EVENTS = 500;
+
+/**
+ * Split a list into contiguous chunks of at most `size`, preserving order.
+ * A queue of N items yields ceil(N/size) chunks; every chunk is <= size and
+ * only the last may be shorter. No item is dropped, duplicated, or reordered.
+ */
+export function chunkEvents<T>(events: readonly T[], size: number = MAX_BATCH_EVENTS): T[][] {
+    const cap = Math.max(1, Math.min(size, MAX_BATCH_EVENTS));
+    if (events.length <= cap) return events.length ? [events.slice()] : [];
+    const out: T[][] = [];
+    for (let i = 0; i < events.length; i += cap) {
+        out.push(events.slice(i, i + cap));
+    }
+    return out;
+}
+
+/** Clamp a caller-configured batch size into the server-safe range [1, MAX_BATCH_EVENTS]. */
+export function clampBatchSize(configured: number | undefined, fallback: number): number {
+    const n = typeof configured === 'number' && configured > 0 ? configured : fallback;
+    return Math.max(1, Math.min(n, MAX_BATCH_EVENTS));
+}
+
+/**
+ * Wave 2 (§2F.2): a STABLE batch idempotency key derived from the batch's event
+ * ids. The same leading events produce the same key across transient retries, so
+ * the server replays the first response instead of re-counting accepts; a changed
+ * batch produces a different key. Non-cryptographic (FNV-1a) — this is a dedup
+ * label, not a security token. The per-event id remains the true dedup anchor.
+ */
+export function batchIdempotencyKey(eventIds: readonly string[]): string {
+    let h = 0x811c9dc5; // FNV-1a 32-bit offset basis
+    const joined = eventIds.join('
');
+    for (let i = 0; i < joined.length; i++) {
+        h ^= joined.charCodeAt(i);
+        h = Math.imul(h, 0x01000193) >>> 0;
+    }
+    return `sdk-${eventIds.length}-${h.toString(16).padStart(8, '0')}`;
+}

package/src/analytics/eventLane.ts

@@ -0,0 +1,48 @@
+/**
+ * ScaleBun SDK — event lane routing.
+ *
+ * A tracked event goes to exactly one of two lanes:
+ *  - `analytics`: product events (public, non-`$`) → EventTracker → `/batch`
+ *    → raw_events → events. These are the rows a customer queries/visualizes.
+ *  - `session`: SDK-internal signals (`$`-prefixed: `$log`, `$network_request`,
+ *    `$perf_event`, `$internal_event`, …) → session/replay/debug lane only.
+ *    They must NOT enter the analytics `events` table.
+ *
+ * The `$` prefix is the single source of truth for this split. Keeping the
+ * decision in one pure function keeps the facade and any tooling in agreement
+ * and makes the split unit-testable without the native runtime.
+ */
+
+export type EventLane = 'analytics' | 'session';
+
+/** True for SDK-internal (`$`-prefixed) signals that ride the session lane only. */
+export function isSessionLaneEvent(name: string): boolean {
+    return name.startsWith('$');
+}
+
+/** Resolve the destination lane for a tracked event name. */
+export function resolveEventLane(name: string): EventLane {
+    return isSessionLaneEvent(name) ? 'session' : 'analytics';
+}
+
+/**
+ * Signals that stay IN-PROCESS: they fan out to the engage trigger engine, the perf collectors and
+ * the desktop debug stream, but are NOT uploaded as session events — because each one already has
+ * its own dedicated ingestion lane carrying strictly more data.
+ *
+ * `$network_request` is the founding member: NetworkFeature writes every request to the
+ * `network_requests` table via reportNetworkRequest (method/status/timing/sizes/headers), and ALSO
+ * tracked it — which uploaded a second copy as a USER_ACTION session event that nothing reads. The
+ * dashboard's inspector explicitly filters that echo out as noise, the heatmap route catalog
+ * documents it as pollution, and measured sessions carried ~15% of their event volume in it.
+ * (`$perf_event` was the same pattern, removed at its emit site — d81e0ab.)
+ *
+ * Rule for adding here: the signal must have a dedicated lane that every consumer reads. A signal
+ * whose ONLY record is the session event stream must never be added.
+ */
+const INTERNAL_ONLY_SIGNALS = new Set(['$network_request']);
+
+/** Should this tracked event be uploaded to the session-events lane at all? */
+export function isUploadedSessionEvent(name: string): boolean {
+    return !INTERNAL_ONLY_SIGNALS.has(name);
+}

package/src/analytics/revenue.ts

@@ -0,0 +1,143 @@
+/**
+ * Revenue modelling for the mobile SDK — the twin of `revenue.ts` in the web SDK.
+ *
+ * WHY THIS EXISTS AT ALL. `trackPurchase` used to be three fields and a spread:
+ * `revenue`, `currency`, `transactionId`, everything else passed through
+ * untouched. That was fine while revenue was one number on a dashboard card, and
+ * it is not fine now that the Business section bridges gross to net, splits by
+ * plan, and separates refunds from charges. Three concrete consequences of the
+ * old shape, all silent:
+ *
+ *   1. A REFUND COUNTED AS A SALE. The web SDK stores a refund as a NEGATIVE
+ *      amount; mobile stored whatever sign the caller used. An app sending
+ *      `{ revenue: 30, type: 'refund' }` from iOS added $30 to GROSS revenue and
+ *      to the customer's lifetime value. Same call from the browser subtracted
+ *      it. Nothing reported the disagreement.
+ *   2. NO PLAN ATTRIBUTION. `productId` was not mapped to the `product_id`
+ *      property the rollup groups by, so every mobile sale landed in the
+ *      "Unattributed" bucket of "Top plans by revenue".
+ *   3. ADJUSTMENTS WERE UNVALIDATED. A store commission sent as the string
+ *      "0.30" reached the aggregate, failed its numeric check there, and was
+ *      dropped with no error — so mobile net revenue was quietly overstated by
+ *      the size of the app store's cut.
+ *
+ * The shapes and the property names here are the web SDK's, deliberately: both
+ * write into one `events` table that one rollup reads. A field named differently
+ * on one platform is a field that platform does not have.
+ *
+ * No third-party dependency, browser API or React import — this is pure data
+ * transformation, callable from the tracker and directly testable.
+ */
+
+/**
+ * What KIND of money movement this is.
+ *
+ * `dispute` and `adjustment` exist for the transaction ledger, which has to
+ * separate them: a chargeback is money taken back by the bank and an adjustment
+ * is a correction someone made, and lumping either into `refund` makes a refund
+ * rate that cannot be acted on.
+ *
+ * SIGN CONVENTION, matching the web SDK exactly:
+ *   refund, dispute  ALWAYS stored negative — money left, whatever sign the
+ *                    caller used.
+ *   adjustment       keeps the CALLER's sign; it is the one kind that
+ *                    legitimately goes either way (a credit or a debit).
+ */
+export type RevenueType = 'one_time' | 'subscription' | 'refund' | 'dispute' | 'adjustment';
+
+export interface RevenueInput {
+  /** Amount in `currency`. For refunds and disputes pass the positive amount; it is stored negative. */
+  revenue: number;
+  /** ISO-4217 currency; normalized to upper-case. */
+  currency: string;
+  /** Idempotency key — the backend dedups by (appId, transactionId). */
+  transactionId: string;
+  /** Revenue kind. Default 'one_time'. */
+  type?: RevenueType;
+  /** SKU / plan id. This is what "Top plans by revenue" groups by. */
+  productId?: string;
+  /** Human-readable SKU / plan name. Sent as `product_name` for Business plan attribution. */
+  productName?: string;
+  quantity?: number;
+  /** Billing cadence for subscriptions (e.g. 'monthly' | 'yearly'). */
+  recurrence?: string;
+  /**
+   * What came OUT of the charge before it was yours — the gross-to-net bridge.
+   *
+   * Each is a POSITIVE amount in `currency`, deducted from gross to produce net.
+   * On mobile `fee` is usually the store's 15/30% commission, which is the
+   * single largest reason a mobile net figure differs from its gross one.
+   *
+   * A missing adjustment is treated as ABSENT, not as zero: net then does not
+   * claim a precision the payload did not carry. Sending `tax: 0` for a
+   * zero-rated sale is a different, and stronger, statement than sending nothing.
+   */
+  tax?: number;
+  fee?: number;
+  discount?: number;
+  [k: string]: unknown;
+}
+
+export interface NormalizedRevenue {
+  revenue: number;
+  currency: string;
+  props: Record<string, unknown>;
+}
+
+/** The adjustment keys, in the order the bridge deducts them. */
+const ADJUSTMENTS = ['tax', 'fee', 'discount'] as const;
+
+/** Upper-case a 3-letter ISO-like code; return an empty string when invalid. */
+export function normalizeCurrency(c: string): string {
+  c = c.trim();
+  return /^[a-z]{3}$/i.test(c) ? c.toUpperCase() : '';
+}
+
+export function validBusinessAmount(value: unknown): value is number {
+  return typeof value === 'number' && Math.abs(value) < 1e10;
+}
+
+/**
+ * Validate and normalize a revenue event into a top-level amount/currency plus
+ * folded properties. Returns null — a DROP — when a required field is missing or
+ * unusable, because a purchase without an idempotency key cannot be deduplicated,
+ * one without a currency cannot be added to anything, and silently dropping an
+ * invalid explicit fee/tax/discount would overstate net revenue.
+ */
+export function normalizeRevenue(input: RevenueInput): NormalizedRevenue | null {
+  input = input || {} as RevenueInput;
+  const { revenue, currency, transactionId, type, productId, productName, quantity, recurrence, ...rest } = input;
+  const normalizedCurrency = typeof currency === 'string' ? normalizeCurrency(currency) : '';
+  const normalizedTransactionId = typeof transactionId === 'string' ? transactionId.trim() : '';
+  if (!validBusinessAmount(revenue) || !normalizedCurrency || !normalizedTransactionId
+    || normalizedTransactionId.length > 256) return null;
+
+  const kind = type ?? 'one_time';
+  if (!/^(one_time|subscription|refund|dispute|adjustment)$/.test(kind)) return null;
+
+  // A refund or a dispute is negative whatever sign the caller used, so sums and
+  // LTV are right without every call site having to remember the convention.
+  const outflow = kind === 'refund' || kind === 'dispute';
+  const amount = outflow ? -Math.abs(revenue) : revenue;
+
+  const props: Record<string, unknown> = { ...rest, transaction_id: normalizedTransactionId, revenue_type: kind };
+  const productIdText = typeof productId === 'string' ? productId.trim() : '';
+  const productNameText = typeof productName === 'string' ? productName.trim() : '';
+  if (productIdText && productIdText.length <= 256) props.product_id = productIdText;
+  if (productNameText && productNameText.length <= 512) props.product_name = productNameText;
+  if (quantity != null) props.quantity = quantity;
+  if (recurrence) props.recurrence = recurrence;
+
+  // Adjustments are always positive because the aggregate DEDUCTS them. Reject the
+  // whole purchase when an explicit adjustment is invalid: silently omitting a fee
+  // would overstate net revenue while making the event look complete.
+  for (const k of ADJUSTMENTS) {
+    const v = input[k];
+    if (v !== undefined) {
+      if (!validBusinessAmount(v)) return null;
+      props[k] = Math.abs(v);
+    }
+  }
+
+  return { revenue: amount, currency: normalizedCurrency, props };
+}

package/src/analytics/subscription.ts

@@ -0,0 +1,145 @@
+/**
+ * Subscription lifecycle normalization — the mobile half of the Web SDK contract.
+ *
+ * These events feed the event-sourced subscription ledger used by Business
+ * Overview, MRR, retention and trials. Invalid price-setting events are dropped
+ * instead of manufacturing recurring revenue from incomplete data.
+ */
+import { normalizeCurrency, validBusinessAmount } from './revenue';
+/** Backend subscription-ledger wire contract. Additive fields require a new version. */
+export const SUBSCRIPTION_SCHEMA_VERSION = 3;
+const SUBSCRIPTION_KEY = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,159}$/;
+export type SubscriptionStatus =
+    | 'trial_started'
+    | 'trial_converted'
+    | 'started'
+    | 'renewed'
+    | 'plan_changed'
+    | 'cancel_scheduled'
+    | 'resumed'
+    | 'canceled'
+    | 'expired'
+    | 'payment_failed'
+    | 'refunded';
+
+/** Stable cancellation taxonomy shared by React Native, Web and the dashboard. */
+export type CancellationReason =
+    | 'too_expensive'
+    | 'no_longer_needed'
+    | 'competitive_offer'
+    | 'missing_features'
+    | 'poor_experience'
+    | 'payment_issue'
+    | 'other';
+
+const CANCELLATION_REASONS: readonly CancellationReason[] = [
+    'too_expensive', 'no_longer_needed', 'competitive_offer', 'missing_features',
+    'poor_experience', 'payment_issue', 'other',
+];
+
+const STATUSES: readonly SubscriptionStatus[] = [
+    'trial_started', 'trial_converted', 'started', 'plan_changed', 'renewed', 'cancel_scheduled',
+    'resumed', 'canceled', 'expired', 'payment_failed', 'refunded',
+];
+
+export interface SubscriptionPlan {
+    id?: string;
+    name?: string;
+    amount: number;
+    currency: string;
+    interval: 'day' | 'week' | 'month' | 'year';
+    intervalCount?: number;
+}
+
+export interface SubscriptionInput {
+    /** Stable subscription identity, scoped to the current app/environment. */
+    subscriptionId: string;
+    /**
+     * Optional stable identity for this lifecycle change. Reuse it when the host repeats the same
+     * logical call; the backend keeps the first accepted payload. A missing key falls back to the
+     * SDK envelope event id, so transport retries remain idempotent either way.
+     */
+    subscriptionEventId?: string;
+    status: SubscriptionStatus;
+    /** Optional structured reason for cancel_scheduled/canceled/expired events. */
+    cancellationReason?: CancellationReason;
+    /** Optional free-text detail; bounded before it enters the event ledger. */
+    cancellationComment?: string;
+    plan?: SubscriptionPlan;
+    trialEndAt?: string | Date;
+    effectiveAt?: string | Date;
+    properties?: Record<string, unknown>;
+}
+
+/** `undefined` means absent; `null` means an explicit but invalid business timestamp. */
+function toIso(value: unknown, maxFutureMs: number): string | null | undefined {
+    if (value === undefined) return undefined;
+    if (typeof value === 'string' ? value.length > 64 : !(value instanceof Date)) return null;
+    const date = new Date(value as string | Date);
+    return +date <= Date.now() + maxFutureMs ? date.toISOString() : null;
+}
+
+function cleanPlan(plan: unknown): Record<string, unknown> | null {
+    const p = (plan || {}) as SubscriptionPlan;
+    const currency = typeof p.currency === 'string' ? normalizeCurrency(p.currency) : '';
+    const intervalCount = p.intervalCount;
+    if (!validBusinessAmount(p.amount) || p.amount < 0
+        || !currency || !/^(day|week|month|year)$/.test(p.interval)
+        || (intervalCount !== undefined && (intervalCount !== (intervalCount | 0)
+            || intervalCount <= 0 || intervalCount > 1_000))) return null;
+    const id = typeof p.id === 'string' ? p.id.trim() : '';
+    const name = typeof p.name === 'string' ? p.name.trim() : '';
+    return {
+        amount: p.amount,
+        currency,
+        interval: p.interval,
+        ...(intervalCount === undefined ? {} : { intervalCount }),
+        ...(id && id.length <= 256 ? { id } : {}),
+        ...(name && name.length <= 512 ? { name } : {}),
+    };
+}
+
+/** Validate and build the canonical `$subscription` event properties. */
+export function normalizeSubscription(input: SubscriptionInput): Record<string, unknown> | null {
+    input = input || {} as SubscriptionInput;
+    const subscriptionId = typeof input.subscriptionId === 'string' ? input.subscriptionId.trim() : '';
+    const subscriptionEventId = typeof input.subscriptionEventId === 'string'
+        ? input.subscriptionEventId.trim()
+        : input.subscriptionEventId;
+    const status = input.status;
+    const statusIndex = STATUSES.indexOf(status);
+    if (!SUBSCRIPTION_KEY.test(subscriptionId)
+        || (subscriptionEventId !== undefined
+            && (typeof subscriptionEventId !== 'string' || !SUBSCRIPTION_KEY.test(subscriptionEventId)))
+        || statusIndex < 0) return null;
+
+    const cancellationReason = input.cancellationReason;
+    const cancellationComment = typeof input.cancellationComment === 'string'
+        ? input.cancellationComment.trim()
+        : input.cancellationComment;
+    const cancellationStatus = status === 'cancel_scheduled' || status === 'canceled' || status === 'expired';
+    if ((cancellationReason !== undefined || cancellationComment !== undefined) && !cancellationStatus) return null;
+    if (cancellationReason !== undefined && !CANCELLATION_REASONS.includes(cancellationReason)) return null;
+    if (cancellationComment !== undefined
+        && (typeof cancellationComment !== 'string' || !cancellationComment || cancellationComment.length > 500)) return null;
+
+    const plan = input.plan;
+    const normalizedPlan = plan === undefined ? undefined : cleanPlan(plan);
+    if (!normalizedPlan && (statusIndex < 4 || plan !== undefined)) return null;
+
+    const trialEndAt = toIso(input.trialEndAt, 316224000000);
+    const effectiveAt = toIso(input.effectiveAt, 86400000);
+    if (trialEndAt === null || effectiveAt === null) return null;
+    return {
+        ...(input.properties ?? {}),
+        schemaVersion: SUBSCRIPTION_SCHEMA_VERSION,
+        subscriptionId,
+        ...(subscriptionEventId === undefined ? {} : { subscriptionEventId }),
+        status,
+        ...(cancellationReason === undefined ? {} : { cancellationReason }),
+        ...(cancellationComment === undefined ? {} : { cancellationComment }),
+        plan: normalizedPlan,
+        trialEndAt,
+        effectiveAt,
+    };
+}

package/src/bootstrap/FeatureRegistry.ts

@@ -0,0 +1,81 @@
+/**
+ * ScaleBun SDK — Feature Registry
+ *
+ * Central registry for SDK feature modules.
+ * Manages feature registration, initialization order, and lifecycle teardown.
+ *
+ * SOLID: Single Responsibility — only manages feature lifecycle.
+ * SOLID: Dependency Inversion — depends on IFeature abstraction.
+ */
+
+import type { IFeature, FeatureContext } from '../core/contracts/IFeature';
+import { logger } from '../core/logger/internalLogger';
+
+export class FeatureRegistry {
+    private features: Map<string, IFeature> = new Map();
+    private initialized = false;
+
+    /**
+     * Register a feature. Must be called before `initializeAll()`.
+     * Duplicate registrations are silently ignored (idempotent).
+     */
+    register(feature: IFeature): void {
+        if (this.features.has(feature.name)) {
+            __DEV__ && logger.debug(`Feature '${feature.name}' already registered, skipping`);
+            return;
+        }
+        this.features.set(feature.name, feature);
+        __DEV__ && logger.debug(`Feature '${feature.name}' registered`);
+    }
+
+    /**
+     * Initialize all registered features with the provided context.
+     * Features that fail to initialize are logged but don't break others.
+     */
+    async initializeAll(context: FeatureContext): Promise<void> {
+        if (this.initialized) return;
+
+        for (const [name, feature] of this.features) {
+            try {
+                await feature.initialize(context);
+                __DEV__ && logger.debug(`Feature '${name}' initialized`);
+            } catch (err) {
+                logger.error(`Feature '${name}' failed to initialize:`, err);
+            }
+        }
+        this.initialized = true;
+    }
+
+    /**
+     * Tear down all features in reverse registration order.
+     * Safe to call even if not initialized.
+     */
+    teardownAll(): void {
+        const entries = Array.from(this.features.entries()).reverse();
+        for (const [name, feature] of entries) {
+            try {
+                feature.teardown();
+                __DEV__ && logger.debug(`Feature '${name}' torn down`);
+            } catch (err) {
+                logger.error(`Feature '${name}' teardown failed:`, err);
+            }
+        }
+        this.features.clear();
+        this.initialized = false;
+    }
+
+    /** Get a feature by name */
+    get(name: string): IFeature | undefined {
+        return this.features.get(name);
+    }
+
+    /** Check if a feature is registered and active */
+    isFeatureActive(name: string): boolean {
+        return this.features.get(name)?.isActive ?? false;
+    }
+
+    /** Get all registered feature names */
+    getRegisteredFeatures(): string[] {
+        return Array.from(this.features.keys());
+    }
+}