sketchmark 2.1.1 → 2.1.2

package/dist/src/project.js

@@ -1,107 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadVisualProject = loadVisualProject;
-exports.buildSymbolIndex = buildSymbolIndex;
-exports.validateVisualProject = validateVisualProject;
-const validate_1 = require("./validate");
-const utils_1 = require("./utils");
-const fs = require("node:fs");
-const path = require("node:path");
-function loadVisualProject(entryPath) {
-    const entry = path.resolve(entryPath);
-    const root = path.dirname(entry);
-    const files = {};
-    const document = loadRecursive(entry, root, files, new Set());
-    const project = { root, entry, document, files, symbols: [] };
-    project.symbols = buildSymbolIndex(project);
-    const result = validateVisualProject(project);
-    if (!result.ok) {
-        const first = result.issues[0];
-        throw new Error(first ? `${first.path}: ${first.message}` : "Invalid visual project.");
-    }
-    return project;
-}
-function buildSymbolIndex(project) {
-    const symbols = [];
-    const addElements = (elements, file, scene, prefix) => {
-        for (const [index, element] of (0, utils_1.flattenElements)(elements ?? []).entries()) {
-            if (!element.id)
-                continue;
-            symbols.push({
-                id: element.id,
-                type: element.type,
-                ...(file ? { file } : {}),
-                ...(scene ? { scene } : {}),
-                path: `${prefix}/${index}`
-            });
-        }
-    };
-    for (const [file, document] of Object.entries(project.files ?? {})) {
-        addElements(document.elements, file, undefined, `/files/${file}/elements`);
-        for (const [sceneId, scene] of Object.entries(document.scenes ?? {})) {
-            addElements(scene.elements, file, sceneId, `/files/${file}/scenes/${sceneId}/elements`);
-        }
-    }
-    if (!project.files || !Object.keys(project.files).length) {
-        addElements(project.document.elements, undefined, undefined, "/elements");
-        for (const [sceneId, scene] of Object.entries(project.document.scenes ?? {})) {
-            addElements(scene.elements, undefined, sceneId, `/scenes/${sceneId}/elements`);
-        }
-    }
-    return symbols;
-}
-function validateVisualProject(project) {
-    const merged = (0, validate_1.validateVisualDocument)(project.document);
-    const issues = [...merged.issues];
-    const warnings = [...merged.warnings];
-    for (const [file, document] of Object.entries(project.files ?? {})) {
-        const result = (0, validate_1.validateVisualDocument)({ ...document, sequences: undefined });
-        issues.push(...result.issues.map((item) => ({ ...item, path: `/files/${file}${item.path}` })));
-        warnings.push(...result.warnings.map((item) => ({ ...item, path: `/files/${file}${item.path}` })));
-    }
-    const seen = new Set();
-    for (const symbol of project.symbols ?? []) {
-        const scope = `${symbol.file ?? "<merged>"}:${symbol.scene ?? "<root>"}:${symbol.id}`;
-        if (seen.has(scope)) {
-            issues.push({
-                path: symbol.path,
-                code: "duplicate_symbol",
-                message: `Duplicate id '${symbol.id}' in the same file/scene scope.`,
-                suggestion: "Use stable unique ids so AI patches can target one primitive."
-            });
-        }
-        seen.add(scope);
-    }
-    return { ok: issues.length === 0, issues, warnings };
-}
-function loadRecursive(filePath, root, files, seen) {
-    const absolute = path.resolve(filePath);
-    const relative = normalizePath(path.relative(root, absolute));
-    if (seen.has(absolute))
-        throw new Error(`Circular import detected at '${relative}'.`);
-    seen.add(absolute);
-    const source = JSON.parse(fs.readFileSync(absolute, "utf8"));
-    files[relative] = source;
-    const merged = {
-        ...source,
-        elements: [...(source.elements ?? [])],
-        scenes: { ...(source.scenes ?? {}) },
-        sequences: { ...(source.sequences ?? {}) },
-        assets: { ...(source.assets ?? {}) }
-    };
-    for (const [key, importPath] of Object.entries(source.imports ?? {})) {
-        const child = loadRecursive(path.resolve(path.dirname(absolute), importPath), root, files, seen);
-        if (child.elements?.length) {
-            merged.scenes = merged.scenes ?? {};
-            merged.scenes[key] = { id: key, canvas: child.canvas, elements: child.elements };
-        }
-        merged.scenes = { ...(merged.scenes ?? {}), ...(child.scenes ?? {}) };
-        merged.sequences = { ...(merged.sequences ?? {}), ...(child.sequences ?? {}) };
-        merged.assets = { ...(merged.assets ?? {}), ...(child.assets ?? {}) };
-    }
-    seen.delete(absolute);
-    return merged;
-}
-function normalizePath(value) {
-    return value.replace(/\\/g, "/");
-}

package/dist/src/render/raw-three.d.ts

@@ -1,7 +0,0 @@
-export interface RawThreeModuleOptions {
-    width: number;
-    height: number;
-    moduleUrl: string;
-    background?: string;
-}
-export declare function renderRawThreeModuleHtml(options: RawThreeModuleOptions): string;

package/dist/src/render/raw-three.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.renderRawThreeModuleHtml = renderRawThreeModuleHtml;
-function renderRawThreeModuleHtml(options) {
-    const background = options.background ?? "#ffffff";
-    return `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Sketchmark Raw Three Module</title><style>html,body{margin:0;width:100%;height:100%;overflow:hidden;background:${escapeCss(background)}}canvas{display:block}</style></head><body><canvas id="stage"></canvas><script type="module">
-import { createSketchmarkThreeScene } from ${JSON.stringify(options.moduleUrl)};
-const canvas = document.getElementById("stage");
-const runtime = await createSketchmarkThreeScene({ canvas, width: ${Number(options.width)}, height: ${Number(options.height)}, background: ${JSON.stringify(background)} });
-if (runtime && typeof runtime.render === "function") runtime.render(0);
-window.__SKETCHMARK_SHOW_TIME__ = (time) => runtime && typeof runtime.render === "function" ? runtime.render(time || 0) : undefined;
-window.__SKETCHMARK_READY__ = true;
-</script></body></html>`;
-}
-function escapeCss(value) {
-    return String(value).replace(/[<>"'()\\]/g, "");
-}

package/dist/src/render/three-html.d.ts

@@ -1,2 +0,0 @@
-import type { RenderOptions, VisualDocument } from "../types";
-export declare function renderToThreeHtml(document: VisualDocument, options?: RenderOptions): string;

package/dist/src/render/three-html.js

@@ -1,257 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.renderToThreeHtml = renderToThreeHtml;
-const kernel_1 = require("../kernel");
-const DEFAULT_THREE_RUNTIME = "https://cdn.jsdelivr.net/npm/three@0.184.0/build/three.module.js";
-function renderToThreeHtml(document, options = {}) {
-    const width = document.canvas.width;
-    const height = document.canvas.height;
-    const background = options.transparent ? "transparent" : (document.canvas.background ?? "#ffffff");
-    const initialTime = Number(options.time ?? 0);
-    const frames = JSON.stringify(sampleKernelFrames(document, initialTime));
-    const threeRuntime = options.threeRuntime ?? DEFAULT_THREE_RUNTIME;
-    return `<!doctype html>
-<html>
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width,initial-scale=1">
-  <title>Sketchmark Three</title>
-  <style>
-    html, body {
-      margin: 0;
-      width: 100%;
-      height: 100%;
-      overflow: hidden;
-      background: ${background};
-      display: grid;
-      place-items: center;
-    }
-    main { width: min(100vw, ${width}px); }
-    canvas {
-      display: block;
-      width: min(100vw, ${width}px);
-      height: auto;
-      aspect-ratio: ${width} / ${height};
-      background: transparent;
-    }
-  </style>
-</head>
-<body>
-<main><canvas id="stage"></canvas></main>
-<script>
-window.__SKETCHMARK_ERROR__ = "";
-window.addEventListener("error", (event) => {
-  window.__SKETCHMARK_ERROR__ = event.message || String(event.error || "Unknown script error");
-});
-window.addEventListener("unhandledrejection", (event) => {
-  window.__SKETCHMARK_ERROR__ = event.reason && event.reason.message ? event.reason.message : String(event.reason || "Unhandled promise rejection");
-});
-</script>
-<script type="module">
-import * as THREE from ${JSON.stringify(threeRuntime)};
-
-const width = ${JSON.stringify(width)};
-const height = ${JSON.stringify(height)};
-const background = ${JSON.stringify(background)};
-const frames = ${frames};
-const canvas = document.getElementById("stage");
-const renderer = new THREE.WebGLRenderer({ canvas, antialias: true, alpha: true, preserveDrawingBuffer: true });
-renderer.setSize(width, height, false);
-renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, 2));
-
-const scene = new THREE.Scene();
-if (background !== "transparent") scene.background = new THREE.Color(background);
-
-const camera = new THREE.PerspectiveCamera(50, width / height, 0.1, 1000);
-camera.position.set(6, 4, 8);
-camera.lookAt(0, 0, 0);
-
-const content = new THREE.Group();
-scene.add(content);
-let currentFrameIndex = -1;
-
-function createObject(element) {
-  if (element.type === "mesh3d") {
-    const vertices = Array.isArray(element.vertices) ? element.vertices.flatMap((point) => vector(point, [0, 0, 0])) : [];
-    const indices = Array.isArray(element.indices) ? element.indices.map((value) => Number(value) || 0) : [];
-    const geometry = new THREE.BufferGeometry();
-    geometry.setAttribute("position", new THREE.Float32BufferAttribute(vertices, 3));
-    if (indices.length) geometry.setIndex(indices);
-    geometry.computeVertexNormals();
-    const material = materialFor(element);
-    const mesh = new THREE.Mesh(geometry, material);
-    applyPosition(mesh, element.position);
-    return mesh;
-  }
-
-  if (element.type === "line3d") {
-    const points = [new THREE.Vector3(...vector(element.from, [0, 0, 0])), new THREE.Vector3(...vector(element.to, [0, 0, 0]))];
-    return new THREE.Line(new THREE.BufferGeometry().setFromPoints(points), new THREE.LineBasicMaterial({ color: element.stroke || "#111827" }));
-  }
-
-  if (element.type === "point3d") {
-    const object = new THREE.Object3D();
-    applyPosition(object, element.position);
-    return object;
-  }
-
-  if (element.type === "group3d") {
-    const group = new THREE.Group();
-    for (const child of element.children || []) {
-      const childObject = createObject(child);
-      if (childObject) group.add(childObject);
-    }
-    applyPosition(group, element.position);
-    return group;
-  }
-
-  if (element.type === "text3d") {
-    const textCanvas = document.createElement("canvas");
-    textCanvas.width = 512;
-    textCanvas.height = 128;
-    const ctx = textCanvas.getContext("2d");
-    ctx.clearRect(0, 0, textCanvas.width, textCanvas.height);
-    ctx.fillStyle = element.fill || "#111827";
-    ctx.font = "700 48px Inter, Arial, sans-serif";
-    ctx.textAlign = "center";
-    ctx.textBaseline = "middle";
-    ctx.fillText(element.text || "", 256, 64);
-    const texture = new THREE.CanvasTexture(textCanvas);
-    const sprite = new THREE.Sprite(new THREE.SpriteMaterial({ map: texture, transparent: true, opacity: number(element.opacity, 1) }));
-    const scale = number(element.fontSize, 1);
-    sprite.scale.set(scale * 4, scale, 1);
-    applyPosition(sprite, element.position);
-    return sprite;
-  }
-
-  if (element.type === "light") {
-    const kind = element.kind || "ambient";
-    const intensity = number(element.intensity, kind === "ambient" ? 0.6 : 1);
-    const light = kind === "directional"
-      ? new THREE.DirectionalLight(0xffffff, intensity)
-      : kind === "point"
-        ? new THREE.PointLight(0xffffff, intensity)
-        : new THREE.AmbientLight(0xffffff, intensity);
-    applyPosition(light, element.position);
-    return light;
-  }
-
-  return undefined;
-}
-
-function materialFor(element) {
-  const opacity = number(element.opacity, 1);
-  return new THREE.MeshStandardMaterial({
-    color: element.fill || element.stroke || "#2563eb",
-    roughness: 0.45,
-    transparent: opacity < 1,
-    opacity
-  });
-}
-
-function showTime(rawTime = 0) {
-  const time = Number.isFinite(Number(rawTime)) ? Number(rawTime) : 0;
-  const frameIndex = nearestFrameIndex(time);
-  if (frameIndex !== currentFrameIndex) {
-    currentFrameIndex = frameIndex;
-    setElements(frames[frameIndex] ? frames[frameIndex].elements : []);
-  }
-  renderer.render(scene, camera);
-  return true;
-}
-
-function setElements(elements) {
-  while (content.children.length) {
-    const child = content.children[0];
-    content.remove(child);
-    disposeObject(child);
-  }
-  let hasLight = false;
-  for (const element of elements || []) {
-    const object = createObject(element);
-    if (!object) continue;
-    content.add(object);
-    if (element.type === "light") hasLight = true;
-  }
-  if (!hasLight) {
-    const ambient = new THREE.AmbientLight(0xffffff, 0.6);
-    content.add(ambient);
-    const light = new THREE.DirectionalLight(0xffffff, 1);
-    light.position.set(5, 8, 5);
-    content.add(light);
-  }
-}
-
-function nearestFrameIndex(time) {
-  if (!frames.length) return 0;
-  let best = 0;
-  let bestDistance = Infinity;
-  for (let index = 0; index < frames.length; index += 1) {
-    const distance = Math.abs(number(frames[index].time, 0) - time);
-    if (distance < bestDistance) {
-      best = index;
-      bestDistance = distance;
-    }
-  }
-  return best;
-}
-
-function disposeObject(object) {
-  object.traverse((child) => {
-    if (child.geometry) child.geometry.dispose();
-    const materials = Array.isArray(child.material) ? child.material : child.material ? [child.material] : [];
-    for (const material of materials) {
-      if (material.map) material.map.dispose();
-      material.dispose();
-    }
-  });
-}
-
-function applyPosition(object, position) {
-  const p = vector(position, [0, 0, 0]);
-  object.position.set(p[0], p[1], p[2]);
-}
-
-function vector(value, fallback) {
-  return Array.isArray(value) ? fallback.map((item, index) => number(value[index], item)) : fallback;
-}
-
-function number(value, fallback) {
-  const numeric = Number(value);
-  return Number.isFinite(numeric) ? numeric : fallback;
-}
-
-function degrees(value) {
-  return number(value, 0) * Math.PI / 180;
-}
-
-window.__SKETCHMARK_SHOW_TIME__ = showTime;
-window.__SKETCHMARK_READY__ = true;
-window.addEventListener("message", (event) => {
-  const data = event.data || {};
-  if (data.type === "sketchmark-show") showTime(data.time || 0);
-});
-showTime(${JSON.stringify(initialTime)});
-</script>
-</body>
-</html>`;
-}
-function sampleKernelFrames(document, initialTime) {
-    const duration = finiteNumber(document.canvas.duration, 0);
-    const fps = Math.max(1, Math.min(60, finiteNumber(document.canvas.fps, 30)));
-    const times = new Set([0, Math.max(0, initialTime)]);
-    if (duration > 0) {
-        const frameCount = Math.ceil(duration * fps);
-        for (let index = 0; index <= frameCount; index += 1) {
-            times.add(Number((index / fps).toFixed(6)));
-        }
-        times.add(duration);
-    }
-    return [...times]
-        .sort((left, right) => left - right)
-        .map((time) => ({ time, elements: (0, kernel_1.resolveKernelFrame)(document, time).elements ?? [] }));
-}
-function finiteNumber(value, fallback) {
-    const numeric = Number(value);
-    return Number.isFinite(numeric) ? numeric : fallback;
-}

package/dist/src/render/three-preview-svg.d.ts

@@ -1,3 +0,0 @@
-import type { KernelVisualDocument, RenderOptions, ResolvedVisualDocument, VisualDocument } from "../types";
-export declare function renderThreePreviewSvg(document: VisualDocument, time?: number, options?: RenderOptions): string;
-export declare function renderResolvedThreePreviewSvg(document: ResolvedVisualDocument | KernelVisualDocument, options?: RenderOptions): string;

package/dist/src/render/three-preview-svg.js

@@ -1,102 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.renderThreePreviewSvg = renderThreePreviewSvg;
-exports.renderResolvedThreePreviewSvg = renderResolvedThreePreviewSvg;
-const kernel_1 = require("../kernel");
-function renderThreePreviewSvg(document, time = 0, options = {}) {
-    const frame = (0, kernel_1.resolveKernelFrame)(document, time);
-    return renderResolvedThreePreviewSvg(frame, options);
-}
-function renderResolvedThreePreviewSvg(document, options = {}) {
-    const kernel = isKernelVisualDocument(document) ? document : (0, kernel_1.lowerResolvedVisualDocument)(document);
-    const width = document.canvas.width;
-    const height = document.canvas.height;
-    const background = document.canvas.background ?? "#ffffff";
-    const elements = [...(kernel.elements ?? [])].sort((a, b) => depthOf(a) - depthOf(b));
-    const backdrop = options.transparent ? "" : `<rect x="0" y="0" width="${width}" height="${height}" fill="${escapeAttr(background)}"/>`;
-    return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" role="img">${backdrop}${elements.map((element) => renderElement(element, width, height)).join("")}</svg>`;
-}
-function renderElement(element, width, height) {
-    const opacity = element.opacity === undefined ? "" : ` opacity="${Number(element.opacity)}"`;
-    const id = element.id ? ` id="${escapeAttr(element.id)}"` : "";
-    const fill = escapeAttr(String(element.fill ?? "#2563eb"));
-    const stroke = escapeAttr(String(element.stroke ?? "#111827"));
-    const strokeWidth = Number(element.strokeWidth ?? 1);
-    if (element.type === "mesh3d") {
-        const faces = meshFaces(element, width, height);
-        return faces
-            .sort((a, b) => a.depth - b.depth)
-            .map((face, index) => `<polygon${index === 0 ? `${id}${opacity}` : opacity} points="${face.points.map((point) => point.join(",")).join(" ")}" fill="${shade(fill, face.shade)}" stroke="${stroke}" stroke-width="${strokeWidth}"/>`)
-            .join("");
-    }
-    if (element.type === "line3d" && Array.isArray(element.from) && Array.isArray(element.to)) {
-        const from = project(element.from, width, height);
-        const to = project(element.to, width, height);
-        return `<line${id}${opacity} x1="${from[0]}" y1="${from[1]}" x2="${to[0]}" y2="${to[1]}" stroke="${stroke}" stroke-width="${strokeWidth}" fill="none"/>`;
-    }
-    if (element.type === "text3d") {
-        const point = project(element.position, width, height);
-        return `<text${id}${opacity} x="${point[0]}" y="${point[1]}" text-anchor="middle" dominant-baseline="middle" font-family="Inter, Arial, sans-serif" font-size="${Number(element.fontSize ?? 18)}" font-weight="700" fill="${fill}">${escapeText(element.text)}</text>`;
-    }
-    return "";
-}
-function isKernelVisualDocument(document) {
-    return (document.elements ?? []).every((element) => element.type === "group" || element.type === "path" || element.type === "text" || element.type === "image" || element.type === "point" || element.type === "group3d" || element.type === "mesh3d" || element.type === "line3d" || element.type === "text3d" || element.type === "point3d" || element.type === "light");
-}
-function meshFaces(element, width, height) {
-    const faces = element.faces && element.faces.length ? element.faces : indicesToFaces(element.indices);
-    return faces
-        .filter((face) => face.length >= 3)
-        .map((face, index) => {
-        const world = face.map((vertexIndex) => worldVertex(element, vertexIndex));
-        const depth = world.reduce((total, point) => total + point[2] - point[1] * 0.1, 0) / world.length;
-        return {
-            points: world.map((point) => project(point, width, height)),
-            shade: 0.74 + (index % 4) * 0.08,
-            depth
-        };
-    });
-}
-function indicesToFaces(indices) {
-    const faces = [];
-    for (let index = 0; index < indices.length; index += 3)
-        faces.push(indices.slice(index, index + 3));
-    return faces;
-}
-function worldVertex(element, index) {
-    const vertex = element.vertices[index] ?? [0, 0, 0];
-    const position = element.position ?? [0, 0, 0];
-    return [vertex[0] + position[0], vertex[1] + position[1], vertex[2] + position[2]];
-}
-function project([x, y, z], width, height) {
-    const s = scale(width, height);
-    return [
-        width / 2 + (x - z) * s * 0.9,
-        height / 2 - y * s * 0.9 + (x + z) * s * 0.35
-    ];
-}
-function scale(width, height) {
-    return Math.min(width, height) / 8;
-}
-function depthOf(element) {
-    if ("position" in element && Array.isArray(element.position))
-        return element.position[2] - element.position[1] * 0.1;
-    return 0;
-}
-function shade(hex, factor) {
-    const color = parseHex(hex);
-    if (!color)
-        return hex;
-    return `#${color.map((channel) => Math.max(0, Math.min(255, Math.round(channel * factor))).toString(16).padStart(2, "0")).join("")}`;
-}
-function parseHex(value) {
-    if (!/^#[0-9a-fA-F]{6}$/.test(value))
-        return undefined;
-    return [parseInt(value.slice(1, 3), 16), parseInt(value.slice(3, 5), 16), parseInt(value.slice(5, 7), 16)];
-}
-function escapeAttr(value) {
-    return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
-}
-function escapeText(value) {
-    return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}

package/dist/src/scenes.d.ts

@@ -1,4 +0,0 @@
-import type { ResolvedVisualDocument, VisualDocument } from "./types";
-export declare function listScenes(document: VisualDocument): string[];
-export declare function documentForScene(document: VisualDocument, sceneId: string): VisualDocument;
-export declare function resolvedFrameForScene(document: VisualDocument, sceneId: string, time?: number): ResolvedVisualDocument;

package/dist/src/scenes.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.listScenes = listScenes;
-exports.documentForScene = documentForScene;
-exports.resolvedFrameForScene = resolvedFrameForScene;
-const normalize_1 = require("./normalize");
-const utils_1 = require("./utils");
-function listScenes(document) {
-    return Object.keys(document.scenes ?? {});
-}
-function documentForScene(document, sceneId) {
-    const scene = document.scenes?.[sceneId];
-    if (!scene)
-        throw new Error(`Unknown scene '${sceneId}'.`);
-    return {
-        ...(0, utils_1.clone)(document),
-        canvas: { ...document.canvas, ...(scene.canvas ?? {}) },
-        elements: (0, utils_1.clone)(scene.elements),
-        motion: (0, utils_1.clone)(scene.motion),
-        scenes: undefined,
-        sequences: undefined
-    };
-}
-function resolvedFrameForScene(document, sceneId, time = 0) {
-    return (0, normalize_1.resolveVisualFrame)(documentForScene(document, sceneId), time);
-}

package/dist/src/sequences.d.ts

@@ -1,43 +0,0 @@
-import type { ResolvedVisualDocument, VisualDocument } from "./types";
-export interface CompiledVisualSequence {
-    id: string;
-    duration: number;
-    clips: Array<{
-        scene: string;
-        start: number;
-        duration: number;
-        transition: NormalizedTransition;
-    }>;
-}
-export interface SequenceFrame {
-    document: VisualDocument;
-    scene: string;
-    localTime: number;
-    globalTime: number;
-    transition?: {
-        type: "fade";
-        fromScene: string;
-        toScene: string;
-        progress: number;
-        duration: number;
-    };
-}
-export interface ResolvedSequenceFrame extends Omit<SequenceFrame, "document"> {
-    document: ResolvedVisualDocument;
-}
-export interface SequenceTimelineFrame {
-    index: number;
-    time: number;
-    scene: string;
-    localTime: number;
-    transition?: SequenceFrame["transition"];
-}
-export interface NormalizedTransition {
-    type: "cut" | "fade";
-    duration: number;
-}
-export declare function compileVisualSequence(document: VisualDocument, sequenceId: string): CompiledVisualSequence;
-export declare function defaultSequenceId(document: VisualDocument): string | undefined;
-export declare function documentForSequenceTime(document: VisualDocument, sequenceId: string, time: number): SequenceFrame;
-export declare function resolvedFrameForSequenceTime(document: VisualDocument, sequenceId: string, time: number): ResolvedSequenceFrame;
-export declare function sequenceTimeline(document: VisualDocument, sequenceId: string, fps: number): SequenceTimelineFrame[];