@meframe/core 0.0.1

package/dist/stages/mux/types.d.ts

@@ -0,0 +1,95 @@
+export interface MuxConfig {
+    container: 'mp4';
+    output?: {
+        target: 'blob' | 'opfs' | 'stream';
+        filePath?: string;
+        stream?: WritableStream<Uint8Array>;
+    };
+    video?: {
+        codec: string;
+        width: number;
+        height: number;
+        frameRate?: number;
+        bitrate?: number;
+        description?: Uint8Array;
+    };
+    audio?: {
+        codec: string;
+        sampleRate: number;
+        channelCount: number;
+        bitrate?: number;
+        description?: Uint8Array;
+    };
+    mp4?: {
+        fragmentDuration?: number;
+        fragmented?: boolean;
+        fastStart?: boolean;
+        brands?: string[];
+    };
+    metadata?: {
+        title?: string;
+        artist?: string;
+        album?: string;
+        date?: string;
+        comment?: string;
+        custom?: Record<string, string>;
+    };
+    performance?: {
+        bufferSize?: number;
+        flushInterval?: number;
+        maxMemory?: number;
+    };
+}
+export interface MuxSample {
+    trackId: number;
+    data: Uint8Array;
+    timestamp: number;
+    dts?: number;
+    duration: number;
+    isKeyFrame: boolean;
+    flags?: {
+        isLeading?: number;
+        dependsOn?: number;
+        isDependedOn?: number;
+        hasRedundancy?: number;
+        degradationPriority?: number;
+    };
+}
+export interface MuxTrack {
+    id: number;
+    type: 'video' | 'audio';
+    codec: string;
+    timescale: number;
+    duration?: number;
+    width?: number;
+    height?: number;
+    frameRate?: number;
+    sampleRate?: number;
+    channelCount?: number;
+    codecConfig?: Uint8Array;
+}
+export interface MuxerEvents {
+    onReady?: () => void;
+    onProgress?: (written: number) => void;
+    onError?: (error: Error) => void;
+    onComplete?: (output: Blob | FileSystemFileHandle | void) => void;
+}
+export interface BaseMuxer {
+    configure(config: MuxConfig): Promise<void>;
+    addTrack(track: MuxTrack): number;
+    writeSample(sample: MuxSample): void;
+    flush(): Promise<void>;
+    finalize(): Promise<Blob | FileSystemFileHandle | void>;
+    reset(): void;
+    destroy(): void;
+}
+export interface MuxerOptions {
+    config: MuxConfig;
+    events?: MuxerEvents;
+}
+export interface EncodedChunkData {
+    type: 'video' | 'audio';
+    chunk: EncodedVideoChunk | EncodedAudioChunk;
+    trackId: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/stages/mux/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/stages/mux/types.ts"],"names":[],"mappings":"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"}

package/dist/stages/mux/utils.d.ts

@@ -0,0 +1,32 @@
+import { EncodedChunkData, MuxSample } from './types';
+
+/**
+ * Convert WebCodecs EncodedChunk to MuxSample
+ */
+export declare function encodedChunkToMuxSample(data: EncodedChunkData): MuxSample;
+/**
+ * Convert microseconds to timescale units
+ */
+export declare function usToTimescale(microseconds: number, timescale: number): number;
+/**
+ * Convert timescale units to microseconds
+ */
+export declare function timescaleToUs(units: number, timescale: number): number;
+/**
+ * Calculate optimal timescale for given frame rate
+ */
+export declare function calculateTimescale(frameRate?: number): number;
+/**
+ * Parse codec string to extract codec parameters
+ * e.g., 'avc1.42E01E' -> { codec: 'avc1', profile: '42', level: '1E' }
+ */
+export declare function parseCodecString(codec: string): {
+    codec: string;
+    profile?: string;
+    level?: string;
+};
+/**
+ * Create MP4 file brands based on codec
+ */
+export declare function createBrands(codecs: string[]): string[];
+//# sourceMappingURL=utils.d.ts.map

package/dist/stages/mux/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/stages/mux/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAE3D;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,gBAAgB,GAAG,SAAS,CAczE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAE7E;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAa7D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAiBA;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAkBvD"}

package/dist/stages/mux/utils.js

@@ -0,0 +1,34 @@
+function usToTimescale(microseconds, timescale) {
+  return Math.round(microseconds * timescale / 1e6);
+}
+function calculateTimescale(frameRate) {
+  if (!frameRate) return 9e4;
+  const commonRates = {
+    24: 24e3,
+    25: 25e3,
+    30: 3e4,
+    50: 5e4,
+    60: 6e4
+  };
+  return commonRates[Math.round(frameRate)] || 9e4;
+}
+function parseCodecString(codec) {
+  const parts = codec.split(".");
+  const result = { codec: parts[0] };
+  if (parts[0] === "avc1" || parts[0] === "hev1" || parts[0] === "hvc1") {
+    if (parts[1]) {
+      result.profile = parts[1].substring(0, 2);
+      result.level = parts[1].substring(4, 6);
+    }
+  } else if (parts[0] === "mp4a") {
+    if (parts[1]) result.objectType = parts[1];
+    if (parts[2]) result.audioObjectType = parts[2];
+  }
+  return result;
+}
+export {
+  calculateTimescale,
+  parseCodecString,
+  usToTimescale
+};
+//# sourceMappingURL=utils.js.map

package/dist/stages/mux/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../../src/stages/mux/utils.ts"],"sourcesContent":["import type { EncodedChunkData, MuxSample } from './types';\n\n/**\n * Convert WebCodecs EncodedChunk to MuxSample\n */\nexport function encodedChunkToMuxSample(data: EncodedChunkData): MuxSample {\n  const { chunk, trackId, type } = data;\n\n  // Create buffer for chunk data\n  const buffer = new Uint8Array(chunk.byteLength);\n  chunk.copyTo(buffer);\n\n  return {\n    trackId,\n    data: buffer,\n    timestamp: chunk.timestamp,\n    duration: chunk.duration || 0,\n    isKeyFrame: type === 'video' ? (chunk as EncodedVideoChunk).type === 'key' : true, // Audio samples are always \"key frames\"\n  };\n}\n\n/**\n * Convert microseconds to timescale units\n */\nexport function usToTimescale(microseconds: number, timescale: number): number {\n  return Math.round((microseconds * timescale) / 1_000_000);\n}\n\n/**\n * Convert timescale units to microseconds\n */\nexport function timescaleToUs(units: number, timescale: number): number {\n  return Math.round((units * 1_000_000) / timescale);\n}\n\n/**\n * Calculate optimal timescale for given frame rate\n */\nexport function calculateTimescale(frameRate?: number): number {\n  if (!frameRate) return 90000; // Default for video\n\n  // Common frame rates and their optimal timescales\n  const commonRates: Record<number, number> = {\n    24: 24000,\n    25: 25000,\n    30: 30000,\n    50: 50000,\n    60: 60000,\n  };\n\n  return commonRates[Math.round(frameRate)] || 90000;\n}\n\n/**\n * Parse codec string to extract codec parameters\n * e.g., 'avc1.42E01E' -> { codec: 'avc1', profile: '42', level: '1E' }\n */\nexport function parseCodecString(codec: string): {\n  codec: string;\n  profile?: string;\n  level?: string;\n} {\n  const parts = codec.split('.');\n  const result: any = { codec: parts[0] };\n\n  if (parts[0] === 'avc1' || parts[0] === 'hev1' || parts[0] === 'hvc1') {\n    // H.264/H.265 codec string format\n    if (parts[1]) {\n      result.profile = parts[1].substring(0, 2);\n      result.level = parts[1].substring(4, 6);\n    }\n  } else if (parts[0] === 'mp4a') {\n    // AAC codec string format\n    if (parts[1]) result.objectType = parts[1];\n    if (parts[2]) result.audioObjectType = parts[2];\n  }\n\n  return result;\n}\n\n/**\n * Create MP4 file brands based on codec\n */\nexport function createBrands(codecs: string[]): string[] {\n  const brands = new Set<string>(['isom', 'iso2']);\n\n  for (const codec of codecs) {\n    if (codec.startsWith('avc1')) {\n      brands.add('avc1');\n      brands.add('mp41');\n    } else if (codec.startsWith('hev1') || codec.startsWith('hvc1')) {\n      brands.add('hev1');\n      brands.add('hvc1');\n    } else if (codec.startsWith('av01')) {\n      brands.add('av01');\n    } else if (codec.startsWith('mp4a')) {\n      brands.add('mp41');\n    }\n  }\n\n  return Array.from(brands);\n}\n"],"names":[],"mappings":"AAwBO,SAAS,cAAc,cAAsB,WAA2B;AAC7E,SAAO,KAAK,MAAO,eAAe,YAAa,GAAS;AAC1D;AAYO,SAAS,mBAAmB,WAA4B;AAC7D,MAAI,CAAC,UAAW,QAAO;AAGvB,QAAM,cAAsC;AAAA,IAC1C,IAAI;AAAA,IACJ,IAAI;AAAA,IACJ,IAAI;AAAA,IACJ,IAAI;AAAA,IACJ,IAAI;AAAA,EAAA;AAGN,SAAO,YAAY,KAAK,MAAM,SAAS,CAAC,KAAK;AAC/C;AAMO,SAAS,iBAAiB,OAI/B;AACA,QAAM,QAAQ,MAAM,MAAM,GAAG;AAC7B,QAAM,SAAc,EAAE,OAAO,MAAM,CAAC,EAAA;AAEpC,MAAI,MAAM,CAAC,MAAM,UAAU,MAAM,CAAC,MAAM,UAAU,MAAM,CAAC,MAAM,QAAQ;AAErE,QAAI,MAAM,CAAC,GAAG;AACZ,aAAO,UAAU,MAAM,CAAC,EAAE,UAAU,GAAG,CAAC;AACxC,aAAO,QAAQ,MAAM,CAAC,EAAE,UAAU,GAAG,CAAC;AAAA,IACxC;AAAA,EACF,WAAW,MAAM,CAAC,MAAM,QAAQ;AAE9B,QAAI,MAAM,CAAC,EAAG,QAAO,aAAa,MAAM,CAAC;AACzC,QAAI,MAAM,CAAC,EAAG,QAAO,kBAAkB,MAAM,CAAC;AAAA,EAChD;AAEA,SAAO;AACT;"}

package/dist/types.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Core type definitions
+ */
+export type { MeframeConfig, ResolvedConfig } from './config/types';
+export type MeframeState = 'idle' | 'loading' | 'ready' | 'playing' | 'paused' | 'exporting' | 'error' | 'destroyed';
+export interface ExportOptions {
+    /** Output format */
+    format: 'mp4' | 'webm';
+    /** Video codec */
+    videoCodec?: 'h264' | 'h265' | 'vp9' | 'av1';
+    /** Audio codec */
+    audioCodec?: 'aac' | 'opus';
+    /** Video bitrate in bps */
+    videoBitrate?: number;
+    /** Audio bitrate in bps */
+    audioBitrate?: number;
+    /** Output resolution */
+    width?: number;
+    height?: number;
+    /** Frame rate */
+    fps?: number;
+    /** Quality preset */
+    quality?: 'low' | 'medium' | 'high' | 'highest';
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEpE,MAAM,MAAM,YAAY,GACpB,MAAM,GACN,SAAS,GACT,OAAO,GACP,SAAS,GACT,QAAQ,GACR,WAAW,GACX,OAAO,GACP,WAAW,CAAC;AAEhB,MAAM,WAAW,aAAa;IAC5B,oBAAoB;IACpB,MAAM,EAAE,KAAK,GAAG,MAAM,CAAC;IAEvB,kBAAkB;IAClB,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC;IAE7C,kBAAkB;IAClB,UAAU,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IAE5B,2BAA2B;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,2BAA2B;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,wBAAwB;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,iBAAiB;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb,qBAAqB;IACrB,OAAO,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;CACjD"}

package/dist/utils/BackpressureAdapter.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Backpressure adapter for bridging Stream API with non-stream components
+ * Handles MessageChannel and GPU boundaries
+ */
+export declare class BackpressureAdapter {
+    /**
+     * Monitor MessageChannel capacity
+     */
+    createMessageChannelBridge<T>(port: MessagePort, options?: {
+        maxPendingMessages?: number;
+        highWaterMark?: number;
+    }): WritableStream<T>;
+    /**
+     * Create GPU upload throttle
+     */
+    createGPUThrottle(maxTextureMemory?: number): TransformStream<VideoFrame, VideoFrame>;
+    /**
+     * Memory-aware transform with automatic degradation
+     */
+    createMemoryAwareTransform<T>(options?: {
+        maxMemoryBytes?: number;
+        onMemoryPressure?: () => void;
+        estimateSize?: (item: T) => number;
+    }): TransformStream<T, T>;
+}
+//# sourceMappingURL=BackpressureAdapter.d.ts.map

package/dist/utils/BackpressureAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BackpressureAdapter.d.ts","sourceRoot":"","sources":["../../src/utils/BackpressureAdapter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,mBAAmB;IAC9B;;OAEG;IACH,0BAA0B,CAAC,CAAC,EAC1B,IAAI,EAAE,WAAW,EACjB,OAAO,GAAE;QACP,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;KACnB,GACL,cAAc,CAAC,CAAC,CAAC;IAyCpB;;OAEG;IACH,iBAAiB,CACf,gBAAgB,GAAE,MAA0B,GAC3C,eAAe,CAAC,UAAU,EAAE,UAAU,CAAC;IAwB1C;;OAEG;IACH,0BAA0B,CAAC,CAAC,EAC1B,OAAO,GAAE;QACP,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,gBAAgB,CAAC,EAAE,MAAM,IAAI,CAAC;QAC9B,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,CAAC;KAC/B,GACL,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC;CAgCzB"}

package/dist/utils/binary-search.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Binary search utilities for sorted arrays
+ */
+/**
+ * Find the first index where the predicate returns true
+ * Assumes array is sorted such that predicate returns false for all elements before target
+ * and true for all elements at or after target
+ */
+export declare function binarySearchFirst<T>(array: T[], predicate: (item: T) => boolean): number;
+/**
+ * Find an item in a sorted array that contains a given value within its range
+ * @param array - Sorted array of items with ranges
+ * @param value - Value to search for
+ * @param getRange - Function to get start and end values from an item
+ * @returns The item containing the value, or null if not found
+ */
+export declare function binarySearchRange<T>(array: T[], value: number, getRange: (item: T) => {
+    start: number;
+    end: number;
+}): T | null;
+/**
+ * Find all items in a sorted array that overlap with a given range
+ * @param array - Sorted array of items with ranges
+ * @param startValue - Start of the search range (inclusive)
+ * @param endValue - End of the search range (exclusive)
+ * @param getRange - Function to get start and end values from an item
+ * @returns Array of items that overlap with the search range
+ */
+export declare function binarySearchOverlapping<T>(array: T[], startValue: number, endValue: number, getRange: (item: T) => {
+    start: number;
+    end: number;
+}): T[];
+//# sourceMappingURL=binary-search.d.ts.map

package/dist/utils/binary-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-search.d.ts","sourceRoot":"","sources":["../../src/utils/binary-search.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAAG,MAAM,CAiBxF;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GACpD,CAAC,GAAG,IAAI,CAoBV;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EACvC,KAAK,EAAE,CAAC,EAAE,EACV,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GACpD,CAAC,EAAE,CA+BL"}

package/dist/utils/binary-search.js

@@ -0,0 +1,62 @@
+function binarySearchFirst(array, predicate) {
+  let left = 0;
+  let right = array.length - 1;
+  let firstIndex = array.length;
+  while (left <= right) {
+    const mid = Math.floor((left + right) / 2);
+    const midItem = array[mid];
+    if (midItem && predicate(midItem)) {
+      firstIndex = mid;
+      right = mid - 1;
+    } else {
+      left = mid + 1;
+    }
+  }
+  return firstIndex;
+}
+function binarySearchRange(array, value, getRange) {
+  let left = 0;
+  let right = array.length - 1;
+  while (left <= right) {
+    const mid = Math.floor((left + right) / 2);
+    const item = array[mid];
+    if (!item) return null;
+    const range = getRange(item);
+    if (value >= range.start && value < range.end) {
+      return item;
+    } else if (value < range.start) {
+      right = mid - 1;
+    } else {
+      left = mid + 1;
+    }
+  }
+  return null;
+}
+function binarySearchOverlapping(array, startValue, endValue, getRange) {
+  if (startValue >= endValue) {
+    return [];
+  }
+  const firstIndex = binarySearchFirst(array, (item) => {
+    const range = getRange(item);
+    return range.end > startValue;
+  });
+  const results = [];
+  for (let i = firstIndex; i < array.length; i++) {
+    const item = array[i];
+    if (!item) continue;
+    const range = getRange(item);
+    if (range.start >= endValue) {
+      break;
+    }
+    if (range.start < endValue && range.end > startValue) {
+      results.push(item);
+    }
+  }
+  return results;
+}
+export {
+  binarySearchFirst,
+  binarySearchOverlapping,
+  binarySearchRange
+};
+//# sourceMappingURL=binary-search.js.map

package/dist/utils/binary-search.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-search.js","sources":["../../src/utils/binary-search.ts"],"sourcesContent":["/**\n * Binary search utilities for sorted arrays\n */\n\n/**\n * Find the first index where the predicate returns true\n * Assumes array is sorted such that predicate returns false for all elements before target\n * and true for all elements at or after target\n */\nexport function binarySearchFirst<T>(array: T[], predicate: (item: T) => boolean): number {\n  let left = 0;\n  let right = array.length - 1;\n  let firstIndex = array.length;\n\n  while (left <= right) {\n    const mid = Math.floor((left + right) / 2);\n    const midItem = array[mid];\n    if (midItem && predicate(midItem)) {\n      firstIndex = mid;\n      right = mid - 1;\n    } else {\n      left = mid + 1;\n    }\n  }\n\n  return firstIndex;\n}\n\n/**\n * Find an item in a sorted array that contains a given value within its range\n * @param array - Sorted array of items with ranges\n * @param value - Value to search for\n * @param getRange - Function to get start and end values from an item\n * @returns The item containing the value, or null if not found\n */\nexport function binarySearchRange<T>(\n  array: T[],\n  value: number,\n  getRange: (item: T) => { start: number; end: number }\n): T | null {\n  let left = 0;\n  let right = array.length - 1;\n\n  while (left <= right) {\n    const mid = Math.floor((left + right) / 2);\n    const item = array[mid];\n    if (!item) return null;\n    const range = getRange(item);\n\n    if (value >= range.start && value < range.end) {\n      return item;\n    } else if (value < range.start) {\n      right = mid - 1;\n    } else {\n      left = mid + 1;\n    }\n  }\n\n  return null;\n}\n\n/**\n * Find all items in a sorted array that overlap with a given range\n * @param array - Sorted array of items with ranges\n * @param startValue - Start of the search range (inclusive)\n * @param endValue - End of the search range (exclusive)\n * @param getRange - Function to get start and end values from an item\n * @returns Array of items that overlap with the search range\n */\nexport function binarySearchOverlapping<T>(\n  array: T[],\n  startValue: number,\n  endValue: number,\n  getRange: (item: T) => { start: number; end: number }\n): T[] {\n  // Invalid range (start >= end) doesn't overlap with anything\n  // This includes empty ranges where start === end\n  if (startValue >= endValue) {\n    return [];\n  }\n\n  // Find first item that might overlap (its end > startValue)\n  const firstIndex = binarySearchFirst(array, (item) => {\n    const range = getRange(item);\n    return range.end > startValue;\n  });\n\n  const results: T[] = [];\n  for (let i = firstIndex; i < array.length; i++) {\n    const item = array[i];\n    if (!item) continue;\n    const range = getRange(item);\n\n    // Stop if we've passed the search range\n    if (range.start >= endValue) {\n      break;\n    }\n\n    // Add if overlapping\n    if (range.start < endValue && range.end > startValue) {\n      results.push(item);\n    }\n  }\n\n  return results;\n}\n"],"names":[],"mappings":"AASO,SAAS,kBAAqB,OAAY,WAAyC;AACxF,MAAI,OAAO;AACX,MAAI,QAAQ,MAAM,SAAS;AAC3B,MAAI,aAAa,MAAM;AAEvB,SAAO,QAAQ,OAAO;AACpB,UAAM,MAAM,KAAK,OAAO,OAAO,SAAS,CAAC;AACzC,UAAM,UAAU,MAAM,GAAG;AACzB,QAAI,WAAW,UAAU,OAAO,GAAG;AACjC,mBAAa;AACb,cAAQ,MAAM;AAAA,IAChB,OAAO;AACL,aAAO,MAAM;AAAA,IACf;AAAA,EACF;AAEA,SAAO;AACT;AASO,SAAS,kBACd,OACA,OACA,UACU;AACV,MAAI,OAAO;AACX,MAAI,QAAQ,MAAM,SAAS;AAE3B,SAAO,QAAQ,OAAO;AACpB,UAAM,MAAM,KAAK,OAAO,OAAO,SAAS,CAAC;AACzC,UAAM,OAAO,MAAM,GAAG;AACtB,QAAI,CAAC,KAAM,QAAO;AAClB,UAAM,QAAQ,SAAS,IAAI;AAE3B,QAAI,SAAS,MAAM,SAAS,QAAQ,MAAM,KAAK;AAC7C,aAAO;AAAA,IACT,WAAW,QAAQ,MAAM,OAAO;AAC9B,cAAQ,MAAM;AAAA,IAChB,OAAO;AACL,aAAO,MAAM;AAAA,IACf;AAAA,EACF;AAEA,SAAO;AACT;AAUO,SAAS,wBACd,OACA,YACA,UACA,UACK;AAGL,MAAI,cAAc,UAAU;AAC1B,WAAO,CAAA;AAAA,EACT;AAGA,QAAM,aAAa,kBAAkB,OAAO,CAAC,SAAS;AACpD,UAAM,QAAQ,SAAS,IAAI;AAC3B,WAAO,MAAM,MAAM;AAAA,EACrB,CAAC;AAED,QAAM,UAAe,CAAA;AACrB,WAAS,IAAI,YAAY,IAAI,MAAM,QAAQ,KAAK;AAC9C,UAAM,OAAO,MAAM,CAAC;AACpB,QAAI,CAAC,KAAM;AACX,UAAM,QAAQ,SAAS,IAAI;AAG3B,QAAI,MAAM,SAAS,UAAU;AAC3B;AAAA,IACF;AAGA,QAAI,MAAM,QAAQ,YAAY,MAAM,MAAM,YAAY;AACpD,cAAQ,KAAK,IAAI;AAAA,IACnB;AAAA,EACF;AAEA,SAAO;AACT;"}

package/dist/utils/canvas-utils.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Canvas utility functions for handling DPI and high-quality rendering
+ */
+/**
+ * Setup canvas with proper DPI handling for Retina/HiDPI displays
+ *
+ * @param canvas - HTMLCanvasElement to configure
+ * @param displayWidth - CSS display width in logical pixels
+ * @param displayHeight - CSS display height in logical pixels
+ * @returns Actual canvas dimensions (considering DPI)
+ *
+ * @example
+ * const canvas = document.createElement('canvas');
+ * const dims = setupCanvasDPI(canvas, 540, 960);
+ * console.log(dims); // { width: 1080, height: 1920 } on 2x DPI screen
+ */
+export declare function setupCanvasDPI(canvas: HTMLCanvasElement, displayWidth: number, displayHeight: number): {
+    width: number;
+    height: number;
+};
+/**
+ * Get recommended composition canvas size based on display canvas
+ *
+ * @param displayCanvas - The preview canvas element
+ * @returns Recommended composition dimensions
+ *
+ * @example
+ * const canvas = document.getElementById('preview');
+ * const composeSize = getCompositionSize(canvas);
+ * // Use composeSize.width and composeSize.height for Meframe config
+ */
+export declare function getCompositionSize(displayCanvas: HTMLCanvasElement): {
+    width: number;
+    height: number;
+};
+/**
+ * Create a high-DPI canvas with proper settings
+ *
+ * @param container - Optional container element to append canvas to
+ * @param options - Canvas configuration options
+ * @returns Configured canvas element and its dimensions
+ *
+ * @example
+ * const { canvas, dimensions } = createHiDPICanvas(document.body, {
+ *   displayWidth: 540,
+ *   displayHeight: 960,
+ * });
+ *
+ * const meframe = await Meframe.create({
+ *   canvas,
+ *   config: {
+ *     compose: {
+ *       canvas: {
+ *         width: dimensions.width,
+ *         height: dimensions.height,
+ *       }
+ *     }
+ *   }
+ * });
+ */
+export declare function createHiDPICanvas(container?: HTMLElement, options?: {
+    displayWidth: number;
+    displayHeight: number;
+    className?: string;
+    id?: string;
+}): {
+    canvas: HTMLCanvasElement;
+    dimensions: {
+        width: number;
+        height: number;
+    };
+};
+/**
+ * Check if canvas DPI is properly configured
+ *
+ * @param canvas - Canvas element to check
+ * @returns Diagnostic information about canvas DPI setup
+ *
+ * @example
+ * const info = checkCanvasDPI(myCanvas);
+ * if (!info.isOptimal) {
+ *   console.warn('Canvas DPI not optimal:', info.message);
+ * }
+ */
+export declare function checkCanvasDPI(canvas: HTMLCanvasElement): {
+    dpr: number;
+    canvasWidth: number;
+    canvasHeight: number;
+    displayWidth: number;
+    displayHeight: number;
+    expectedWidth: number;
+    expectedHeight: number;
+    isOptimal: boolean;
+    message: string;
+};
+//# sourceMappingURL=canvas-utils.d.ts.map

package/dist/utils/canvas-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas-utils.d.ts","sourceRoot":"","sources":["../../src/utils/canvas-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,iBAAiB,EACzB,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,GACpB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAenC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,iBAAiB,GAAG;IACpE,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAKA;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,CAAC,EAAE,WAAW,EACvB,OAAO,GAAE;IACP,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,EAAE,CAAC,EAAE,MAAM,CAAC;CAC+B,GAC5C;IACD,MAAM,EAAE,iBAAiB,CAAC;IAC1B,UAAU,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CAC/C,CAkBA;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,iBAAiB,GAAG;IACzD,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB,CA6BA"}

package/dist/utils/canvas-utils.js

@@ -0,0 +1,58 @@
+function setupCanvasDPI(canvas, displayWidth, displayHeight) {
+  const dpr = window.devicePixelRatio || 1;
+  canvas.width = Math.round(displayWidth * dpr);
+  canvas.height = Math.round(displayHeight * dpr);
+  canvas.style.width = `${displayWidth}px`;
+  canvas.style.height = `${displayHeight}px`;
+  return {
+    width: canvas.width,
+    height: canvas.height
+  };
+}
+function createHiDPICanvas(container, options = { displayWidth: 540, displayHeight: 960 }) {
+  const canvas = document.createElement("canvas");
+  if (options.id) {
+    canvas.id = options.id;
+  }
+  if (options.className) {
+    canvas.className = options.className;
+  }
+  const dimensions = setupCanvasDPI(canvas, options.displayWidth, options.displayHeight);
+  if (container) {
+    container.appendChild(canvas);
+  }
+  return { canvas, dimensions };
+}
+function checkCanvasDPI(canvas) {
+  const dpr = window.devicePixelRatio || 1;
+  const displayWidth = canvas.clientWidth;
+  const displayHeight = canvas.clientHeight;
+  const expectedWidth = Math.round(displayWidth * dpr);
+  const expectedHeight = Math.round(displayHeight * dpr);
+  const widthMatch = Math.abs(canvas.width - expectedWidth) <= 1;
+  const heightMatch = Math.abs(canvas.height - expectedHeight) <= 1;
+  const isOptimal = widthMatch && heightMatch;
+  let message = "";
+  if (!isOptimal) {
+    message = `Canvas DPI mismatch! Expected ${expectedWidth}×${expectedHeight} but got ${canvas.width}×${canvas.height}. This will cause blurry rendering on ${dpr}x DPI screens.`;
+  } else {
+    message = `Canvas DPI is properly configured for ${dpr}x display.`;
+  }
+  return {
+    dpr,
+    canvasWidth: canvas.width,
+    canvasHeight: canvas.height,
+    displayWidth,
+    displayHeight,
+    expectedWidth,
+    expectedHeight,
+    isOptimal,
+    message
+  };
+}
+export {
+  checkCanvasDPI,
+  createHiDPICanvas,
+  setupCanvasDPI
+};
+//# sourceMappingURL=canvas-utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"canvas-utils.js","sources":["../../src/utils/canvas-utils.ts"],"sourcesContent":["/**\n * Canvas utility functions for handling DPI and high-quality rendering\n */\n\n/**\n * Setup canvas with proper DPI handling for Retina/HiDPI displays\n *\n * @param canvas - HTMLCanvasElement to configure\n * @param displayWidth - CSS display width in logical pixels\n * @param displayHeight - CSS display height in logical pixels\n * @returns Actual canvas dimensions (considering DPI)\n *\n * @example\n * const canvas = document.createElement('canvas');\n * const dims = setupCanvasDPI(canvas, 540, 960);\n * console.log(dims); // { width: 1080, height: 1920 } on 2x DPI screen\n */\nexport function setupCanvasDPI(\n  canvas: HTMLCanvasElement,\n  displayWidth: number,\n  displayHeight: number\n): { width: number; height: number } {\n  const dpr = window.devicePixelRatio || 1;\n\n  // Set actual canvas pixel dimensions (considering DPI)\n  canvas.width = Math.round(displayWidth * dpr);\n  canvas.height = Math.round(displayHeight * dpr);\n\n  // Set CSS display dimensions\n  canvas.style.width = `${displayWidth}px`;\n  canvas.style.height = `${displayHeight}px`;\n\n  return {\n    width: canvas.width,\n    height: canvas.height,\n  };\n}\n\n/**\n * Get recommended composition canvas size based on display canvas\n *\n * @param displayCanvas - The preview canvas element\n * @returns Recommended composition dimensions\n *\n * @example\n * const canvas = document.getElementById('preview');\n * const composeSize = getCompositionSize(canvas);\n * // Use composeSize.width and composeSize.height for Meframe config\n */\nexport function getCompositionSize(displayCanvas: HTMLCanvasElement): {\n  width: number;\n  height: number;\n} {\n  return {\n    width: displayCanvas.width,\n    height: displayCanvas.height,\n  };\n}\n\n/**\n * Create a high-DPI canvas with proper settings\n *\n * @param container - Optional container element to append canvas to\n * @param options - Canvas configuration options\n * @returns Configured canvas element and its dimensions\n *\n * @example\n * const { canvas, dimensions } = createHiDPICanvas(document.body, {\n *   displayWidth: 540,\n *   displayHeight: 960,\n * });\n *\n * const meframe = await Meframe.create({\n *   canvas,\n *   config: {\n *     compose: {\n *       canvas: {\n *         width: dimensions.width,\n *         height: dimensions.height,\n *       }\n *     }\n *   }\n * });\n */\nexport function createHiDPICanvas(\n  container?: HTMLElement,\n  options: {\n    displayWidth: number;\n    displayHeight: number;\n    className?: string;\n    id?: string;\n  } = { displayWidth: 540, displayHeight: 960 }\n): {\n  canvas: HTMLCanvasElement;\n  dimensions: { width: number; height: number };\n} {\n  const canvas = document.createElement('canvas');\n\n  if (options.id) {\n    canvas.id = options.id;\n  }\n\n  if (options.className) {\n    canvas.className = options.className;\n  }\n\n  const dimensions = setupCanvasDPI(canvas, options.displayWidth, options.displayHeight);\n\n  if (container) {\n    container.appendChild(canvas);\n  }\n\n  return { canvas, dimensions };\n}\n\n/**\n * Check if canvas DPI is properly configured\n *\n * @param canvas - Canvas element to check\n * @returns Diagnostic information about canvas DPI setup\n *\n * @example\n * const info = checkCanvasDPI(myCanvas);\n * if (!info.isOptimal) {\n *   console.warn('Canvas DPI not optimal:', info.message);\n * }\n */\nexport function checkCanvasDPI(canvas: HTMLCanvasElement): {\n  dpr: number;\n  canvasWidth: number;\n  canvasHeight: number;\n  displayWidth: number;\n  displayHeight: number;\n  expectedWidth: number;\n  expectedHeight: number;\n  isOptimal: boolean;\n  message: string;\n} {\n  const dpr = window.devicePixelRatio || 1;\n  const displayWidth = canvas.clientWidth;\n  const displayHeight = canvas.clientHeight;\n  const expectedWidth = Math.round(displayWidth * dpr);\n  const expectedHeight = Math.round(displayHeight * dpr);\n\n  const widthMatch = Math.abs(canvas.width - expectedWidth) <= 1;\n  const heightMatch = Math.abs(canvas.height - expectedHeight) <= 1;\n  const isOptimal = widthMatch && heightMatch;\n\n  let message = '';\n  if (!isOptimal) {\n    message = `Canvas DPI mismatch! Expected ${expectedWidth}×${expectedHeight} but got ${canvas.width}×${canvas.height}. This will cause blurry rendering on ${dpr}x DPI screens.`;\n  } else {\n    message = `Canvas DPI is properly configured for ${dpr}x display.`;\n  }\n\n  return {\n    dpr,\n    canvasWidth: canvas.width,\n    canvasHeight: canvas.height,\n    displayWidth,\n    displayHeight,\n    expectedWidth,\n    expectedHeight,\n    isOptimal,\n    message,\n  };\n}\n"],"names":[],"mappings":"AAiBO,SAAS,eACd,QACA,cACA,eACmC;AACnC,QAAM,MAAM,OAAO,oBAAoB;AAGvC,SAAO,QAAQ,KAAK,MAAM,eAAe,GAAG;AAC5C,SAAO,SAAS,KAAK,MAAM,gBAAgB,GAAG;AAG9C,SAAO,MAAM,QAAQ,GAAG,YAAY;AACpC,SAAO,MAAM,SAAS,GAAG,aAAa;AAEtC,SAAO;AAAA,IACL,OAAO,OAAO;AAAA,IACd,QAAQ,OAAO;AAAA,EAAA;AAEnB;AAgDO,SAAS,kBACd,WACA,UAKI,EAAE,cAAc,KAAK,eAAe,OAIxC;AACA,QAAM,SAAS,SAAS,cAAc,QAAQ;AAE9C,MAAI,QAAQ,IAAI;AACd,WAAO,KAAK,QAAQ;AAAA,EACtB;AAEA,MAAI,QAAQ,WAAW;AACrB,WAAO,YAAY,QAAQ;AAAA,EAC7B;AAEA,QAAM,aAAa,eAAe,QAAQ,QAAQ,cAAc,QAAQ,aAAa;AAErF,MAAI,WAAW;AACb,cAAU,YAAY,MAAM;AAAA,EAC9B;AAEA,SAAO,EAAE,QAAQ,WAAA;AACnB;AAcO,SAAS,eAAe,QAU7B;AACA,QAAM,MAAM,OAAO,oBAAoB;AACvC,QAAM,eAAe,OAAO;AAC5B,QAAM,gBAAgB,OAAO;AAC7B,QAAM,gBAAgB,KAAK,MAAM,eAAe,GAAG;AACnD,QAAM,iBAAiB,KAAK,MAAM,gBAAgB,GAAG;AAErD,QAAM,aAAa,KAAK,IAAI,OAAO,QAAQ,aAAa,KAAK;AAC7D,QAAM,cAAc,KAAK,IAAI,OAAO,SAAS,cAAc,KAAK;AAChE,QAAM,YAAY,cAAc;AAEhC,MAAI,UAAU;AACd,MAAI,CAAC,WAAW;AACd,cAAU,iCAAiC,aAAa,IAAI,cAAc,YAAY,OAAO,KAAK,IAAI,OAAO,MAAM,yCAAyC,GAAG;AAAA,EACjK,OAAO;AACL,cAAU,yCAAyC,GAAG;AAAA,EACxD;AAEA,SAAO;AAAA,IACL;AAAA,IACA,aAAa,OAAO;AAAA,IACpB,cAAc,OAAO;AAAA,IACrB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEJ;"}

package/dist/utils/object-utils.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Deep merge two objects recursively
+ * Later values override earlier ones
+ * Supports merging objects with different but compatible types
+ */
+export declare function deepMerge<T = any>(target: any, ...sources: any[]): T;
+/**
+ * Type-safe deep merge for configuration objects
+ * Ensures the result conforms to the target type structure
+ */
+export declare function deepMergeConfig<T extends Record<string, any>>(defaults: T, ...overrides: Array<Partial<Record<keyof T, any>>>): T;
+/**
+ * Get a nested value from an object using a path
+ * @param obj The object to query
+ * @param path Path to the value (e.g., 'a.b.c' or ['a', 'b', 'c'])
+ * @param defaultValue Default value if path doesn't exist
+ */
+export declare function get<T = any>(obj: any, path: string | string[], defaultValue?: T): T;
+/**
+ * Set a nested value in an object using a path
+ * @param obj The object to modify
+ * @param path Path to the value (e.g., 'a.b.c' or ['a', 'b', 'c'])
+ * @param value The value to set
+ */
+export declare function set<T extends Record<string, any>>(obj: T, path: string | string[], value: any): T;
+/**
+ * Check if a value is a plain object
+ */
+export declare function isPlainObject(value: any): value is Record<string, any>;
+/**
+ * Clone an object deeply
+ */
+export declare function cloneDeep<T>(obj: T): T;
+//# sourceMappingURL=object-utils.d.ts.map

package/dist/utils/object-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-utils.d.ts","sourceRoot":"","sources":["../../src/utils/object-utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,GAAG,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,OAAO,EAAE,GAAG,EAAE,GAAG,CAAC,CAgCpE;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3D,QAAQ,EAAE,CAAC,EACX,GAAG,SAAS,EAAE,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,GACjD,CAAC,CAEH;AAED;;;;;GAKG;AACH,wBAAgB,GAAG,CAAC,CAAC,GAAG,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,CAAC,CAYnF;AAED;;;;;GAKG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,KAAK,EAAE,GAAG,GAAG,CAAC,CAiBjG;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAOtE;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAgBtC"}

package/dist/utils/object-utils.js

@@ -0,0 +1,22 @@
+function deepMerge(target, ...sources) {
+  if (!sources.length) return target;
+  const result = { ...target };
+  for (const source of sources) {
+    if (!source) continue;
+    for (const key in source) {
+      const sourceValue = source[key];
+      const targetValue = result[key];
+      if (sourceValue === void 0) continue;
+      if (sourceValue !== null && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue !== null && typeof targetValue === "object" && !Array.isArray(targetValue)) {
+        result[key] = deepMerge(targetValue, sourceValue);
+      } else {
+        result[key] = sourceValue;
+      }
+    }
+  }
+  return result;
+}
+export {
+  deepMerge
+};
+//# sourceMappingURL=object-utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"object-utils.js","sources":["../../src/utils/object-utils.ts"],"sourcesContent":["/**\n * Deep merge two objects recursively\n * Later values override earlier ones\n * Supports merging objects with different but compatible types\n */\nexport function deepMerge<T = any>(target: any, ...sources: any[]): T {\n  if (!sources.length) return target as T;\n\n  const result = { ...target };\n\n  for (const source of sources) {\n    if (!source) continue;\n\n    for (const key in source) {\n      const sourceValue = source[key];\n      const targetValue = result[key];\n\n      if (sourceValue === undefined) continue;\n\n      if (\n        sourceValue !== null &&\n        typeof sourceValue === 'object' &&\n        !Array.isArray(sourceValue) &&\n        targetValue !== null &&\n        typeof targetValue === 'object' &&\n        !Array.isArray(targetValue)\n      ) {\n        // Recursively merge objects\n        result[key] = deepMerge(targetValue, sourceValue);\n      } else {\n        // Direct assignment for primitives and arrays\n        result[key] = sourceValue;\n      }\n    }\n  }\n\n  return result as T;\n}\n\n/**\n * Type-safe deep merge for configuration objects\n * Ensures the result conforms to the target type structure\n */\nexport function deepMergeConfig<T extends Record<string, any>>(\n  defaults: T,\n  ...overrides: Array<Partial<Record<keyof T, any>>>\n): T {\n  return deepMerge<T>(defaults, ...overrides);\n}\n\n/**\n * Get a nested value from an object using a path\n * @param obj The object to query\n * @param path Path to the value (e.g., 'a.b.c' or ['a', 'b', 'c'])\n * @param defaultValue Default value if path doesn't exist\n */\nexport function get<T = any>(obj: any, path: string | string[], defaultValue?: T): T {\n  const keys = Array.isArray(path) ? path : path.split('.');\n  let current = obj;\n\n  for (const key of keys) {\n    if (current == null || typeof current !== 'object') {\n      return defaultValue as T;\n    }\n    current = current[key];\n  }\n\n  return current !== undefined ? current : (defaultValue as T);\n}\n\n/**\n * Set a nested value in an object using a path\n * @param obj The object to modify\n * @param path Path to the value (e.g., 'a.b.c' or ['a', 'b', 'c'])\n * @param value The value to set\n */\nexport function set<T extends Record<string, any>>(obj: T, path: string | string[], value: any): T {\n  const keys = Array.isArray(path) ? path : path.split('.');\n  const lastKey = keys.pop();\n\n  if (!lastKey) return obj;\n\n  let current: any = obj;\n\n  for (const key of keys) {\n    if (!current[key] || typeof current[key] !== 'object') {\n      current[key] = {};\n    }\n    current = current[key];\n  }\n\n  current[lastKey] = value;\n  return obj;\n}\n\n/**\n * Check if a value is a plain object\n */\nexport function isPlainObject(value: any): value is Record<string, any> {\n  return (\n    value !== null &&\n    typeof value === 'object' &&\n    value.constructor === Object &&\n    Object.prototype.toString.call(value) === '[object Object]'\n  );\n}\n\n/**\n * Clone an object deeply\n */\nexport function cloneDeep<T>(obj: T): T {\n  if (obj === null || typeof obj !== 'object') return obj;\n  if (obj instanceof Date) return new Date(obj.getTime()) as any;\n  if (obj instanceof Array) return obj.map((item) => cloneDeep(item)) as any;\n  if (obj instanceof Set) return new Set(Array.from(obj).map((item) => cloneDeep(item))) as any;\n  if (obj instanceof Map) {\n    return new Map(Array.from(obj.entries()).map(([k, v]) => [cloneDeep(k), cloneDeep(v)])) as any;\n  }\n\n  const cloned = {} as T;\n  for (const key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) {\n      cloned[key] = cloneDeep(obj[key]);\n    }\n  }\n  return cloned;\n}\n"],"names":[],"mappings":"AAKO,SAAS,UAAmB,WAAgB,SAAmB;AACpE,MAAI,CAAC,QAAQ,OAAQ,QAAO;AAE5B,QAAM,SAAS,EAAE,GAAG,OAAA;AAEpB,aAAW,UAAU,SAAS;AAC5B,QAAI,CAAC,OAAQ;AAEb,eAAW,OAAO,QAAQ;AACxB,YAAM,cAAc,OAAO,GAAG;AAC9B,YAAM,cAAc,OAAO,GAAG;AAE9B,UAAI,gBAAgB,OAAW;AAE/B,UACE,gBAAgB,QAChB,OAAO,gBAAgB,YACvB,CAAC,MAAM,QAAQ,WAAW,KAC1B,gBAAgB,QAChB,OAAO,gBAAgB,YACvB,CAAC,MAAM,QAAQ,WAAW,GAC1B;AAEA,eAAO,GAAG,IAAI,UAAU,aAAa,WAAW;AAAA,MAClD,OAAO;AAEL,eAAO,GAAG,IAAI;AAAA,MAChB;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;"}

package/dist/utils/time-utils.d.ts

@@ -0,0 +1,10 @@
+import { TimeUs } from '../model/types';
+
+export type QuantizeStrategy = 'nearest' | 'floor' | 'ceil';
+export declare const DEFAULT_FRAME_TOLERANCE_US: TimeUs;
+export declare function normalizeFps(value?: number): number;
+export declare function frameDurationFromFps(fps?: number): TimeUs;
+export declare function frameIndexFromTimestamp(baseTimestampUs: TimeUs, timestampUs: TimeUs, fps?: number, strategy?: QuantizeStrategy): number;
+export declare function quantizeTimestampToFrame(timestampUs: TimeUs, baseTimestampUs: TimeUs, fps?: number, strategy?: QuantizeStrategy): TimeUs;
+export declare function isTimestampWithinFrame(targetTimeUs: TimeUs, frameTimestampUs: TimeUs, frameDurationUs: TimeUs, toleranceUs?: TimeUs): boolean;
+//# sourceMappingURL=time-utils.d.ts.map

package/dist/utils/time-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-utils.d.ts","sourceRoot":"","sources":["../../src/utils/time-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAG7C,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,CAAC;AAI5D,eAAO,MAAM,0BAA0B,EAAE,MAAe,CAAC;AAEzD,wBAAgB,YAAY,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAKnD;AAED,wBAAgB,oBAAoB,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAIzD;AAED,wBAAgB,uBAAuB,CACrC,eAAe,EAAE,MAAM,EACvB,WAAW,EAAE,MAAM,EACnB,GAAG,CAAC,EAAE,MAAM,EACZ,QAAQ,GAAE,gBAA4B,GACrC,MAAM,CAqBR;AAED,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,MAAM,EACvB,GAAG,CAAC,EAAE,MAAM,EACZ,QAAQ,GAAE,gBAA4B,GACrC,MAAM,CAIR;AAED,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,MAAM,EACxB,eAAe,EAAE,MAAM,EACvB,WAAW,GAAE,MAAmC,GAC/C,OAAO,CAeT"}