@rendley/sdk 1.12.26 → 1.14.0

package/dist/modules/library/types/Property.types.d.ts

@@ -43,16 +43,28 @@ export declare const PropertyDescriptionSchema: z.ZodObject<{
     label: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
     defaultValue: z.ZodType<Required<any>, z.ZodTypeDef, Required<any>>;
+    min: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
+    max: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
+    step: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
+    initOnly: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     type: PropertyDescriptionTypeEnum;
     name: string;
     defaultValue: Required<any>;
     label?: string | undefined;
     description?: string | undefined;
+    min?: number | number[] | undefined;
+    max?: number | number[] | undefined;
+    step?: number | number[] | undefined;
+    initOnly?: boolean | undefined;
 }, {
     type: PropertyDescriptionTypeEnum;
     name: string;
     defaultValue: Required<any>;
     label?: string | undefined;
     description?: string | undefined;
+    min?: number | number[] | undefined;
+    max?: number | number[] | undefined;
+    step?: number | number[] | undefined;
+    initOnly?: boolean | undefined;
 }>;

package/dist/modules/renderer/OutputChunkHelper.d.ts

@@ -0,0 +1,106 @@
+export interface OutputChunkFileDesc {
+    filename: string;
+    path: string;
+    chunkId: number;
+}
+export declare class OutputChunkHelper {
+    chunks: OutputChunkFileDesc[];
+    mimeType: string;
+    extension: string;
+    constructor(chunks: OutputChunkFileDesc[], mimeType: string, extension: string);
+    /**
+     * Reads the raw bytes for a chunk by its numeric identifier.
+     *
+     * Attempts to read the chunk as Uint8Array from the chunkId. If the chunk exists and the read succeeds, the promise resolves to a
+     * Uint8Array containing the file bytes. If the chunk is missing or an error occurs
+     * during reading, the error is logged and the promise resolves to null.
+     *
+     * @param chunkId - The numeric identifier (index) of the chunk to read.
+     * @returns A promise that resolves to the chunk's bytes as a Uint8Array, or null if the
+     *          chunk does not exist or could not be read.
+     */
+    readChunkAsBytes(chunkId: number): Promise<Uint8Array | null>;
+    /**
+     * Reads the specified chunk and returns it as a Blob.
+     *
+     * @remarks
+     * Not recommended because it will double the memory usage!
+     *
+     * If the chunk with the given id exists, this method attempts to read its bytes via readChunkBytes
+     * and constructs a Blob using the instance's mimeType. If the chunk does not exist or the bytes
+     * cannot be read, the promise resolves to null.
+     *
+     * @param chunkId - Identifier (index) of the chunk to read.
+     * @returns A Promise that resolves to a Blob containing the chunk's data, or null if the chunk is missing or unreadable.
+     * @throws Propagates any error thrown by readChunkBytes.
+     */
+    readChunkAsBlob(chunkId: number): Promise<Blob | null>;
+    /**
+     * Creates an object URL for the specified chunk if it exists.
+     *
+     * @remarks
+     * Not recommended because it will double the memory usage!
+     *
+     * Attempts to read the chunk as a Blob (via `readChunkAsBlob`) and, if a Blob
+     * is obtained, returns a URL created with `URL.createObjectURL(blob)`. If the
+     * chunk is not present or cannot be read, the promise resolves to `null`.
+     *
+     * Note: callers are responsible for revoking the returned URL with
+     * `URL.revokeObjectURL` when it is no longer needed to avoid memory leaks.
+     *
+     * @param chunkId - The identifier (index) of the chunk to read.
+     * @returns A `Promise` that resolves to an object URL `string` for the chunk
+     *          Blob, or `null` if the chunk does not exist or could not be read.
+     */
+    readChunkAsUrl(chunkId: number): Promise<string | null>;
+    /**
+     * Reads and merges all chunks into a single Uint8Array.
+     *
+     * @returns {Promise<Uint8Array | null>} A promise that resolves to a merged Uint8Array containing all chunk data,
+     * or null if an error occurs during reading or merging.
+     *
+     * @throws Does not throw, but logs errors at ERROR level if chunk reading or merging fails.
+     *
+     * @example
+     * const mergedData = await helper.readMergedChunksAsBytes();
+     * if (mergedData) {
+     *   // Process merged chunk data
+     * }
+     */
+    readMergedChunksAsBytes(): Promise<Uint8Array | null>;
+    /**
+     * Reads merged chunks and converts them to a Blob object.
+     * @remarks
+     * Not recommended because it will double the memory usage!
+     * @returns A promise that resolves to a Blob if chunks are successfully read and merged,
+     *          or null if no bytes are available.
+     */
+    readMergedChunksAsBlob(): Promise<Blob | null>;
+    /**
+     * Reads merged chunks and returns them as a URL object reference.
+     * @remarks
+     * Not recommended because it will double the memory usage!
+     * Don't forget to revoke the URL after usage!
+     * @returns A promise that resolves to a blob URL string, or null if no blob data is available.
+     */
+    readMergedChunksAsUrl(): Promise<string | null>;
+    removeChunk(chunkId: number): Promise<void>;
+    removeAllChunks(): Promise<void>;
+    /**
+     * Checks whether the browser supports the File System Access save picker API.
+     *
+     * @returns `true` when `window.showSaveFilePicker` is available; otherwise `false`.
+     */
+    isSaveToFileSupported(): boolean;
+    /**
+     * Prompts the user for a save location and writes all output chunks to the selected file.
+     *
+     * Uses the File System Access API (`showSaveFilePicker`) and writes each chunk sequentially.
+     *
+     * @param fileName - Suggested filename shown in the save dialog.
+     * @param bufferSize - Reserved chunk step size in bytes. Defaults to `100 * 1024 * 1024` (100 MB).
+     * @param progressCallback - Optional callback function to receive progress updates. range [0 - 1]
+     * @returns A promise that resolves to `true` when all chunks are written successfully, otherwise `false`.
+     */
+    browseAndSaveToFile(fileName: string, progressCallback?: ((progress: number) => void) | null, bufferSize?: number): Promise<boolean>;
+}

package/dist/modules/renderer/Renderer.d.ts

@@ -1,4 +1,10 @@
-import { ExportOptions, ExportResult } from '../../index';
+import { AudioExtensions, ExportOptions, ExportResult, MediaExtensions } from '../../index';
+import { FFmpeg as RootFFmpeg } from '../../libs/ffmpeg';
+declare enum AudioMixResults {
+    SUCCESS = "success",
+    ERROR = "error",
+    NO_OUTPUT = "no_output"
+}
 export declare class Renderer {
     private rendering;
     private isBackgrounded;
@@ -8,6 +14,8 @@ export declare class Renderer {
     private originalWidth;
     private originalHeight;
     private originalResolution;
+    private ensureWorkerDir;
+    private mountMediaInWorker;
     constructor();
     destroy(): void;
     private visibilityChangeHandler;
@@ -34,4 +42,7 @@ export declare class Renderer {
     private sleep;
     render(payload?: ExportOptions): Promise<ExportResult | null>;
     render_with_frames(payload?: ExportOptions): Promise<ExportResult | null>;
+    muxVideo(ffmpeg: RootFFmpeg, mixGenerated: AudioMixResults, extension: MediaExtensions, audioExtension: AudioExtensions, from: number, to: number): Promise<ExportResult>;
+    muxChunkedVideo(ffmpeg: RootFFmpeg, mixGenerated: AudioMixResults, extension: MediaExtensions, audioExtension: AudioExtensions, from: number, to: number, outputFiles: string[]): Promise<ExportResult>;
 }
+export {};

package/dist/modules/renderer/index.d.ts

@@ -1 +1,2 @@
 export * from "./Renderer";
+export * from "./OutputChunkHelper";

package/dist/modules/settings/Settings.d.ts

@@ -34,6 +34,7 @@ export declare enum MonoMixType {
 }
 export declare const SettingsSchema: z.ZodObject<{
     m3u8MaxResolution: z.ZodDefault<z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+    useInternalTranscoder: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     clipAudioStoreSamples: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     clipAudioSampleRate: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     clipAudioSampleForceMono: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -55,6 +56,8 @@ export declare const SettingsSchema: z.ZodObject<{
     renderAudioUseWorker: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     renderCancelFailTimeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     renderVideoUseDirectFrames: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    renderUseChunkedOutput: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    renderChunkedOutputMaxSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     decoderUseWebCodecs: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     decoderPreferredAcceleration: z.ZodDefault<z.ZodOptional<z.ZodNativeEnum<typeof PreferredAcceleration>>>;
     decoderUseSeparateWorker: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -76,6 +79,7 @@ export declare const SettingsSchema: z.ZodObject<{
     mediaHashAlgorithm: z.ZodDefault<z.ZodOptional<z.ZodNativeEnum<typeof HashAlgorithmEnum>>>;
 }, "strip", z.ZodTypeAny, {
     m3u8MaxResolution: [number, number];
+    useInternalTranscoder: boolean;
     clipAudioStoreSamples: boolean;
     clipAudioSampleRate: number;
     clipAudioSampleForceMono: boolean;
@@ -97,6 +101,8 @@ export declare const SettingsSchema: z.ZodObject<{
     renderAudioUseWorker: boolean;
     renderCancelFailTimeout: number;
     renderVideoUseDirectFrames: boolean;
+    renderUseChunkedOutput: boolean;
+    renderChunkedOutputMaxSize: number;
     decoderUseWebCodecs: boolean;
     decoderPreferredAcceleration: PreferredAcceleration;
     decoderUseSeparateWorker: boolean;
@@ -118,6 +124,7 @@ export declare const SettingsSchema: z.ZodObject<{
     mediaHashAlgorithm: HashAlgorithmEnum;
 }, {
     m3u8MaxResolution?: [number, number] | undefined;
+    useInternalTranscoder?: boolean | undefined;
     clipAudioStoreSamples?: boolean | undefined;
     clipAudioSampleRate?: number | undefined;
     clipAudioSampleForceMono?: boolean | undefined;
@@ -139,6 +146,8 @@ export declare const SettingsSchema: z.ZodObject<{
     renderAudioUseWorker?: boolean | undefined;
     renderCancelFailTimeout?: number | undefined;
     renderVideoUseDirectFrames?: boolean | undefined;
+    renderUseChunkedOutput?: boolean | undefined;
+    renderChunkedOutputMaxSize?: number | undefined;
     decoderUseWebCodecs?: boolean | undefined;
     decoderPreferredAcceleration?: PreferredAcceleration | undefined;
     decoderUseSeparateWorker?: boolean | undefined;
@@ -161,6 +170,7 @@ export declare const SettingsSchema: z.ZodObject<{
 }>;
 export declare class Settings {
     private m3u8MaxResolution;
+    private useInternalTranscoder;
     private clipAudioStoreSamples;
     private clipAudioSampleRate;
     private clipAudioSampleForceMono;
@@ -197,6 +207,8 @@ export declare class Settings {
     private renderAudioUseWorker;
     private renderCancelFailTimeout;
     private renderVideoUseDirectFrames;
+    private renderUseChunkedOutput;
+    private renderChunkedOutputMaxSize;
     private subtitlesScaleOnResize;
     private subtitlesAutoWrapOnResize;
     private viewAutoLayoutOnResize;
@@ -205,6 +217,7 @@ export declare class Settings {
     constructor();
     getDefaultSettings(): {
         m3u8MaxResolution: [number, number];
+        useInternalTranscoder: boolean;
         clipAudioStoreSamples: boolean;
         clipAudioSampleRate: number;
         clipAudioSampleForceMono: boolean;
@@ -226,6 +239,8 @@ export declare class Settings {
         renderAudioUseWorker: boolean;
         renderCancelFailTimeout: number;
         renderVideoUseDirectFrames: boolean;
+        renderUseChunkedOutput: boolean;
+        renderChunkedOutputMaxSize: number;
         decoderUseWebCodecs: boolean;
         decoderPreferredAcceleration: PreferredAcceleration;
         decoderUseSeparateWorker: boolean;
@@ -320,6 +335,10 @@ export declare class Settings {
     getRenderCancelFailTimeout(): number;
     setRenderVideoUseDirectFrames(use: boolean): void;
     getRenderVideoUseDirectFrames(): boolean;
+    setRenderUseChunkedOutput(use: boolean): void;
+    getRenderUseChunkedOutput(): boolean;
+    setRenderChunkedOutputMaxSize(size: number): void;
+    getRenderChunkedOutputMaxSize(): number;
     setDecoderUseWebCodecs(use: boolean): void;
     getDecoderUseWebCodecs(): boolean;
     setDecoderPreferredAcceleration(acceleration: PreferredAcceleration): void;
@@ -332,6 +351,8 @@ export declare class Settings {
     getEncoderPreferredAcceleration(): PreferredAcceleration;
     setM3u8MaxResolution(width: number, height: number): void;
     getM3u8MaxResolution(): number[];
+    setUseInternalTranscoder(use: boolean): void;
+    getUseInternalTranscoder(): boolean;
     setSubtitlesScaleOnResize(scale: boolean): void;
     getSubtitlesScaleOnResize(): boolean;
     setSubtitlesAutoWrapOnResize(autoWrap: boolean): void;
@@ -342,6 +363,7 @@ export declare class Settings {
     getMediaHashAlgorithm(): HashAlgorithmEnum;
     serialize(): {
         m3u8MaxResolution: [number, number];
+        useInternalTranscoder: boolean;
         clipAudioStoreSamples: boolean;
         clipAudioSampleRate: number;
         clipAudioSampleForceMono: boolean;
@@ -363,6 +385,8 @@ export declare class Settings {
         renderAudioUseWorker: boolean;
         renderCancelFailTimeout: number;
         renderVideoUseDirectFrames: boolean;
+        renderUseChunkedOutput: boolean;
+        renderChunkedOutputMaxSize: number;
         decoderUseWebCodecs: boolean;
         decoderPreferredAcceleration: PreferredAcceleration;
         decoderUseSeparateWorker: boolean;

package/dist/modules/storage/StorageProviderBase.d.ts

@@ -10,7 +10,7 @@ export interface StorageStoreResults {
 }
 export interface StorageMediaData {
     hash: string;
-    data: Uint8Array;
+    mediaSource: Blob | File;
     mediaId: string;
     name?: string;
     fileName?: string;

package/dist/modules/timeline/Timeline.d.ts

@@ -197,6 +197,7 @@ export declare class Timeline {
     getAllCustomData(): Map<string, unknown> | undefined;
     render(options?: TimelineRenderOptions): Promise<void>;
     postRender(): void;
+    stopRenderingLoop(): void;
     loadSerializedData(data: object): Promise<void>;
     serialize(): {
         startTime: number;

package/dist/types/hash.types.d.ts

@@ -1,4 +1,5 @@
 export declare enum HashAlgorithmEnum {
     SHA256 = "SHA256",
-    XXHash128 = "XXHash128"
+    XXHash128 = "XXHash128",
+    XXHash64 = "XXHash64"
 }

package/dist/utils/browser/checkVideoCompatibilityOrTranscode.d.ts

@@ -0,0 +1,18 @@
+import { MediaInfo } from '../../modules/ffmpeg/types/FFmpeg.types';
+interface CheckVideoCompatibilityOrTranscodeOptions {
+    blobUrl: string;
+    filePath: string;
+    outputPath?: string;
+    getData: () => Promise<Uint8Array>;
+    info: MediaInfo;
+    fileName: string;
+    permanentUrl?: string;
+    mimeType?: string;
+    mediaDataId: string;
+    waitForMediaInfoUnlock: () => Promise<void>;
+    lockMediaInfo: () => void;
+    unlockMediaInfo: () => void;
+    timeoutMs?: number;
+}
+export declare function checkVideoCompatibilityOrTranscode({ blobUrl, filePath, outputPath, getData, info, fileName, permanentUrl, mimeType, mediaDataId, waitForMediaInfoUnlock, lockMediaInfo, unlockMediaInfo, timeoutMs, }: CheckVideoCompatibilityOrTranscodeOptions): Promise<boolean>;
+export {};

package/dist/utils/file/urlToBlobChunks.d.ts

@@ -0,0 +1 @@
+export declare function urlToBlobChunks(url: string, signal?: AbortSignal): Promise<Blob>;

package/dist/utils/transcode/transcodeMedia.d.ts

@@ -0,0 +1,25 @@
+import { TranscodeMediaDetails } from '../../modules/transcode';
+interface InternalFFmpegTranscodeOptions {
+    filePath: string;
+    outputPath?: string;
+    mediaDataId: string;
+    waitForMediaInfoUnlock: () => Promise<void>;
+    lockMediaInfo: () => void;
+    unlockMediaInfo: () => void;
+}
+export declare function internalFFmpegTranscode({ filePath, outputPath, mediaDataId, waitForMediaInfoUnlock, lockMediaInfo, unlockMediaInfo, }: InternalFFmpegTranscodeOptions): Promise<boolean>;
+interface TranscodeMediaOptions {
+    filePath: string;
+    outputPath?: string;
+    getData: () => Promise<Uint8Array>;
+    info: TranscodeMediaDetails["mediaInfo"];
+    fileName: string;
+    permanentUrl?: string;
+    mimeType?: string;
+    mediaDataId: string;
+    waitForMediaInfoUnlock: () => Promise<void>;
+    lockMediaInfo: () => void;
+    unlockMediaInfo: () => void;
+}
+export declare function transcodeMedia({ filePath, outputPath, getData, info, fileName, permanentUrl, mimeType, mediaDataId, waitForMediaInfoUnlock, lockMediaInfo, unlockMediaInfo, }: TranscodeMediaOptions): Promise<boolean>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rendley/sdk",
-  "version": "1.12.26",
+  "version": "1.14.0",
   "license": "LICENSE",
   "author": "Onix Technologies",
   "homepage": "https://rendleysdk.com",