featurefly 0.1.0

package/dist/shared/rollout.js

@@ -0,0 +1,77 @@
+/**
+ * Deterministically checks if a given key falls within a rollout percentage.
+ *
+ * @param key The stickiness key (e.g. userId)
+ * @param config Rollout configuration including percentage, salt, and bucket max
+ * @returns true if the key hashes to a bucket < percentage
+ */
+export function isInRollout(key, config) {
+    if (!config)
+        return false;
+    if (config.percentage <= 0)
+        return false;
+    if (config.percentage >= 100)
+        return true;
+    if (!key)
+        return false; // Anonymous users cannot be deterministically bucketed
+    const bucket = getHashBucket(key, config.salt, config.buckets);
+    // Example: percentage 20 means buckets 0-19 are true, 20-99 are false
+    // For buckets=1000, percentage 20.5 means buckets 0-204 are true
+    const maxBucket = (config.percentage / 100) * (config.buckets || 100);
+    return bucket < maxBucket;
+}
+/**
+ * Returns a deterministic bucket number (default 0-99) for a given key and salt.
+ * Uses MurmurHash3 (32-bit).
+ */
+export function getHashBucket(key, salt = '', buckets = 100) {
+    const hash = murmurhash3(`${salt}:${key}`);
+    return hash % buckets;
+}
+/**
+ * Fast, pure-TypeScript implementation of MurmurHash3 (32-bit).
+ * Standard algorithm for deterministic feature flag bucket distribution.
+ */
+function murmurhash3(key, seed = 0) {
+    let h1b, k1;
+    let h1;
+    const remainder = key.length & 3;
+    const bytes = key.length - remainder;
+    h1 = seed;
+    const c1 = 0xcc9e2d51;
+    const c2 = 0x1b873593;
+    let i = 0;
+    while (i < bytes) {
+        k1 =
+            ((key.charCodeAt(i) & 0xff)) |
+                ((key.charCodeAt(++i) & 0xff) << 8) |
+                ((key.charCodeAt(++i) & 0xff) << 16) |
+                ((key.charCodeAt(++i) & 0xff) << 24);
+        ++i;
+        k1 = ((((k1 & 0xffff) * c1) + ((((k1 >>> 16) * c1) & 0xffff) << 16))) & 0xffffffff;
+        k1 = (k1 << 15) | (k1 >>> 17);
+        k1 = ((((k1 & 0xffff) * c2) + ((((k1 >>> 16) * c2) & 0xffff) << 16))) & 0xffffffff;
+        h1 ^= k1;
+        h1 = (h1 << 13) | (h1 >>> 19);
+        h1b = ((((h1 & 0xffff) * 5) + ((((h1 >>> 16) * 5) & 0xffff) << 16))) & 0xffffffff;
+        h1 = (((h1b & 0xffff) + 0x6b64) + ((((h1b >>> 16) + 0xe654) & 0xffff) << 16));
+    }
+    k1 = 0;
+    switch (remainder) {
+        case 3: k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
+        case 2: k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
+        case 1:
+            k1 ^= (key.charCodeAt(i) & 0xff);
+            k1 = (((k1 & 0xffff) * c1) + ((((k1 >>> 16) * c1) & 0xffff) << 16)) & 0xffffffff;
+            k1 = (k1 << 15) | (k1 >>> 17);
+            k1 = (((k1 & 0xffff) * c2) + ((((k1 >>> 16) * c2) & 0xffff) << 16)) & 0xffffffff;
+            h1 ^= k1;
+    }
+    h1 ^= key.length;
+    h1 ^= h1 >>> 16;
+    h1 = (((h1 & 0xffff) * 0x85ebca6b) + ((((h1 >>> 16) * 0x85ebca6b) & 0xffff) << 16)) & 0xffffffff;
+    h1 ^= h1 >>> 13;
+    h1 = (((h1 & 0xffff) * 0xc2b2ae35) + ((((h1 >>> 16) * 0xc2b2ae35) & 0xffff) << 16)) & 0xffffffff;
+    h1 ^= h1 >>> 16;
+    return h1 >>> 0;
+}

package/dist/shared/streaming.d.ts

@@ -0,0 +1,35 @@
+import { StreamingConfig, ILogger } from './types';
+import { EventEmitter } from './event-emitter';
+/**
+ * Server-Sent Events (SSE) client for real-time feature flag updates.
+ */
+export declare class FlagStreamClient {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private eventSource;
+    private readonly config;
+    private readonly logger;
+    private readonly events;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private disposed;
+    constructor(baseUrl: string, apiKey: string | undefined, config: StreamingConfig, logger: ILogger, events: EventEmitter);
+    /**
+     * Connect to the SSE endpoint.
+     */
+    connect(): void;
+    private handleUpdateEvent;
+    private scheduleReconnect;
+    /**
+     * Disconnect the stream. Automatically reconnects won't trigger unless connect() is called again.
+     */
+    disconnect(): void;
+    /**
+     * Checks if the stream is currently connected.
+     */
+    isConnected(): boolean;
+    /**
+     * Permanently dispose of the stream client.
+     */
+    dispose(): void;
+}

package/dist/shared/streaming.js

@@ -0,0 +1,117 @@
+/**
+ * Server-Sent Events (SSE) client for real-time feature flag updates.
+ */
+export class FlagStreamClient {
+    constructor(baseUrl, apiKey, config, logger, events) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+        this.eventSource = null;
+        this.reconnectAttempts = 0;
+        this.reconnectTimer = null;
+        this.disposed = false;
+        this.handleUpdateEvent = (event) => {
+            try {
+                const data = JSON.parse(event.data);
+                this.logger.debug('Received stream update', data);
+                // Invalidate cache natively inside the client via events
+                this.events.emit('flagsUpdated', { source: 'stream', count: 1 });
+            }
+            catch (e) {
+                this.logger.error('Failed to parse SSE message', event.data);
+            }
+        };
+        this.config = {
+            reconnectDelayMs: 1000,
+            maxReconnectDelayMs: 30000,
+            ...config,
+        };
+        this.logger = logger;
+        this.events = events;
+    }
+    /**
+     * Connect to the SSE endpoint.
+     */
+    connect() {
+        if (this.disposed)
+            return;
+        if (this.eventSource)
+            return; // Already connected
+        const url = this.config.url || `${this.baseUrl}/feature-flags/stream`;
+        try {
+            // In browser or Node with EventSource polyfill
+            if (typeof EventSource !== 'undefined') {
+                const urlWithAuth = this.apiKey ? `${url}?apiKey=${this.apiKey}` : url;
+                this.eventSource = new EventSource(urlWithAuth);
+                this.eventSource.onopen = () => {
+                    this.logger.info(`Stream connected to ${url}`);
+                    this.reconnectAttempts = 0; // Reset backoff
+                    this.events.emit('streamConnected', undefined);
+                };
+                this.eventSource.onerror = (err) => {
+                    this.logger.warn(`Stream error, reconnecting...`, err);
+                    this.scheduleReconnect();
+                };
+                // Listen for specific SSE events (requires type assertion due to DOM lib typings missing in some envs)
+                /* eslint-disable @typescript-eslint/no-explicit-any */
+                this.eventSource.addEventListener('flag.updated', this.handleUpdateEvent);
+                this.eventSource.addEventListener('flag.created', this.handleUpdateEvent);
+                this.eventSource.addEventListener('flag.deleted', this.handleUpdateEvent);
+                this.eventSource.addEventListener('message', this.handleUpdateEvent); // Fallback generic message
+                /* eslint-enable @typescript-eslint/no-explicit-any */
+            }
+            else {
+                this.logger.warn('EventSource is not available in this environment, streaming disabled.');
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to initialize EventSource:', error);
+            this.scheduleReconnect();
+        }
+    }
+    scheduleReconnect() {
+        this.disconnect();
+        if (this.disposed)
+            return;
+        this.reconnectAttempts++;
+        const baseDelay = this.config.reconnectDelayMs || 1000;
+        const maxDelay = this.config.maxReconnectDelayMs || 30000;
+        // Exponential backoff with jitter
+        const delay = Math.min(baseDelay * Math.pow(2, this.reconnectAttempts), maxDelay);
+        const jitter = Math.random() * 1000;
+        const actualDelay = delay + jitter;
+        this.logger.info(`Scheduling stream reconnect in ${Math.round(actualDelay)}ms (attempt ${this.reconnectAttempts})`);
+        this.reconnectTimer = setTimeout(() => {
+            this.connect();
+        }, actualDelay);
+    }
+    /**
+     * Disconnect the stream. Automatically reconnects won't trigger unless connect() is called again.
+     */
+    disconnect() {
+        if (this.eventSource) {
+            this.eventSource.close();
+            this.eventSource = null;
+            this.events.emit('streamDisconnected', { error: undefined });
+            this.logger.info('Stream disconnected');
+        }
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    /**
+     * Checks if the stream is currently connected.
+     */
+    isConnected() {
+        if (typeof EventSource === 'undefined')
+            return false;
+        return this.eventSource?.readyState === EventSource.OPEN;
+    }
+    /**
+     * Permanently dispose of the stream client.
+     */
+    dispose() {
+        this.disposed = true;
+        this.disconnect();
+    }
+}

package/dist/shared/targeting.d.ts

@@ -0,0 +1,10 @@
+import { EvaluationContext, FlagValue, TargetingRule } from './types';
+/**
+ * Evaluates a set of targeting rules against an evaluation context.
+ * Returns the value of the first matching rule, or null if no rules match.
+ */
+export declare function evaluateRules(rules: TargetingRule[] | undefined, context: EvaluationContext | undefined): FlagValue | null;
+/**
+ * Evaluates a single rule. A rule matches if ALL its conditions match (AND logic).
+ */
+export declare function evaluateRule(rule: TargetingRule, context: EvaluationContext | undefined): boolean;

package/dist/shared/targeting.js

@@ -0,0 +1,133 @@
+/**
+ * Evaluates a set of targeting rules against an evaluation context.
+ * Returns the value of the first matching rule, or null if no rules match.
+ */
+export function evaluateRules(rules, context) {
+    if (!rules || rules.length === 0)
+        return null;
+    // Sort by priority (lower number = higher priority / evaluated first)
+    const sortedRules = [...rules].sort((a, b) => a.priority - b.priority);
+    for (const rule of sortedRules) {
+        if (evaluateRule(rule, context)) {
+            // NOTE: Rollout percentage within a rule is evaluated separately by the rollout engine.
+            // If a rule matches, its value is the candidate. 
+            return rule.value;
+        }
+    }
+    return null;
+}
+/**
+ * Evaluates a single rule. A rule matches if ALL its conditions match (AND logic).
+ */
+export function evaluateRule(rule, context) {
+    if (!rule.conditions || rule.conditions.length === 0) {
+        return true; // Empty conditions match everyone
+    }
+    for (const condition of rule.conditions) {
+        if (!evaluateCondition(condition, context)) {
+            return false; // ANY condition fails -> rule fails
+        }
+    }
+    return true; // ALL conditions matched
+}
+/**
+ * Evaluates a single condition against the context.
+ */
+function evaluateCondition(condition, context) {
+    const { attribute, operator, value: targetValue } = condition;
+    const contextValue = getContextAttribute(attribute, context);
+    if (contextValue === undefined && operator !== 'not_equals' && operator !== 'not_contains' && operator !== 'not_in') {
+        return false; // Missing attribute fails most checks
+    }
+    switch (operator) {
+        case 'equals':
+            return String(contextValue) === String(targetValue);
+        case 'not_equals':
+            return String(contextValue) !== String(targetValue);
+        case 'contains':
+            return typeof contextValue === 'string' && String(targetValue) !== '' && contextValue.includes(String(targetValue));
+        case 'not_contains':
+            return typeof contextValue !== 'string' || String(targetValue) === '' || !contextValue.includes(String(targetValue));
+        case 'starts_with':
+            return typeof contextValue === 'string' && String(targetValue) !== '' && contextValue.startsWith(String(targetValue));
+        case 'ends_with':
+            return typeof contextValue === 'string' && String(targetValue) !== '' && contextValue.endsWith(String(targetValue));
+        case 'in':
+            return Array.isArray(targetValue) && targetValue.map(String).includes(String(contextValue));
+        case 'not_in':
+            return !Array.isArray(targetValue) || !targetValue.map(String).includes(String(contextValue));
+        case 'gt':
+            return isNumeric(contextValue) && isNumeric(targetValue) && Number(contextValue) > Number(targetValue);
+        case 'gte':
+            return isNumeric(contextValue) && isNumeric(targetValue) && Number(contextValue) >= Number(targetValue);
+        case 'lt':
+            return isNumeric(contextValue) && isNumeric(targetValue) && Number(contextValue) < Number(targetValue);
+        case 'lte':
+            return isNumeric(contextValue) && isNumeric(targetValue) && Number(contextValue) <= Number(targetValue);
+        case 'regex':
+            try {
+                const regex = new RegExp(String(targetValue));
+                return typeof contextValue === 'string' && regex.test(contextValue);
+            }
+            catch (e) {
+                return false; // Invalid regex fails
+            }
+        case 'semver_eq':
+        case 'semver_gt':
+        case 'semver_lt':
+            return compareSemver(String(contextValue), String(targetValue), operator);
+        default:
+            return false; // Unknown operator fails
+    }
+}
+/**
+ * Extracts an attribute from the context.
+ * Supports special top-level attributes like 'userId' and 'workspaceId'.
+ */
+function getContextAttribute(attribute, context) {
+    if (!context)
+        return undefined;
+    if (attribute === 'userId')
+        return context.userId;
+    if (attribute === 'workspaceId')
+        return context.workspaceId;
+    return context.attributes?.[attribute];
+}
+/**
+ * Checks if a value is numeric.
+ */
+function isNumeric(value) {
+    if (typeof value === 'number')
+        return true;
+    if (typeof value === 'string')
+        return value.trim() !== '' && !Number.isNaN(Number(value));
+    return false;
+}
+/**
+ * Basic semantic version comparison.
+ * Note: Assumes standard x.y.z format without prerelease tags for simplicity in this lightweight implementation.
+ */
+function compareSemver(v1, v2, operator) {
+    if (typeof v1 !== 'string' || typeof v2 !== 'string')
+        return false;
+    const parts1 = v1.split('.').map(Number);
+    const parts2 = v2.split('.').map(Number);
+    // Pad arrays to same length
+    const maxLength = Math.max(parts1.length, parts2.length);
+    for (let i = 0; i < maxLength; i++) {
+        const p1 = parts1[i] || 0;
+        const p2 = parts2[i] || 0;
+        if (p1 > p2)
+            return operator === 'semver_gt';
+        if (p1 < p2)
+            return operator === 'semver_lt';
+    }
+    // All parts equal numerically up to maxLength
+    // For exact match, strictly require identical structures or 0-padding equivalence
+    // We'll consider 2.0.0 and 2.0 NOT equal for strictness in rule targeting, 
+    // users should specify full versions.
+    if (operator === 'semver_eq') {
+        return parts1.length === parts2.length;
+    }
+    return false;
+}

package/dist/shared/types.d.ts

@@ -0,0 +1,248 @@
+/**
+ * Supported flag value types for multi-variant flags
+ */
+export type FlagValue = boolean | string | number | Record<string, unknown>;
+/**
+ * Feature flag definition
+ */
+export interface FeatureFlag {
+    id: string;
+    slug: string;
+    name: string;
+    description?: string;
+    category: 'frontend' | 'backend' | 'both';
+    defaultValue: FlagValue;
+    valueType: FlagValueType;
+    targetServices?: string[];
+    tags?: string[];
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+    targetingRules?: TargetingRule[];
+    rollout?: RolloutConfig;
+    experiment?: Experiment;
+}
+/**
+ * Allowed value types for a flag
+ */
+export type FlagValueType = 'boolean' | 'string' | 'number' | 'json';
+/**
+ * Workspace-level override for a flag
+ */
+export interface WorkspaceFeatureFlag {
+    id: string;
+    workspaceId: string;
+    flagId: string;
+    value: FlagValue;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+    flag?: FeatureFlag;
+}
+export type TargetingOperator = 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'starts_with' | 'ends_with' | 'in' | 'not_in' | 'gt' | 'gte' | 'lt' | 'lte' | 'regex' | 'semver_gt' | 'semver_lt' | 'semver_eq';
+export interface TargetingCondition {
+    attribute: string;
+    operator: TargetingOperator;
+    value: string | number | boolean | string[];
+}
+export interface TargetingRule {
+    id: string;
+    priority: number;
+    conditions: TargetingCondition[];
+    value: FlagValue;
+    rolloutPercentage?: number;
+}
+export interface RolloutConfig {
+    percentage: number;
+    stickinessKey?: string;
+    salt?: string;
+    buckets?: number;
+}
+export interface Variation {
+    id: string;
+    value: FlagValue;
+    weight: number;
+}
+export interface Experiment {
+    id: string;
+    name?: string;
+    variations: Variation[];
+    stickinessKey?: string;
+    salt?: string;
+}
+export interface ExperimentAssignment {
+    experimentId: string;
+    variationId: string;
+    value: FlagValue;
+    context: EvaluationContext;
+}
+export type TrackingCallback = (assignment: ExperimentAssignment) => void;
+export interface StreamingConfig {
+    url?: string;
+    reconnectDelayMs?: number;
+    maxReconnectDelayMs?: number;
+}
+export interface FlagDocument {
+    flags: FeatureFlag[];
+    version: number;
+    fetchedAt: string;
+}
+export interface CreateFlagData {
+    slug: string;
+    name: string;
+    description?: string;
+    category: 'frontend' | 'backend' | 'both';
+    valueType?: FlagValueType;
+    defaultValue?: FlagValue;
+    targetServices?: string[];
+    tags?: string[];
+}
+export interface UpdateFlagData {
+    name?: string;
+    description?: string;
+    category?: 'frontend' | 'backend' | 'both';
+    defaultValue?: FlagValue;
+    targetServices?: string[];
+    tags?: string[];
+}
+export interface SetWorkspaceFlagData {
+    value: FlagValue;
+}
+/**
+ * Context passed during flag evaluation for targeting/segmentation
+ */
+export interface EvaluationContext {
+    workspaceId?: string;
+    userId?: string;
+    attributes?: Record<string, string | number | boolean>;
+}
+export interface FeatureFlagEvaluation {
+    slug: string;
+    value: FlagValue;
+    reason: EvaluationReason;
+    context?: EvaluationContext;
+    evaluatedAt: string;
+}
+export type EvaluationReason = 'DEFAULT' | 'WORKSPACE_OVERRIDE' | 'TARGETING_MATCH' | 'PERCENTAGE_ROLLOUT' | 'EXPERIMENT_ASSIGNMENT' | 'FALLBACK' | 'ERROR' | 'LOCAL_OVERRIDE' | 'CACHE_HIT';
+export interface BatchEvaluation {
+    flags: Record<string, FlagValue>;
+    context?: EvaluationContext;
+    evaluatedAt: string;
+}
+export interface FeatureFlagStats {
+    total: number;
+    byCategory: Record<string, number>;
+    byTargetService: Record<string, number>;
+    byValueType: Record<string, number>;
+    activeWorkspaces: number;
+}
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
+/**
+ * Injectable logger interface. Users can provide their own logger (e.g. pino, winston).
+ * Defaults to console-based logging.
+ */
+export interface ILogger {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+/**
+ * Circuit breaker configuration
+ */
+export interface CircuitBreakerConfig {
+    /** Number of consecutive failures before opening the circuit (default: 5) */
+    failureThreshold: number;
+    /** Time in ms to wait before attempting a request after circuit opens (default: 30000) */
+    resetTimeoutMs: number;
+}
+/**
+ * Retry configuration
+ */
+export interface RetryConfig {
+    /** Max number of retry attempts (default: 3) */
+    maxAttempts: number;
+    /** Base delay in ms between retries, doubles each attempt (default: 1000) */
+    baseDelayMs: number;
+    /** Max delay cap in ms (default: 10000) */
+    maxDelayMs: number;
+}
+/**
+ * Main SDK configuration
+ */
+export interface FeatureFlagsConfig {
+    /** Base URL of the feature flags API */
+    baseUrl: string;
+    /** Optional API key for authentication */
+    apiKey?: string;
+    /** HTTP request timeout in ms (default: 10000) */
+    timeout?: number;
+    /** Enable/disable in-memory cache (default: true) */
+    cacheEnabled?: boolean;
+    /** Cache TTL in ms (default: 60000) */
+    cacheTtlMs?: number;
+    /** Retry configuration */
+    retry?: Partial<RetryConfig>;
+    /** Circuit breaker configuration */
+    circuitBreaker?: Partial<CircuitBreakerConfig>;
+    /** Log level (default: 'warn') */
+    logLevel?: LogLevel;
+    /** Custom logger implementation */
+    logger?: ILogger;
+    /** Local flag overrides — useful for development/testing. These skip HTTP entirely. */
+    localOverrides?: Record<string, FlagValue>;
+    /** Default values when the server is unreachable and no cache exists */
+    fallbackDefaults?: Record<string, FlagValue>;
+    /** Configure SSE streaming for real-time updates */
+    streaming?: boolean | StreamingConfig;
+    /** Pass a flag document to enable Edge mode (offline local evaluation) */
+    edgeDocument?: FlagDocument;
+    /** Hook for A/B testing variable assignments */
+    trackingCallback?: TrackingCallback;
+}
+export type FeatureFlyEvent = 'flagEvaluated' | 'flagChanged' | 'cacheHit' | 'cacheMiss' | 'cacheCleared' | 'requestFailed' | 'circuitOpen' | 'circuitClosed' | 'circuitHalfOpen' | 'flagsUpdated' | 'streamConnected' | 'streamDisconnected' | 'experimentAssigned';
+export interface FlagEvaluatedPayload {
+    slug: string;
+    value: FlagValue;
+    reason: EvaluationReason;
+    durationMs: number;
+}
+export interface FlagChangedPayload {
+    slug: string;
+    previousValue: FlagValue;
+    newValue: FlagValue;
+}
+export interface RequestFailedPayload {
+    endpoint: string;
+    error: string;
+    attempt: number;
+}
+export interface CircuitStatePayload {
+    state: 'open' | 'closed' | 'half-open';
+    failures: number;
+}
+export type EventPayloadMap = {
+    flagEvaluated: FlagEvaluatedPayload;
+    flagChanged: FlagChangedPayload;
+    cacheHit: {
+        key: string;
+    };
+    cacheMiss: {
+        key: string;
+    };
+    cacheCleared: void;
+    requestFailed: RequestFailedPayload;
+    circuitOpen: CircuitStatePayload;
+    circuitClosed: CircuitStatePayload;
+    circuitHalfOpen: CircuitStatePayload;
+    flagsUpdated: {
+        source: 'stream' | 'fetch';
+        count: number;
+    };
+    streamConnected: void;
+    streamDisconnected: {
+        error?: Error;
+    };
+    experimentAssigned: ExperimentAssignment;
+};
+export type EventHandler<E extends FeatureFlyEvent> = (payload: EventPayloadMap[E]) => void;

package/dist/shared/types.js

@@ -0,0 +1,4 @@
+// ═══════════════════════════════════════════════════════════════════════════════
+// CORE TYPES
+// ═══════════════════════════════════════════════════════════════════════════════
+export {};

package/dist/vue/index.d.ts

@@ -0,0 +1,60 @@
+import { type Ref, type App } from 'vue';
+import type { FeatureFlagsClient } from '../shared/client';
+import type { EvaluationContext, FlagValue } from '../shared/types';
+/**
+ * Vue Plugin that provides the FeatureFlagsClient to the entire app.
+ *
+ * @example
+ * ```ts
+ * import { createApp } from 'vue';
+ * import { FeatureFlyPlugin } from 'featurefly/vue';
+ *
+ * const app = createApp(App);
+ * app.use(FeatureFlyPlugin, { client: featureFlyClient });
+ * ```
+ */
+export declare const FeatureFlyPlugin: {
+    install(app: App, options: {
+        client: FeatureFlagsClient;
+    }): void;
+};
+/**
+ * Vue composable for evaluating a single feature flag.
+ * Returns a reactive `Ref` that auto-updates on flag changes.
+ *
+ * @param slug Flag slug identifier
+ * @param defaultValue Default value while loading
+ * @param context Optional reactive evaluation context
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { useFeatureFlag } from 'featurefly/vue';
+ *
+ * const darkMode = useFeatureFlag('dark-mode', false);
+ * </script>
+ *
+ * <template>
+ *   <div :class="{ dark: darkMode.value }">...</div>
+ * </template>
+ * ```
+ */
+export declare function useFeatureFlag<T extends FlagValue = boolean>(slug: string, defaultValue: T, context?: Ref<EvaluationContext> | EvaluationContext): Ref<T>;
+/**
+ * Vue composable for batch-evaluating all feature flags.
+ * Returns a reactive `Ref<Record<string, FlagValue>>` that auto-updates.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { useAllFlags } from 'featurefly/vue';
+ *
+ * const flags = useAllFlags({ workspaceId: 'ws-123' });
+ * </script>
+ *
+ * <template>
+ *   <NewFeature v-if="flags['new-feature']" />
+ * </template>
+ * ```
+ */
+export declare function useAllFlags(context?: Ref<EvaluationContext> | EvaluationContext): Ref<Record<string, FlagValue>>;