@aelionsdk/render-ir 0.1.0-beta.1

package/dist/evaluate.js

@@ -0,0 +1,260 @@
+import { mapIrSourceTime } from './time-map.js';
+function isAnimation(value) {
+    if (value === null || Array.isArray(value) || typeof value !== 'object')
+        return false;
+    const animation = Reflect.get(value, 'animation');
+    return (animation !== null &&
+        !Array.isArray(animation) &&
+        typeof animation === 'object' &&
+        Array.isArray(Reflect.get(animation, 'keyframes')));
+}
+function cubicBezierCoordinate(t, first, second) {
+    const inverse = 1 - t;
+    return 3 * inverse * inverse * t * first + 3 * inverse * t * t * second + t * t * t;
+}
+function cubicBezierProgress(progress, easing) {
+    const x1 = numberProperty(easing.x1, 0);
+    const y1 = numberProperty(easing.y1, 0);
+    const x2 = numberProperty(easing.x2, 1);
+    const y2 = numberProperty(easing.y2, 1);
+    let low = 0;
+    let high = 1;
+    for (let iteration = 0; iteration < 20; iteration += 1) {
+        const middle = (low + high) / 2;
+        if (cubicBezierCoordinate(middle, x1, x2) < progress)
+            low = middle;
+        else
+            high = middle;
+    }
+    return cubicBezierCoordinate((low + high) / 2, y1, y2);
+}
+function animationTime(animation, sequenceTimeUs, ownerStartUs) {
+    return animation.timeSpace === 'sequence' ? sequenceTimeUs : sequenceTimeUs - ownerStartUs;
+}
+function positiveModulo(value, divisor) {
+    return ((value % divisor) + divisor) % divisor;
+}
+function infinityTime(timeUs, firstUs, lastUs, mode) {
+    const durationUs = lastUs - firstUs;
+    if (durationUs <= 0 || (mode !== 'cycle' && mode !== 'ping-pong'))
+        return timeUs;
+    const progress = positiveModulo(timeUs - firstUs, durationUs);
+    if (mode === 'cycle')
+        return firstUs + progress;
+    const cycle = Math.floor((timeUs - firstUs) / durationUs);
+    return Math.abs(cycle) % 2 === 0 ? firstUs + progress : lastUs - progress;
+}
+function interpolateJson(from, to, progress) {
+    if (typeof from === 'number' && typeof to === 'number')
+        return from + (to - from) * progress;
+    if (Array.isArray(from) && Array.isArray(to) && from.length === to.length) {
+        return from.map((value, index) => interpolateJson(value, to[index] ?? value, progress));
+    }
+    if (from !== null &&
+        to !== null &&
+        typeof from === 'object' &&
+        typeof to === 'object' &&
+        !Array.isArray(from) &&
+        !Array.isArray(to)) {
+        const keys = Object.keys(from);
+        if (keys.length === Object.keys(to).length && keys.every(key => Object.hasOwn(to, key))) {
+            return Object.fromEntries(keys.map(key => [key, interpolateJson(from[key] ?? null, to[key] ?? null, progress)]));
+        }
+    }
+    return from;
+}
+function easingProgress(progress, from) {
+    const easing = objectProperty(Reflect.get(from, 'easing'));
+    if (easing.type === 'steps') {
+        const count = Math.max(1, Math.floor(numberProperty(easing.count, 1)));
+        return easing.position === 'start'
+            ? Math.min(1, Math.ceil(progress * count) / count)
+            : Math.floor(progress * count) / count;
+    }
+    return from.interpolation === 'cubic-bezier' ? cubicBezierProgress(progress, easing) : progress;
+}
+export function evaluateAnimatedValue(value, sequenceTimeUs, ownerStartUs = 0) {
+    if (!isAnimation(value))
+        return value;
+    const animation = value.animation;
+    let timeUs = animationTime(animation, sequenceTimeUs, ownerStartUs);
+    const keyframes = value.animation.keyframes;
+    if (keyframes.length === 0)
+        return null;
+    const firstKeyframe = keyframes[0];
+    const lastKeyframe = keyframes.at(-1);
+    if (firstKeyframe === undefined || lastKeyframe === undefined)
+        return null;
+    if (timeUs < firstKeyframe.timeUs) {
+        timeUs = infinityTime(timeUs, firstKeyframe.timeUs, lastKeyframe.timeUs, animation.preInfinity);
+    }
+    else if (timeUs > lastKeyframe.timeUs) {
+        timeUs = infinityTime(timeUs, firstKeyframe.timeUs, lastKeyframe.timeUs, animation.postInfinity);
+    }
+    const right = keyframes.findIndex(keyframe => keyframe.timeUs > timeUs);
+    if (right === 0) {
+        if (animation.preInfinity === 'none')
+            return null;
+        if (animation.preInfinity !== 'linear' || keyframes.length < 2)
+            return keyframes[0]?.value ?? null;
+    }
+    if (right < 0) {
+        if (animation.postInfinity === 'none')
+            return null;
+        if (animation.postInfinity !== 'linear' || keyframes.length < 2) {
+            return keyframes.at(-1)?.value ?? null;
+        }
+    }
+    const toIndex = right === 0 ? 1 : right < 0 ? keyframes.length - 1 : right;
+    const from = keyframes[toIndex - 1];
+    const to = keyframes[toIndex];
+    if (from === undefined || to === undefined)
+        return null;
+    if ((from.interpolation !== 'linear' && from.interpolation !== 'cubic-bezier') ||
+        to.timeUs === from.timeUs) {
+        return from.value;
+    }
+    let progress = (timeUs - from.timeUs) / (to.timeUs - from.timeUs);
+    progress = easingProgress(progress, from);
+    return interpolateJson(from.value, to.value, progress);
+}
+export function evaluateAnimatableNumber(value, sequenceTimeUs, ownerStartUs, fallback) {
+    const evaluated = value === undefined ? undefined : evaluateAnimatedValue(value, sequenceTimeUs, ownerStartUs);
+    return numberProperty(evaluated, fallback);
+}
+export function evaluateMaterialInstance(material, sequenceTimeUs, ownerStartUs = 0) {
+    return {
+        id: material.id,
+        parameters: Object.fromEntries(Object.entries(material.parameters).map(([id, value]) => [
+            id,
+            evaluateAnimatedValue(value, sequenceTimeUs, ownerStartUs),
+        ])),
+        resourceBindings: material.resourceBindings,
+        inputBindings: material.inputBindings,
+    };
+}
+function contains(startUs, durationUs, timeUs) {
+    return timeUs >= startUs && timeUs < startUs + durationUs;
+}
+function mapBaseClipSourceTime(clip, sequenceTimeUs, allowOutsideItem = false) {
+    const localUs = sequenceTimeUs - clip.range.startUs;
+    return mapIrSourceTime(allowOutsideItem ? { ...clip.source, boundary: 'hold' } : clip.source, clip.range.durationUs, localUs, {
+        allowOutsideItem,
+    });
+}
+export function mapClipSourceTime(clip, sequenceTimeUs) {
+    return mapBaseClipSourceTime(clip, sequenceTimeUs);
+}
+function isVisualRenderClip(clip) {
+    return (clip.kind === 'visual-clip' ||
+        clip.kind === 'text-clip' ||
+        clip.kind === 'nested-sequence-clip' ||
+        clip.kind === 'generator-clip' ||
+        clip.kind === 'shape-clip' ||
+        clip.kind === 'material-content-clip' ||
+        clip.kind === 'adjustment-clip');
+}
+function mapNestedSourceTime(clip, sequenceTimeUs, allowOutsideItem = false) {
+    return mapIrSourceTime({
+        assetId: clip.source.sequenceId,
+        streamType: 'video',
+        streamIndex: 0,
+        sourceRange: clip.source.sourceRange,
+        timeMapping: clip.source.timeMapping,
+        boundary: allowOutsideItem ? 'hold' : clip.source.boundary,
+    }, clip.range.durationUs, sequenceTimeUs - clip.range.startUs, { allowOutsideItem });
+}
+function numberProperty(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+function objectProperty(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+export function evaluateAudioState(ir, startUs, durationUs) {
+    if (!Number.isSafeInteger(startUs) ||
+        !Number.isSafeInteger(durationUs) ||
+        startUs < 0 ||
+        durationUs <= 0 ||
+        startUs + durationUs > ir.durationUs) {
+        throw new RangeError('Audio evaluation range is outside the Render IR duration');
+    }
+    const hasSoloTrack = ir.tracks.some(track => track.kind === 'audio' && track.enabled && objectProperty(track.audio).solo === true);
+    return {
+        startUs,
+        durationUs,
+        clips: ir.tracks
+            .filter(track => {
+            if (track.kind !== 'audio' || !track.enabled)
+                return false;
+            const audio = objectProperty(track.audio);
+            return audio.muted !== true && (!hasSoloTrack || audio.solo === true);
+        })
+            .flatMap(track => track.clips.flatMap(clip => {
+            if (clip.kind !== 'audio-clip' || !clip.enabled)
+                return [];
+            const overlapStart = Math.max(startUs, clip.range.startUs);
+            const overlapEnd = Math.min(startUs + durationUs, clip.range.startUs + clip.range.durationUs);
+            if (overlapStart >= overlapEnd)
+                return [];
+            const sourceStartUs = mapBaseClipSourceTime(clip, overlapStart);
+            if (sourceStartUs === null)
+                return [];
+            const trackAudio = objectProperty(track.audio);
+            const gainDb = evaluateAnimatableNumber(trackAudio.gainDb, overlapStart, 0, 0) + evaluateAnimatableNumber(clip.audio.gainDb, overlapStart, clip.range.startUs, 0);
+            const pan = evaluateAnimatableNumber(trackAudio.pan, overlapStart, 0, 0) + evaluateAnimatableNumber(clip.audio.pan, overlapStart, clip.range.startUs, 0);
+            return [
+                {
+                    clip,
+                    sourceStartUs,
+                    sequenceStartUs: overlapStart,
+                    durationUs: overlapEnd - overlapStart,
+                    gain: 10 ** (gainDb / 20),
+                    pan: Math.max(-1, Math.min(1, pan)),
+                    trackAudio: track.audio ?? {},
+                },
+            ];
+        })),
+    };
+}
+export function evaluateVisualState(ir, timeUs) {
+    if (!Number.isSafeInteger(timeUs) || timeUs < 0 || timeUs >= ir.durationUs) {
+        throw new RangeError('timeUs is outside the Render IR duration');
+    }
+    const transition = ir.transitions.find(value => contains(value.range.startUs, value.range.durationUs, timeUs));
+    const transitionInputIds = transition === undefined ? undefined : new Set([transition.fromItemId, transition.toItemId]);
+    const clips = ir.tracks
+        .filter(track => (track.kind === 'visual' || track.kind === 'caption') && track.enabled)
+        .flatMap(track => track.clips
+        .filter((clip) => isVisualRenderClip(clip) &&
+        clip.enabled &&
+        (contains(clip.range.startUs, clip.range.durationUs, timeUs) ||
+            transitionInputIds?.has(clip.id) === true))
+        .map(clip => ({
+        clip,
+        sourceTimeUs: clip.kind === 'visual-clip'
+            ? mapBaseClipSourceTime(clip, timeUs, transitionInputIds?.has(clip.id) === true)
+            : clip.kind === 'nested-sequence-clip'
+                ? mapNestedSourceTime(clip, timeUs, transitionInputIds?.has(clip.id) === true)
+                : null,
+        materials: clip.materialInstanceIds.flatMap(id => {
+            const value = ir.materials[id];
+            return value?.enabled === true ? [value] : [];
+        }),
+    })));
+    const transitionMaterial = transition === undefined ? undefined : ir.materials[transition.materialInstanceId];
+    return {
+        timeUs,
+        clips,
+        ...(transition === undefined || transitionMaterial?.enabled !== true
+            ? {}
+            : {
+                transition: {
+                    transition,
+                    progress: (timeUs - transition.range.startUs) / transition.range.durationUs,
+                    material: transitionMaterial,
+                },
+            }),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './captions.js';
+export * from './color.js';
+export * from './compiler.js';
+export * from './evaluate.js';
+export * from './text-layout.js';
+export * from './time-map.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from './captions.js';
+export * from './color.js';
+export * from './compiler.js';
+export * from './evaluate.js';
+export * from './text-layout.js';
+export * from './time-map.js';
+export * from './types.js';

package/dist/text-layout.d.ts

@@ -0,0 +1,46 @@
+import type { JsonObject } from '@aelionsdk/core';
+import type { IrTextClip } from './types.js';
+export interface IrLaidOutTextSpan {
+    readonly text: string;
+    readonly x: number;
+    readonly y: number;
+    readonly advancePx: number;
+    readonly glyphs: readonly IrLaidOutTextGlyph[];
+    readonly style: PortableTextStyle;
+}
+export interface IrLaidOutTextGlyph {
+    readonly text: string;
+    readonly x: number;
+    readonly advancePx: number;
+}
+export interface IrLaidOutTextLine {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly spans: readonly IrLaidOutTextSpan[];
+}
+export interface IrTextLayout {
+    readonly metricsId: 'aelion-portable-text-metrics/1';
+    readonly fontSizePx: number;
+    readonly overflowed: boolean;
+    readonly lines: readonly IrLaidOutTextLine[];
+}
+export interface PortableTextStyle {
+    readonly fontFamilies: readonly string[];
+    readonly fontSizePx: number;
+    readonly fontWeight: number;
+    readonly fontStyle: 'normal' | 'italic' | 'oblique';
+    readonly lineHeightPx: number;
+    readonly letterSpacingPx: number;
+    readonly fill: string;
+    readonly stroke: string | undefined;
+    readonly strokeWidthPx: number;
+    readonly align: 'start' | 'center' | 'end';
+    readonly direction: 'ltr' | 'rtl';
+}
+export declare function portableTextStyle(runStyle: JsonObject, paragraphStyle?: JsonObject, scale?: number): PortableTextStyle;
+export declare function portableGlyphAdvance(character: string, style: PortableTextStyle): number;
+/** Deterministic, host-independent line breaking used by Preview and Export. */
+export declare function layoutIrText(clip: IrTextClip): IrTextLayout;
+//# sourceMappingURL=text-layout.d.ts.map

package/dist/text-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-layout.d.ts","sourceRoot":"","sources":["../src/text-layout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,YAAY,CAAC;AAQxD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAC/C,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC;CACnC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAC9C;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,SAAS,EAAE,gCAAgC,CAAC;IACrD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAC9C;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;IACpD,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAC;IAC3C,QAAQ,CAAC,SAAS,EAAE,KAAK,GAAG,KAAK,CAAC;CACnC;AAUD,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,UAAU,EACpB,cAAc,GAAE,UAAe,EAC/B,KAAK,SAAI,GACR,iBAAiB,CAsBnB;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,GAAG,MAAM,CAaxF;AA8HD,gFAAgF;AAChF,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,YAAY,CA2B3D"}

package/dist/text-layout.js

@@ -0,0 +1,188 @@
+const graphemeSegmenter = new Intl.Segmenter('und', { granularity: 'grapheme' });
+function graphemes(value) {
+    return Array.from(graphemeSegmenter.segment(value), segment => segment.segment);
+}
+function finite(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+function text(value, fallback) {
+    return typeof value === 'string' ? value : fallback;
+}
+export function portableTextStyle(runStyle, paragraphStyle = {}, scale = 1) {
+    const combined = { ...paragraphStyle, ...runStyle };
+    const families = Array.isArray(combined.fontFamilies)
+        ? combined.fontFamilies.filter((value) => typeof value === 'string')
+        : [text(combined.fontFamily, 'sans-serif')];
+    const fontSizePx = Math.max(1, finite(combined.fontSizePx, 32) * scale);
+    const fontStyle = text(combined.fontStyle, 'normal');
+    const align = text(combined.align, 'start');
+    const direction = text(combined.direction, 'ltr');
+    return {
+        fontFamilies: families.length === 0 ? ['sans-serif'] : families,
+        fontSizePx,
+        fontWeight: Math.max(1, Math.min(1_000, finite(combined.fontWeight, 400))),
+        fontStyle: fontStyle === 'italic' || fontStyle === 'oblique' ? fontStyle : 'normal',
+        lineHeightPx: Math.max(fontSizePx, finite(combined.lineHeightPx, fontSizePx * 1.2) * scale),
+        letterSpacingPx: finite(combined.letterSpacingPx, 0) * scale,
+        fill: text(combined.fill, '#ffffff'),
+        stroke: typeof combined.stroke === 'string' ? combined.stroke : undefined,
+        strokeWidthPx: Math.max(0, finite(combined.strokeWidthPx, 0) * scale),
+        align: align === 'center' || align === 'end' ? align : 'start',
+        direction: direction === 'rtl' ? 'rtl' : 'ltr',
+    };
+}
+export function portableGlyphAdvance(character, style) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    const em = character === ' '
+        ? 0.33
+        : codePoint >= 0x2e80 || codePoint > 0xffff
+            ? 1
+            : /[ilI1.,'`]/u.test(character)
+                ? 0.32
+                : /[MW@#%]/u.test(character)
+                    ? 0.9
+                    : 0.6;
+    return style.fontSizePx * em + style.letterSpacingPx;
+}
+function runTokens(run) {
+    return run.text
+        .split(/(\r?\n|[\t ]+|(?=[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]))/gu)
+        .filter(Boolean);
+}
+function tokenAdvance(token, style) {
+    return graphemes(token).reduce((total, character) => total + portableGlyphAdvance(character, style), 0);
+}
+function lineOffset(width, boxWidth, align, direction) {
+    if (align === 'center')
+        return (boxWidth - width) / 2;
+    if (align === 'end')
+        return direction === 'rtl' ? 0 : boxWidth - width;
+    return direction === 'rtl' ? boxWidth - width : 0;
+}
+function laidOutSpan(value, x, y, style) {
+    let cursor = x;
+    const glyphs = graphemes(value).map(character => {
+        const advancePx = portableGlyphAdvance(character, style);
+        const glyph = { text: character, x: cursor, advancePx };
+        cursor += advancePx;
+        return glyph;
+    });
+    return { text: value, x, y, advancePx: cursor - x, glyphs, style };
+}
+function layoutAtScale(clip, scale) {
+    const lines = [];
+    let cursorY = clip.box.y;
+    let current = [];
+    let width = 0;
+    let height = 0;
+    let align = 'start';
+    let direction = 'ltr';
+    let overflowed = false;
+    const flush = () => {
+        if (current.length === 0 && height === 0)
+            return;
+        const offset = lineOffset(width, clip.box.width, align, direction);
+        let rtlCursor = clip.box.x + width;
+        const positioned = current.map(span => {
+            if (direction !== 'rtl')
+                return span;
+            rtlCursor -= span.advancePx;
+            const shift = rtlCursor - span.x;
+            return {
+                ...span,
+                x: rtlCursor,
+                glyphs: span.glyphs.map(glyph => ({ ...glyph, x: glyph.x + shift })),
+            };
+        });
+        lines.push({
+            x: clip.box.x + offset,
+            y: cursorY,
+            width,
+            height,
+            spans: positioned.map(span => ({
+                ...span,
+                x: span.x + offset,
+                glyphs: span.glyphs.map(glyph => ({ ...glyph, x: glyph.x + offset })),
+            })),
+        });
+        cursorY += height;
+        current = [];
+        width = 0;
+        height = 0;
+    };
+    for (const paragraph of clip.paragraphs) {
+        for (const run of paragraph.runs) {
+            const style = portableTextStyle(run.style, paragraph.style, scale);
+            for (const token of runTokens(run)) {
+                if (token === '\n' || token === '\r\n') {
+                    flush();
+                    continue;
+                }
+                if (current.length === 0) {
+                    align = style.align;
+                    direction = style.direction;
+                }
+                const advance = tokenAdvance(token, style);
+                if (width > 0 && width + advance > clip.box.width && token.trim().length > 0)
+                    flush();
+                if (cursorY + Math.max(height, style.lineHeightPx) > clip.box.y + clip.box.height) {
+                    overflowed = true;
+                }
+                current.push(laidOutSpan(token, clip.box.x + width, cursorY, style));
+                width += advance;
+                height = Math.max(height, style.lineHeightPx);
+            }
+        }
+        flush();
+    }
+    if (clip.overflow === 'ellipsis' && overflowed) {
+        const last = lines.findLast(line => line.y + line.height <= clip.box.y + clip.box.height);
+        if (last !== undefined && last.spans.length > 0) {
+            const spans = last.spans.slice();
+            const tail = spans.at(-1);
+            if (tail !== undefined) {
+                const replacement = laidOutSpan(`${tail.text.trimEnd()}…`, tail.x, tail.y, tail.style);
+                spans[spans.length - 1] = replacement;
+            }
+            const index = lines.indexOf(last);
+            lines.splice(index, lines.length - index, { ...last, spans });
+        }
+    }
+    return {
+        metricsId: 'aelion-portable-text-metrics/1',
+        fontSizePx: 32 * scale,
+        overflowed,
+        lines,
+    };
+}
+/** Deterministic, host-independent line breaking used by Preview and Export. */
+export function layoutIrText(clip) {
+    if (clip.writingMode !== 'horizontal-tb') {
+        // Portable vertical fallback treats each grapheme as a line. It remains
+        // deterministic and preserves content when native vertical shaping is unavailable.
+        const vertical = {
+            ...clip,
+            paragraphs: clip.paragraphs.map(paragraph => ({
+                ...paragraph,
+                runs: paragraph.runs.map(run => ({ ...run, text: graphemes(run.text).join('\n') })),
+            })),
+        };
+        return layoutAtScale(vertical, 1);
+    }
+    let result = layoutAtScale(clip, 1);
+    if (clip.overflow !== 'auto-fit' || !result.overflowed)
+        return result;
+    let low = 0.25;
+    let high = 1;
+    for (let iteration = 0; iteration < 12; iteration++) {
+        const middle = (low + high) / 2;
+        const candidate = layoutAtScale(clip, middle);
+        if (candidate.overflowed)
+            high = middle;
+        else {
+            low = middle;
+            result = candidate;
+        }
+    }
+    return result;
+}

package/dist/time-map.d.ts

@@ -0,0 +1,26 @@
+import type { IrMediaSource, IrTimeMapping } from './types.js';
+export type IrTimeMapDirection = 'forward' | 'reverse' | 'hold';
+export interface IrTimeMapSegment {
+    readonly itemStartUs: number;
+    readonly itemEndUs: number;
+    readonly sourceStartUs: number;
+    readonly sourceEndUs: number;
+    readonly direction: IrTimeMapDirection;
+    readonly interpolation: 'linear' | 'hold' | 'cubic';
+}
+export interface IrTimeMapInverse {
+    readonly kind: 'point' | 'range';
+    readonly itemStartUs: number;
+    readonly itemEndUs: number;
+}
+/** Returns the canonical mapping, including compatibility for legacy hand-authored IR. */
+export declare function irTimeMapping(source: IrMediaSource): IrTimeMapping;
+/** Validates and exposes independently monotonic portions of a TimeMap. */
+export declare function analyzeIrTimeMap(source: IrMediaSource, itemDurationUs: number): readonly IrTimeMapSegment[];
+/** Inverts all monotonic TimeMap segments. Hold regions return an Item-local range. */
+export declare function invertIrSourceTime(source: IrMediaSource, itemDurationUs: number, sourceTimeUs: number): readonly IrTimeMapInverse[];
+/** Maps Item-local time to normalized absolute source presentation time. */
+export declare function mapIrSourceTime(source: IrMediaSource, itemDurationUs: number, localUs: number, options?: {
+    readonly allowOutsideItem?: boolean;
+}): number | null;
+//# sourceMappingURL=time-map.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"time-map.d.ts","sourceRoot":"","sources":["../src/time-map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,aAAa,EACb,aAAa,EACd,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC;AAEhE,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,kBAAkB,CAAC;IACvC,QAAQ,CAAC,aAAa,EAAE,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;CACrD;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;IACjC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAuBD,0FAA0F;AAC1F,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,aAAa,CAElE;AA4CD,2EAA2E;AAC3E,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,aAAa,EACrB,cAAc,EAAE,MAAM,GACrB,SAAS,gBAAgB,EAAE,CAqD7B;AAcD,uFAAuF;AACvF,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,aAAa,EACrB,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,MAAM,GACnB,SAAS,gBAAgB,EAAE,CA0C7B;AAqBD,4EAA4E;AAC5E,wBAAgB,eAAe,CAC7B,MAAM,EAAE,aAAa,EACrB,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IAAE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAO,GACpD,MAAM,GAAG,IAAI,CAkBf"}