@meframe/core 0.0.1

package/dist/utils/time-utils.js

@@ -0,0 +1,60 @@
+import { MICROSECONDS_PER_SECOND } from "../model/types.js";
+const DEFAULT_FPS = 30;
+const DEFAULT_FRAME_TOLERANCE_US = 33333;
+function normalizeFps(value) {
+  if (!Number.isFinite(value) || value <= 0) {
+    return DEFAULT_FPS;
+  }
+  return value;
+}
+function frameDurationFromFps(fps) {
+  const normalized = normalizeFps(fps);
+  const duration = MICROSECONDS_PER_SECOND / normalized;
+  return Math.max(Math.round(duration), 1);
+}
+function frameIndexFromTimestamp(baseTimestampUs, timestampUs, fps, strategy = "nearest") {
+  const frameDurationUs = frameDurationFromFps(fps);
+  if (frameDurationUs <= 0) {
+    return 0;
+  }
+  const delta = timestampUs - baseTimestampUs;
+  const rawIndex = delta / frameDurationUs;
+  if (!Number.isFinite(rawIndex)) {
+    return 0;
+  }
+  switch (strategy) {
+    case "floor":
+      return Math.floor(rawIndex);
+    case "ceil":
+      return Math.ceil(rawIndex);
+    default:
+      return Math.round(rawIndex);
+  }
+}
+function quantizeTimestampToFrame(timestampUs, baseTimestampUs, fps, strategy = "nearest") {
+  const frameDurationUs = frameDurationFromFps(fps);
+  const index = frameIndexFromTimestamp(baseTimestampUs, timestampUs, fps, strategy);
+  return baseTimestampUs + index * frameDurationUs;
+}
+function isTimestampWithinFrame(targetTimeUs, frameTimestampUs, frameDurationUs, toleranceUs = DEFAULT_FRAME_TOLERANCE_US) {
+  if (!Number.isFinite(frameTimestampUs)) {
+    return false;
+  }
+  const delta = Math.abs(targetTimeUs - frameTimestampUs);
+  if (delta <= toleranceUs) {
+    return true;
+  }
+  if (frameDurationUs > 0 && frameTimestampUs <= targetTimeUs) {
+    return targetTimeUs < frameTimestampUs + frameDurationUs;
+  }
+  return false;
+}
+export {
+  DEFAULT_FRAME_TOLERANCE_US,
+  frameDurationFromFps,
+  frameIndexFromTimestamp,
+  isTimestampWithinFrame,
+  normalizeFps,
+  quantizeTimestampToFrame
+};
+//# sourceMappingURL=time-utils.js.map

package/dist/utils/time-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-utils.js","sources":["../../src/utils/time-utils.ts"],"sourcesContent":["import type { TimeUs } from '../model/types';\nimport { MICROSECONDS_PER_SECOND } from '../model/types';\n\nexport type QuantizeStrategy = 'nearest' | 'floor' | 'ceil';\n\nconst DEFAULT_FPS = 30;\n\nexport const DEFAULT_FRAME_TOLERANCE_US: TimeUs = 33_333;\n\nexport function normalizeFps(value?: number): number {\n  if (!Number.isFinite(value) || (value as number) <= 0) {\n    return DEFAULT_FPS;\n  }\n  return value as number;\n}\n\nexport function frameDurationFromFps(fps?: number): TimeUs {\n  const normalized = normalizeFps(fps);\n  const duration = MICROSECONDS_PER_SECOND / normalized;\n  return Math.max(Math.round(duration), 1);\n}\n\nexport function frameIndexFromTimestamp(\n  baseTimestampUs: TimeUs,\n  timestampUs: TimeUs,\n  fps?: number,\n  strategy: QuantizeStrategy = 'nearest'\n): number {\n  const frameDurationUs = frameDurationFromFps(fps);\n  if (frameDurationUs <= 0) {\n    return 0;\n  }\n\n  const delta = timestampUs - baseTimestampUs;\n  const rawIndex = delta / frameDurationUs;\n\n  if (!Number.isFinite(rawIndex)) {\n    return 0;\n  }\n\n  switch (strategy) {\n    case 'floor':\n      return Math.floor(rawIndex);\n    case 'ceil':\n      return Math.ceil(rawIndex);\n    default:\n      return Math.round(rawIndex);\n  }\n}\n\nexport function quantizeTimestampToFrame(\n  timestampUs: TimeUs,\n  baseTimestampUs: TimeUs,\n  fps?: number,\n  strategy: QuantizeStrategy = 'nearest'\n): TimeUs {\n  const frameDurationUs = frameDurationFromFps(fps);\n  const index = frameIndexFromTimestamp(baseTimestampUs, timestampUs, fps, strategy);\n  return baseTimestampUs + index * frameDurationUs;\n}\n\nexport function isTimestampWithinFrame(\n  targetTimeUs: TimeUs,\n  frameTimestampUs: TimeUs,\n  frameDurationUs: TimeUs,\n  toleranceUs: TimeUs = DEFAULT_FRAME_TOLERANCE_US\n): boolean {\n  if (!Number.isFinite(frameTimestampUs)) {\n    return false;\n  }\n\n  const delta = Math.abs(targetTimeUs - frameTimestampUs);\n  if (delta <= toleranceUs) {\n    return true;\n  }\n\n  if (frameDurationUs > 0 && frameTimestampUs <= targetTimeUs) {\n    return targetTimeUs < frameTimestampUs + frameDurationUs;\n  }\n\n  return false;\n}\n"],"names":[],"mappings":";AAKA,MAAM,cAAc;AAEb,MAAM,6BAAqC;AAE3C,SAAS,aAAa,OAAwB;AACnD,MAAI,CAAC,OAAO,SAAS,KAAK,KAAM,SAAoB,GAAG;AACrD,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAEO,SAAS,qBAAqB,KAAsB;AACzD,QAAM,aAAa,aAAa,GAAG;AACnC,QAAM,WAAW,0BAA0B;AAC3C,SAAO,KAAK,IAAI,KAAK,MAAM,QAAQ,GAAG,CAAC;AACzC;AAEO,SAAS,wBACd,iBACA,aACA,KACA,WAA6B,WACrB;AACR,QAAM,kBAAkB,qBAAqB,GAAG;AAChD,MAAI,mBAAmB,GAAG;AACxB,WAAO;AAAA,EACT;AAEA,QAAM,QAAQ,cAAc;AAC5B,QAAM,WAAW,QAAQ;AAEzB,MAAI,CAAC,OAAO,SAAS,QAAQ,GAAG;AAC9B,WAAO;AAAA,EACT;AAEA,UAAQ,UAAA;AAAA,IACN,KAAK;AACH,aAAO,KAAK,MAAM,QAAQ;AAAA,IAC5B,KAAK;AACH,aAAO,KAAK,KAAK,QAAQ;AAAA,IAC3B;AACE,aAAO,KAAK,MAAM,QAAQ;AAAA,EAAA;AAEhC;AAEO,SAAS,yBACd,aACA,iBACA,KACA,WAA6B,WACrB;AACR,QAAM,kBAAkB,qBAAqB,GAAG;AAChD,QAAM,QAAQ,wBAAwB,iBAAiB,aAAa,KAAK,QAAQ;AACjF,SAAO,kBAAkB,QAAQ;AACnC;AAEO,SAAS,uBACd,cACA,kBACA,iBACA,cAAsB,4BACb;AACT,MAAI,CAAC,OAAO,SAAS,gBAAgB,GAAG;AACtC,WAAO;AAAA,EACT;AAEA,QAAM,QAAQ,KAAK,IAAI,eAAe,gBAAgB;AACtD,MAAI,SAAS,aAAa;AACxB,WAAO;AAAA,EACT;AAEA,MAAI,kBAAkB,KAAK,oBAAoB,cAAc;AAC3D,WAAO,eAAe,mBAAmB;AAAA,EAC3C;AAEA,SAAO;AACT;"}

package/dist/worker/BaseWorker.d.ts

@@ -0,0 +1,44 @@
+import { WorkerChannel } from './WorkerChannel';
+import { WorkerStateInfo, WorkerType } from './types';
+import { EventBus } from '../event/EventBus';
+import { EventPayloadMap } from '../event/events';
+
+export interface BaseWorkerConfig {
+    type: WorkerType;
+    url: string;
+    eventBus: EventBus<EventPayloadMap>;
+    clipId?: string;
+}
+export declare class BaseWorker {
+    private worker;
+    readonly channel: WorkerChannel;
+    private state;
+    private taskCount;
+    private lastError?;
+    readonly type: WorkerType;
+    readonly clipId?: string;
+    private eventBus;
+    constructor(config: BaseWorkerConfig);
+    private setupErrorHandling;
+    initialize(config?: any): Promise<void>;
+    sendStream<T = Uint8Array>(stream: ReadableStream<T>, metadata?: {
+        type?: string;
+        url?: string;
+        streamId?: string;
+        [key: string]: any;
+    }): Promise<void>;
+    send<T = any, R = any>(command: string, payload?: T, options?: {
+        timeout?: number;
+        transfer?: Transferable[];
+        signal?: AbortSignal;
+    }): Promise<R>;
+    receiveStream(onStream: (stream: ReadableStream, metadata?: Record<string, any>) => void): void;
+    notify(command: string, payload?: any, transfer?: Transferable[]): void;
+    get port(): MessagePort;
+    getChannel(): WorkerChannel;
+    terminate(): void;
+    get status(): WorkerStateInfo;
+    getWorkerId(): string;
+    onError?(error: Error): void;
+}
+//# sourceMappingURL=BaseWorker.d.ts.map

package/dist/worker/BaseWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseWorker.d.ts","sourceRoot":"","sources":["../../src/worker/BaseWorker.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAqB,KAAK,eAAe,EAAE,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AACnF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAgB,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAErE,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,UAAU,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAS;IACvB,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC,OAAO,CAAC,KAAK,CAAoC;IACjD,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,SAAS,CAAC,CAAQ;IAE1B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,QAAQ,CAA4B;gBAEhC,MAAM,EAAE,gBAAgB;IAcpC,OAAO,CAAC,kBAAkB;IAcpB,UAAU,CAAC,MAAM,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBvC,UAAU,CAAC,CAAC,GAAG,UAAU,EAC7B,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,EACzB,QAAQ,CAAC,EAAE;QACT,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KACpB,GACA,OAAO,CAAC,IAAI,CAAC;IAIV,IAAI,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,EACzB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,CAAC,EACX,OAAO,CAAC,EAAE;QACR,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,QAAQ,CAAC,EAAE,YAAY,EAAE,CAAC;QAC1B,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,GACA,OAAO,CAAC,CAAC,CAAC;IAeb,aAAa,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,cAAc,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,IAAI,GAAG,IAAI;IAI/F,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,QAAQ,CAAC,EAAE,YAAY,EAAE,GAAG,IAAI;IAIvE,IAAI,IAAI,IAAI,WAAW,CAEtB;IAED,UAAU,IAAI,aAAa;IAI3B,SAAS,IAAI,IAAI;IAOjB,IAAI,MAAM,IAAI,eAAe,CAM5B;IAED,WAAW,IAAI,MAAM;IAIrB,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;CAC7B"}

package/dist/worker/BaseWorker.js

@@ -0,0 +1,98 @@
+import { WorkerChannel } from "./WorkerChannel.js";
+import { WorkerMessageType } from "./types.js";
+import { MeframeEvent } from "../event/events.js";
+class BaseWorker {
+  worker;
+  channel;
+  state = "idle";
+  taskCount = 0;
+  lastError;
+  type;
+  clipId;
+  eventBus;
+  constructor(config) {
+    this.type = config.type;
+    this.clipId = config.clipId;
+    this.eventBus = config.eventBus;
+    this.worker = new Worker(config.url, { type: "module" });
+    this.channel = new WorkerChannel(this.worker, {
+      name: this.getWorkerId(),
+      timeout: 3e4
+    });
+    this.setupErrorHandling();
+  }
+  setupErrorHandling() {
+    this.worker.onerror = (error) => {
+      this.state = "error";
+      this.lastError = new Error(error.message || "Worker error");
+      this.onError?.(this.lastError);
+      this.eventBus.emit(MeframeEvent.WorkerError, {
+        type: this.type,
+        workerId: this.getWorkerId(),
+        error: this.lastError
+      });
+    };
+  }
+  async initialize(config) {
+    this.eventBus.emit(MeframeEvent.WorkerStarted, {
+      type: this.type,
+      workerId: this.getWorkerId()
+    });
+    await this.channel.send(WorkerMessageType.Configure, {
+      config,
+      initial: true
+    });
+    this.eventBus.emit(MeframeEvent.WorkerReady, {
+      type: this.type,
+      workerId: this.getWorkerId()
+    });
+  }
+  async sendStream(stream, metadata) {
+    await this.channel.sendStream(stream, metadata);
+  }
+  async send(command, payload, options) {
+    this.taskCount++;
+    this.state = "busy";
+    try {
+      const result = await this.channel.send(command, payload, options);
+      return result;
+    } finally {
+      this.taskCount--;
+      if (this.taskCount === 0) {
+        this.state = "idle";
+      }
+    }
+  }
+  receiveStream(onStream) {
+    this.channel.receiveStream(onStream);
+  }
+  notify(command, payload, transfer) {
+    this.channel.notify(command, payload, transfer);
+  }
+  get port() {
+    return this.channel.port;
+  }
+  getChannel() {
+    return this.channel;
+  }
+  terminate() {
+    this.channel.dispose();
+    this.worker.terminate();
+    this.state = "terminated";
+    this.taskCount = 0;
+  }
+  get status() {
+    return {
+      state: this.state,
+      taskCount: this.taskCount,
+      lastError: this.lastError?.message
+    };
+  }
+  getWorkerId() {
+    return this.clipId ? `${this.type}#${this.clipId}` : this.type;
+  }
+}
+export {
+  BaseWorker
+};
+//# sourceMappingURL=BaseWorker.js.map

package/dist/worker/BaseWorker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseWorker.js","sources":["../../src/worker/BaseWorker.ts"],"sourcesContent":["/**\n * BaseWorker: Lightweight wrapper for Worker + WorkerChannel\n * Provides a thin abstraction over Web Worker with state management\n */\n\nimport { WorkerChannel } from './WorkerChannel';\nimport { WorkerMessageType, type WorkerStateInfo, type WorkerType } from './types';\nimport type { EventBus } from '../event/EventBus';\nimport { MeframeEvent, type EventPayloadMap } from '../event/events';\n\nexport interface BaseWorkerConfig {\n  type: WorkerType;\n  url: string;\n  eventBus: EventBus<EventPayloadMap>;\n  clipId?: string;\n}\n\nexport class BaseWorker {\n  private worker: Worker;\n  readonly channel: WorkerChannel;\n  private state: WorkerStateInfo['state'] = 'idle';\n  private taskCount = 0;\n  private lastError?: Error;\n\n  readonly type: WorkerType;\n  readonly clipId?: string;\n  private eventBus: EventBus<EventPayloadMap>;\n\n  constructor(config: BaseWorkerConfig) {\n    this.type = config.type;\n    this.clipId = config.clipId;\n    this.eventBus = config.eventBus;\n\n    this.worker = new Worker(config.url, { type: 'module' });\n    this.channel = new WorkerChannel(this.worker, {\n      name: this.getWorkerId(),\n      timeout: 30000,\n    });\n\n    this.setupErrorHandling();\n  }\n\n  private setupErrorHandling(): void {\n    this.worker.onerror = (error) => {\n      this.state = 'error';\n      this.lastError = new Error(error.message || 'Worker error');\n      this.onError?.(this.lastError);\n\n      this.eventBus.emit(MeframeEvent.WorkerError, {\n        type: this.type,\n        workerId: this.getWorkerId(),\n        error: this.lastError,\n      });\n    };\n  }\n\n  async initialize(config?: any): Promise<void> {\n    this.eventBus.emit(MeframeEvent.WorkerStarted, {\n      type: this.type,\n      workerId: this.getWorkerId(),\n    });\n    await this.channel.send(WorkerMessageType.Configure, {\n      config,\n      initial: true,\n    });\n\n    this.eventBus.emit(MeframeEvent.WorkerReady, {\n      type: this.type,\n      workerId: this.getWorkerId(),\n    });\n  }\n\n  async sendStream<T = Uint8Array>(\n    stream: ReadableStream<T>,\n    metadata?: {\n      type?: string;\n      url?: string;\n      streamId?: string;\n      [key: string]: any;\n    }\n  ): Promise<void> {\n    await this.channel.sendStream(stream, metadata);\n  }\n\n  async send<T = any, R = any>(\n    command: string,\n    payload?: T,\n    options?: {\n      timeout?: number;\n      transfer?: Transferable[];\n      signal?: AbortSignal;\n    }\n  ): Promise<R> {\n    this.taskCount++;\n    this.state = 'busy';\n\n    try {\n      const result = await this.channel.send(command as any, payload, options);\n      return result as R;\n    } finally {\n      this.taskCount--;\n      if (this.taskCount === 0) {\n        this.state = 'idle';\n      }\n    }\n  }\n\n  receiveStream(onStream: (stream: ReadableStream, metadata?: Record<string, any>) => void): void {\n    this.channel.receiveStream(onStream);\n  }\n\n  notify(command: string, payload?: any, transfer?: Transferable[]): void {\n    this.channel.notify(command, payload, transfer);\n  }\n\n  get port(): MessagePort {\n    return this.channel.port as unknown as MessagePort;\n  }\n\n  getChannel(): WorkerChannel {\n    return this.channel;\n  }\n\n  terminate(): void {\n    this.channel.dispose();\n    this.worker.terminate();\n    this.state = 'terminated';\n    this.taskCount = 0;\n  }\n\n  get status(): WorkerStateInfo {\n    return {\n      state: this.state,\n      taskCount: this.taskCount,\n      lastError: this.lastError?.message,\n    };\n  }\n\n  getWorkerId(): string {\n    return this.clipId ? `${this.type}#${this.clipId}` : this.type;\n  }\n\n  onError?(error: Error): void;\n}\n"],"names":[],"mappings":";;;AAiBO,MAAM,WAAW;AAAA,EACd;AAAA,EACC;AAAA,EACD,QAAkC;AAAA,EAClC,YAAY;AAAA,EACZ;AAAA,EAEC;AAAA,EACA;AAAA,EACD;AAAA,EAER,YAAY,QAA0B;AACpC,SAAK,OAAO,OAAO;AACnB,SAAK,SAAS,OAAO;AACrB,SAAK,WAAW,OAAO;AAEvB,SAAK,SAAS,IAAI,OAAO,OAAO,KAAK,EAAE,MAAM,UAAU;AACvD,SAAK,UAAU,IAAI,cAAc,KAAK,QAAQ;AAAA,MAC5C,MAAM,KAAK,YAAA;AAAA,MACX,SAAS;AAAA,IAAA,CACV;AAED,SAAK,mBAAA;AAAA,EACP;AAAA,EAEQ,qBAA2B;AACjC,SAAK,OAAO,UAAU,CAAC,UAAU;AAC/B,WAAK,QAAQ;AACb,WAAK,YAAY,IAAI,MAAM,MAAM,WAAW,cAAc;AAC1D,WAAK,UAAU,KAAK,SAAS;AAE7B,WAAK,SAAS,KAAK,aAAa,aAAa;AAAA,QAC3C,MAAM,KAAK;AAAA,QACX,UAAU,KAAK,YAAA;AAAA,QACf,OAAO,KAAK;AAAA,MAAA,CACb;AAAA,IACH;AAAA,EACF;AAAA,EAEA,MAAM,WAAW,QAA6B;AAC5C,SAAK,SAAS,KAAK,aAAa,eAAe;AAAA,MAC7C,MAAM,KAAK;AAAA,MACX,UAAU,KAAK,YAAA;AAAA,IAAY,CAC5B;AACD,UAAM,KAAK,QAAQ,KAAK,kBAAkB,WAAW;AAAA,MACnD;AAAA,MACA,SAAS;AAAA,IAAA,CACV;AAED,SAAK,SAAS,KAAK,aAAa,aAAa;AAAA,MAC3C,MAAM,KAAK;AAAA,MACX,UAAU,KAAK,YAAA;AAAA,IAAY,CAC5B;AAAA,EACH;AAAA,EAEA,MAAM,WACJ,QACA,UAMe;AACf,UAAM,KAAK,QAAQ,WAAW,QAAQ,QAAQ;AAAA,EAChD;AAAA,EAEA,MAAM,KACJ,SACA,SACA,SAKY;AACZ,SAAK;AACL,SAAK,QAAQ;AAEb,QAAI;AACF,YAAM,SAAS,MAAM,KAAK,QAAQ,KAAK,SAAgB,SAAS,OAAO;AACvE,aAAO;AAAA,IACT,UAAA;AACE,WAAK;AACL,UAAI,KAAK,cAAc,GAAG;AACxB,aAAK,QAAQ;AAAA,MACf;AAAA,IACF;AAAA,EACF;AAAA,EAEA,cAAc,UAAkF;AAC9F,SAAK,QAAQ,cAAc,QAAQ;AAAA,EACrC;AAAA,EAEA,OAAO,SAAiB,SAAe,UAAiC;AACtE,SAAK,QAAQ,OAAO,SAAS,SAAS,QAAQ;AAAA,EAChD;AAAA,EAEA,IAAI,OAAoB;AACtB,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA,EAEA,aAA4B;AAC1B,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,YAAkB;AAChB,SAAK,QAAQ,QAAA;AACb,SAAK,OAAO,UAAA;AACZ,SAAK,QAAQ;AACb,SAAK,YAAY;AAAA,EACnB;AAAA,EAEA,IAAI,SAA0B;AAC5B,WAAO;AAAA,MACL,OAAO,KAAK;AAAA,MACZ,WAAW,KAAK;AAAA,MAChB,WAAW,KAAK,WAAW;AAAA,IAAA;AAAA,EAE/B;AAAA,EAEA,cAAsB;AACpB,WAAO,KAAK,SAAS,GAAG,KAAK,IAAI,IAAI,KAAK,MAAM,KAAK,KAAK;AAAA,EAC5D;AAGF;"}

package/dist/worker/WorkerChannel.d.ts

@@ -0,0 +1,105 @@
+import { WorkerMessageType, PendingRequest, MessageHandler, MessageHandlers, WorkerState, PortLike } from './types';
+import { RetryConfig } from './worker-retry';
+
+export interface WorkerChannelConfig {
+    name: string;
+    timeout?: number;
+    maxRetries?: number;
+}
+export declare class WorkerChannel {
+    name: string;
+    port: PortLike;
+    pendingRequests: Map<string, PendingRequest>;
+    messageHandlers: MessageHandlers;
+    state: WorkerState;
+    defaultTimeout: number;
+    defaultMaxRetries: number;
+    constructor(port: PortLike, config: WorkerChannelConfig);
+    /**
+     * Send a message and wait for response with retry support
+     */
+    send<T = any, R = any>(type: WorkerMessageType, payload?: T, options?: {
+        timeout?: number;
+        maxRetries?: number;
+        transfer?: Transferable[];
+        retryConfig?: Partial<RetryConfig>;
+    }): Promise<R>;
+    /**
+     * Send a message once (without retry)
+     */
+    private sendOnce;
+    /**
+     * Send a message without waiting for response
+     */
+    post<T = any>(type: WorkerMessageType, payload?: T, transfer?: Transferable[]): void;
+    /**
+     * Register a message handler
+     */
+    on<T = any, R = any>(type: WorkerMessageType, handler: MessageHandler<T, R>): void;
+    /**
+     * Unregister a message handler
+     */
+    off(type: WorkerMessageType): void;
+    /**
+     * Dispose the channel
+     */
+    dispose(): void;
+    /**
+     * Setup message handler for incoming messages
+     */
+    private setupMessageHandler;
+    /**
+     * Handle incoming request
+     */
+    private handleRequest;
+    /**
+     * Handle incoming response
+     */
+    private handleResponse;
+    /**
+     * Send a response message
+     */
+    private sendResponse;
+    /**
+     * Check if message is a response
+     */
+    private isResponse;
+    /**
+     * Check if message is a request
+     */
+    private isRequest;
+    /**
+     * Generate unique message ID
+     */
+    private generateMessageId;
+    /**
+     * Send a notification message without waiting for response
+     * Alias for post() method for compatibility
+     */
+    notify<T = any>(type: WorkerMessageType | string, payload?: T, transfer?: Transferable[]): void;
+    /**
+     * Register a message handler
+     * Alias for on() method for compatibility
+     */
+    registerHandler<T = any, R = any>(type: WorkerMessageType | string, handler: MessageHandler<T, R>): void;
+    /**
+     * Send a ReadableStream to another worker
+     * Automatically handles transferable streams vs chunk-by-chunk fallback
+     */
+    sendStream<T = Uint8Array>(stream: ReadableStream<T>, metadata?: {
+        type?: string;
+        url?: string;
+        streamId?: string;
+        [key: string]: any;
+    }): Promise<void>;
+    /**
+     * Stream chunks from a ReadableStream (fallback when transfer is not supported)
+     */
+    private streamChunks;
+    /**
+     * Receive a stream from another worker
+     * Handles both transferable streams and chunk-by-chunk reconstruction
+     */
+    receiveStream<T = Uint8Array>(onStream: (stream: ReadableStream<T>, metadata?: Record<string, any>) => void): Promise<void>;
+}
+//# sourceMappingURL=WorkerChannel.d.ts.map

package/dist/worker/WorkerChannel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkerChannel.d.ts","sourceRoot":"","sources":["../../src/worker/WorkerChannel.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAIL,iBAAiB,EACjB,cAAc,EACd,cAAc,EACd,eAAe,EACf,WAAW,EACX,QAAQ,EACT,MAAM,SAAS,CAAC;AACjB,OAAO,EAAa,WAAW,EAAsB,MAAM,gBAAgB,CAAC;AAG5E,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,aAAa;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,CAAC;IACf,eAAe,8BAAqC;IACpD,eAAe,EAAE,eAAe,CAAM;IACtC,KAAK,EAAE,WAAW,CAAoB;IACtC,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;gBAEd,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,mBAAmB;IAUvD;;OAEG;IACG,IAAI,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,EACzB,IAAI,EAAE,iBAAiB,EACvB,OAAO,CAAC,EAAE,CAAC,EACX,OAAO,CAAC,EAAE;QACR,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,EAAE,YAAY,EAAE,CAAC;QAC1B,WAAW,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;KACpC,GACA,OAAO,CAAC,CAAC,CAAC;IAcb;;OAEG;YACW,QAAQ;IAoDtB;;OAEG;IACH,IAAI,CAAC,CAAC,GAAG,GAAG,EAAE,IAAI,EAAE,iBAAiB,EAAE,OAAO,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,EAAE,YAAY,EAAE,GAAG,IAAI;IAepF;;OAEG;IACH,EAAE,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,EAAE,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI;IAIlF;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,iBAAiB,GAAG,IAAI;IAIlC;;OAEG;IACH,OAAO,IAAI,IAAI;IAgBf;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAkB3B;;OAEG;YACW,aAAa;IAgC3B;;OAEG;IACH,OAAO,CAAC,cAAc;IAwBtB;;OAEG;IACH,OAAO,CAAC,YAAY;IAiBpB;;OAEG;IACH,OAAO,CAAC,UAAU;IAMlB;;OAEG;IACH,OAAO,CAAC,SAAS;IAIjB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAIzB;;;OAGG;IACH,MAAM,CAAC,CAAC,GAAG,GAAG,EAAE,IAAI,EAAE,iBAAiB,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,EAAE,YAAY,EAAE,GAAG,IAAI;IAI/F;;;OAGG;IACH,eAAe,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,EAC9B,IAAI,EAAE,iBAAiB,GAAG,MAAM,EAChC,OAAO,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,GAC5B,IAAI;IAIP;;;OAGG;IACG,UAAU,CAAC,CAAC,GAAG,UAAU,EAC7B,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,EACzB,QAAQ,CAAC,EAAE;QACT,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KACpB,GACA,OAAO,CAAC,IAAI,CAAC;IAoBhB;;OAEG;YACW,YAAY;IAkE1B;;;OAGG;IACG,aAAa,CAAC,CAAC,GAAG,UAAU,EAChC,QAAQ,EAAE,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,IAAI,GAC5E,OAAO,CAAC,IAAI,CAAC;CAsEjB"}

package/dist/worker/WorkerChannel.js

@@ -0,0 +1,355 @@
+import { WorkerState } from "./types.js";
+import { withRetry, defaultRetryConfig } from "./worker-retry.js";
+import { isTransferable, extractTransferables } from "./transferable-helper.js";
+class WorkerChannel {
+  name;
+  port;
+  pendingRequests = /* @__PURE__ */ new Map();
+  messageHandlers = {};
+  state = WorkerState.Idle;
+  defaultTimeout;
+  defaultMaxRetries;
+  constructor(port, config) {
+    this.name = config.name;
+    this.port = port;
+    this.defaultTimeout = config.timeout ?? 3e4;
+    this.defaultMaxRetries = config.maxRetries ?? 3;
+    this.setupMessageHandler();
+    this.state = WorkerState.Ready;
+  }
+  /**
+   * Send a message and wait for response with retry support
+   */
+  async send(type, payload, options) {
+    const maxRetries = options?.maxRetries ?? this.defaultMaxRetries;
+    const retryConfig = {
+      ...defaultRetryConfig,
+      maxRetries,
+      ...options?.retryConfig
+    };
+    return withRetry(() => this.sendOnce(type, payload, options), retryConfig);
+  }
+  /**
+   * Send a message once (without retry)
+   */
+  async sendOnce(type, payload, options) {
+    const id = this.generateMessageId();
+    const timeout = options?.timeout ?? this.defaultTimeout;
+    const message = {
+      type,
+      id,
+      payload,
+      timestamp: Date.now()
+    };
+    return new Promise((resolve, reject) => {
+      const request = {
+        id,
+        type,
+        timestamp: Date.now(),
+        timeout,
+        resolve,
+        reject
+      };
+      this.pendingRequests.set(id, request);
+      const timeoutId = setTimeout(() => {
+        const pending = this.pendingRequests.get(id);
+        if (pending) {
+          this.pendingRequests.delete(id);
+          const error = new Error(`Request timeout: ${id} ${type} (${timeout}ms)`);
+          error.code = "TIMEOUT";
+          pending.reject(error);
+        }
+      }, timeout);
+      request.timeoutId = timeoutId;
+      if (options?.transfer) {
+        this.port.postMessage(message, options.transfer);
+      } else {
+        this.port.postMessage(message);
+      }
+    });
+  }
+  /**
+   * Send a message without waiting for response
+   */
+  post(type, payload, transfer) {
+    const message = {
+      type,
+      id: this.generateMessageId(),
+      payload,
+      timestamp: Date.now()
+    };
+    if (transfer) {
+      this.port.postMessage(message, transfer);
+    } else {
+      this.port.postMessage(message);
+    }
+  }
+  /**
+   * Register a message handler
+   */
+  on(type, handler) {
+    this.messageHandlers[type] = handler;
+  }
+  /**
+   * Unregister a message handler
+   */
+  off(type) {
+    delete this.messageHandlers[type];
+  }
+  /**
+   * Dispose the channel
+   */
+  dispose() {
+    this.state = WorkerState.Disposed;
+    for (const [, request] of this.pendingRequests) {
+      if (request.timeoutId) {
+        clearTimeout(request.timeoutId);
+      }
+      request.reject(new Error("Channel disposed"));
+    }
+    this.pendingRequests.clear();
+    this.port.onmessage = null;
+  }
+  /**
+   * Setup message handler for incoming messages
+   */
+  setupMessageHandler() {
+    this.port.onmessage = async (event) => {
+      const data = event.data;
+      if (this.isResponse(data)) {
+        this.handleResponse(data);
+        return;
+      }
+      if (this.isRequest(data)) {
+        await this.handleRequest(data);
+        return;
+      }
+    };
+  }
+  /**
+   * Handle incoming request
+   */
+  async handleRequest(message) {
+    const handler = this.messageHandlers[message.type];
+    if (!handler) {
+      this.sendResponse(message.id, false, null, {
+        code: "NO_HANDLER",
+        message: `No handler registered for message type: ${message.type}`
+      });
+      return;
+    }
+    this.state = WorkerState.Processing;
+    Promise.resolve().then(() => handler(message.payload, message.transfer)).then((result) => {
+      this.sendResponse(message.id, true, result);
+      this.state = WorkerState.Ready;
+    }).catch((error) => {
+      const workerError = {
+        code: "HANDLER_ERROR",
+        message: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0
+      };
+      this.sendResponse(message.id, false, null, workerError);
+      this.state = WorkerState.Ready;
+    });
+  }
+  /**
+   * Handle incoming response
+   */
+  handleResponse(response) {
+    const request = this.pendingRequests.get(response.id);
+    if (!request) {
+      return;
+    }
+    this.pendingRequests.delete(response.id);
+    if (request.timeoutId) {
+      clearTimeout(request.timeoutId);
+    }
+    if (response.success) {
+      request.resolve(response.result);
+    } else {
+      const error = new Error(response.error?.message || "Unknown error");
+      if (response.error) {
+        Object.assign(error, response.error);
+      }
+      request.reject(error);
+    }
+  }
+  /**
+   * Send a response message
+   */
+  sendResponse(id, success, result, error) {
+    let transfer = [];
+    if (isTransferable(result)) {
+      transfer.push(result);
+    }
+    const response = {
+      id,
+      success,
+      result,
+      error,
+      timestamp: Date.now()
+    };
+    this.port.postMessage(response, transfer);
+  }
+  /**
+   * Check if message is a response
+   */
+  isResponse(data) {
+    return data && typeof data === "object" && "id" in data && "success" in data && !("type" in data);
+  }
+  /**
+   * Check if message is a request
+   */
+  isRequest(data) {
+    return data && typeof data === "object" && "id" in data && "type" in data;
+  }
+  /**
+   * Generate unique message ID
+   */
+  generateMessageId() {
+    return `${this.name}-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+  }
+  /**
+   * Send a notification message without waiting for response
+   * Alias for post() method for compatibility
+   */
+  notify(type, payload, transfer) {
+    this.post(type, payload, transfer);
+  }
+  /**
+   * Register a message handler
+   * Alias for on() method for compatibility
+   */
+  registerHandler(type, handler) {
+    this.on(type, handler);
+  }
+  /**
+   * Send a ReadableStream to another worker
+   * Automatically handles transferable streams vs chunk-by-chunk fallback
+   */
+  async sendStream(stream, metadata) {
+    const streamId = metadata?.streamId || this.generateMessageId();
+    if (isTransferable(stream)) {
+      this.port.postMessage(
+        {
+          type: "stream_transfer",
+          ...metadata,
+          stream,
+          streamId
+        },
+        [stream]
+        // Transfer ownership
+      );
+    } else {
+      await this.streamChunks(stream, streamId, metadata);
+    }
+  }
+  /**
+   * Stream chunks from a ReadableStream (fallback when transfer is not supported)
+   */
+  async streamChunks(stream, streamId, metadata) {
+    const reader = stream.getReader();
+    this.post("stream_start", {
+      streamId,
+      ...metadata,
+      mode: "chunk_transfer"
+    });
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          this.post("stream_end", {
+            streamId,
+            ...metadata
+          });
+          break;
+        }
+        const transfer = [];
+        if (value instanceof ArrayBuffer) {
+          transfer.push(value);
+        } else if (value instanceof Uint8Array) {
+          transfer.push(value.buffer);
+        } else if (typeof AudioData !== "undefined" && value instanceof AudioData) {
+          transfer.push(value);
+        } else if (typeof VideoFrame !== "undefined" && value instanceof VideoFrame) {
+          transfer.push(value);
+        } else if (typeof value === "object" && value !== null) {
+          const extracted = extractTransferables(value);
+          transfer.push(...extracted);
+        }
+        this.post(
+          "stream_chunk",
+          {
+            streamId,
+            chunk: value,
+            ...metadata
+          },
+          transfer
+        );
+      }
+    } catch (error) {
+      this.post("stream_error", {
+        streamId,
+        error: error instanceof Error ? error.message : String(error),
+        ...metadata
+      });
+      throw error;
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  /**
+   * Receive a stream from another worker
+   * Handles both transferable streams and chunk-by-chunk reconstruction
+   */
+  async receiveStream(onStream) {
+    const chunkedStreams = /* @__PURE__ */ new Map();
+    const prev = this.port.onmessage;
+    const handler = (event) => {
+      const raw = event.data;
+      const envelopeType = raw?.type;
+      const hasPayload = raw && typeof raw === "object" && "payload" in raw;
+      const payload = hasPayload ? raw.payload : raw;
+      if (envelopeType === "stream_transfer" && payload?.stream) {
+        onStream(payload.stream, payload);
+        return;
+      }
+      if (envelopeType === "stream_start" && payload?.streamId) {
+        const stream = new ReadableStream({
+          start(controller) {
+            chunkedStreams.set(payload.streamId, { controller, metadata: payload });
+          }
+        });
+        onStream(stream, payload);
+        return;
+      }
+      if (envelopeType === "stream_chunk" && payload?.streamId && chunkedStreams.has(payload.streamId)) {
+        const s = chunkedStreams.get(payload.streamId);
+        if (s) s.controller.enqueue(payload.chunk);
+        return;
+      }
+      if (envelopeType === "stream_end" && payload?.streamId && chunkedStreams.has(payload.streamId)) {
+        const s = chunkedStreams.get(payload.streamId);
+        if (s) {
+          s.controller.close();
+          chunkedStreams.delete(payload.streamId);
+        }
+        return;
+      }
+      if (envelopeType === "stream_error" && payload?.streamId && chunkedStreams.has(payload.streamId)) {
+        const s = chunkedStreams.get(payload.streamId);
+        if (s) {
+          s.controller.error(new Error(String(payload.error || "stream error")));
+          chunkedStreams.delete(payload.streamId);
+        }
+        return;
+      }
+      if (typeof prev === "function") prev.call(this.port, event);
+    };
+    this.port.onmessage = handler;
+  }
+}
+export {
+  WorkerChannel
+};
+//# sourceMappingURL=WorkerChannel.js.map