@simulatte/doppler 0.1.8 → 0.2.0

package/src/storage/inventory.js

@@ -1,218 +0,0 @@
-import { getRuntimeConfig } from '../config/runtime.js';
-import { isIndexedDBAvailable, isOPFSAvailable } from './quota.js';
-import { createIdbStore } from './backends/idb-store.js';
-import { DEFAULT_OPFS_PATH_CONFIG } from '../config/schema/loading.schema.js';
-
-const LEGACY_OPFS_ROOTS = ['models'];
-const SYSTEM_DIRS = new Set(['reports']);
-
-async function scanOpfsDirectory(dirHandle) {
-  let totalBytes = 0;
-  let fileCount = 0;
-  let shardCount = 0;
-  let hasManifest = false;
-
-  for await (const entry of dirHandle.values()) {
-    if (entry.kind === 'file') {
-      const file = await entry.getFile();
-      totalBytes += file.size;
-      fileCount += 1;
-      if (entry.name === 'manifest.json') {
-        hasManifest = true;
-      }
-      if (entry.name.startsWith('shard_') && entry.name.endsWith('.bin')) {
-        shardCount += 1;
-      }
-    } else if (entry.kind === 'directory') {
-      const child = await scanOpfsDirectory(entry);
-      totalBytes += child.totalBytes;
-      fileCount += child.fileCount;
-      shardCount += child.shardCount;
-      hasManifest = hasManifest || child.hasManifest;
-    }
-  }
-
-  return {
-    totalBytes,
-    fileCount,
-    shardCount,
-    hasManifest,
-  };
-}
-
-async function hasFile(dirHandle, filename) {
-  try {
-    await dirHandle.getFileHandle(filename);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function hasModelChild(dirHandle) {
-  for await (const entry of dirHandle.values()) {
-    if (entry.kind !== 'directory') continue;
-    if (await hasFile(entry, 'manifest.json')) {
-      return true;
-    }
-  }
-  return false;
-}
-
-async function discoverOpfsRoots(rootHandle) {
-  const roots = [];
-  for await (const entry of rootHandle.values()) {
-    if (entry.kind !== 'directory') continue;
-    const hasRegistry = await hasFile(entry, 'models.json');
-    if (hasRegistry || await hasModelChild(entry)) {
-      roots.push(entry.name);
-    }
-  }
-  return roots;
-}
-
-function resolveOpfsRootDir(runtime) {
-  return runtime?.loading?.opfsPath?.opfsRootDir || DEFAULT_OPFS_PATH_CONFIG.opfsRootDir;
-}
-
-async function listOpfsRoots(runtime) {
-  if (!isOPFSAvailable()) {
-    return [];
-  }
-  const root = await navigator.storage.getDirectory();
-  const configured = resolveOpfsRootDir(runtime);
-  const roots = new Set([configured, ...LEGACY_OPFS_ROOTS]);
-  const discovered = await discoverOpfsRoots(root);
-  for (const name of discovered) {
-    roots.add(name);
-  }
-  const resolved = [];
-  for (const name of roots) {
-    try {
-      const handle = await root.getDirectoryHandle(name);
-      resolved.push({ name, handle });
-    } catch {
-      // Root does not exist.
-    }
-  }
-  return resolved;
-}
-
-async function listOpfsEntries(runtime) {
-  if (!isOPFSAvailable()) {
-    return { entries: [], systemEntries: [], opfsRoots: [] };
-  }
-  const roots = await listOpfsRoots(runtime);
-  const entries = [];
-  const systemEntries = [];
-
-  for (const root of roots) {
-    for await (const entry of root.handle.values()) {
-      if (entry.kind !== 'directory') continue;
-      const stats = await scanOpfsDirectory(entry);
-      const base = {
-        modelId: entry.name,
-        backend: 'opfs',
-        root: root.name,
-        totalBytes: stats.totalBytes,
-        fileCount: stats.fileCount,
-        shardCount: stats.shardCount,
-        hasManifest: stats.hasManifest,
-      };
-      if (SYSTEM_DIRS.has(entry.name)) {
-        systemEntries.push({
-          ...base,
-          kind: 'system',
-          label: entry.name,
-        });
-      } else {
-        entries.push(base);
-      }
-    }
-  }
-
-  return {
-    entries,
-    systemEntries,
-    opfsRoots: roots.map((root) => root.name),
-  };
-}
-
-async function listIndexedDbEntries(runtime) {
-  if (!isIndexedDBAvailable()) {
-    return [];
-  }
-  const store = createIdbStore(runtime.loading.storage.backend.indexeddb);
-  const modelIds = await store.listModels();
-  const entries = [];
-
-  for (const modelId of modelIds) {
-    const stats = await store.getModelStats(modelId);
-    entries.push({
-      modelId,
-      backend: 'indexeddb',
-      totalBytes: stats.totalBytes,
-      fileCount: stats.fileCount,
-      shardCount: stats.shardCount,
-      hasManifest: stats.hasManifest,
-    });
-  }
-
-  return entries;
-}
-
-export async function listStorageInventory() {
-  const runtime = getRuntimeConfig();
-  const opfsResult = await listOpfsEntries(runtime);
-  const idbEntries = await listIndexedDbEntries(runtime);
-
-  return {
-    entries: [...opfsResult.entries, ...idbEntries],
-    systemEntries: opfsResult.systemEntries,
-    opfsRoots: opfsResult.opfsRoots,
-    backendAvailability: {
-      opfs: isOPFSAvailable(),
-      indexeddb: isIndexedDBAvailable(),
-    },
-  };
-}
-
-export async function deleteStorageEntry(entry) {
-  if (!entry?.modelId) {
-    return false;
-  }
-  const runtime = getRuntimeConfig();
-
-  if (entry.backend === 'opfs') {
-    if (!isOPFSAvailable()) {
-      throw new Error('OPFS not available in this browser');
-    }
-    const rootName = entry.root || resolveOpfsRootDir(runtime);
-    const root = await navigator.storage.getDirectory();
-    let opfsRoot = null;
-    try {
-      opfsRoot = await root.getDirectoryHandle(rootName, { create: false });
-    } catch {
-      return false;
-    }
-    try {
-      await opfsRoot.removeEntry(entry.modelId, { recursive: true });
-      return true;
-    } catch (error) {
-      if (error?.name === 'NotFoundError') {
-        return false;
-      }
-      throw error;
-    }
-  }
-
-  if (entry.backend === 'indexeddb') {
-    if (!isIndexedDBAvailable()) {
-      throw new Error('IndexedDB not available in this browser');
-    }
-    const store = createIdbStore(runtime.loading.storage.backend.indexeddb);
-    return store.deleteModel(entry.modelId);
-  }
-
-  return false;
-}

package/src/storage/preflight.d.ts

@@ -1,144 +0,0 @@
-/**
- * preflight.ts - Pre-download Validation
- *
- * Performs checks before model download:
- * - VRAM estimation and validation
- * - Storage space availability
- * - GPU capability verification
- *
- * @module storage/preflight
- */
-
-/**
- * VRAM check result
- */
-export interface VRAMCheckResult {
-  /** Bytes required for inference */
-  required: number;
-  /** Estimated available VRAM in bytes */
-  available: number;
-  /** True if available >= required */
-  sufficient: boolean;
-  /** Human-readable message */
-  message: string;
-}
-
-/**
- * Storage check result
- */
-export interface StorageCheckResult {
-  /** Download size in bytes */
-  required: number;
-  /** Available OPFS space in bytes */
-  available: number;
-  /** True if available >= required */
-  sufficient: boolean;
-  /** Human-readable message */
-  message: string;
-}
-
-export interface StorageBackendCheckResult {
-  requested: string;
-  selected: string;
-  persistent: boolean;
-  ok: boolean;
-  message: string;
-  caps: {
-    opfs: boolean;
-    indexeddb: boolean;
-    sharedArrayBuffer: boolean;
-    byob: boolean;
-    syncAccessHandle: boolean;
-  };
-}
-
-/**
- * GPU info result
- */
-export interface GPUCheckResult {
-  /** WebGPU is available */
-  hasWebGPU: boolean;
-  /** shader-f16 feature available */
-  hasF16: boolean;
-  /** Device description */
-  device: string;
-  /** Is unified memory (Apple/AMD) */
-  isUnified: boolean;
-}
-
-/**
- * Complete pre-flight check result
- */
-export interface PreflightResult {
-  /** Overall: can proceed with download */
-  canProceed: boolean;
-  /** VRAM check details */
-  vram: VRAMCheckResult;
-  /** Storage check details */
-  storage: StorageCheckResult;
-  /** GPU capability details */
-  gpu: GPUCheckResult;
-  /** Storage backend selection and capabilities */
-  storageBackend: StorageBackendCheckResult;
-  /** Warning messages (non-blocking) */
-  warnings: string[];
-  /** Blocker messages (prevents download) */
-  blockers: string[];
-}
-
-/**
- * Model requirements definition
- */
-export interface ModelRequirements {
-  /** Model identifier */
-  modelId: string;
-  /** Display name */
-  displayName: string;
-  /** Total download size in bytes */
-  downloadSize: number;
-  /** VRAM required for inference in bytes */
-  vramRequired: number;
-  /** Parameter count string (e.g., "1B", "7B") */
-  paramCount: string;
-  /** Quantization type (e.g., "Q4_K_M", "BF16") */
-  quantization: string;
-  /** Model architecture (e.g., "gemma3", "llama") */
-  architecture?: string;
-}
-
-/**
- * Gemma 1B requirements (Q4_K_M quantization)
- */
-export declare const GEMMA_1B_REQUIREMENTS: ModelRequirements;
-
-/**
- * All available model requirements
- * Naming convention: {family}-{version}-{size}-{weights}[-{override-groups}]
- * Examples: gemma-3-1b-it-q4k-ehf16-af32, llama-3.2-1b-q4, mistral-7b-v0.3-q4
- */
-export declare const MODEL_REQUIREMENTS: Record<string, ModelRequirements>;
-
-/**
- * Run all pre-flight checks before model download
- *
- * @param requirements - Model requirements to check against
- * @returns Pre-flight check result with all details
- *
- * @example
- * ```typescript
- * import { log } from '../debug/index.js';
- *
- * const result = await runPreflightChecks(GEMMA_1B_REQUIREMENTS);
- * if (!result.canProceed) {
- *   log.error('Preflight', 'Cannot download', result.blockers);
- * }
- * ```
- */
-export declare function runPreflightChecks(
-  requirements: ModelRequirements
-): Promise<PreflightResult>;
-
-/**
- * Format pre-flight result for display
- */
-export declare function formatPreflightResult(result: PreflightResult): string;

package/src/storage/preflight.js

@@ -1,316 +0,0 @@
-
-
-import { getMemoryCapabilities } from '../memory/capability.js';
-import { getQuotaInfo, formatBytes } from './quota.js';
-import { getRuntimeConfig } from '../config/runtime.js';
-import { getStorageCapabilities } from './shard-manager.js';
-import { GB, MB } from '../config/schema/index.js';
-
-// ============================================================================
-// Model Requirements Constants
-// ============================================================================
-
-
-export const GEMMA_1B_REQUIREMENTS = {
-  modelId: 'gemma-3-1b-it-q4k-ehf16-af32',
-  displayName: 'Gemma 3 1B IT (Q4_K_M)',
-  downloadSize: 565 * MB,       // ~565MB actual size from manifest shards
-  vramRequired: 1.5 * GB,       // ~1.5GB VRAM for inference (weights + KV cache)
-  paramCount: '1B',
-  quantization: 'Q4_K_M',
-  architecture: 'Gemma3ForCausalLM',
-};
-
-const GEMMA_270M_REQUIREMENTS = {
-  modelId: 'gemma-3-270m-it-q4k-ehf16-af32',
-  displayName: 'Gemma 3 270M IT (Q4K)',
-  downloadSize: 418512553,
-  vramRequired: 1.0 * GB,
-  paramCount: '270M',
-  quantization: 'Q4K',
-  architecture: 'Gemma3ForCausalLM',
-};
-
-const EMBEDDINGGEMMA_300M_REQUIREMENTS = {
-  modelId: 'google-embeddinggemma-300m-q4k-ehf16-af32',
-  displayName: 'EmbeddingGemma 300M (Q4K)',
-  downloadSize: 480562497,
-  vramRequired: 1.0 * GB,
-  paramCount: '300M',
-  quantization: 'Q4K',
-  architecture: 'EmbeddingGemmaForEmbedding',
-};
-
-
-export const MODEL_REQUIREMENTS = {
-  'gemma-3-270m-it-q4k-ehf16-af32': GEMMA_270M_REQUIREMENTS,
-  'google-embeddinggemma-300m-q4k-ehf16-af32': EMBEDDINGGEMMA_300M_REQUIREMENTS,
-  'gemma-3-1b-it-q4k-ehf16-af32': GEMMA_1B_REQUIREMENTS,
-};
-
-// ============================================================================
-// VRAM Estimation
-// ============================================================================
-
-
-function estimateAvailableVRAM(memCaps) {
-  const info = memCaps.unifiedMemoryInfo;
-
-  // Unified memory: use estimated system memory (leave headroom)
-  if (info.isUnified && info.estimatedMemoryGB) {
-    // Use configured ratio of unified memory available for GPU
-    return (info.estimatedMemoryGB * GB) * getRuntimeConfig().loading.storage.vramEstimation.unifiedMemoryRatio;
-  }
-
-  // Discrete GPU: use maxBufferSize as heuristic
-  // This isn't actual VRAM but gives us a sense of GPU capability
-  if (info.limits?.maxBufferSize) {
-    // Conservative: discrete GPUs can usually allocate ~80% of VRAM
-    return info.limits.maxBufferSize;
-  }
-
-  // Fallback: use configured fallback VRAM
-  return getRuntimeConfig().loading.storage.vramEstimation.fallbackVramBytes;
-}
-
-
-async function checkVRAM(
-  requirements,
-  memCaps
-) {
-  const available = estimateAvailableVRAM(memCaps);
-  const required = requirements.vramRequired;
-  const sufficient = available >= required;
-
-  
-  let message;
-  if (sufficient) {
-    message = `VRAM OK: ${formatBytes(available)} available, ${formatBytes(required)} required`;
-  } else {
-    message = `Insufficient VRAM: ${formatBytes(available)} available, ${formatBytes(required)} required`;
-  }
-
-  return { required, available, sufficient, message };
-}
-
-// ============================================================================
-// Storage Check
-// ============================================================================
-
-
-async function checkStorage(
-  requirements
-) {
-  const quotaInfo = await getQuotaInfo();
-  const available = quotaInfo.available;
-  const required = requirements.downloadSize;
-  const sufficient = available >= required;
-
-  
-  let message;
-  if (sufficient) {
-    message = `Storage OK: ${formatBytes(available)} available, ${formatBytes(required)} required`;
-  } else {
-    const shortfall = required - available;
-    message = `Insufficient storage: need ${formatBytes(shortfall)} more space`;
-  }
-
-  return { required, available, sufficient, message };
-}
-
-function resolveStorageBackend() {
-  const config = getRuntimeConfig().loading.storage.backend;
-  const caps = getStorageCapabilities();
-  const requested = config.backend;
-  let selected = 'memory';
-  let persistent = false;
-  let ok = true;
-  let message = '';
-
-  if (requested === 'opfs') {
-    selected = 'opfs';
-    persistent = true;
-    ok = caps.opfs;
-    message = caps.opfs ? 'OPFS available' : 'OPFS requested but not available';
-  } else if (requested === 'indexeddb') {
-    selected = 'indexeddb';
-    persistent = true;
-    ok = caps.indexeddb;
-    message = caps.indexeddb ? 'IndexedDB available' : 'IndexedDB requested but not available';
-  } else if (requested === 'memory') {
-    selected = 'memory';
-    persistent = false;
-    message = 'Memory store requested';
-  } else {
-    if (caps.opfs) {
-      selected = 'opfs';
-      persistent = true;
-      message = 'Auto-selected OPFS';
-    } else if (caps.indexeddb) {
-      selected = 'indexeddb';
-      persistent = true;
-      message = 'Auto-selected IndexedDB';
-    } else {
-      selected = 'memory';
-      persistent = false;
-      message = 'Auto-selected memory fallback';
-    }
-  }
-
-  return {
-    requested,
-    selected,
-    persistent,
-    ok,
-    message,
-    caps,
-  };
-}
-
-// ============================================================================
-// GPU Check
-// ============================================================================
-
-
-async function checkGPU(memCaps) {
-  const hasWebGPU = typeof navigator !== 'undefined' && !!navigator.gpu;
-
-  if (!hasWebGPU) {
-    return {
-      hasWebGPU: false,
-      hasF16: false,
-      device: 'WebGPU not available',
-      isUnified: false,
-    };
-  }
-
-  const info = memCaps.unifiedMemoryInfo;
-  let device = 'Unknown GPU';
-
-  if (info.apple?.isApple) {
-    device = info.apple.description || `Apple M${info.apple.mSeriesGen || '?'}`;
-  } else if (info.amd?.isAMDUnified) {
-    device = info.amd.description || 'AMD Strix';
-  } else if (info.limits?.maxBufferSize) {
-    device = `GPU (${formatBytes(info.limits.maxBufferSize)} max buffer)`;
-  }
-
-  // Check for F16 support (need to request adapter to check features)
-  let hasF16 = false;
-  try {
-    const adapter = await navigator.gpu.requestAdapter({ powerPreference: 'high-performance' });
-    if (adapter) {
-      hasF16 = adapter.features.has('shader-f16');
-    }
-  } catch {
-    // Ignore - hasF16 stays false
-  }
-
-  return {
-    hasWebGPU: true,
-    hasF16,
-    device,
-    isUnified: info.isUnified,
-  };
-}
-
-// ============================================================================
-// Public API
-// ============================================================================
-
-
-export async function runPreflightChecks(
-  requirements
-) {
-  
-  const warnings = [];
-  
-  const blockers = [];
-
-  // Get memory capabilities (cached internally)
-  const memCaps = await getMemoryCapabilities();
-
-  // Run all checks
-  const [vram, storage, gpu] = await Promise.all([
-    checkVRAM(requirements, memCaps),
-    checkStorage(requirements),
-    checkGPU(memCaps),
-  ]);
-  const storageBackend = resolveStorageBackend();
-
-  // Determine blockers
-  if (!gpu.hasWebGPU) {
-    blockers.push('WebGPU is not available in this browser');
-  }
-
-  if (!vram.sufficient) {
-    blockers.push(vram.message);
-  }
-
-  if (!storage.sufficient) {
-    blockers.push(storage.message);
-  }
-  if (!storageBackend.ok) {
-    blockers.push(storageBackend.message);
-  }
-
-  // Determine warnings
-  if (!gpu.hasF16) {
-    warnings.push('F16 not supported - inference may be slower');
-  }
-  if (storageBackend.selected === 'indexeddb' && storageBackend.caps.opfs === false) {
-    warnings.push('OPFS unavailable - using IndexedDB fallback (slower)');
-  }
-  if (storageBackend.selected === 'memory') {
-    warnings.push('Persistent storage unavailable - using memory fallback');
-    const maxBytes = getRuntimeConfig().loading.storage.backend.memory.maxBytes;
-    if (maxBytes < requirements.downloadSize) {
-      blockers.push('Memory fallback too small for model download');
-    }
-  }
-
-  if (!gpu.isUnified && vram.sufficient) {
-    // Discrete GPU with borderline VRAM
-    const headroom = vram.available - vram.required;
-    if (headroom < getRuntimeConfig().loading.storage.vramEstimation.lowVramHeadroomBytes) {
-      warnings.push('Low VRAM headroom - may cause issues with longer contexts');
-    }
-  }
-
-  const canProceed = blockers.length === 0;
-
-  return {
-    canProceed,
-    vram,
-    storage,
-    gpu,
-    storageBackend,
-    warnings,
-    blockers,
-  };
-}
-
-
-export function formatPreflightResult(result) {
-  
-  const lines = [];
-
-  lines.push(`GPU: ${result.gpu.device}`);
-  lines.push(`VRAM: ${result.vram.message}`);
-  lines.push(`Storage: ${result.storage.message}`);
-  if (result.storageBackend) {
-    lines.push(`Storage backend: ${result.storageBackend.selected} (${result.storageBackend.message})`);
-  }
-
-  if (result.warnings.length > 0) {
-    lines.push(`Warnings: ${result.warnings.join('; ')}`);
-  }
-
-  if (result.blockers.length > 0) {
-    lines.push(`Blockers: ${result.blockers.join('; ')}`);
-  }
-
-  lines.push(`Can proceed: ${result.canProceed ? 'Yes' : 'No'}`);
-
-  return lines.join('\n');
-}