@simulatte/doppler 0.1.0

package/src/bridge/index.d.ts

@@ -0,0 +1,68 @@
+/**
+ * DOPPLER Native Bridge Module
+ * Phase 3: Native Host Communication
+ *
+ * @module bridge
+ */
+
+export {
+  MAGIC,
+  HEADER_SIZE,
+  MAX_CHUNK_SIZE,
+  Command,
+  Flag,
+  ErrorCode,
+  CMD,
+  FLAGS,
+  ERROR_CODES,
+  encodeMessage,
+  decodeHeader,
+  createReadRequest,
+  createAck,
+  parseReadResponse,
+  parseErrorResponse,
+} from './protocol.js';
+
+export type {
+  CommandType,
+  FlagType,
+  ErrorCodeType,
+  MessageHeader,
+  ReadResponse,
+  ErrorResponse,
+  ListEntry,
+} from './protocol.js';
+
+export {
+  ExtensionBridgeClient,
+  BridgeStatus,
+  getBridgeClient,
+  isBridgeAvailable,
+} from './extension-client.js';
+
+export type {
+  BridgeStatusType,
+  StatusChangeCallback,
+  ErrorCallback,
+  ChunkCallback,
+} from './extension-client.js';
+
+/**
+ * Create and connect a bridge client
+ * @param extensionId - Optional extension ID
+ */
+export declare function createBridgeClient(
+  extensionId?: string | null
+): Promise<import('./extension-client.js').ExtensionBridgeClient>;
+
+/**
+ * Read file via native bridge
+ * @param path - File path
+ * @param offset - Byte offset (default: 0)
+ * @param length - Bytes to read (default: entire file)
+ */
+export declare function readFileNative(
+  path: string,
+  offset?: number,
+  length?: number
+): Promise<Uint8Array>;

package/src/bridge/index.js

@@ -0,0 +1,51 @@
+
+
+export {
+  MAGIC,
+  HEADER_SIZE,
+  MAX_CHUNK_SIZE,
+  Command,
+  Flag,
+  ErrorCode,
+  CMD,
+  FLAGS,
+  ERROR_CODES,
+  encodeMessage,
+  decodeHeader,
+  createReadRequest,
+  createAck,
+  parseReadResponse,
+  parseErrorResponse,
+} from './protocol.js';
+
+export {
+  ExtensionBridgeClient,
+  BridgeStatus,
+  getBridgeClient,
+  isBridgeAvailable,
+} from './extension-client.js';
+
+
+export async function createBridgeClient(extensionId = null) {
+  const { ExtensionBridgeClient, isBridgeAvailable } = await import('./extension-client.js');
+
+  if (!isBridgeAvailable()) {
+    throw new Error('Native bridge not available - Chrome extension API required');
+  }
+
+  const client = new ExtensionBridgeClient();
+  await client.connect(extensionId);
+  return client;
+}
+
+
+export async function readFileNative(path, offset = 0, length = 0) {
+  const { getBridgeClient } = await import('./extension-client.js');
+  const client = getBridgeClient();
+
+  if (!client.isConnected()) {
+    await client.connect();
+  }
+
+  return client.read(path, offset, length);
+}

package/src/bridge/protocol.d.ts

@@ -0,0 +1,96 @@
+/**
+ * DOPPLER Native Bridge Protocol
+ * Binary protocol for Extension <-> Native Host communication.
+ */
+
+export declare const MAGIC: number;
+export declare const HEADER_SIZE: number;
+export declare const MAX_CHUNK_SIZE: number;
+export declare const ACK_SIZE: number;
+
+export declare const Command: {
+  readonly PING: 0x00;
+  readonly PONG: 0x01;
+  readonly READ: 0x02;
+  readonly READ_RESPONSE: 0x03;
+  readonly WRITE: 0x04;
+  readonly WRITE_ACK: 0x05;
+  readonly LIST: 0x06;
+  readonly LIST_RESPONSE: 0x07;
+  readonly ERROR: 0xff;
+};
+
+export type CommandType = (typeof Command)[keyof typeof Command];
+
+export declare const Flag: {
+  readonly NONE: 0x00;
+  readonly COMPRESSED: 0x01;
+  readonly LAST_CHUNK: 0x02;
+};
+
+export type FlagType = (typeof Flag)[keyof typeof Flag];
+
+export declare const ErrorCode: {
+  readonly OK: 0;
+  readonly NOT_FOUND: 1;
+  readonly PERMISSION_DENIED: 2;
+  readonly IO_ERROR: 3;
+  readonly INVALID_REQUEST: 4;
+  readonly QUOTA_EXCEEDED: 5;
+};
+
+export type ErrorCodeType = (typeof ErrorCode)[keyof typeof ErrorCode];
+
+export interface MessageHeader {
+  cmd: CommandType;
+  flags: FlagType;
+  reqId: number;
+  payloadLen: number;
+}
+
+export interface ReadResponse {
+  offset: number;
+  data: Uint8Array;
+}
+
+export interface ErrorResponse {
+  code: ErrorCodeType;
+  message: string;
+}
+
+export interface ListEntry {
+  name: string;
+  isDir: boolean;
+  size: number;
+}
+
+export declare function encodeMessage(
+  cmd: CommandType,
+  reqId: number,
+  payload?: Uint8Array | null,
+  flags?: FlagType
+): ArrayBuffer;
+
+export declare function decodeHeader(buffer: ArrayBuffer): MessageHeader | null;
+
+export declare function createReadRequest(
+  reqId: number,
+  path: string,
+  offset: number,
+  length: number
+): ArrayBuffer;
+
+export declare function createListRequest(reqId: number, path: string): ArrayBuffer;
+
+export declare function createAck(reqId: number): ArrayBuffer;
+
+export declare function parseReadResponse(payload: Uint8Array): ReadResponse;
+
+export declare function parseListResponse(payload: Uint8Array): ListEntry[];
+
+export declare function parseErrorResponse(payload: Uint8Array): ErrorResponse;
+
+// Legacy aliases
+export declare const CMD: typeof Command;
+export declare const FLAGS: typeof Flag;
+export declare const ERROR_CODES: typeof ErrorCode;

package/src/bridge/protocol.js

@@ -0,0 +1,130 @@
+
+import { MB } from '../config/schema/index.js';
+
+export const MAGIC = 0x5245504c;
+export const HEADER_SIZE = 16;
+export const MAX_CHUNK_SIZE = 8 * MB;
+export const ACK_SIZE = 4;
+
+export const Command = {
+  PING: 0x00,
+  PONG: 0x01,
+  READ: 0x02,
+  READ_RESPONSE: 0x03,
+  WRITE: 0x04,
+  WRITE_ACK: 0x05,
+  LIST: 0x06,
+  LIST_RESPONSE: 0x07,
+  ERROR: 0xff,
+};
+
+export const Flag = {
+  NONE: 0x00,
+  COMPRESSED: 0x01,
+  LAST_CHUNK: 0x02,
+};
+
+export const ErrorCode = {
+  OK: 0,
+  NOT_FOUND: 1,
+  PERMISSION_DENIED: 2,
+  IO_ERROR: 3,
+  INVALID_REQUEST: 4,
+  QUOTA_EXCEEDED: 5,
+};
+
+export function encodeMessage(
+  cmd,
+  reqId,
+  payload = null,
+  flags = Flag.NONE
+) {
+  const payloadLen = payload?.length ?? 0;
+  const buffer = new ArrayBuffer(HEADER_SIZE + payloadLen);
+  const view = new DataView(buffer);
+
+  view.setUint32(0, MAGIC, true);
+  view.setUint8(4, cmd);
+  view.setUint8(5, flags);
+  view.setUint16(6, 0, true);
+  view.setUint32(8, reqId, true);
+  view.setUint32(12, payloadLen, true);
+
+  if (payload && payloadLen > 0) {
+    new Uint8Array(buffer, HEADER_SIZE).set(payload);
+  }
+
+  return buffer;
+}
+
+export function decodeHeader(buffer) {
+  if (buffer.byteLength < HEADER_SIZE) return null;
+
+  const view = new DataView(buffer);
+  if (view.getUint32(0, true) !== MAGIC) return null;
+
+  return {
+    cmd: view.getUint8(4),
+    flags: view.getUint8(5),
+    reqId: view.getUint32(8, true),
+    payloadLen: view.getUint32(12, true),
+  };
+}
+
+export function createReadRequest(
+  reqId,
+  path,
+  offset,
+  length
+) {
+  const pathBytes = new TextEncoder().encode(path);
+  const payload = new Uint8Array(16 + pathBytes.length);
+  const view = new DataView(payload.buffer);
+
+  view.setUint32(0, offset & 0xffffffff, true);
+  view.setUint32(4, Math.floor(offset / 0x100000000), true);
+  view.setUint32(8, length & 0xffffffff, true);
+  view.setUint32(12, Math.floor(length / 0x100000000), true);
+  payload.set(pathBytes, 16);
+
+  return encodeMessage(Command.READ, reqId, payload);
+}
+
+export function createListRequest(reqId, path) {
+  const pathBytes = new TextEncoder().encode(path);
+  return encodeMessage(Command.LIST, reqId, pathBytes);
+}
+
+export function createAck(reqId) {
+  const buffer = new ArrayBuffer(ACK_SIZE);
+  new DataView(buffer).setUint32(0, reqId, true);
+  return buffer;
+}
+
+export function parseReadResponse(payload) {
+  const view = new DataView(payload.buffer, payload.byteOffset);
+  const offsetLow = view.getUint32(0, true);
+  const offsetHigh = view.getUint32(4, true);
+
+  return {
+    offset: offsetLow + offsetHigh * 0x100000000,
+    data: payload.slice(8),
+  };
+}
+
+export function parseListResponse(payload) {
+  return JSON.parse(new TextDecoder().decode(payload));
+}
+
+export function parseErrorResponse(payload) {
+  const view = new DataView(payload.buffer, payload.byteOffset);
+  return {
+    code: view.getUint32(0, true),
+    message: new TextDecoder().decode(payload.slice(4)),
+  };
+}
+
+// Legacy aliases for backwards compatibility
+export const CMD = Command;
+export const FLAGS = Flag;
+export const ERROR_CODES = ErrorCode;

package/src/browser/browser-converter.d.ts

@@ -0,0 +1,71 @@
+/**
+ * browser-converter.ts - Browser Model Converter
+ *
+ * Converts GGUF and safetensors models to RDRR format in the browser.
+ * Uses ShardPacker for platform-agnostic shard packing logic.
+ *
+ * Supports:
+ * - GGUF files
+ * - Single safetensors files
+ * - Sharded HuggingFace models (multiple safetensors + config)
+ *
+ * Output is written to OPFS when available, with IndexedDB fallback.
+ *
+ * @module browser/browser-converter
+ */
+
+import type { TensorLocation, ShardPackerResult } from '../converter/shard-packer.js';
+import type {
+  ConvertStageType,
+  ConvertProgress,
+  ConvertOptions as CoreConvertOptions,
+  ShardInfo,
+  RDRRManifest,
+} from '../converter/core.js';
+import type { TensorSource } from './tensor-source-file.js';
+import type { HttpTensorSourceOptions } from './tensor-source-http.js';
+import type { ConverterConfigSchema } from '../config/schema/converter.schema.js';
+
+export { ConvertStage } from '../converter/core.js';
+export type {
+  ConvertStageType,
+  ConvertProgress,
+  ShardInfo,
+  TensorLocation,
+  RDRRManifest,
+};
+
+/** Check if browser conversion is supported (OPFS or IndexedDB). */
+export declare function isConversionSupported(): boolean;
+
+/**
+ * Create TensorSource entries for remote model files.
+ */
+export declare function createRemoteModelSources(
+  urls: string[],
+  options?: HttpTensorSourceOptions & { converterConfig?: ConverterConfigSchema }
+): Promise<TensorSource[]>;
+
+/**
+ * Browser conversion options (extends core with File[] input)
+ */
+export interface ConvertOptions extends CoreConvertOptions {
+  // Browser-specific: no additional options needed
+}
+
+/**
+ * Convert model files to RDRR format
+ *
+ * @param files - Selected model files
+ * @param options - Conversion options
+ * @returns Model ID
+ */
+export declare function convertModel(files: Array<File | TensorSource>, options?: ConvertOptions): Promise<string>;
+
+/**
+ * Pick model files using File System Access API
+ * @returns Selected files
+ */
+export declare function pickModelFiles(): Promise<File[]>;
+
+export default convertModel;