visualfries 0.1.10115 → 0.3.2

package/dist/agent/inspectScene.d.ts

@@ -0,0 +1,36 @@
+import { type ComponentCapability } from './capabilities.js';
+export type SceneInspectionIssue = {
+    level: 'error' | 'warning';
+    type: string;
+    code?: string;
+    capabilityId?: string;
+    path?: string;
+    message: string;
+    componentId?: string;
+    layerId?: string;
+};
+export type SceneInspectionReport = {
+    valid: boolean;
+    schemaValid: boolean;
+    runtimeSupported: boolean;
+    issues: SceneInspectionIssue[];
+    components: Array<{
+        id: string;
+        layerId: string;
+        type: string;
+        capability?: ComponentCapability;
+    }>;
+    summary: {
+        duration: number;
+        width: number;
+        height: number;
+        layers: number;
+        components: number;
+        runtimeWarnings: number;
+    };
+};
+export type InspectSceneOptions = {
+    strictRuntimeSupport?: boolean;
+    includeCapabilities?: boolean;
+};
+export declare function inspectScene(input: unknown, options?: InspectSceneOptions): SceneInspectionReport;

package/dist/agent/inspectScene.js

@@ -0,0 +1,139 @@
+import { SceneShape } from '../schemas/scene/index.js';
+import { getComponentCapability } from './capabilities.js';
+import { analyzeRuntimeSupport } from './runtimeSupport.js';
+export function inspectScene(input, options = {}) {
+    const parsed = SceneShape.safeParse(input);
+    if (!parsed.success) {
+        return {
+            valid: false,
+            schemaValid: false,
+            runtimeSupported: false,
+            issues: [
+                {
+                    level: 'error',
+                    type: 'schema',
+                    message: parsed.error.message
+                }
+            ],
+            components: [],
+            summary: { duration: 0, width: 0, height: 0, layers: 0, components: 0, runtimeWarnings: 0 }
+        };
+    }
+    const scene = parsed.data;
+    const issues = [];
+    const assetIds = new Set((scene.assets ?? []).map((asset) => asset.id));
+    let components = 0;
+    const componentReports = [];
+    for (const layer of scene.layers ?? []) {
+        for (const component of layer.components ?? []) {
+            components += 1;
+            componentReports.push({
+                id: component.id,
+                layerId: layer.id,
+                type: component.type,
+                ...(options.includeCapabilities === false
+                    ? {}
+                    : { capability: getComponentCapability(component.type) })
+            });
+            if (component.timeline.endAt > scene.settings.duration) {
+                issues.push({
+                    level: 'warning',
+                    type: 'timeline-outside-scene',
+                    message: `Component ends after scene duration (${component.timeline.endAt}s > ${scene.settings.duration}s).`,
+                    componentId: component.id,
+                    layerId: layer.id
+                });
+            }
+            if ('source' in component &&
+                component.source?.assetId &&
+                !assetIds.has(component.source.assetId)) {
+                issues.push({
+                    level: 'warning',
+                    type: 'missing-asset',
+                    message: `Component references asset "${component.source.assetId}" that is not in scene.assets.`,
+                    componentId: component.id,
+                    layerId: layer.id
+                });
+            }
+            if (component.type === 'SUBTITLES') {
+                const assetId = component.timingAnchor.assetId ?? component.source?.assetId;
+                const languageCode = component.source?.languageCode;
+                if (!assetId) {
+                    issues.push({
+                        level: 'error',
+                        type: 'subtitle-anchor-missing',
+                        message: 'Subtitles component needs timingAnchor.assetId or source.assetId.',
+                        componentId: component.id,
+                        layerId: layer.id
+                    });
+                }
+                else if (!scene.settings.subtitles?.data?.[assetId]) {
+                    issues.push({
+                        level: 'warning',
+                        type: 'subtitle-data-missing',
+                        message: `No scene.settings.subtitles.data entry found for "${assetId}".`,
+                        componentId: component.id,
+                        layerId: layer.id
+                    });
+                }
+                else if (languageCode &&
+                    (!scene.settings.subtitles.data[assetId]?.[languageCode] ||
+                        scene.settings.subtitles.data[assetId][languageCode].length === 0)) {
+                    issues.push({
+                        level: 'warning',
+                        type: 'subtitle-language-data-missing',
+                        message: `No subtitle data found for asset "${assetId}" and language "${languageCode}". Runtime may fall back to another language.`,
+                        componentId: component.id,
+                        layerId: layer.id
+                    });
+                }
+            }
+        }
+    }
+    const runtime = analyzeRuntimeSupport(scene, {
+        mode: (options.strictRuntimeSupport ? 'strict' : 'warn')
+    });
+    issues.push(...runtime.issues);
+    const rawRuntimeIssues = [];
+    const rawLayers = input?.layers;
+    if (Array.isArray(rawLayers)) {
+        for (const [layerIndex, rawLayer] of rawLayers.entries()) {
+            const layer = rawLayer;
+            if (!Array.isArray(layer.components))
+                continue;
+            for (const [componentIndex, rawComponent] of layer.components.entries()) {
+                const component = rawComponent;
+                if (component.appearance?.clipColor === undefined &&
+                    component.appearance?.text?.clipColor === undefined) {
+                    continue;
+                }
+                rawRuntimeIssues.push({
+                    level: options.strictRuntimeSupport ? 'error' : 'warning',
+                    type: 'runtime-support',
+                    code: 'runtime-text-clip-color-unsupported',
+                    capabilityId: `component.${component.type ?? 'TEXT'}.text.clipColor`,
+                    path: `layers.${layerIndex}.components.${componentIndex}.appearance.text.clipColor`,
+                    message: 'clipColor has no defined VisualFries runtime semantics and would otherwise be stripped during parsing.',
+                    componentId: component.id,
+                    layerId: layer.id
+                });
+            }
+        }
+    }
+    issues.push(...rawRuntimeIssues);
+    return {
+        valid: !issues.some((issue) => issue.level === 'error'),
+        schemaValid: true,
+        runtimeSupported: runtime.supported && rawRuntimeIssues.length === 0,
+        issues,
+        components: componentReports,
+        summary: {
+            duration: scene.settings.duration,
+            width: scene.settings.width,
+            height: scene.settings.height,
+            layers: scene.layers.length,
+            components,
+            runtimeWarnings: runtime.issues.length + rawRuntimeIssues.length
+        }
+    };
+}

package/dist/agent/localRender.d.ts

@@ -0,0 +1,82 @@
+import { type AgentRenderPlan } from './renderPlan.js';
+export type LocalRenderModulePaths = {
+    vite?: string;
+    svelteVitePlugin?: string;
+    playwright?: string;
+    nodeModules?: string;
+};
+export type LocalRenderOptions = {
+    scene: unknown;
+    output: string;
+    framesOnly?: boolean;
+    frameIndices: number[];
+    fps: number;
+    imageFormat?: 'png' | 'jpg' | 'jpeg';
+    imageQuality?: number;
+    audioOverride?: string;
+    keepFrames?: boolean;
+    skipDuplicates?: boolean;
+    streamEncode?: boolean;
+    crf?: number;
+    preset?: string;
+    renderPlan?: AgentRenderPlan;
+    tmpDir?: string;
+    packageRoot?: string;
+    modulePaths?: LocalRenderModulePaths;
+    chromiumPath?: string;
+    serverRendererMode?: 'canvas' | 'webgl';
+    preferWebGL2?: boolean;
+    powerPreference?: 'default' | 'high-performance' | 'low-power';
+    mediaDiagnostics?: boolean;
+    explain?: Array<{
+        componentId: string;
+        frame: number;
+    }>;
+    environment?: 'client' | 'server';
+};
+export type LocalRenderResult = {
+    ok: true;
+    scene: {
+        id: string;
+        width: number;
+        height: number;
+        duration: number;
+        fps: number;
+    };
+    frames: {
+        count: number;
+        dir: string;
+        items: Array<{
+            frame: number;
+            time: number;
+            path: string | null;
+            isDuplicate: boolean;
+        }>;
+        transport: 'range-binding' | 'sparse-evaluate' | 'range-binding-stream-encode';
+        skippedDuplicates: number;
+    };
+    output: string;
+    encoded: boolean;
+    encoding: {
+        mode: 'none' | 'frame-sequence';
+    } | {
+        mode: 'image2pipe';
+        elapsedMs: number;
+        audioMuxed: boolean;
+    };
+    audio: {
+        mode: 'none' | 'override' | 'mixed' | 'primary-fallback';
+        selectedSources: number;
+        skippedSources: number;
+        plannedSources: number;
+        path?: string;
+    };
+    mediaDiagnosticsPath: string | null;
+    mediaDiagnostics: Array<Record<string, unknown>>;
+    explanations?: Array<Record<string, unknown> | null>;
+    runtimeErrors?: string[];
+};
+export declare const localPathFromUrl: (value: string | undefined) => string | undefined;
+export declare const eventEmitter3ShimSource = "export default class EventEmitter{constructor(){this._events=new Map();}_add(name,fn,context,once){if(typeof fn!=='function')throw new TypeError('The listener must be a function');const list=this._events.get(name)||[];list.push({fn,context:context===undefined?this:context,once});this._events.set(name,list);return this;}on(name,fn,context){return this._add(name,fn,context,false);}addListener(name,fn,context){return this.on(name,fn,context);}once(name,fn,context){return this._add(name,fn,context,true);}off(name,fn,context,once){return this.removeListener(name,fn,context,once);}removeListener(name,fn,context,once){const list=this._events.get(name);if(!list)return this;if(fn===undefined){this._events.delete(name);return this;}const next=list.filter((listener)=>listener.fn!==fn||(context!==undefined&&listener.context!==context)||(once!==undefined&&listener.once!==once));if(next.length)this._events.set(name,next);else this._events.delete(name);return this;}removeAllListeners(name){if(name===undefined)this._events.clear();else this._events.delete(name);return this;}emit(name,...args){const list=this._events.get(name);if(!list?.length)return false;for(const listener of [...list]){if(listener.once)this.removeListener(name,listener.fn,listener.context,true);listener.fn.apply(listener.context,args);}return true;}listeners(name){return (this._events.get(name)||[]).map((listener)=>listener.fn);}listenerCount(name){return this._events.get(name)?.length||0;}eventNames(){return [...this._events.keys()];}}\nexport { EventEmitter };\n";
+export declare const normalizeImageQuality: (value: number | undefined, fallback?: number) => number;
+export declare function renderSceneLocally(options: LocalRenderOptions): Promise<LocalRenderResult>;