@meframe/core 0.0.1

package/dist/cache/l1/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cache/l1/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/cache/l1/types.d.ts

@@ -0,0 +1,17 @@
+import { TimeUs } from '../../model/types';
+
+export interface L1Config {
+    maxMemoryMB: number;
+    maxGOPs?: number;
+    gopIntervalUs?: number;
+}
+export interface AudioSlot {
+    timestampUs: TimeUs;
+    durationUs: TimeUs;
+    planes: Float32Array[];
+}
+export interface AudioMetadata {
+    sampleRate: number;
+    numberOfChannels: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/cache/l1/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/cache/l1/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,MAAM,WAAW,QAAQ;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,SAAS;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,YAAY,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;CAC1B"}

package/dist/cache/types.d.ts

@@ -0,0 +1,93 @@
+import { RcFrame } from '../model';
+import { TimeUs } from '../model/types';
+
+export interface CacheConfig {
+    /** Maximum L1 cache size in bytes */
+    maxL1Size: number;
+    /** Maximum L2 cache size in bytes */
+    maxL2Size: number;
+    /** Cache eviction policy */
+    evictionPolicy: 'lru' | 'lfu' | 'fifo';
+    /** Prefetch window in microseconds */
+    prefetchWindowUs: TimeUs;
+    /** Retention window in microseconds */
+    retentionWindowUs: TimeUs;
+}
+export interface CacheStats {
+    /** L1 cache statistics */
+    l1: {
+        size: number;
+        maxSize: number;
+        hitRate: number;
+        missRate: number;
+        evictions: number;
+        entries: number;
+    };
+    /** L2 cache statistics */
+    l2: {
+        size: number;
+        maxSize: number;
+        hitRate: number;
+        missRate: number;
+        evictions: number;
+        entries: number;
+    };
+    /** Overall statistics */
+    total: {
+        hits: number;
+        misses: number;
+        hitRate: number;
+    };
+}
+export interface CacheEntry<T> {
+    /** Entry key */
+    key: string;
+    /** Cached data */
+    data: T;
+    /** Size in bytes */
+    size: number;
+    /** Creation timestamp */
+    createdAt: number;
+    /** Last access timestamp */
+    lastAccessedAt: number;
+    /** Access count */
+    accessCount: number;
+    /** Pin tokens referencing this entry (window aware retention). @better-ai.mdc retain window */
+    pinnedBy?: Set<string>;
+}
+export interface GOP {
+    /** GOP index */
+    index: number;
+    /** Start time in microseconds */
+    startUs: TimeUs;
+    /** Duration in microseconds */
+    durationUs: TimeUs;
+    /** Video frames in this GOP */
+    frames: RcFrame[];
+    /** Whether this GOP starts with a keyframe */
+    isKeyframe: boolean;
+    /** Clip ID for clip-aware caching */
+    clipId: string;
+}
+export interface ClipMetadata {
+    /** Clip identifier */
+    id: string;
+    /** Clip hash for cache key */
+    hash: string;
+    /** Start time in composition */
+    startUs: TimeUs;
+    /** Duration */
+    durationUs: TimeUs;
+    /** Number of chunks */
+    chunkCount: number;
+    /** Total size in bytes */
+    totalBytes: number;
+    /** Codec configuration */
+    codecConfig?: {
+        codec: string;
+        width?: number;
+        height?: number;
+        bitrate?: number;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/cache/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/cache/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACxC;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAE7C,MAAM,WAAW,WAAW;IAC1B,qCAAqC;IACrC,SAAS,EAAE,MAAM,CAAC;IAElB,qCAAqC;IACrC,SAAS,EAAE,MAAM,CAAC;IAElB,4BAA4B;IAC5B,cAAc,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;IAEvC,sCAAsC;IACtC,gBAAgB,EAAE,MAAM,CAAC;IAEzB,uCAAuC;IACvC,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,UAAU;IACzB,0BAA0B;IAC1B,EAAE,EAAE;QACF,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IAEF,0BAA0B;IAC1B,EAAE,EAAE;QACF,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IAEF,yBAAyB;IACzB,KAAK,EAAE;QACL,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAED,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,gBAAgB;IAChB,GAAG,EAAE,MAAM,CAAC;IAEZ,kBAAkB;IAClB,IAAI,EAAE,CAAC,CAAC;IAER,oBAAoB;IACpB,IAAI,EAAE,MAAM,CAAC;IAEb,yBAAyB;IACzB,SAAS,EAAE,MAAM,CAAC;IAElB,4BAA4B;IAC5B,cAAc,EAAE,MAAM,CAAC;IAEvB,mBAAmB;IACnB,WAAW,EAAE,MAAM,CAAC;IAEpB,+FAA+F;IAC/F,QAAQ,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACxB;AAED,MAAM,WAAW,GAAG;IAClB,gBAAgB;IAChB,KAAK,EAAE,MAAM,CAAC;IAEd,iCAAiC;IACjC,OAAO,EAAE,MAAM,CAAC;IAEhB,+BAA+B;IAC/B,UAAU,EAAE,MAAM,CAAC;IAEnB,+BAA+B;IAC/B,MAAM,EAAE,OAAO,EAAE,CAAC;IAElB,8CAA8C;IAC9C,UAAU,EAAE,OAAO,CAAC;IAEpB,qCAAqC;IACrC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC3B,sBAAsB;IACtB,EAAE,EAAE,MAAM,CAAC;IAEX,8BAA8B;IAC9B,IAAI,EAAE,MAAM,CAAC;IAEb,gCAAgC;IAChC,OAAO,EAAE,MAAM,CAAC;IAEhB,eAAe;IACf,UAAU,EAAE,MAAM,CAAC;IAEnB,uBAAuB;IACvB,UAAU,EAAE,MAAM,CAAC;IAEnB,0BAA0B;IAC1B,UAAU,EAAE,MAAM,CAAC;IAEnB,0BAA0B;IAC1B,WAAW,CAAC,EAAE;QACZ,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH"}

package/dist/config/ConfigLoader.d.ts

@@ -0,0 +1,69 @@
+import { MeframeConfig, ResolvedConfig, ConfigLoaderOptions } from './types';
+import { TUNING_PRESETS } from './defaults';
+
+/**
+ * Configuration loader for Meframe
+ * Handles loading, validation, and resolution of configuration
+ */
+export declare class ConfigLoader {
+    private static instance;
+    private config;
+    private userConfig;
+    /**
+     * Get singleton instance
+     */
+    static getInstance(): ConfigLoader;
+    /**
+     * Load and resolve configuration
+     * In build time, this would be handled by Vite/Rollup virtual module plugin
+     * At runtime, we use defaults or provided overrides
+     */
+    load(options?: ConfigLoaderOptions): Promise<ResolvedConfig>;
+    /**
+     * Get current resolved configuration
+     */
+    getConfig(): ResolvedConfig;
+    /**
+     * Apply a tuning preset
+     */
+    applyPreset(presetName: keyof typeof TUNING_PRESETS): ResolvedConfig;
+    /**
+     * Update configuration at runtime
+     */
+    update(partial: MeframeConfig): ResolvedConfig;
+    /**
+     * Reset to defaults
+     */
+    reset(): ResolvedConfig;
+    /**
+     * Clear singleton instance (mainly for testing)
+     */
+    static clearInstance(): void;
+    /**
+     * Resolve configuration by merging with defaults
+     * Each stage resolves its own configuration section
+     */
+    private resolveConfig;
+    /**
+     * Load configuration from virtual module
+     * This would be injected by Vite/Rollup at build time
+     */
+    private loadFromVirtualModule;
+    /**
+     * Load configuration from file path (for testing)
+     */
+    private loadFromPath;
+}
+/**
+ * Convenience function to get the global config loader
+ */
+export declare function getConfigLoader(): ConfigLoader;
+/**
+ * Convenience function to load configuration
+ */
+export declare function loadConfig(options?: ConfigLoaderOptions): Promise<ResolvedConfig>;
+/**
+ * Convenience function to get current configuration
+ */
+export declare function getConfig(): ResolvedConfig;
+//# sourceMappingURL=ConfigLoader.d.ts.map

package/dist/config/ConfigLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigLoader.d.ts","sourceRoot":"","sources":["../../src/config/ConfigLoader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAClF,OAAO,EAAkB,cAAc,EAAE,MAAM,YAAY,CAAC;AAI5D;;;GAGG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA6B;IACpD,OAAO,CAAC,MAAM,CAA+B;IAC7C,OAAO,CAAC,UAAU,CAA8B;IAEhD;;OAEG;IACH,MAAM,CAAC,WAAW,IAAI,YAAY;IAOlC;;;;OAIG;IACG,IAAI,CAAC,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,cAAc,CAAC;IAgCtE;;OAEG;IACH,SAAS,IAAI,cAAc;IAQ3B;;OAEG;IACH,WAAW,CAAC,UAAU,EAAE,MAAM,OAAO,cAAc,GAAG,cAAc;IAOpE;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,cAAc;IAkB9C;;OAEG;IACH,KAAK,IAAI,cAAc;IAMvB;;OAEG;IACH,MAAM,CAAC,aAAa,IAAI,IAAI;IAI5B;;;OAGG;IACH,OAAO,CAAC,aAAa;IASrB;;;OAGG;YACW,qBAAqB;IAenC;;OAEG;YACW,YAAY;CAM3B;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,YAAY,CAE9C;AAED;;GAEG;AACH,wBAAsB,UAAU,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,cAAc,CAAC,CAEvF;AAED;;GAEG;AACH,wBAAgB,SAAS,IAAI,cAAc,CAE1C"}

package/dist/config/ConfigLoader.js

@@ -0,0 +1,133 @@
+import { DEFAULT_CONFIG, TUNING_PRESETS } from "./defaults.js";
+import { validateConfig } from "./validation.js";
+import { deepMerge } from "../utils/object-utils.js";
+class ConfigLoader {
+  static instance = null;
+  config = null;
+  userConfig = null;
+  /**
+   * Get singleton instance
+   */
+  static getInstance() {
+    if (!ConfigLoader.instance) {
+      ConfigLoader.instance = new ConfigLoader();
+    }
+    return ConfigLoader.instance;
+  }
+  /**
+   * Load and resolve configuration
+   * In build time, this would be handled by Vite/Rollup virtual module plugin
+   * At runtime, we use defaults or provided overrides
+   */
+  async load(options = {}) {
+    if (options.override) {
+      this.userConfig = options.override;
+    } else if (options.configPath) {
+      this.userConfig = await this.loadFromPath(options.configPath);
+    } else {
+      this.userConfig = await this.loadFromVirtualModule();
+    }
+    if (this.userConfig) {
+      const validation = validateConfig(this.userConfig);
+      if (!validation.valid) {
+        console.warn("[ConfigLoader] Configuration validation warnings:", validation.warnings);
+        if (validation.errors.length > 0) {
+          throw new Error(`Configuration validation failed: ${validation.errors.join(", ")}`);
+        }
+      } else if (validation.warnings.length > 0) {
+        console.warn("[ConfigLoader] Configuration warnings:", validation.warnings);
+      }
+    }
+    this.config = this.resolveConfig(this.userConfig);
+    return this.config;
+  }
+  /**
+   * Get current resolved configuration
+   */
+  getConfig() {
+    if (!this.config) {
+      return DEFAULT_CONFIG;
+    }
+    return this.config;
+  }
+  /**
+   * Apply a tuning preset
+   */
+  applyPreset(presetName) {
+    const preset = TUNING_PRESETS[presetName];
+    this.userConfig = preset;
+    this.config = this.resolveConfig(preset);
+    return this.config;
+  }
+  /**
+   * Update configuration at runtime
+   */
+  update(partial) {
+    this.userConfig = deepMerge(this.userConfig || {}, partial);
+    const validation = validateConfig(this.userConfig);
+    if (!validation.valid) {
+      console.warn("[ConfigLoader] Configuration validation warnings:", validation.warnings);
+      if (validation.errors.length > 0) {
+        throw new Error(`Configuration validation failed: ${validation.errors.join(", ")}`);
+      }
+    }
+    this.config = this.resolveConfig(this.userConfig);
+    return this.config;
+  }
+  /**
+   * Reset to defaults
+   */
+  reset() {
+    this.userConfig = null;
+    this.config = DEFAULT_CONFIG;
+    return this.config;
+  }
+  /**
+   * Clear singleton instance (mainly for testing)
+   */
+  static clearInstance() {
+    ConfigLoader.instance = null;
+  }
+  /**
+   * Resolve configuration by merging with defaults
+   * Each stage resolves its own configuration section
+   */
+  resolveConfig(userConfig) {
+    if (!userConfig) {
+      return DEFAULT_CONFIG;
+    }
+    return deepMerge(DEFAULT_CONFIG, userConfig);
+  }
+  /**
+   * Load configuration from virtual module
+   * This would be injected by Vite/Rollup at build time
+   */
+  async loadFromVirtualModule() {
+    if (typeof window !== "undefined" && window.__MEFRAME_CONFIG__) {
+      return window.__MEFRAME_CONFIG__;
+    }
+    if (typeof global !== "undefined" && global.__MEFRAME_CONFIG__) {
+      return global.__MEFRAME_CONFIG__;
+    }
+    return null;
+  }
+  /**
+   * Load configuration from file path (for testing)
+   */
+  async loadFromPath(path) {
+    console.warn(`[ConfigLoader] Loading from path '${path}' not implemented in runtime`);
+    return null;
+  }
+}
+function getConfigLoader() {
+  return ConfigLoader.getInstance();
+}
+async function loadConfig(options) {
+  return getConfigLoader().load(options);
+}
+export {
+  ConfigLoader,
+  getConfigLoader,
+  loadConfig
+};
+//# sourceMappingURL=ConfigLoader.js.map

package/dist/config/ConfigLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigLoader.js","sources":["../../src/config/ConfigLoader.ts"],"sourcesContent":["import type { MeframeConfig, ResolvedConfig, ConfigLoaderOptions } from './types';\nimport { DEFAULT_CONFIG, TUNING_PRESETS } from './defaults';\nimport { validateConfig } from './validation';\nimport { deepMerge } from '../utils/object-utils';\n\n/**\n * Configuration loader for Meframe\n * Handles loading, validation, and resolution of configuration\n */\nexport class ConfigLoader {\n  private static instance: ConfigLoader | null = null;\n  private config: ResolvedConfig | null = null;\n  private userConfig: MeframeConfig | null = null;\n\n  /**\n   * Get singleton instance\n   */\n  static getInstance(): ConfigLoader {\n    if (!ConfigLoader.instance) {\n      ConfigLoader.instance = new ConfigLoader();\n    }\n    return ConfigLoader.instance;\n  }\n\n  /**\n   * Load and resolve configuration\n   * In build time, this would be handled by Vite/Rollup virtual module plugin\n   * At runtime, we use defaults or provided overrides\n   */\n  async load(options: ConfigLoaderOptions = {}): Promise<ResolvedConfig> {\n    // If override is provided, use it directly\n    if (options.override) {\n      this.userConfig = options.override;\n    } else if (options.configPath) {\n      // In a real implementation, this would load from the virtual module\n      // For now, we'll just use the path as a hint for testing\n      this.userConfig = await this.loadFromPath(options.configPath);\n    } else {\n      // Try to load from virtual module (injected at build time)\n      this.userConfig = await this.loadFromVirtualModule();\n    }\n\n    // Validate user configuration\n    if (this.userConfig) {\n      const validation = validateConfig(this.userConfig);\n      if (!validation.valid) {\n        console.warn('[ConfigLoader] Configuration validation warnings:', validation.warnings);\n        if (validation.errors.length > 0) {\n          throw new Error(`Configuration validation failed: ${validation.errors.join(', ')}`);\n        }\n      } else if (validation.warnings.length > 0) {\n        console.warn('[ConfigLoader] Configuration warnings:', validation.warnings);\n      }\n    }\n\n    // Resolve configuration\n    this.config = this.resolveConfig(this.userConfig);\n\n    return this.config;\n  }\n\n  /**\n   * Get current resolved configuration\n   */\n  getConfig(): ResolvedConfig {\n    if (!this.config) {\n      // Return defaults if not loaded yet\n      return DEFAULT_CONFIG;\n    }\n    return this.config;\n  }\n\n  /**\n   * Apply a tuning preset\n   */\n  applyPreset(presetName: keyof typeof TUNING_PRESETS): ResolvedConfig {\n    const preset = TUNING_PRESETS[presetName];\n    this.userConfig = preset;\n    this.config = this.resolveConfig(preset);\n    return this.config;\n  }\n\n  /**\n   * Update configuration at runtime\n   */\n  update(partial: MeframeConfig): ResolvedConfig {\n    // Merge with existing user config\n    this.userConfig = deepMerge(this.userConfig || {}, partial) as MeframeConfig;\n\n    // Validate\n    const validation = validateConfig(this.userConfig);\n    if (!validation.valid) {\n      console.warn('[ConfigLoader] Configuration validation warnings:', validation.warnings);\n      if (validation.errors.length > 0) {\n        throw new Error(`Configuration validation failed: ${validation.errors.join(', ')}`);\n      }\n    }\n\n    // Resolve and update\n    this.config = this.resolveConfig(this.userConfig);\n    return this.config;\n  }\n\n  /**\n   * Reset to defaults\n   */\n  reset(): ResolvedConfig {\n    this.userConfig = null;\n    this.config = DEFAULT_CONFIG;\n    return this.config;\n  }\n\n  /**\n   * Clear singleton instance (mainly for testing)\n   */\n  static clearInstance(): void {\n    ConfigLoader.instance = null;\n  }\n\n  /**\n   * Resolve configuration by merging with defaults\n   * Each stage resolves its own configuration section\n   */\n  private resolveConfig(userConfig: MeframeConfig | null): ResolvedConfig {\n    if (!userConfig) {\n      return DEFAULT_CONFIG;\n    }\n\n    // Use improved deepMerge that handles type differences\n    return deepMerge<ResolvedConfig>(DEFAULT_CONFIG, userConfig);\n  }\n\n  /**\n   * Load configuration from virtual module\n   * This would be injected by Vite/Rollup at build time\n   */\n  private async loadFromVirtualModule(): Promise<MeframeConfig | null> {\n    // Check if virtual module is available\n    if (typeof window !== 'undefined' && (window as any).__MEFRAME_CONFIG__) {\n      return (window as any).__MEFRAME_CONFIG__;\n    }\n\n    // In Node.js environment, check global\n    if (typeof global !== 'undefined' && (global as any).__MEFRAME_CONFIG__) {\n      return (global as any).__MEFRAME_CONFIG__;\n    }\n\n    // No user configuration found, will use defaults\n    return null;\n  }\n\n  /**\n   * Load configuration from file path (for testing)\n   */\n  private async loadFromPath(path: string): Promise<MeframeConfig | null> {\n    // In a real implementation, this would use dynamic import\n    // For now, return null and rely on overrides for testing\n    console.warn(`[ConfigLoader] Loading from path '${path}' not implemented in runtime`);\n    return null;\n  }\n}\n\n/**\n * Convenience function to get the global config loader\n */\nexport function getConfigLoader(): ConfigLoader {\n  return ConfigLoader.getInstance();\n}\n\n/**\n * Convenience function to load configuration\n */\nexport async function loadConfig(options?: ConfigLoaderOptions): Promise<ResolvedConfig> {\n  return getConfigLoader().load(options);\n}\n\n/**\n * Convenience function to get current configuration\n */\nexport function getConfig(): ResolvedConfig {\n  return getConfigLoader().getConfig();\n}\n"],"names":[],"mappings":"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"}

package/dist/config/defaults.d.ts

@@ -0,0 +1,125 @@
+import { ResolvedConfig } from './types';
+
+/**
+ * Default configuration values based on mobile 1080p30 memory budget
+ *
+ * Note: Canvas dimensions are fixed for the entire project.
+ * All video clips will be scaled/fitted to this resolution.
+ * Choose based on your primary content type:
+ * - 720×1280: Mobile vertical video
+ * - 1080×1920: HD vertical video (TikTok, Instagram Reels) ← default
+ * - 1920×1080: HD horizontal video (YouTube)
+ */
+export declare const DEFAULT_CONFIG: ResolvedConfig;
+/**
+ * Tuning presets for common scenarios
+ */
+export declare const TUNING_PRESETS: {
+    /**
+     * Low-latency live streaming
+     * Minimize buffering for real-time playback
+     */
+    readonly lowLatency: {
+        readonly global: {
+            readonly logLevel: "info";
+        };
+        readonly load: {
+            readonly backpressure: {
+                readonly highWaterMark: number;
+            };
+        };
+        readonly demux: {
+            readonly backpressure: {
+                readonly highWaterMark: 3;
+            };
+        };
+        readonly decode: {
+            readonly video: {
+                readonly backpressure: {
+                    readonly highWaterMark: 2;
+                    readonly decodeQueueThreshold: 4;
+                };
+            };
+            readonly audio: {
+                readonly backpressure: {
+                    readonly highWaterMark: 10;
+                };
+            };
+        };
+    };
+    /**
+     * 4K60 playback/export
+     * Larger buffers for high bitrate content
+     */
+    readonly highQuality: {
+        readonly global: {
+            readonly logLevel: "info";
+        };
+        readonly load: {
+            readonly backpressure: {
+                readonly highWaterMark: number;
+            };
+            readonly retry: {
+                readonly maxAttempts: 3;
+                readonly baseDelayMs: 500;
+            };
+        };
+        readonly demux: {
+            readonly backpressure: {
+                readonly highWaterMark: 20;
+            };
+        };
+        readonly decode: {
+            readonly video: {
+                readonly backpressure: {
+                    readonly highWaterMark: 8;
+                    readonly decodeQueueThreshold: 24;
+                };
+                readonly codecHints: ("h264" | "hevc")[];
+            };
+            readonly audio: {
+                readonly backpressure: {
+                    readonly highWaterMark: 30;
+                };
+            };
+        };
+        readonly cache: {
+            readonly l2: {
+                readonly quotaGb: 1;
+            };
+        };
+    };
+    /**
+     * Batch offline transcode
+     * Maximum throughput, memory not a concern
+     */
+    readonly offline: {
+        readonly global: {
+            readonly logLevel: "warn";
+        };
+        readonly load: {
+            readonly backpressure: {
+                readonly highWaterMark: number;
+            };
+        };
+        readonly demux: {
+            readonly backpressure: {
+                readonly highWaterMark: 25;
+            };
+        };
+        readonly decode: {
+            readonly video: {
+                readonly backpressure: {
+                    readonly highWaterMark: 12;
+                    readonly decodeQueueThreshold: 32;
+                };
+            };
+            readonly audio: {
+                readonly backpressure: {
+                    readonly highWaterMark: 40;
+                };
+            };
+        };
+    };
+};
+//# sourceMappingURL=defaults.d.ts.map

package/dist/config/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/config/defaults.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAiB9C;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,EAAE,cAiE5B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc;IACzB;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA8BH;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;qCAyBmC,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE;;;;;;;;;;;;;;IAezD;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BK,CAAC"}

package/dist/config/defaults.js

@@ -0,0 +1,191 @@
+import { CANVAS_PRESETS } from "./presets.js";
+function getWorkerConfig() {
+  const isDev = typeof process !== "undefined" && process.env.NODE_ENV !== "production" || typeof window !== "undefined" && window.location?.hostname === "localhost";
+  return {
+    workerBaseUrl: isDev ? "/src/stages" : "/dist/stages",
+    workerExtension: isDev ? ".ts" : ".js"
+  };
+}
+const DEFAULT_CONFIG = {
+  global: {
+    logLevel: "info",
+    enablePerfMonitor: false,
+    ...getWorkerConfig(),
+    defaultCanvasWidth: CANVAS_PRESETS.MOBILE_PORTRAIT.width,
+    defaultCanvasHeight: CANVAS_PRESETS.MOBILE_PORTRAIT.height,
+    defaultFps: 30
+  },
+  load: {
+    backpressure: {
+      highWaterMark: 64 * 1024,
+      // 64 KB
+      stallTimeoutMs: 500
+    },
+    retry: {
+      maxAttempts: 3,
+      baseDelayMs: 500
+    },
+    window: {
+      maxInflightPerClip: 1,
+      maxInflight: 4,
+      chunkSize: 1 * 1024 * 1024
+      // 1 MB
+    }
+  },
+  demux: {
+    backpressure: {
+      highWaterMark: 10
+      // 10 EncodedChunks
+    }
+  },
+  decode: {
+    video: {
+      backpressure: {
+        highWaterMark: 4,
+        // 4 EncodedVideoChunks
+        decodeQueueThreshold: 16
+        // Pause when decoder has 16+ chunks
+      },
+      maxGOPs: 4
+      // Cache 4 GOPs for seeking
+    },
+    audio: {
+      backpressure: {
+        highWaterMark: 20
+        // 20 EncodedAudioChunks
+      }
+    }
+  },
+  compose: {
+    visual: {},
+    audio: {
+      enableDucking: false
+      // Default: no ducking
+    }
+  },
+  encode: {
+    video: {},
+    audio: {}
+  },
+  cache: {
+    l1: {},
+    l2: {}
+  },
+  mux: {}
+};
+const TUNING_PRESETS = {
+  /**
+   * Low-latency live streaming
+   * Minimize buffering for real-time playback
+   */
+  lowLatency: {
+    global: {
+      logLevel: "info"
+    },
+    load: {
+      backpressure: {
+        highWaterMark: 16 * 1024
+        // 16 KB
+      }
+    },
+    demux: {
+      backpressure: {
+        highWaterMark: 3
+      }
+    },
+    decode: {
+      video: {
+        backpressure: {
+          highWaterMark: 2,
+          decodeQueueThreshold: 4
+        }
+      },
+      audio: {
+        backpressure: {
+          highWaterMark: 10
+        }
+      }
+    }
+  },
+  /**
+   * 4K60 playback/export
+   * Larger buffers for high bitrate content
+   */
+  highQuality: {
+    global: {
+      logLevel: "info"
+    },
+    load: {
+      backpressure: {
+        highWaterMark: 256 * 1024
+        // 256 KB
+      },
+      retry: {
+        maxAttempts: 3,
+        baseDelayMs: 500
+      }
+    },
+    demux: {
+      backpressure: {
+        highWaterMark: 20
+      }
+    },
+    decode: {
+      video: {
+        backpressure: {
+          highWaterMark: 8,
+          decodeQueueThreshold: 24
+        },
+        codecHints: ["h264", "hevc"]
+      },
+      audio: {
+        backpressure: {
+          highWaterMark: 30
+        }
+      }
+    },
+    cache: {
+      l2: {
+        quotaGb: 1
+      }
+    }
+  },
+  /**
+   * Batch offline transcode
+   * Maximum throughput, memory not a concern
+   */
+  offline: {
+    global: {
+      logLevel: "warn"
+    },
+    load: {
+      backpressure: {
+        highWaterMark: 512 * 1024
+        // 512 KB
+      }
+    },
+    demux: {
+      backpressure: {
+        highWaterMark: 25
+      }
+    },
+    decode: {
+      video: {
+        backpressure: {
+          highWaterMark: 12,
+          decodeQueueThreshold: 32
+        }
+      },
+      audio: {
+        backpressure: {
+          highWaterMark: 40
+        }
+      }
+    }
+  }
+};
+export {
+  DEFAULT_CONFIG,
+  TUNING_PRESETS
+};
+//# sourceMappingURL=defaults.js.map

package/dist/config/defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.js","sources":["../../src/config/defaults.ts"],"sourcesContent":["import type { ResolvedConfig } from './types';\nimport { CANVAS_PRESETS } from './presets';\n\n/**\n * Get default worker configuration based on environment\n */\nfunction getWorkerConfig() {\n  const isDev =\n    (typeof process !== 'undefined' && process.env.NODE_ENV !== 'production') ||\n    (typeof window !== 'undefined' && window.location?.hostname === 'localhost');\n\n  return {\n    workerBaseUrl: isDev ? '/src/stages' : '/dist/stages',\n    workerExtension: isDev ? '.ts' : '.js',\n  };\n}\n\n/**\n * Default configuration values based on mobile 1080p30 memory budget\n *\n * Note: Canvas dimensions are fixed for the entire project.\n * All video clips will be scaled/fitted to this resolution.\n * Choose based on your primary content type:\n * - 720×1280: Mobile vertical video\n * - 1080×1920: HD vertical video (TikTok, Instagram Reels) ← default\n * - 1920×1080: HD horizontal video (YouTube)\n */\nexport const DEFAULT_CONFIG: ResolvedConfig = {\n  global: {\n    logLevel: 'info',\n    enablePerfMonitor: false,\n    ...getWorkerConfig(),\n    defaultCanvasWidth: CANVAS_PRESETS.MOBILE_PORTRAIT.width,\n    defaultCanvasHeight: CANVAS_PRESETS.MOBILE_PORTRAIT.height,\n    defaultFps: 30,\n  },\n\n  load: {\n    backpressure: {\n      highWaterMark: 64 * 1024, // 64 KB\n      stallTimeoutMs: 500,\n    },\n    retry: {\n      maxAttempts: 3,\n      baseDelayMs: 500,\n    },\n    window: {\n      maxInflightPerClip: 1,\n      maxInflight: 4,\n      chunkSize: 1 * 1024 * 1024, // 1 MB\n    },\n  },\n\n  demux: {\n    backpressure: {\n      highWaterMark: 10, // 10 EncodedChunks\n    },\n  },\n\n  decode: {\n    video: {\n      backpressure: {\n        highWaterMark: 4, // 4 EncodedVideoChunks\n        decodeQueueThreshold: 16, // Pause when decoder has 16+ chunks\n      },\n      maxGOPs: 4, // Cache 4 GOPs for seeking\n    },\n    audio: {\n      backpressure: {\n        highWaterMark: 20, // 20 EncodedAudioChunks\n      },\n    },\n  },\n\n  compose: {\n    visual: {},\n    audio: {\n      enableDucking: false, // Default: no ducking\n    },\n  },\n\n  encode: {\n    video: {},\n    audio: {},\n  },\n\n  cache: {\n    l1: {},\n    l2: {},\n  },\n\n  mux: {},\n};\n\n/**\n * Tuning presets for common scenarios\n */\nexport const TUNING_PRESETS = {\n  /**\n   * Low-latency live streaming\n   * Minimize buffering for real-time playback\n   */\n  lowLatency: {\n    global: {\n      logLevel: 'info' as const,\n    },\n    load: {\n      backpressure: {\n        highWaterMark: 16 * 1024, // 16 KB\n      },\n    },\n    demux: {\n      backpressure: {\n        highWaterMark: 3,\n      },\n    },\n    decode: {\n      video: {\n        backpressure: {\n          highWaterMark: 2,\n          decodeQueueThreshold: 4,\n        },\n      },\n      audio: {\n        backpressure: {\n          highWaterMark: 10,\n        },\n      },\n    },\n  },\n\n  /**\n   * 4K60 playback/export\n   * Larger buffers for high bitrate content\n   */\n  highQuality: {\n    global: {\n      logLevel: 'info' as const,\n    },\n    load: {\n      backpressure: {\n        highWaterMark: 256 * 1024, // 256 KB\n      },\n      retry: {\n        maxAttempts: 3,\n        baseDelayMs: 500,\n      },\n    },\n    demux: {\n      backpressure: {\n        highWaterMark: 20,\n      },\n    },\n    decode: {\n      video: {\n        backpressure: {\n          highWaterMark: 8,\n          decodeQueueThreshold: 24,\n        },\n        codecHints: ['h264', 'hevc'] as ('h264' | 'hevc')[],\n      },\n      audio: {\n        backpressure: {\n          highWaterMark: 30,\n        },\n      },\n    },\n    cache: {\n      l2: {\n        quotaGb: 1,\n      },\n    },\n  },\n\n  /**\n   * Batch offline transcode\n   * Maximum throughput, memory not a concern\n   */\n  offline: {\n    global: {\n      logLevel: 'warn' as const,\n    },\n    load: {\n      backpressure: {\n        highWaterMark: 512 * 1024, // 512 KB\n      },\n    },\n    demux: {\n      backpressure: {\n        highWaterMark: 25,\n      },\n    },\n    decode: {\n      video: {\n        backpressure: {\n          highWaterMark: 12,\n          decodeQueueThreshold: 32,\n        },\n      },\n      audio: {\n        backpressure: {\n          highWaterMark: 40,\n        },\n      },\n    },\n  },\n} as const;\n"],"names":[],"mappings":"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"}