@simulatte/doppler 0.1.8 → 0.2.0

package/src/browser/tensor-source-download.js

@@ -1,245 +0,0 @@
-
-
-import { getRuntimeConfig } from '../config/runtime.js';
-import { isIndexedDBAvailable, isOPFSAvailable } from '../storage/quota.js';
-import { createIdbStore } from '../storage/backends/idb-store.js';
-import { createFileTensorSource } from './tensor-source-file.js';
-import { createHttpTensorSource } from './tensor-source-http.js';
-
-const TEMP_DIR = 'temp-downloads';
-const TEMP_MODEL_PREFIX = '__temp_download__';
-let tempNameCounter = 0;
-
-function randomSuffix() {
-  if (typeof crypto !== 'undefined' && typeof crypto.getRandomValues === 'function') {
-    const bytes = new Uint8Array(4);
-    crypto.getRandomValues(bytes);
-    return Array.from(bytes, (value) => value.toString(16).padStart(2, '0')).join('').slice(0, 8);
-  }
-  tempNameCounter = (tempNameCounter + 1) >>> 0;
-  return tempNameCounter.toString(36).padStart(8, '0').slice(-8);
-}
-
-function resolveMaxDownloadBytes(options) {
-  const raw = options?.maxDownloadBytes;
-  if (!Number.isFinite(raw)) return null;
-  const normalized = Math.max(0, Math.floor(raw));
-  return normalized > 0 ? normalized : null;
-}
-
-function inferNameFromUrl(url) {
-  try {
-    const baseHref = typeof globalThis.location !== 'undefined' ? globalThis.location.href : undefined;
-    const parsed = new URL(url, baseHref);
-    const pathname = parsed.pathname || '';
-    const part = pathname.split('/').filter(Boolean).pop();
-    return part || 'remote';
-  } catch {
-    const parts = String(url).split('/');
-    return parts[parts.length - 1] || 'remote';
-  }
-}
-
-function sanitizeFilename(name) {
-  return name.replace(/[^a-zA-Z0-9._-]/g, '_');
-}
-
-function buildTempFilename(name) {
-  const safe = sanitizeFilename(name);
-  const stamp = Date.now().toString(36);
-  const rand = randomSuffix();
-  return `${stamp}-${rand}-${safe}`;
-}
-
-async function streamDownload(url, options, onChunk) {
-  const { headers, signal } = options;
-  const maxBytes = resolveMaxDownloadBytes(options);
-  const response = await fetch(url, { headers, signal });
-  if (!response.ok) {
-    throw new Error(`Download failed: ${response.status}`);
-  }
-
-  const lengthHeader = response.headers.get('content-length');
-  const contentLength = Number.parseInt(lengthHeader || '', 10);
-  if (maxBytes !== null && Number.isFinite(contentLength) && contentLength > maxBytes) {
-    throw new Error(`Download exceeds limit (${maxBytes} bytes).`);
-  }
-
-  let totalBytes = 0;
-  if (response.body && response.body.getReader) {
-    const reader = response.body.getReader();
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      if (value) {
-        const nextTotal = totalBytes + value.byteLength;
-        if (maxBytes !== null && nextTotal > maxBytes) {
-          if (typeof reader.cancel === 'function') {
-            await reader.cancel();
-          }
-          throw new Error(`Download exceeds limit (${maxBytes} bytes).`);
-        }
-        totalBytes = nextTotal;
-        await onChunk(value);
-      }
-    }
-  } else {
-    const buffer = new Uint8Array(await response.arrayBuffer());
-    if (maxBytes !== null && buffer.byteLength > maxBytes) {
-      throw new Error(`Download exceeds limit (${maxBytes} bytes).`);
-    }
-    totalBytes = buffer.byteLength;
-    await onChunk(buffer);
-  }
-
-  return {
-    totalBytes,
-    contentLength: response.headers.get('content-length'),
-  };
-}
-
-async function downloadToOpfs(url, options = {}) {
-  const runtime = getRuntimeConfig();
-  const root = await navigator.storage.getDirectory();
-  const opfsRoot = await root.getDirectoryHandle(runtime.loading.opfsPath.opfsRootDir, { create: true });
-  const tempDir = await opfsRoot.getDirectoryHandle(TEMP_DIR, { create: true });
-
-  const originalName = options.name || inferNameFromUrl(url);
-  const tempName = buildTempFilename(originalName);
-  const fileHandle = await tempDir.getFileHandle(tempName, { create: true });
-  const writable = await fileHandle.createWritable();
-
-  let result;
-  try {
-    result = await streamDownload(url, options, async (chunk) => {
-      await writable.write(chunk);
-    });
-    await writable.close();
-  } catch (error) {
-    if (typeof writable.abort === 'function') {
-      await writable.abort();
-    } else {
-      await writable.close();
-    }
-    try {
-      await tempDir.removeEntry(tempName);
-    } catch {
-      // ignore cleanup errors
-    }
-    throw error;
-  }
-
-  const file = await fileHandle.getFile();
-  const source = createFileTensorSource(file);
-  const size = file.size || result.totalBytes;
-
-  return {
-    source: {
-      ...source,
-      name: originalName,
-      sourceType: 'download-opfs',
-      cleanup: async () => {
-        await tempDir.removeEntry(tempName);
-      },
-    },
-    size,
-  };
-}
-
-async function downloadToIdb(url, options = {}) {
-  const runtime = getRuntimeConfig();
-  const idbConfig = runtime.loading.storage.backend.indexeddb;
-  const store = createIdbStore(idbConfig);
-  const originalName = options.name || inferNameFromUrl(url);
-  const tempName = buildTempFilename(originalName);
-  const modelId = `${TEMP_MODEL_PREFIX}${tempName}`;
-
-  await store.openModel(modelId, { create: true });
-  const stream = await store.createWriteStream(tempName);
-
-  let result;
-  try {
-    result = await streamDownload(url, options, async (chunk) => {
-      await stream.write(chunk);
-    });
-    await stream.close();
-  } catch (error) {
-    if (typeof stream.abort === 'function') {
-      await stream.abort();
-    }
-    await store.deleteModel(modelId);
-    await store.cleanup();
-    throw error;
-  }
-
-  let cached = null;
-  const readAll = async () => {
-    if (!cached) {
-      cached = new Uint8Array(await store.readFile(tempName));
-    }
-    return cached;
-  };
-
-  const size = cached ? cached.byteLength : Number.parseInt(result.contentLength || '0', 10) || result.totalBytes;
-
-  return {
-    source: {
-      sourceType: 'download-idb',
-      name: originalName,
-      size,
-      readRange: async (offset, length) => {
-        if (!Number.isFinite(offset) || !Number.isFinite(length) || length <= 0) {
-          return new ArrayBuffer(0);
-        }
-        const bytes = await readAll();
-        const start = Math.max(0, offset);
-        const end = Math.min(start + length, bytes.byteLength);
-        return bytes.slice(start, end).buffer;
-      },
-      readAll: async () => {
-        const bytes = await readAll();
-        return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-      },
-      close: async () => {
-        return;
-      },
-      getAuxFiles: async () => {
-        return {};
-      },
-      cleanup: async () => {
-        await store.deleteModel(modelId);
-        await store.cleanup();
-      },
-    },
-    size,
-  };
-}
-
-export async function createDownloadTensorSource(url, options = {}) {
-  if (isOPFSAvailable()) {
-    return downloadToOpfs(url, options);
-  }
-  if (isIndexedDBAvailable()) {
-    return downloadToIdb(url, options);
-  }
-  throw new Error('No storage backend available for download fallback');
-}
-
-export async function createRemoteTensorSource(url, options = {}) {
-  try {
-    const source = await createHttpTensorSource(url, options);
-    return { source, size: source.size, supportsRange: true };
-  } catch (error) {
-    if (options.allowDownloadFallback === false) {
-      throw error;
-    }
-    if (options.allowDownloadFallback !== true) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(
-        `HTTP tensor source failed for "${url}" and download fallback is not explicitly enabled: ${message}`
-      );
-    }
-    const downloaded = await createDownloadTensorSource(url, options);
-    return { ...downloaded, supportsRange: false };
-  }
-}

package/src/browser/tensor-source-file.d.ts

@@ -1,26 +0,0 @@
-/**
- * tensor-source-file.ts - File-backed tensor source
- *
- * Wraps File/Blob inputs with a readRange interface.
- *
- * @module browser/tensor-source-file
- */
-
-export interface TensorSource {
-  name: string;
-  size: number;
-  sourceType?: string;
-  file?: File;
-  url?: string;
-  readRange(offset: number, length: number): Promise<ArrayBuffer>;
-  readAll(): Promise<ArrayBuffer>;
-  close(): Promise<void>;
-  getAuxFiles(): Promise<Record<string, unknown>>;
-  cleanup?: () => Promise<void> | void;
-}
-
-export declare function isTensorSource(value: unknown): value is TensorSource;
-
-export declare function createFileTensorSource(file: File | Blob): TensorSource;
-
-export declare function normalizeTensorSource(input: File | Blob | TensorSource): TensorSource;

package/src/browser/tensor-source-file.js

@@ -1,53 +0,0 @@
-
-
-export function isTensorSource(value) {
-  return value && typeof value.readRange === 'function' && typeof value.size === 'number';
-}
-
-export function createFileTensorSource(file) {
-  if (!file || typeof file.slice !== 'function') {
-    throw new Error('File tensor source requires a File or Blob');
-  }
-
-  const relativePath = typeof file.relativePath === 'string' && file.relativePath.length > 0
-    ? file.relativePath
-    : typeof file.webkitRelativePath === 'string' && file.webkitRelativePath.length > 0
-      ? file.webkitRelativePath
-      : null;
-  const name = relativePath || (typeof file.name === 'string' ? file.name : 'unknown');
-
-  return {
-    sourceType: 'file',
-    name,
-    size: file.size ?? 0,
-    file,
-    async readRange(offset, length) {
-      if (!Number.isFinite(offset) || !Number.isFinite(length) || length <= 0) {
-        return new ArrayBuffer(0);
-      }
-      const start = Math.max(0, offset);
-      const end = Math.min(start + length, file.size ?? start + length);
-      const blob = file.slice(start, end);
-      return blob.arrayBuffer();
-    },
-    async readAll() {
-      if (typeof file.arrayBuffer === 'function') {
-        return file.arrayBuffer();
-      }
-      return this.readRange(0, file.size ?? 0);
-    },
-    async close() {
-      return;
-    },
-    async getAuxFiles() {
-      return {};
-    },
-  };
-}
-
-export function normalizeTensorSource(input) {
-  if (isTensorSource(input)) {
-    return input;
-  }
-  return createFileTensorSource(input);
-}

package/src/browser/tensor-source-http.d.ts

@@ -1,29 +0,0 @@
-/**
- * tensor-source-http.ts - HTTP tensor source with Range support
- *
- * @module browser/tensor-source-http
- */
-
-import type { TensorSource } from './tensor-source-file.js';
-
-export interface HttpRangeProbe {
-  ok: boolean;
-  status: number;
-  supportsRange: boolean;
-  size: number | null;
-  acceptRanges: string | null;
-  contentEncoding: string | null;
-  error?: string | null;
-}
-
-export interface HttpTensorSourceOptions {
-  headers?: Record<string, string>;
-  signal?: AbortSignal;
-  name?: string;
-  allowDownloadFallback?: boolean;
-  maxDownloadBytes?: number | null;
-}
-
-export declare function probeHttpRange(url: string, options?: HttpTensorSourceOptions): Promise<HttpRangeProbe>;
-
-export declare function createHttpTensorSource(url: string, options?: HttpTensorSourceOptions): Promise<TensorSource>;

package/src/browser/tensor-source-http.js

@@ -1,130 +0,0 @@
-
-
-function normalizeHeaderValue(value) {
-  return value ? value.toLowerCase().trim() : '';
-}
-
-function parseContentLength(value) {
-  if (!value) return null;
-  const parsed = Number.parseInt(value, 10);
-  return Number.isFinite(parsed) ? parsed : null;
-}
-
-function inferNameFromUrl(url) {
-  try {
-    const baseHref = typeof globalThis.location !== 'undefined' ? globalThis.location.href : undefined;
-    const parsed = new URL(url, baseHref);
-    const pathname = parsed.pathname || '';
-    const part = pathname.split('/').filter(Boolean).pop();
-    return part || 'remote';
-  } catch {
-    const parts = String(url).split('/');
-    return parts[parts.length - 1] || 'remote';
-  }
-}
-
-export async function probeHttpRange(url, options = {}) {
-  const { headers, signal } = options;
-  try {
-    const response = await fetch(url, {
-      method: 'HEAD',
-      headers,
-      signal,
-    });
-
-    if (!response.ok) {
-      return {
-        ok: false,
-        status: response.status,
-        supportsRange: false,
-        size: null,
-        acceptRanges: null,
-        contentEncoding: null,
-      };
-    }
-
-    const acceptRanges = normalizeHeaderValue(response.headers.get('accept-ranges'));
-    const contentEncoding = normalizeHeaderValue(response.headers.get('content-encoding'));
-    const contentLength = parseContentLength(response.headers.get('content-length'));
-
-    const supportsRange = Boolean(
-      acceptRanges.includes('bytes') &&
-      contentLength !== null &&
-      (!contentEncoding || contentEncoding === 'identity')
-    );
-
-    return {
-      ok: true,
-      status: response.status,
-      supportsRange,
-      size: contentLength,
-      acceptRanges,
-      contentEncoding,
-    };
-  } catch (error) {
-    return {
-      ok: false,
-      status: 0,
-      supportsRange: false,
-      size: null,
-      acceptRanges: null,
-      contentEncoding: null,
-      error: error instanceof Error ? error.message : String(error),
-    };
-  }
-}
-
-export async function createHttpTensorSource(url, options = {}) {
-  const { headers, signal, name: overrideName } = options;
-  const probe = await probeHttpRange(url, { headers, signal });
-  if (!probe.ok && probe.status === 0 && probe.error) {
-    throw new Error(`HTTP tensor source probe failed for "${url}": ${probe.error}`);
-  }
-  if (!probe.supportsRange || probe.size == null) {
-    throw new Error('HTTP range requests not supported for tensor source');
-  }
-
-  const name = overrideName || inferNameFromUrl(url);
-  const size = probe.size;
-
-  return {
-    sourceType: 'http',
-    name,
-    size,
-    url,
-    async readRange(offset, length) {
-      if (!Number.isFinite(offset) || !Number.isFinite(length) || length <= 0) {
-        return new ArrayBuffer(0);
-      }
-      const start = Math.max(0, offset);
-      const end = Math.min(start + length - 1, size - 1);
-      if (end < start) {
-        return new ArrayBuffer(0);
-      }
-
-      const rangeHeader = `bytes=${start}-${end}`;
-      const response = await fetch(url, {
-        headers: {
-          ...(headers || {}),
-          Range: rangeHeader,
-        },
-        signal,
-      });
-
-      if (response.status !== 206) {
-        throw new Error(`HTTP range request failed: ${response.status}`);
-      }
-
-      return response.arrayBuffer();
-    },
-    async readAll() {
-      return this.readRange(0, size);
-    },
-    async close() {
-      return;
-    },
-    async getAuxFiles() {
-      return {};
-    },
-  };
-}

package/src/client/doppler-api.browser.d.ts

@@ -1 +0,0 @@
-export * from './doppler-api.d.ts';