@aelionsdk/render-ir 0.1.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FoyonaCZY and AelionSDK contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# @aelionsdk/render-ir
+
+Incremental render intermediate representation compiler for AelionSDK
+
+Install with `npm install @aelionsdk/render-ir@next`.
+
+Version 0.1.0-beta.1 is a prerelease and its API may change before the first stable release. This package is part of [AelionSDK](https://github.com/FoyonaCZY/AelionSDK); see the repository README for supported browsers, examples and deployment requirements.

package/dist/captions.d.ts

@@ -0,0 +1,16 @@
+export interface CaptionCue {
+    readonly id?: string;
+    readonly startUs: number;
+    readonly endUs: number;
+    readonly text: string;
+    readonly settings?: Readonly<Record<string, string>>;
+}
+export interface CaptionSerialization {
+    readonly text: string;
+    readonly warnings: readonly string[];
+}
+export declare function parseSrt(input: string): readonly CaptionCue[];
+export declare function serializeSrt(cues: readonly CaptionCue[]): CaptionSerialization;
+export declare function parseWebVtt(input: string): readonly CaptionCue[];
+export declare function serializeWebVtt(cues: readonly CaptionCue[]): CaptionSerialization;
+//# sourceMappingURL=captions.d.ts.map

package/dist/captions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"captions.d.ts","sourceRoot":"","sources":["../src/captions.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACtD;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC;AAoCD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,UAAU,EAAE,CAuB7D;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,UAAU,EAAE,GAAG,oBAAoB,CAc9E;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,UAAU,EAAE,CA0ChE;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,UAAU,EAAE,GAAG,oBAAoB,CAcjF"}

package/dist/captions.js

@@ -0,0 +1,131 @@
+function timestamp(value) {
+    const match = /^(?:(\d{1,3}):)?(\d{2}):(\d{2})[,.](\d{3})$/u.exec(value.trim());
+    if (match === null)
+        throw new TypeError(`CAPTION_TIMESTAMP_INVALID: ${value}`);
+    const hours = Number(match[1] ?? 0);
+    const minutes = Number(match[2]);
+    const seconds = Number(match[3]);
+    const milliseconds = Number(match[4]);
+    if (minutes >= 60 || seconds >= 60)
+        throw new TypeError(`CAPTION_TIMESTAMP_INVALID: ${value}`);
+    return ((hours * 60 * 60 + minutes * 60 + seconds) * 1_000 + milliseconds) * 1_000;
+}
+function formatTimestamp(timeUs, separator) {
+    if (!Number.isSafeInteger(timeUs) || timeUs < 0)
+        throw new RangeError('Caption time is invalid');
+    const milliseconds = Math.floor(timeUs / 1_000);
+    const hours = Math.floor(milliseconds / 3_600_000);
+    const minutes = Math.floor((milliseconds % 3_600_000) / 60_000);
+    const seconds = Math.floor((milliseconds % 60_000) / 1_000);
+    const millis = milliseconds % 1_000;
+    return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}${separator}${millis.toString().padStart(3, '0')}`;
+}
+function validateCues(cues) {
+    for (const cue of cues) {
+        if (!Number.isSafeInteger(cue.startUs) ||
+            !Number.isSafeInteger(cue.endUs) ||
+            cue.startUs < 0 ||
+            cue.endUs <= cue.startUs) {
+            throw new RangeError('CAPTION_RANGE_INVALID');
+        }
+    }
+}
+export function parseSrt(input) {
+    const normalized = input.replaceAll('\r\n', '\n').trim();
+    if (normalized.length === 0)
+        return [];
+    const cues = normalized.split(/\n{2,}/u).map(block => {
+        const lines = block.split('\n');
+        const timelineIndex = lines.findIndex(line => line.includes('-->'));
+        const timeline = lines[timelineIndex];
+        if (timelineIndex < 0 || timeline === undefined)
+            throw new TypeError('SRT_CUE_INVALID');
+        const parts = timeline.split(/\s+-->\s+/u);
+        if (parts.length !== 2)
+            throw new TypeError('SRT_CUE_INVALID');
+        const start = parts[0];
+        const end = parts[1];
+        if (start === undefined || end === undefined)
+            throw new TypeError('SRT_CUE_INVALID');
+        const id = timelineIndex > 0 ? lines[0]?.trim() : undefined;
+        return {
+            ...(id === undefined || id.length === 0 ? {} : { id }),
+            startUs: timestamp(start),
+            endUs: timestamp(end),
+            text: lines.slice(timelineIndex + 1).join('\n'),
+        };
+    });
+    validateCues(cues);
+    return cues;
+}
+export function serializeSrt(cues) {
+    validateCues(cues);
+    const warnings = cues.some(cue => cue.settings !== undefined)
+        ? ['SRT does not preserve WebVTT cue settings; settings were omitted.']
+        : [];
+    return {
+        text: `${cues
+            .map((cue, index) => `${(index + 1).toString()}\n${formatTimestamp(cue.startUs, ',')} --> ${formatTimestamp(cue.endUs, ',')}\n${cue.text}`)
+            .join('\n\n')}\n`,
+        warnings,
+    };
+}
+export function parseWebVtt(input) {
+    const normalized = input
+        .replaceAll('\r\n', '\n')
+        .replace(/^\uFEFF/u, '')
+        .trim();
+    if (!normalized.startsWith('WEBVTT'))
+        throw new TypeError('WEBVTT_HEADER_MISSING');
+    const body = normalized.slice(normalized.indexOf('\n') + 1).trim();
+    if (body.length === 0)
+        return [];
+    const cues = body
+        .split(/\n{2,}/u)
+        .filter(block => !/^(NOTE|STYLE|REGION)(?:\s|$)/u.test(block))
+        .map(block => {
+        const lines = block.split('\n');
+        const timelineIndex = lines.findIndex(line => line.includes('-->'));
+        const timeline = lines[timelineIndex];
+        if (timelineIndex < 0 || timeline === undefined)
+            throw new TypeError('WEBVTT_CUE_INVALID');
+        const match = /^(\S+)\s+-->\s+(\S+)(?:\s+(.*))?$/u.exec(timeline);
+        if (match?.[1] === undefined || match[2] === undefined) {
+            throw new TypeError('WEBVTT_CUE_INVALID');
+        }
+        const settings = Object.fromEntries((match[3] ?? '')
+            .split(/\s+/u)
+            .filter(Boolean)
+            .map(value => {
+            const separator = value.indexOf(':');
+            return separator < 1
+                ? [value, '']
+                : [value.slice(0, separator), value.slice(separator + 1)];
+        }));
+        const id = timelineIndex > 0 ? lines[0]?.trim() : undefined;
+        return {
+            ...(id === undefined || id.length === 0 ? {} : { id }),
+            startUs: timestamp(match[1]),
+            endUs: timestamp(match[2]),
+            text: lines.slice(timelineIndex + 1).join('\n'),
+            ...(Object.keys(settings).length === 0 ? {} : { settings }),
+        };
+    });
+    validateCues(cues);
+    return cues;
+}
+export function serializeWebVtt(cues) {
+    validateCues(cues);
+    return {
+        text: `WEBVTT\n\n${cues
+            .map(cue => {
+            const settings = Object.entries(cue.settings ?? {})
+                .sort(([left], [right]) => left.localeCompare(right))
+                .map(([key, value]) => `${key}:${value}`)
+                .join(' ');
+            return `${cue.id === undefined ? '' : `${cue.id}\n`}${formatTimestamp(cue.startUs, '.')} --> ${formatTimestamp(cue.endUs, '.')}${settings.length === 0 ? '' : ` ${settings}`}\n${cue.text}`;
+        })
+            .join('\n\n')}\n`,
+        warnings: [],
+    };
+}

package/dist/color.d.ts

@@ -0,0 +1,18 @@
+import type { Diagnostic } from '@aelionsdk/core';
+import type { RenderIr } from './types.js';
+export type IrTransferFunction = 'srgb' | 'gamma22' | 'pq' | 'hlg';
+export type IrOutputBitDepth = 8 | 10;
+export interface ColorPipelineCapability {
+    readonly workingColorSpaces: ReadonlySet<string>;
+    readonly transferFunctions: ReadonlySet<IrTransferFunction>;
+    readonly bitDepths: ReadonlySet<IrOutputBitDepth>;
+    readonly hdrPresentation: boolean;
+}
+export interface ColorPipelineReport {
+    readonly ok: boolean;
+    readonly issues: readonly Diagnostic[];
+}
+export declare function validateColorPipelineContract(ir: RenderIr): void;
+export declare function preflightColorPipeline(ir: RenderIr, capability: ColorPipelineCapability): ColorPipelineReport;
+export declare const LOCAL_RGBA8_COLOR_CAPABILITY: ColorPipelineCapability;
+//# sourceMappingURL=color.d.ts.map

package/dist/color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../src/color.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,KAAK,CAAC;AACnE,MAAM,MAAM,gBAAgB,GAAG,CAAC,GAAG,EAAE,CAAC;AAEtC,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,kBAAkB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACjD,QAAQ,CAAC,iBAAiB,EAAE,WAAW,CAAC,kBAAkB,CAAC,CAAC;IAC5D,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,gBAAgB,CAAC,CAAC;IAClD,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACnC;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,CAAC;CACxC;AAED,wBAAgB,6BAA6B,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI,CAShE;AAED,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,QAAQ,EACZ,UAAU,EAAE,uBAAuB,GAClC,mBAAmB,CAsCrB;AAED,eAAO,MAAM,4BAA4B,EAAE,uBAK1C,CAAC"}

package/dist/color.js

@@ -0,0 +1,55 @@
+export function validateColorPipelineContract(ir) {
+    const transfer = ir.transferFunction ?? 'srgb';
+    const bitDepth = ir.bitDepth ?? 8;
+    if ((transfer === 'pq' || transfer === 'hlg') && ir.workingColorSpace !== 'rec2020-linear') {
+        throw new TypeError('COLOR_HDR_REQUIRES_REC2020');
+    }
+    if ((transfer === 'pq' || transfer === 'hlg') && bitDepth !== 10) {
+        throw new TypeError('COLOR_HDR_REQUIRES_10_BIT');
+    }
+}
+export function preflightColorPipeline(ir, capability) {
+    validateColorPipelineContract(ir);
+    const issues = [];
+    const transfer = ir.transferFunction ?? 'srgb';
+    const bitDepth = ir.bitDepth ?? 8;
+    if (!capability.workingColorSpaces.has(ir.workingColorSpace)) {
+        issues.push({
+            code: 'COLOR_WORKING_SPACE_UNSUPPORTED',
+            severity: 'error',
+            message: `Working color space ${ir.workingColorSpace} is unavailable`,
+            recoverable: true,
+        });
+    }
+    if (!capability.transferFunctions.has(transfer)) {
+        issues.push({
+            code: 'COLOR_TRANSFER_FUNCTION_UNSUPPORTED',
+            severity: 'error',
+            message: `Transfer function ${transfer} is unavailable`,
+            recoverable: true,
+        });
+    }
+    if (!capability.bitDepths.has(bitDepth)) {
+        issues.push({
+            code: 'COLOR_BIT_DEPTH_UNSUPPORTED',
+            severity: 'error',
+            message: `${bitDepth.toString()}-bit output is unavailable`,
+            recoverable: true,
+        });
+    }
+    if ((transfer === 'pq' || transfer === 'hlg') && !capability.hdrPresentation) {
+        issues.push({
+            code: 'COLOR_HDR_PRESENTATION_UNSUPPORTED',
+            severity: 'error',
+            message: 'The active output surface cannot present HDR',
+            recoverable: true,
+        });
+    }
+    return { ok: issues.length === 0, issues };
+}
+export const LOCAL_RGBA8_COLOR_CAPABILITY = {
+    workingColorSpaces: new Set(['srgb-linear', 'display-p3-linear', 'rec2020-linear']),
+    transferFunctions: new Set(['srgb', 'gamma22']),
+    bitDepths: new Set([8]),
+    hdrPresentation: false,
+};

package/dist/compiler.d.ts

@@ -0,0 +1,15 @@
+import { type AelionProject } from '@aelionsdk/project-schema';
+import type { RenderIrCompilation, RenderCompileOptions } from './types.js';
+export declare class IncrementalRenderCompiler {
+    #private;
+    /**
+     * Creates an isolated compiler that reuses this compiler's immutable baseline.
+     * Compiling on the fork cannot advance or corrupt the parent baseline; a host
+     * can promote the fork only after its surrounding transaction commits.
+     */
+    fork(): IncrementalRenderCompiler;
+    /** Releases the incremental baseline retained for clip/transition reuse. */
+    clear(): void;
+    compile(project: AelionProject, sequenceId: string, revision: bigint, optionsOrAffectedRanges?: RenderCompileOptions | RenderIrCompilation['stats']['affectedRanges']): RenderIrCompilation;
+}
+//# sourceMappingURL=compiler.d.ts.map

package/dist/compiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler.d.ts","sourceRoot":"","sources":["../src/compiler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,aAAa,EAAmB,MAAM,2BAA2B,CAAC;AAGpG,OAAO,KAAK,EAaV,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAkZpB,qBAAa,yBAAyB;;IAIpC;;;;OAIG;IACI,IAAI,IAAI,yBAAyB;IAMxC,4EAA4E;IACrE,KAAK,IAAI,IAAI;IAOb,OAAO,CACZ,OAAO,EAAE,aAAa,EACtB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,uBAAuB,GACnB,oBAAoB,GACpB,mBAAmB,CAAC,OAAO,CAAC,CAAC,gBAAgB,CAAM,GACtD,mBAAmB;CAqMvB"}