@llmnative/react 0.1.1 → 1.0.0

package/dist/types/src/providers/data/supabase.d.ts

@@ -1,19 +1,45 @@
-import { DataProviderAdapter, DatabaseOptions, ReadOptions, RecordArray } from "./DataProvider";
-import { type ProviderConfigurationState } from "../ProviderConfiguration";
-interface SupabaseConfig {
+import { DataProviderAdapter, DatabaseOptions, ReadOptions, SetChunksOptions, RecordArray } from './DataProvider';
+import type { ProviderConfigurationState } from '../ProviderConfiguration';
+export interface SupabaseDataConfig {
     url: string;
     anonKey: string;
+    /**
+     * Name of the primary-key column in every Supabase table.
+     * Default: 'id'. Must be a text/uuid column.
+     */
+    primaryKey?: string;
+    /**
+     * Tenant-session JWT signed by the control-plane, scoped to this project.
+     * When present, the adapter uses an uncached, disposable client with this
+     * bearer token instead of the shared single-project client — see
+     * createSupabaseClient() in supabase-init.ts.
+     */
+    accessToken?: string;
 }
 export declare class SupabaseDataProvider implements DataProviderAdapter {
     private config;
-    constructor(config: SupabaseConfig);
+    private get pk();
+    private scopedClient;
+    private get client();
+    constructor(config: SupabaseDataConfig);
+    /** Force-closes any realtime channels left open before this adapter is discarded. No-op for the shared (non-scoped) client. */
+    dispose: () => Promise<void>;
     getConfigurationState(): ProviderConfigurationState;
     isConfigured(): boolean;
-    read: (path: string, _options?: ReadOptions) => Promise<any>;
-    set: (path: string, data: object) => Promise<void>;
-    update: (path: string, data: object) => Promise<void>;
-    remove: (path: string) => Promise<void>;
-    subscribe: (path: string | undefined, setRecords: (records: RecordArray) => void, _options?: DatabaseOptions) => (() => void);
+    read: (path: string, options?: ReadOptions) => Promise<any>;
+    set: (path: string, data: object, exception?: boolean) => Promise<void>;
+    update: (path: string, data: object, exception?: boolean) => Promise<void>;
+    remove: (path: string, exception?: boolean) => Promise<void>;
+    /**
+     * Real-time subscription via Supabase Postgres Changes.
+     * Requires the table to have Realtime enabled in the Supabase dashboard.
+     * Falls back gracefully if the channel cannot be created.
+     */
+    subscribe: (path: string | undefined, setRecords: (records: RecordArray) => void, options?: DatabaseOptions) => (() => void);
     count: (path: string) => Promise<number>;
+    /**
+     * Writes a large dataset in batches.
+     * If opts.purge = true, deletes all existing rows before writing.
+     */
+    setChunks: (path: string, data: object, opts?: SetChunksOptions) => Promise<void>;
 }
-export {};

package/dist/types/src/providers/firebase-init.d.ts

@@ -1,10 +1,21 @@
-import firebase from "firebase/compat/app";
-import 'firebase/compat/database';
-import { Auth } from "firebase/auth";
+import { type FirebaseApp } from 'firebase/app';
+import { type Auth } from "firebase/auth";
 import { FirebaseConfig } from "../Config";
 import { type ProviderConfigurationState } from "./ProviderConfiguration";
 export declare const setFirebaseConfigState: (config: FirebaseConfig | undefined) => void;
 export declare const getFirebaseConfigurationState: () => ProviderConfigurationState;
+export declare const getFirestoreConfigurationState: () => ProviderConfigurationState;
 export declare const getSafeAuth: () => Auth | null;
-declare const init: (config: FirebaseConfig) => Promise<firebase.app.App>;
+export declare const getFirebaseAuthorization: () => Promise<boolean>;
+/**
+ * Signs into the currently-initialized Firebase app using a custom token minted
+ * server-side (Admin SDK createCustomToken()) and scoped to a specific project —
+ * the multi-tenant session-switch path, distinct from the Google-login flow above.
+ *
+ * Forces in-memory persistence: this session must never survive a reload or be
+ * written to IndexedDB/localStorage by the SDK's default persistence behavior.
+ * Call init(config) to point the app at the right project *before* calling this.
+ */
+export declare const signInWithFirebaseCustomToken: (token: string) => Promise<boolean>;
+declare const init: (config: FirebaseConfig) => Promise<FirebaseApp>;
 export default init;

package/dist/types/src/providers/icon/PhosphorIconProvider.d.ts

@@ -2,7 +2,7 @@ import React from 'react';
 import type { IconProviderAdapter, IconComponentProps } from './IconProvider';
 export type PhosphorWeight = 'thin' | 'light' | 'regular' | 'bold' | 'fill' | 'duotone';
 export declare class PhosphorIconProvider implements IconProviderAdapter {
-    private readonly weight;
+    weight: PhosphorWeight;
     readonly id: "phosphor";
     private readonly _cache;
     constructor(weight?: PhosphorWeight);

package/dist/types/src/providers/manifest.d.ts

@@ -1,25 +1,26 @@
+import type { CredentialsAdapter } from './credentials/CredentialsProvider';
 import { MockDataProvider } from './data/mock';
+import type { AIProviderAdapter } from './ai/AIProvider';
 import type { DataProviderAdapter } from './data/DataProvider';
 import type { StorageProviderAdapter } from './storage/StorageProvider';
 import type { AuthProviderAdapter } from './auth/AuthProvider';
 import type { EmailProviderAdapter } from './email/EmailProvider';
-import type { DropboxConfig, FirebaseConfig, GoogleOAuth2, GoogleServiceAccount } from '../Config';
-export type ServiceCategory = 'data' | 'storage' | 'auth' | 'email';
-type AnyAdapter = DataProviderAdapter | StorageProviderAdapter | AuthProviderAdapter | EmailProviderAdapter;
+import type { AIConfig, DropboxConfig, FirebaseConfig, GoogleOAuth2, GoogleServiceAccount, SupabaseConfig } from '../Config';
+import type { ProviderService } from './ProviderRegistryContext';
+/** The 6 built-in categories — alias of ProviderService (ProviderRegistryContext.tsx), derived from ProviderAdapterMap so the two can't drift. */
+export type ServiceCategory = ProviderService;
+type AnyAdapter = DataProviderAdapter | StorageProviderAdapter | AuthProviderAdapter | EmailProviderAdapter | AIProviderAdapter | CredentialsAdapter;
 export interface DriverDescriptor<TConfig = unknown> {
     service: ServiceCategory;
     create: (config: TConfig) => AnyAdapter;
+    when?: (config: TConfig) => boolean;
 }
 export type DriverManifest<TConfig> = Record<string, DriverDescriptor<TConfig>>;
 export type GoogleProviderConfig = GoogleOAuth2 & {
     serviceAccount?: GoogleServiceAccount;
     developerToken?: string;
 };
-export type SupabaseProviderConfig = {
-    url: string;
-    anonKey: string;
-    bucket?: string;
-};
+export type SupabaseProviderConfig = SupabaseConfig;
 export type MockProviderConfig = {
     data?: ConstructorParameters<typeof MockDataProvider>[0];
 };
@@ -28,15 +29,20 @@ export declare const GOOGLE_MANIFEST: DriverManifest<GoogleProviderConfig>;
 export declare const DROPBOX_MANIFEST: DriverManifest<DropboxConfig>;
 export declare const SUPABASE_MANIFEST: DriverManifest<SupabaseProviderConfig>;
 export declare const MOCK_MANIFEST: DriverManifest<MockProviderConfig>;
+export declare const AI_MANIFEST: DriverManifest<AIConfig>;
 export declare const PROVIDER_MANIFESTS: Record<string, DriverManifest<any>>;
-export type DataDriverName = 'dbRealtime' | 'supabaseDb' | 'mock';
+export type DataDriverName = 'dbRealtime' | 'firestoreDb' | 'supabaseDb' | 'mock';
 export type StorageDriverName = 'firestorage' | 'supabaseStorage';
-export type AuthDriverName = 'googleAuth' | 'dropboxAuth';
+export type AuthDriverName = 'googleAuth' | 'firebaseAuth' | 'dropboxAuth' | 'supabaseAuth';
 export type EmailDriverName = 'gmail';
+export type AIDriverName = 'openai' | 'openrouter' | 'opencode' | 'openai-compatible' | 'deepseek' | 'gemini' | 'anthropic' | 'mistral';
+export type CredentialsDriverName = 'googleServiceAccount';
 export type ServicesConfig = {
-    data?: DataDriverName;
-    storage?: StorageDriverName;
-    auth?: AuthDriverName;
-    email?: EmailDriverName;
+    data?: DataDriverName | string;
+    storage?: StorageDriverName | string;
+    auth?: AuthDriverName | string;
+    email?: EmailDriverName | string;
+    ai?: AIDriverName | string;
+    credentials?: CredentialsDriverName | string;
 };
 export {};

package/dist/types/src/providers/proxy/index.d.ts

@@ -0,0 +1,7 @@
+import type { ProxyConfig } from '../../Config';
+export declare const PROXY_CALLER_HEADER = "x-llmnative-proxy";
+export declare const DEFAULT_PROXY_ROUTE = "/api/proxy";
+export declare const configureProxy: (config?: ProxyConfig) => void;
+export declare const proxyFetch: typeof fetch;
+export declare const useProxy: () => typeof fetch;
+export declare const isProxyEnabled: () => boolean;

package/dist/types/src/providers/proxy/vite.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+export declare const PROXY_PATH = "/api/proxy";
+export declare const createProxyPlugin: (route?: string) => Plugin;

package/dist/types/src/providers/scrape/index.d.ts

@@ -1,4 +1,5 @@
-declare const fetchScrape: (caller?: any, storePaths?: string[]) => {
+import { DataProviderAdapter } from "../../providers/data/DataProvider";
+declare const fetchScrape: (dataProvider: DataProviderAdapter) => {
     googleSearch: (search: string) => Promise<any>;
     googleImages: (search: string) => Promise<any>;
     googleAutocomplete: (search: string) => Promise<any>;

package/dist/types/src/providers/seo/google/keyword.d.ts

@@ -10,5 +10,10 @@ type GetKeywordIdeasParams = {
     geoCode?: string;
     languageCode?: string;
 };
-export declare function getKeywordIdeas({ keyword, googleAdsAccountId, geoCode, languageCode, }: GetKeywordIdeasParams): Promise<any>;
+export declare function getKeywordIdeas({ keyword, googleAdsAccountId, geoCode, languageCode, }: GetKeywordIdeasParams): Promise<{
+    keyword: string | undefined;
+    avgMonthlySearches: number;
+    competition: string;
+    cpc: number | null;
+}[]>;
 export {};

package/dist/types/src/providers/storage/StorageProvider.d.ts

@@ -1,7 +1,158 @@
 import type { ProviderConfigurable } from '../ProviderConfiguration';
+export interface UploadOptions {
+    /** Target bucket. Falls back to the provider's default bucket if omitted. */
+    bucket?: string;
+    /** MIME type hint (e.g. 'image/png'). Provider may infer it from the file when omitted. */
+    contentType?: string;
+    /** Called during upload with the completion percentage (0-100). */
+    onProgress?: (percent: number) => void;
+}
+export interface StorageOptions {
+    /** Target bucket. Falls back to the provider's default bucket if omitted. */
+    bucket?: string;
+}
+export interface DeleteOptions extends StorageOptions {
+    /**
+     * When true, deletes all files under the given path prefix (folder delete).
+     * Returns the total number of files deleted.
+     * Default: false - deletes a single file and returns 0 (not found) or 1 (deleted).
+     */
+    recursive?: boolean;
+}
+export interface MoveOptions extends StorageOptions {
+    /**
+     * Destination bucket. Falls back to the source bucket if omitted.
+     * Only relevant for cross-bucket moves.
+     */
+    destBucket?: string;
+    /**
+     * When true, treats `from` as a folder prefix and moves every file under it
+     * to the corresponding path under `to`. Returns the number of files moved.
+     * Default: false - moves a single file.
+     */
+    recursive?: boolean;
+}
+export interface ListOptions extends StorageOptions {
+    /** Traverse sub-folders and return files at any depth. Default: false (direct children only). */
+    recursive?: boolean;
+    /**
+     * Include file entries in the results.
+     * Default: true.
+     */
+    includeFiles?: boolean;
+    /**
+     * Include virtual folder/directory entries in the results.
+     * Default: false. When true, folder entries have isFolder: true.
+     */
+    includeFolders?: boolean;
+    /**
+     * Only return files whose extension matches.
+     * Case-insensitive. Pass a single string ('jpg') or an array (['jpg', 'png']).
+     * Has no effect on folder entries.
+     */
+    filterByExtension?: string | string[];
+    /**
+     * Maximum number of entries to return (applied after all other filters).
+     * Omit for no limit.
+     */
+    limit?: number;
+    /**
+     * When true, fetches size / contentType / updatedAt for each file.
+     * On Firebase this requires one extra network call per file (N+1).
+     * On Supabase metadata is always available at no extra cost.
+     * Default: false.
+     */
+    metadata?: boolean;
+}
+export interface StorageFileInfo {
+    /** Filename without the directory prefix. */
+    name: string;
+    /** Full path as stored in the provider (e.g. "images/avatar.png"). */
+    path: string;
+    size?: number;
+    contentType?: string;
+    updatedAt?: string;
+    /** Present and true when this entry represents a virtual folder (only when includeFolders: true). */
+    isFolder?: boolean;
+}
+/**
+ * Handle returned by createUpload - allows pause, resume and cancel mid-flight.
+ * pause() and resume() are no-ops on providers that do not support them (e.g. Supabase via fetch).
+ */
+export interface UploadHandle {
+    /** Resolves to the public download URL when the upload completes, or undefined on failure/cancel. */
+    readonly url: Promise<string | undefined>;
+    /** Pauses the upload. No-op if the provider does not support it. */
+    pause(): void;
+    /** Resumes a paused upload. No-op if the provider does not support it. */
+    resume(): void;
+    /** Cancels the upload. Always supported. */
+    cancel(): void;
+}
+/**
+ * Common storage interface (Ports & Adapters).
+ * Concrete implementations: FirebaseStorageProvider, SupabaseStorageProvider.
+ *
+ * All methods accept an optional `opts.bucket` to target a specific bucket
+ * instead of the provider's configured default.
+ */
 export interface StorageProviderAdapter extends ProviderConfigurable {
-    upload(file: string, path: string): Promise<string | undefined>;
-    getURL(path: string): Promise<string | undefined>;
-    download(path: string): Promise<Blob | undefined>;
-    delete(path: string): Promise<boolean>;
+    /**
+     * Upload a file and return its public download URL.
+     * Accepts a data URL string, a File, or a Blob.
+     * Fire-and-forget: no pause/resume. Use createUpload() for controllable uploads.
+     */
+    upload(file: string | File | Blob, path: string, opts?: UploadOptions): Promise<string | undefined>;
+    /**
+     * Start a controllable upload and return a handle with pause / resume / cancel.
+     * pause() and resume() are no-ops on Supabase (only Firebase supports them natively).
+     */
+    createUpload(file: string | File | Blob, path: string, opts?: UploadOptions): UploadHandle;
+    /**
+     * Rename a file or folder in place (same parent directory, new name).
+     * For folder rename, set opts.recursive = true.
+     * Semantically equivalent to move() - use rename() when only the name changes,
+     * move() when relocating across directories or buckets.
+     * Returns true if at least one file was successfully renamed.
+     */
+    rename(from: string, to: string, opts?: MoveOptions): Promise<boolean>;
+    /**
+     * Move a file or folder to a different path, directory, or bucket.
+     * For folder move, set opts.recursive = true.
+     * Use opts.destBucket to move across buckets.
+     * Returns the number of files successfully moved (0 on failure, 1 for single file).
+     */
+    move(from: string, to: string, opts?: MoveOptions): Promise<number>;
+    /** Return the public download URL for a stored file. */
+    getURL(path: string, opts?: StorageOptions): Promise<string | undefined>;
+    /**
+     * Return metadata for a single file.
+     * Returns undefined if the file does not exist.
+     */
+    getFileInfo(path: string, opts?: StorageOptions): Promise<StorageFileInfo | undefined>;
+    /** Download a file as a Blob. */
+    download(path: string, opts?: StorageOptions): Promise<Blob | undefined>;
+    /**
+     * Delete a file or all files under a folder prefix.
+     * Returns the number of files deleted:
+     *   - Single file (default): 0 if not found, 1 if deleted.
+     *   - Folder (opts.recursive = true): total files deleted.
+     */
+    delete(path: string, opts?: DeleteOptions): Promise<number>;
+    /**
+     * List files (and optionally folders) under a path prefix.
+     *
+     * Key options:
+     *   recursive       - traverse sub-folders (default: false, direct children only)
+     *   includeFiles    - include file entries (default: true)
+     *   includeFolders  - include folder entries with isFolder: true (default: false)
+     *   filterByExtension - case-insensitive extension filter: 'jpg' or ['jpg','png']
+     *   limit           - cap the number of results after all other filters
+     *   metadata        - fetch size/contentType/updatedAt (N+1 cost on Firebase)
+     */
+    list(path: string, opts?: ListOptions): Promise<StorageFileInfo[]>;
 }
+/** Returns true if `filename` matches any of the allowed extensions. Case-insensitive. */
+export declare function matchesExtension(filename: string, filter: string | string[]): boolean;
+/** Apply limit and extension filter to a list of StorageFileInfo entries. */
+export declare function applyListFilters(items: StorageFileInfo[], opts: ListOptions): StorageFileInfo[];

package/dist/types/src/providers/storage/dropbox.d.ts

@@ -10,7 +10,7 @@ type PathEntry = {
 };
 type ThumbnailEntry = {
     path: string;
-    [key: string]: any;
+    [key: string]: unknown;
 };
 type ThumbnailRequestOptions = {
     thumbnailsRequest: ThumbnailEntry[];
@@ -25,7 +25,7 @@ type ThumbnailResult = {
         mimetype: string;
         width: number;
         height: number;
-        [key: string]: any;
+        [key: string]: unknown;
     };
 };
 export declare const resolvePath: (path: string, includeHost?: boolean) => string;
@@ -36,7 +36,7 @@ export declare const dropBox: {
     setRootPath: (path: string) => void;
     resolvePath: (path: string, includeHost?: boolean) => string;
     createFolders: (paths: string[], basePath?: string) => Promise<any>;
-    deleteBulk: (paths: string[], basePath?: string) => Promise<any>;
+    deleteBulk: (paths: string[], basePath?: string) => Promise<unknown[] | undefined>;
     addTags: (paths: Record<string, string[]>, basePath?: string) => Promise<void>;
     listFolders: ({ path, recursive }?: ListFoldersParams) => Promise<any[]>;
     getThumbnails: ({ thumbnailsRequest, size, format, mode, }: ThumbnailRequestOptions, setThumbnails?: (thumbs: ThumbnailResult) => void) => Promise<ThumbnailResult>;

package/dist/types/src/providers/storage/firebase.d.ts

@@ -1,13 +1,44 @@
-import "firebase/compat/storage";
-import { StorageProviderAdapter } from "./StorageProvider";
-import type { ProviderConfigurationState } from "../ProviderConfiguration";
+import type { StorageProviderAdapter, UploadOptions, StorageOptions, DeleteOptions, MoveOptions, ListOptions, StorageFileInfo, UploadHandle } from './StorageProvider';
+import type { ProviderConfigurationState } from '../ProviderConfiguration';
 export declare class FirebaseStorageProvider implements StorageProviderAdapter {
+    private static listenerRegistered;
+    constructor();
     getConfigurationState(): ProviderConfigurationState;
     isConfigured(): boolean;
-    upload: (file: string, path: string) => Promise<string | undefined>;
-    getURL: (path: string) => Promise<string | undefined>;
-    download: (path: string) => Promise<Blob | undefined>;
-    delete: (path: string) => Promise<boolean>;
+    upload: (file: string | File | Blob, path: string, opts?: UploadOptions) => Promise<string | undefined>;
+    createUpload: (file: string | File | Blob, path: string, opts?: UploadOptions) => UploadHandle;
+    /**
+     * Rename a file or folder. Semantically: change the name in place.
+     * Internally identical to move() - Firebase has no native rename/move API.
+     */
+    rename: (from: string, to: string, opts?: MoveOptions) => Promise<boolean>;
+    /**
+     * Move a file or folder (download → upload to new path → delete old).
+     * Firebase has no native move/rename API.
+     * For folder moves, set opts.recursive = true.
+     * Returns the number of files successfully moved.
+     */
+    move: (from: string, to: string, opts?: MoveOptions) => Promise<number>;
+    private _moveFile;
+    getURL: (path: string, opts?: StorageOptions) => Promise<string | undefined>;
+    getFileInfo: (path: string, opts?: StorageOptions) => Promise<StorageFileInfo | undefined>;
+    download: (path: string, opts?: StorageOptions) => Promise<Blob | undefined>;
+    /**
+     * Delete a single file or all files under a folder prefix.
+     * Returns the number of files deleted (0 or 1 for single file, N for recursive).
+     */
+    delete: (path: string, opts?: DeleteOptions) => Promise<number>;
+    private _deleteFolder;
+    /**
+     * List files (and optionally folders) under a path prefix.
+     *
+     * Firebase note: the SDK's listAll() means "list all pages without pagination" -
+     * it is NOT recursive. Recursion over sub-folders is performed manually here.
+     *
+     * opts.metadata = true fetches size/contentType/updatedAt (one extra call per file).
+     */
+    list: (path: string, opts?: ListOptions) => Promise<StorageFileInfo[]>;
+    private _listLevel;
 }
 declare const _default: FirebaseStorageProvider;
 export default _default;

package/dist/types/src/providers/storage/supabase.d.ts

@@ -1,19 +1,59 @@
-import { StorageProviderAdapter } from "./StorageProvider";
-import { type ProviderConfigurationState } from "../ProviderConfiguration";
+import type { StorageProviderAdapter, UploadOptions, StorageOptions, DeleteOptions, MoveOptions, ListOptions, StorageFileInfo, UploadHandle } from './StorageProvider';
+import { type ProviderConfigurationState } from '../ProviderConfiguration';
 interface SupabaseStorageConfig {
     url: string;
     anonKey: string;
+    /** Default bucket name. Falls back to "public" if omitted. */
     bucket?: string;
+    /**
+     * Tenant-session JWT signed by the control-plane, scoped to this project.
+     * When present, requests authenticate as this session instead of the bare
+     * anon key — needed for RLS-protected buckets. `apikey` stays the anon key
+     * regardless (Supabase always requires it alongside the bearer token).
+     */
+    accessToken?: string;
 }
 export declare class SupabaseStorageProvider implements StorageProviderAdapter {
     private config;
     constructor(config: SupabaseStorageConfig);
     getConfigurationState(): ProviderConfigurationState;
     isConfigured(): boolean;
-    private get bucket();
-    upload: (file: string, path: string) => Promise<string | undefined>;
-    getURL: (path: string) => Promise<string | undefined>;
-    download: (path: string) => Promise<Blob | undefined>;
-    delete: (path: string) => Promise<boolean>;
+    private resolveBucket;
+    private authHeaders;
+    upload: (file: string | File | Blob, path: string, opts?: UploadOptions) => Promise<string | undefined>;
+    /**
+     * Supabase upload with cancel support via AbortController.
+     * pause() and resume() are no-ops - Supabase fetch has no native pause/resume.
+     */
+    createUpload: (file: string | File | Blob, path: string, opts?: UploadOptions) => UploadHandle;
+    /**
+     * Rename a file or folder. Internally calls move().
+     * For Supabase, single-file rename uses the native move API (one round-trip).
+     */
+    rename: (from: string, to: string, opts?: MoveOptions) => Promise<boolean>;
+    /**
+     * Move a file or folder.
+     * Single file: uses Supabase's native move API (one round-trip).
+     * Folder (opts.recursive = true): lists all files then moves each via native API.
+     * Returns the number of files successfully moved.
+     */
+    move: (from: string, to: string, opts?: MoveOptions) => Promise<number>;
+    private _moveFile;
+    getURL: (path: string, opts?: StorageOptions) => Promise<string | undefined>;
+    getFileInfo: (path: string, opts?: StorageOptions) => Promise<StorageFileInfo | undefined>;
+    download: (path: string, opts?: StorageOptions) => Promise<Blob | undefined>;
+    /**
+     * Delete a single file or all files under a folder prefix.
+     * Uses Supabase's bulk-delete API - single request even for N files.
+     * Returns the number of files deleted.
+     */
+    delete: (path: string, opts?: DeleteOptions) => Promise<number>;
+    /**
+     * List files (and optionally folders) under a path prefix.
+     * Supabase always returns metadata in the same response (no N+1 cost).
+     * Folder entries have id === null in the Supabase response.
+     */
+    list: (path: string, opts?: ListOptions) => Promise<StorageFileInfo[]>;
+    private _listLevel;
 }
 export {};

package/dist/types/src/providers/supabase-init.d.ts

@@ -0,0 +1,35 @@
+import { type SupabaseClient } from '@supabase/supabase-js';
+import { type ProviderConfigurationState } from './ProviderConfiguration';
+/**
+ * Returns a shared SupabaseClient for the given project.
+ * One client per URL - subsequent calls with the same URL return the same instance.
+ * For single-project apps only. Multi-tenant session switching must use
+ * createSupabaseClient() instead — see below.
+ */
+export declare function getSupabaseClient(url: string, anonKey: string): SupabaseClient;
+/**
+ * Creates a fresh, uncached SupabaseClient scoped to one tenant session.
+ *
+ * Unlike getSupabaseClient(), this never persists a session (Supabase's default
+ * client persists to localStorage) and is never reused across calls — each tenant
+ * switch must produce a brand new instance with the freshly-resolved credential,
+ * never a stale one left over from a previous project.
+ *
+ * Supabase has no "sign in with custom token" step equivalent to Firebase: the
+ * control-plane mints a JWT signed with the tenant project's own JWT secret, and
+ * that JWT is simply attached as the Authorization header on every request —
+ * PostgREST/Realtime verify it directly, no separate session exchange call.
+ */
+export declare function createSupabaseClient(url: string, anonKey: string, accessToken?: string): SupabaseClient;
+/**
+ * Tears down a scoped client before it's discarded: force-closes any realtime
+ * channels a caller may have failed to unsubscribe from. Safety net, not a
+ * replacement for callers unsubscribing their own subscribe() calls.
+ */
+export declare function disposeSupabaseClient(client: SupabaseClient): Promise<void>;
+export declare function getSupabaseConfigurationState(config: {
+    url?: string;
+    anonKey?: string;
+} | undefined): ProviderConfigurationState;
+/** Clears all cached clients - useful for tests. */
+export declare function _resetSupabaseClients(): void;

package/dist/types/src/types/FormFields.d.ts

@@ -1,9 +1,10 @@
 import { FieldFactory } from "../components/Component";
 import { InputProps, TextAreaProps, CheckboxProps } from "../components/ui/fields/Input";
 import { SelectProps } from "../components/ui/fields/Select";
-import { ImageUrlProps } from "../components/ui/fields/ImageUrl";
+import { ImageFieldProps } from "../components/ui/fields/ImageField";
 import { UploadDocumentProps, UploadImageProps } from "../components/ui/fields/Upload";
 import { PromptProps } from "../components/widgets/Prompt";
+import { CodeEditorProps } from "../components/ui/fields/CodeEditor";
 export interface ComponentFormFieldsMap {
     string: FieldFactory<Partial<InputProps>>;
     number: FieldFactory<Partial<InputProps>>;
@@ -24,10 +25,11 @@ export interface ComponentFormFieldsMap {
     uploadImage: FieldFactory<Partial<UploadImageProps>>;
     uploadDocument: FieldFactory<Partial<UploadDocumentProps>>;
     prompt: FieldFactory<Partial<PromptProps>>;
-    imageUrl: FieldFactory<Partial<ImageUrlProps>>;
+    imageField: FieldFactory<Partial<ImageFieldProps>>;
     menu: FieldFactory<{
         defaultValue?: string;
     }>;
+    codeEditor: FieldFactory<Partial<CodeEditorProps>>;
 }
 declare const componentFormFields: ComponentFormFieldsMap;
 export default componentFormFields;

package/dist/types/src/types/FormSchema.d.ts

@@ -0,0 +1,29 @@
+import { FieldFactory } from "../components/Component";
+import { InputProps, TextAreaProps, CheckboxProps } from "../components/ui/fields/Input";
+import { SelectProps, AutocompleteProps, ChecklistProps } from "../components/ui/fields/Select";
+import { UploadImageProps, UploadDocumentProps } from "../components/ui/fields/Upload";
+import { ImageFieldProps } from "../components/ui/fields/ImageField";
+type SchemaFields = Record<string, ReturnType<FieldFactory>>;
+export interface ComponentFormSchemaMap {
+    string: (overrides?: Partial<InputProps>) => SchemaFields;
+    number: (overrides?: Partial<InputProps>) => SchemaFields;
+    email: (overrides?: Partial<InputProps>) => SchemaFields;
+    password: (overrides?: Partial<InputProps>) => SchemaFields;
+    color: (overrides?: Partial<InputProps>) => SchemaFields;
+    date: (overrides?: Partial<InputProps>) => SchemaFields;
+    time: (overrides?: Partial<InputProps>) => SchemaFields;
+    datetime: (overrides?: Partial<InputProps>) => SchemaFields;
+    week: (overrides?: Partial<InputProps>) => SchemaFields;
+    month: (overrides?: Partial<InputProps>) => SchemaFields;
+    textarea: (overrides?: Partial<TextAreaProps>) => SchemaFields;
+    checkbox: (overrides?: Partial<CheckboxProps>) => SchemaFields;
+    switch: (overrides?: Partial<CheckboxProps>) => SchemaFields;
+    select: (overrides?: Partial<SelectProps>) => SchemaFields;
+    autocomplete: (overrides?: Partial<AutocompleteProps>) => SchemaFields;
+    checklist: (overrides?: Partial<ChecklistProps>) => SchemaFields;
+    uploadImage: (overrides?: Partial<UploadImageProps>) => SchemaFields;
+    uploadDocument: (overrides?: Partial<UploadDocumentProps>) => SchemaFields;
+    imageField: (overrides?: Partial<ImageFieldProps>) => SchemaFields;
+}
+declare const componentFormSchema: ComponentFormSchemaMap;
+export default componentFormSchema;

package/dist/types/themes/tokyo-night-light.d.ts

@@ -0,0 +1,3 @@
+import type { ThemeDefinition } from '../src/Theme';
+declare const definition: ThemeDefinition;
+export default definition;

package/dist/types/themes/tokyo-night.d.ts

@@ -0,0 +1,3 @@
+import type { ThemeDefinition } from '../src/Theme';
+declare const definition: ThemeDefinition;
+export default definition;

package/dist/types/themes/vscode-dark-plus.d.ts

@@ -0,0 +1,3 @@
+import type { ThemeDefinition } from '../src/Theme';
+declare const definition: ThemeDefinition;
+export default definition;

package/dist/types/themes/vscode-light-plus.d.ts

@@ -0,0 +1,3 @@
+import type { ThemeDefinition } from '../src/Theme';
+declare const definition: ThemeDefinition;
+export default definition;

package/dist/vite.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const u="x-llmnative-proxy",p="/api/proxy",h=async t=>{const e=[];for await(const r of t)e.push(Buffer.isBuffer(r)?r:Buffer.from(r));return e.length===0?void 0:Buffer.concat(e)},l=async(t,e,r)=>{const a=new URL(t.url||"/","http://localhost").searchParams.get("url");if(t.headers[u]!=="1"){e.statusCode=403,e.setHeader("Content-Type","application/json"),e.end(JSON.stringify({error:"Proxy access denied."}));return}if(!a){e.statusCode=400,e.setHeader("Content-Type","application/json"),e.end(JSON.stringify({error:'Missing "url" query parameter.'}));return}try{const o=new URL(a);if(o.pathname.startsWith(r)&&["localhost","127.0.0.1"].includes(o.hostname)){e.statusCode=508,e.setHeader("Content-Type","application/json"),e.end(JSON.stringify({error:"Recursive proxy target detected.",target:a}));return}const d=await h(t),f=new Headers,y=new Set([u,"host","origin","referer","content-length","transfer-encoding","connection"]);Object.entries(t.headers).forEach(([i,n])=>{!n||y.has(i.toLowerCase())||f.set(i,Array.isArray(n)?n.join(", "):n)});const c=await fetch(a,{method:t.method||"GET",headers:f,body:d&&!["GET","HEAD"].includes((t.method||"GET").toUpperCase())?d:void 0,redirect:"follow"});e.statusCode=c.status,c.headers.forEach((i,n)=>{n.toLowerCase()!=="content-encoding"&&e.setHeader(n,i)}),e.end(Buffer.from(await c.arrayBuffer()))}catch(o){e.statusCode=502,e.setHeader("Content-Type","application/json"),e.end(JSON.stringify({error:o instanceof Error?o.message:"Proxy request failed."}))}},g=(t=p)=>({name:"llmnative-dev-proxy",configureServer(e){e.middlewares.use(t,(r,s)=>{l(r,s,t)})},configurePreviewServer(e){e.middlewares.use(t,(r,s)=>{l(r,s,t)})}});exports.PROXY_PATH=p;exports.createProxyPlugin=g;