@beeuni/sdk 0.1.0

package/dist/core/http/abort-error.js

@@ -0,0 +1,74 @@
+const ABORT_ERROR_NAMES = new Set(['AbortError', 'MessageAbortedError']);
+const ABORT_TEXT_PATTERNS = [
+    'operation was aborted',
+    'aborted by user',
+    'interrupted by user',
+    'cancelled by user',
+    'canceled by user',
+    'request was cancelled',
+    'request was canceled',
+    'aborterror',
+];
+const TRANSPORT_FAILURE_TEXT_PATTERNS = [
+    'unreachable',
+    'upstream',
+    'econnreset',
+    'econnrefused',
+    'socket hang up',
+    'network',
+    'fetch failed',
+    'timed out',
+    'timeout',
+    'gateway',
+    '502',
+    '503',
+    '504',
+];
+function looksLikeAbortText(text) {
+    const lower = text.toLowerCase();
+    if (TRANSPORT_FAILURE_TEXT_PATTERNS.some((p) => lower.includes(p)))
+        return false;
+    return ABORT_TEXT_PATTERNS.some((p) => lower.includes(p));
+}
+function nestedErrorText(rec) {
+    const data = rec.data;
+    const dataMessage = data && typeof data === 'object' ? data.message : undefined;
+    if (typeof dataMessage === 'string')
+        return dataMessage;
+    return typeof rec.message === 'string' ? rec.message : undefined;
+}
+export function isAbortError(error) {
+    if (typeof error === 'string')
+        return looksLikeAbortText(error);
+    if (!error || typeof error !== 'object')
+        return false;
+    const rec = error;
+    const name = rec.name;
+    if (typeof name === 'string' && ABORT_ERROR_NAMES.has(name))
+        return true;
+    const text = nestedErrorText(rec);
+    return typeof text === 'string' ? looksLikeAbortText(text) : false;
+}
+export const ABORT_REASONS = [
+    'user',
+    'runtime-disposed',
+    'orphan-finalized',
+    'wake',
+];
+export const ABORT_REASONS_NOT_YET_EMITTED = [
+    'orphan-finalized',
+    'wake',
+];
+export function abortErrorReason(error) {
+    if (!error || typeof error !== 'object')
+        return undefined;
+    const data = error.data;
+    if (!data || typeof data !== 'object')
+        return undefined;
+    const reason = data.reason;
+    if (typeof reason !== 'string' || !reason)
+        return undefined;
+    return ABORT_REASONS.includes(reason)
+        ? reason
+        : undefined;
+}

package/dist/core/http/abort.d.ts

@@ -0,0 +1,3 @@
+export declare function createAbortError(): Error;
+export declare function abortable<T>(work: Promise<T>, signal: AbortSignal): Promise<T>;
+export declare function abortableDelay(milliseconds: number, signal?: AbortSignal): Promise<void>;

package/dist/core/http/abort.js

@@ -0,0 +1,34 @@
+export function createAbortError() {
+    if (typeof DOMException === 'function')
+        return new DOMException('Aborted', 'AbortError');
+    return Object.assign(new Error('Aborted'), { name: 'AbortError' });
+}
+export function abortable(work, signal) {
+    return new Promise((resolve, reject) => {
+        const abort = () => {
+            signal.removeEventListener('abort', abort);
+            reject(createAbortError());
+        };
+        signal.addEventListener('abort', abort, { once: true });
+        work.then(resolve, reject).finally(() => signal.removeEventListener('abort', abort));
+        if (signal.aborted)
+            abort();
+    });
+}
+export function abortableDelay(milliseconds, signal) {
+    return new Promise((resolve, reject) => {
+        const abort = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', abort);
+            reject(createAbortError());
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', abort);
+            resolve();
+        }, milliseconds);
+        if (signal?.aborted)
+            abort();
+        else
+            signal?.addEventListener('abort', abort, { once: true });
+    });
+}

package/dist/core/http/api/errors.d.ts

@@ -0,0 +1,68 @@
+export interface ApiErrorFields {
+    status?: number;
+    code?: string;
+    details?: any;
+    data?: any;
+    detail?: any;
+    response?: Response;
+    url?: string;
+    endpoint?: string;
+    timeout?: number;
+    name?: string;
+    stack?: string;
+}
+export declare class ApiError extends Error {
+    status?: number;
+    code?: string;
+    details?: any;
+    data?: any;
+    detail?: any;
+    response?: Response;
+    url?: string;
+    endpoint?: string;
+    timeout?: number;
+    constructor(message: string, fields?: ApiErrorFields);
+}
+export declare class AuthError extends ApiError {
+    constructor(message?: string);
+}
+export declare class BillingError extends ApiError {
+    status: number;
+    detail: {
+        message: string;
+        [key: string]: any;
+    };
+    constructor(status: number, detail: {
+        message: string;
+        [key: string]: any;
+    }, message?: string, fields?: Omit<ApiErrorFields, 'status' | 'detail'>);
+}
+export declare class RequestTooLargeError extends ApiError {
+    status: number;
+    detail: {
+        message: string;
+        suggestion: string;
+    };
+    constructor(status?: number, detail?: {
+        message?: string;
+        suggestion?: string;
+    }, message?: string);
+}
+export declare const ENDPOINT_RETIRED_CODE = "ENDPOINT_RETIRED";
+export declare function retiredEndpointError(name: string, instead?: string): ApiError;
+export declare const FEATURE_DISABLED_CODE: "feature_disabled";
+export interface FeatureDisabledError extends ApiError {
+    status: 403;
+    code: typeof FEATURE_DISABLED_CODE;
+    feature: string;
+}
+export declare function isFeatureDisabledError(error: unknown): error is FeatureDisabledError;
+export declare function featureDisabledKey(error: unknown): string | null;
+export declare function parseBillingError(error: any): Error;
+export declare function isBillingError(error: any): boolean;
+export declare function isAuthFailure(error: unknown): boolean;
+export interface BillingErrorUI {
+    alertTitle: string;
+    alertSubtitle: string;
+}
+export declare function formatBillingErrorForUI(error: any): BillingErrorUI | null;

package/dist/core/http/api/errors.js

@@ -0,0 +1,132 @@
+export class ApiError extends Error {
+    status;
+    code;
+    details;
+    data;
+    detail;
+    response;
+    url;
+    endpoint;
+    timeout;
+    constructor(message, fields = {}) {
+        super(message);
+        this.name = 'ApiError';
+        const { name, stack, ...rest } = fields;
+        Object.assign(this, rest);
+        if (name)
+            this.name = name;
+        if (stack)
+            this.stack = stack;
+        const messageStr = typeof message === 'string' ? message : message == null ? '' : String(message);
+        Object.defineProperty(this, 'message', {
+            value: messageStr,
+            enumerable: true,
+            writable: true,
+            configurable: true,
+        });
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+export class AuthError extends ApiError {
+    constructor(message = 'Not authenticated') {
+        super(message, { code: 'NO_SESSION' });
+        this.name = 'AuthError';
+    }
+}
+export class BillingError extends ApiError {
+    constructor(status, detail, message, fields = {}) {
+        super(message || detail.message || `Billing Error: ${status}`, { ...fields, status, detail });
+        this.name = 'BillingError';
+    }
+}
+export class RequestTooLargeError extends ApiError {
+    constructor(status = 431, detail, message) {
+        const defaultMessage = 'Request headers are too large';
+        const defaultSuggestion = 'Try uploading files one at a time, or reduce the number of files in a single request.';
+        super(message || detail?.message || defaultMessage, {
+            status,
+            detail: {
+                message: detail?.message || defaultMessage,
+                suggestion: detail?.suggestion || defaultSuggestion,
+            },
+        });
+        this.name = 'RequestTooLargeError';
+    }
+}
+export const ENDPOINT_RETIRED_CODE = 'ENDPOINT_RETIRED';
+export function retiredEndpointError(name, instead) {
+    const hint = instead ? ` ${instead}` : '';
+    return new ApiError(`${name}() is retired: the Beeuni API no longer serves this endpoint.${hint}`, { code: ENDPOINT_RETIRED_CODE });
+}
+export const FEATURE_DISABLED_CODE = 'feature_disabled';
+function featureDisabledBody(error) {
+    if (!(error instanceof ApiError))
+        return null;
+    if (error.status !== 403 || error.code !== FEATURE_DISABLED_CODE)
+        return null;
+    const body = error.details ?? error.data;
+    return body && typeof body === 'object' ? body : {};
+}
+export function isFeatureDisabledError(error) {
+    const body = featureDisabledBody(error);
+    if (!body)
+        return false;
+    if (typeof body.feature === 'string' && !error.feature) {
+        error.feature = body.feature;
+    }
+    return true;
+}
+export function featureDisabledKey(error) {
+    const body = featureDisabledBody(error);
+    if (!body)
+        return null;
+    const fromError = error.feature;
+    if (typeof fromError === 'string')
+        return fromError;
+    return typeof body.feature === 'string' ? body.feature : null;
+}
+export function parseBillingError(error) {
+    const status = error.response?.status || error.status;
+    if (status !== 402)
+        return error;
+    const errorData = error.response?.data || error.data || error.detail || {};
+    const detail = errorData?.detail || errorData;
+    return new BillingError(status, {
+        message: detail?.message || error.message || 'Billing error',
+        ...detail,
+    }, undefined, {
+        code: error.code,
+        details: error.details,
+        data: error.data,
+        response: error.response,
+        url: error.url,
+        endpoint: error.endpoint,
+    });
+}
+export function isBillingError(error) {
+    return error instanceof BillingError;
+}
+export function isAuthFailure(error) {
+    if (error instanceof AuthError)
+        return true;
+    const status = error?.status;
+    return status === 401 || status === 403;
+}
+export function formatBillingErrorForUI(error) {
+    if (!(error instanceof BillingError))
+        return null;
+    const message = error.detail?.message?.toLowerCase() || '';
+    const isCreditsExhausted = message.includes('credit') ||
+        message.includes('balance') ||
+        message.includes('insufficient');
+    if (isCreditsExhausted) {
+        return {
+            alertTitle: 'You ran out of credits',
+            alertSubtitle: 'Upgrade your plan to get more credits and continue using the AI assistant.',
+        };
+    }
+    return {
+        alertTitle: 'Billing check failed',
+        alertSubtitle: error.detail?.message || 'Please upgrade to continue.',
+    };
+}

package/dist/core/http/api-client.d.ts

@@ -0,0 +1,44 @@
+import { ApiError } from './api/errors.js';
+export { isAdminBypassEnabled, setAdminBypass } from './transport.js';
+export { ApiError, AuthError, BillingError, RequestTooLargeError, parseBillingError, isAuthFailure, isBillingError, formatBillingErrorForUI, FEATURE_DISABLED_CODE, isFeatureDisabledError, featureDisabledKey, type ApiErrorFields, type BillingErrorUI, type FeatureDisabledError, } from './api/errors.js';
+export interface ErrorContext {
+    operation?: string;
+    resource?: string;
+    silent?: boolean;
+}
+export interface ApiClientOptions {
+    showErrors?: boolean;
+    errorContext?: ErrorContext;
+    timeout?: number;
+    deadlineCoversBody?: boolean;
+    fetch?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+}
+export interface ApiResponse<T = any> {
+    data?: T;
+    error?: ApiError;
+    success: boolean;
+    headers?: Headers;
+}
+export declare const FEATURE_NOT_SUPPORTED_CODE = "feature_not_supported";
+export declare const MODEL_NOT_SERVABLE_CODE = "model_not_servable";
+export declare const PROVISION_IN_FLIGHT_CODE = "provision_in_flight";
+export declare const ANALYTICS_UNAVAILABLE_CODE = "analytics_unavailable";
+export declare const ACCOUNTS_LIST_UNAVAILABLE_CODE = "accounts_list_unavailable";
+export declare const supabaseClient: {
+    execute<T = any>(queryFn: () => Promise<{
+        data: T | null;
+        error: any;
+    }>, errorContext?: ErrorContext): Promise<ApiResponse<T>>;
+};
+declare function postStream(endpoint: string, data: unknown, options?: ApiClientOptions): Promise<Response>;
+export declare const backendApi: {
+    putRaw: <T = any>(endpoint: string, body: BodyInit, options?: Omit<RequestInit & ApiClientOptions, "method" | "body">) => Promise<ApiResponse<T>>;
+    get: <T = any>(endpoint: string, options?: Omit<RequestInit & ApiClientOptions, "method" | "body">) => Promise<ApiResponse<T>>;
+    post: <T = any>(endpoint: string, data?: any, options?: Omit<RequestInit & ApiClientOptions, "method">) => Promise<ApiResponse<T>>;
+    put: <T = any>(endpoint: string, data?: any, options?: Omit<RequestInit & ApiClientOptions, "method">) => Promise<ApiResponse<T>>;
+    patch: <T = any>(endpoint: string, data?: any, options?: Omit<RequestInit & ApiClientOptions, "method">) => Promise<ApiResponse<T>>;
+    delete: <T = any>(endpoint: string, options?: Omit<RequestInit & ApiClientOptions, "method" | "body">) => Promise<ApiResponse<T>>;
+    upload: <T = any>(endpoint: string, formData: FormData, options?: Omit<RequestInit & ApiClientOptions, "method" | "body">) => Promise<ApiResponse<T>>;
+    uploadPut: <T = any>(endpoint: string, formData: FormData, options?: Omit<RequestInit & ApiClientOptions, "method" | "body">) => Promise<ApiResponse<T>>;
+    postStream: typeof postStream;
+};

package/dist/core/http/api-client.js

@@ -0,0 +1,121 @@
+import { syntheticUnauthenticatedResponse } from '../../platform/auth-core.js';
+import { ApiError, AuthError } from './api/errors.js';
+import { platformConfig } from './config.js';
+import { makeRequest } from './request.js';
+import { send } from './transport.js';
+export { isAdminBypassEnabled, setAdminBypass } from './transport.js';
+const getApiUrl = () => platformConfig().backendUrl || '';
+export { ApiError, AuthError, BillingError, RequestTooLargeError, parseBillingError, isAuthFailure, isBillingError, formatBillingErrorForUI, FEATURE_DISABLED_CODE, isFeatureDisabledError, featureDisabledKey, } from './api/errors.js';
+export const FEATURE_NOT_SUPPORTED_CODE = 'feature_not_supported';
+export const MODEL_NOT_SERVABLE_CODE = 'model_not_servable';
+export const PROVISION_IN_FLIGHT_CODE = 'provision_in_flight';
+export const ANALYTICS_UNAVAILABLE_CODE = 'analytics_unavailable';
+export const ACCOUNTS_LIST_UNAVAILABLE_CODE = 'accounts_list_unavailable';
+export const supabaseClient = {
+    async execute(queryFn, errorContext) {
+        try {
+            const { data, error } = await queryFn();
+            if (error) {
+                const apiError = new ApiError(error.message || 'Database error', {
+                    code: error.code,
+                    details: error,
+                });
+                platformConfig().onError?.(apiError, errorContext);
+                return {
+                    error: apiError,
+                    success: false,
+                };
+            }
+            return {
+                data: data,
+                success: true,
+            };
+        }
+        catch (error) {
+            const apiError = error instanceof Error
+                ? new ApiError(error.message, {
+                    name: error.name || 'ApiError',
+                    stack: error.stack,
+                })
+                : new ApiError(String(error));
+            platformConfig().onError?.(apiError, errorContext);
+            return {
+                error: apiError,
+                success: false,
+            };
+        }
+    },
+};
+async function postStream(endpoint, data, options = {}) {
+    const { timeout = 30000, fetch: fetchImpl } = options;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+        return await send(`${getApiUrl()}${endpoint}`, {
+            method: 'POST',
+            headers: { Accept: 'text/event-stream', 'Content-Type': 'application/json' },
+            body: JSON.stringify(data),
+            signal: controller.signal,
+            credentials: 'omit',
+        }, { timeoutMs: null, fetch: fetchImpl });
+    }
+    catch (error) {
+        if (error instanceof AuthError)
+            return syntheticUnauthenticatedResponse();
+        throw error;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+export const backendApi = {
+    putRaw: (endpoint, body, options) => makeRequest(`${getApiUrl()}${endpoint}`, {
+        ...options,
+        method: 'PUT',
+        body,
+        headers: { 'Content-Type': 'application/octet-stream', ...options?.headers },
+    }),
+    get: (endpoint, options) => makeRequest(`${getApiUrl()}${endpoint}`, { ...options, method: 'GET' }),
+    post: (endpoint, data, options) => makeRequest(`${getApiUrl()}${endpoint}`, {
+        ...options,
+        method: 'POST',
+        body: data ? JSON.stringify(data) : undefined,
+    }),
+    put: (endpoint, data, options) => makeRequest(`${getApiUrl()}${endpoint}`, {
+        ...options,
+        method: 'PUT',
+        body: data ? JSON.stringify(data) : undefined,
+    }),
+    patch: (endpoint, data, options) => makeRequest(`${getApiUrl()}${endpoint}`, {
+        ...options,
+        method: 'PATCH',
+        body: data ? JSON.stringify(data) : undefined,
+    }),
+    delete: (endpoint, options) => makeRequest(`${getApiUrl()}${endpoint}`, {
+        ...options,
+        method: 'DELETE',
+    }),
+    upload: (endpoint, formData, options) => {
+        const { headers, ...restOptions } = options || {};
+        const uploadHeaders = { ...headers };
+        delete uploadHeaders['Content-Type'];
+        return makeRequest(`${getApiUrl()}${endpoint}`, {
+            ...restOptions,
+            method: 'POST',
+            body: formData,
+            headers: uploadHeaders,
+        });
+    },
+    uploadPut: (endpoint, formData, options) => {
+        const { headers, ...restOptions } = options || {};
+        const uploadHeaders = { ...headers };
+        delete uploadHeaders['Content-Type'];
+        return makeRequest(`${getApiUrl()}${endpoint}`, {
+            ...restOptions,
+            method: 'PUT',
+            body: formData,
+            headers: uploadHeaders,
+        });
+    },
+    postStream,
+};

package/dist/core/http/auth.d.ts

@@ -0,0 +1,12 @@
+import { type TokenRetryOptions } from '../../platform/auth-core.js';
+export declare function getSupabaseAccessToken(): Promise<string | null>;
+export declare function getSupabaseAccessTokenWithRetry(options?: TokenRetryOptions): Promise<string | null>;
+export declare function invalidateTokenCache(): void;
+export declare function setCachedAuthToken(token: string | null): void;
+export declare function setBootstrapAuthToken(_token: string | null): void;
+export declare function getAuthToken(): Promise<string | null>;
+export declare function getAuthTokenWithRetry(options?: TokenRetryOptions): Promise<string | null>;
+export declare function authenticatedFetch(input: RequestInfo | URL, init?: RequestInit, options?: {
+    retryOnAuthError?: boolean;
+    timeoutMs?: number | null;
+}): Promise<Response>;

package/dist/core/http/auth.js

@@ -0,0 +1,37 @@
+import { syntheticUnauthenticatedResponse, withTokenRetry, } from '../../platform/auth-core.js';
+import { AuthError } from './api/errors.js';
+import { platformConfig } from './config.js';
+import { hostToken, invalidateHostToken, send } from './transport.js';
+export async function getSupabaseAccessToken() {
+    return hostToken();
+}
+export async function getSupabaseAccessTokenWithRetry(options) {
+    return withTokenRetry(() => platformConfig().getToken(), options, invalidateTokenCache);
+}
+export function invalidateTokenCache() {
+    invalidateHostToken();
+}
+export function setCachedAuthToken(token) {
+    if (token === null)
+        invalidateHostToken();
+}
+export function setBootstrapAuthToken(_token) { }
+export async function getAuthToken() {
+    return getSupabaseAccessToken();
+}
+export async function getAuthTokenWithRetry(options) {
+    return getSupabaseAccessTokenWithRetry(options);
+}
+export async function authenticatedFetch(input, init, options) {
+    try {
+        return await send(input, init, {
+            retryOnAuthError: options?.retryOnAuthError,
+            timeoutMs: options?.timeoutMs,
+        });
+    }
+    catch (error) {
+        if (error instanceof AuthError)
+            return syntheticUnauthenticatedResponse();
+        throw error;
+    }
+}

package/dist/core/http/authenticated-request.d.ts

@@ -0,0 +1,5 @@
+export interface AuthenticatedRequest {
+    url: string;
+    headers: Record<string, string>;
+}
+export declare function authenticatedRequest(url: string): Promise<AuthenticatedRequest>;

package/dist/core/http/authenticated-request.js

@@ -0,0 +1,11 @@
+import { platformConfig } from './config.js';
+import { platformRequestHeaders } from './transport.js';
+export async function authenticatedRequest(url) {
+    const backend = new URL(platformConfig().backendUrl, globalThis.location?.href);
+    const target = new URL(url);
+    if (target.origin !== backend.origin) {
+        throw new Error(`Refusing to attach credentials to a URL outside the Beeuni backend: ${target.origin}`);
+    }
+    const { headers } = await platformRequestHeaders(url);
+    return { url, headers: Object.fromEntries(headers.entries()) };
+}

package/dist/core/http/config.d.ts

@@ -0,0 +1,35 @@
+import type { RuntimeEventTransport } from '../runtime/runtime-rest-client.js';
+export interface BeeuniFeatureFlagOverrides {
+    disableMobileAdvertising?: boolean;
+    enableDinoGame?: boolean;
+    enableProjects?: boolean;
+    enableAutoModel?: boolean;
+}
+export interface BeeuniPlatformConfig {
+    backendUrl: string;
+    getToken: (() => Promise<string | null>) & {
+        invalidate?: (rejectedToken: string) => void;
+    };
+    fetch?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+    eventStreamTransport?: RuntimeEventTransport;
+    clientSource?: 'api' | 'cli' | 'mobile' | 'tui' | 'web';
+    clientVersion?: string;
+    onError?: (error: unknown, context?: unknown) => void;
+    sandboxId?: string | null;
+    billingEnabled?: boolean;
+    getUserId?: () => Promise<string | null>;
+    onToast?: (level: 'info' | 'success' | 'error' | 'warning', message: string, options?: unknown) => void;
+    onNotify?: (event: {
+        kind: string;
+        sessionId: string;
+        [key: string]: unknown;
+    }) => void;
+    featureFlags?: BeeuniFeatureFlagOverrides;
+}
+export declare function __setConfigResolver(fn: (() => BeeuniPlatformConfig | undefined) | null): void;
+export declare function __getConfigResolver(): (() => BeeuniPlatformConfig | undefined) | null;
+export declare function configureBeeuni(config: BeeuniPlatformConfig, opts?: {
+    global?: boolean;
+}): void;
+export declare function platformConfig(): BeeuniPlatformConfig;
+export declare function isConfigured(): boolean;

package/dist/core/http/config.js

@@ -0,0 +1,23 @@
+const DEFAULT = {
+    backendUrl: '',
+    getToken: async () => null,
+};
+let current = null;
+let configResolver = null;
+export function __setConfigResolver(fn) {
+    configResolver = fn;
+}
+export function __getConfigResolver() {
+    return configResolver;
+}
+export function configureBeeuni(config, opts) {
+    if (opts?.global === false)
+        return;
+    current = config;
+}
+export function platformConfig() {
+    return configResolver?.() ?? current ?? DEFAULT;
+}
+export function isConfigured() {
+    return current !== null || configResolver?.() !== undefined;
+}

package/dist/core/http/env.d.ts

@@ -0,0 +1 @@
+export declare function safeEnv(name: string): string | undefined;

package/dist/core/http/env.js

@@ -0,0 +1,8 @@
+export function safeEnv(name) {
+    try {
+        return typeof process !== 'undefined' ? process.env?.[name] : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/core/http/feature-flags.d.ts

@@ -0,0 +1,8 @@
+export declare function parseFlagOverride(value: string | undefined): boolean | undefined;
+export interface FeatureFlags {
+    disableMobileAdvertising: boolean;
+    enableDinoGame: boolean;
+    enableProjects: boolean;
+    enableAutoModel: boolean;
+}
+export declare const featureFlags: FeatureFlags;

package/dist/core/http/feature-flags.js

@@ -0,0 +1,41 @@
+import { platformConfig } from './config.js';
+import { safeEnv } from './env.js';
+function parseEnvBoolean(value, defaultValue) {
+    if (value == null)
+        return defaultValue;
+    const normalized = value.trim().toLowerCase();
+    if (['1', 'true', 'yes', 'y', 'on'].includes(normalized))
+        return true;
+    if (['0', 'false', 'no', 'n', 'off'].includes(normalized))
+        return false;
+    return defaultValue;
+}
+export function parseFlagOverride(value) {
+    if (value == null)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (['1', 'true', 'yes', 'y', 'on'].includes(normalized))
+        return true;
+    if (['0', 'false', 'no', 'n', 'off'].includes(normalized))
+        return false;
+    return undefined;
+}
+function resolveFlag(override, envName, defaultValue) {
+    if (override !== undefined)
+        return override;
+    return parseEnvBoolean(safeEnv(envName), defaultValue);
+}
+export const featureFlags = {
+    get disableMobileAdvertising() {
+        return resolveFlag(platformConfig().featureFlags?.disableMobileAdvertising, 'NEXT_PUBLIC_DISABLE_MOBILE_ADVERTISING', false);
+    },
+    get enableDinoGame() {
+        return resolveFlag(platformConfig().featureFlags?.enableDinoGame, 'NEXT_PUBLIC_ENABLE_DINO_GAME', false);
+    },
+    get enableProjects() {
+        return resolveFlag(platformConfig().featureFlags?.enableProjects, 'NEXT_PUBLIC_ENABLE_PROJECTS', false);
+    },
+    get enableAutoModel() {
+        return false;
+    },
+};